From 30c77150b59f285a09d64ec4caa72cafc9b82286 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Tue, 23 Jul 2019 16:29:37 +0100 Subject: [PATCH 01/17] clean up of repository in preparation for porting --- .gitignore | 2 +- dgplib/utils.py | 36 --- dgplib/weighted_multikernel_layers.py | 169 ++++++++++++ doc/notebooks/simple_example.ipynb | 246 ++++++----------- requirements.txt | 4 + setup.py | 11 +- tests/test_multikernel_layer.py | 380 -------------------------- 7 files changed, 257 insertions(+), 591 deletions(-) delete mode 100644 dgplib/utils.py create mode 100644 dgplib/weighted_multikernel_layers.py create mode 100644 requirements.txt delete mode 100644 tests/test_multikernel_layer.py diff --git a/.gitignore b/.gitignore index 37ca938..a7f5b91 100644 --- a/.gitignore +++ b/.gitignore @@ -111,4 +111,4 @@ ENV/ .idea/ # pytest -./pytest_cache +.pytest_cache diff --git a/dgplib/utils.py b/dgplib/utils.py deleted file mode 100644 index dd24098..0000000 --- a/dgplib/utils.py +++ /dev/null @@ -1,36 +0,0 @@ -# -*- coding: utf-8 -*- -""" -Created on Mon May 22 13:36:25 2017 - -@author: hrs13 -""" - -import tensorflow as tf - -from gpflow import settings - -jitter = settings.numerics.jitter_level -float_type = settings.dtypes.float_type - -def tile_over_samples(X, S): - dims_as_tensor = tf.tile([1], tf.expand_dims(tf.rank(X), axis=0)) - multiples = tf.concat([[S], dims_as_tensor], axis=0) - return tf.tile(tf.expand_dims(X, 0), multiples) - -def shape_as_list(X): - s = tf.shape(X) - return tf.unstack(s) - -def normal_sample(mean, var, full_cov=False): - if full_cov is False: - z = tf.random_normal(tf.shape(mean), dtype=float_type) - return mean + z * var ** 0.5 - else: - S, N, D = shape_as_list(mean) # var is SNND - mean = tf.transpose(mean, (0, 2, 1)) # SND -> SDN - var = tf.transpose(var, (0, 3, 1, 2)) # SNND -> SDNN - I = jitter * tf.eye(N, dtype=float_type)[None, None, :, :] # 11NN - chol = tf.cholesky(var + I) # SDNN - z = tf.random_normal([S, D, N, 1], dtype=float_type) - f = mean + tf.matmul(chol, z)[:, :, :, 0] # SDN(1) - return tf.transpose(f, (0, 2, 1)) # SND diff --git a/dgplib/weighted_multikernel_layers.py b/dgplib/weighted_multikernel_layers.py new file mode 100644 index 0000000..4f5f27b --- /dev/null +++ b/dgplib/weighted_multikernel_layers.py @@ -0,0 +1,169 @@ +from __future__ import print_function, absolute_import + +import tensorflow as tf +import numpy as np + +from gpflow import settings + +from gpflow.conditionals import conditional +from gpflow.decors import params_as_tensors, autoflow, defer_build +from gpflow.features import inducingpoint_wrapper +from gpflow.kullback_leiblers import gauss_kl +from gpflow.mean_functions import Linear, Zero +from gpflow.params import Parameter, Parameterized, ParamList + +from .layers import Layer +from .layers import InputMixin, HiddenMixin, OutputMixin + +class MultikernelLayer(Layer): + """ + Inherits from Layer class. Can handle outputs from different priors. + """ + + @defer_build() + def __init__(self, input_dim, output_dim, num_inducing, kernel_list, + share_Z=False, mean_function=None, multitask=False, name=None): + + if output_dim%len(kernel_list) != 0: + raise ValueError("Output dimension must be a multiple of the number of kernels") + + super(MultikernelLayer, self).__init__(input_dim=input_dim, + output_dim=output_dim, + num_inducing=num_inducing, + kernel=kernel_list, + mean_function=mean_function, + multitask=multitask, + name=name) + + self.num_kernels = len(kernel_list) + self._shared_Z = share_Z + self.offset = int(self.output_dim/self.num_kernels) + + if not self._shared_Z: + del self.feature + if multitask: + Z = np.zeros((self.num_inducing, self.input_dim+1)) + else: + Z = np.zeros((self.num_inducing, self.input_dim)) + + self.feature = ParamList([inducingpoint_wrapper(None, Z.copy()) for _ in range(self.num_kernels)]) + + + @params_as_tensors + def build_prior_KL(self, K): + if K: + KL = 0. + for i, k in enumerate(K): + KL += gauss_kl_white(self.q_mu[:,(i*self.offset):((i+1)*self.offset)], + self.q_sqrt[(i*self.offset):((i+1)*self.offset),:,:], + K=k + ) + return KL + else: + return gauss_kl(self.q_mu, self.q_sqrt, K=K) + + @params_as_tensors + def _build_predict(self, Xnew, full_cov=False, stochastic=True): + def f_conditional(Xnew, full_cov=False): + mean = [] + var = [] + if self._shared_Z: + feats = [self.feature for _ in range(self.num_kernels)] + else: + feats = [feat for feat in self.feature] + for i, (k, feat) in enumerate(zip(self.kernel, feats)): + m, v = conditional(Xnew, feat, k, self.q_mu[:,(i*self.offset):((i+1)*self.offset)], + q_sqrt=self.q_sqrt[(i*self.offset):((i+1)*self.offset),:,:,], + full_cov=full_cov, + white=True) + mean.append(m) + + #temporary fix + if full_cov: + var.append(tf.transpose(v)) + else: + var.append(v) + + mean = tf.concat(mean, axis=-1) #NxK + var = tf.concat(var, axis=-1) #NxK or NxNxK + + return mean + self.mean_function(Xnew), var + + def multisample_conditional(Xnew, full_cov=False): + if full_cov: + f = lambda a: f_conditional(a, full_cov=full_cov) + mean, var = tf.map_fn(f, Xnew, dtype=(settings.tf_float, + settings.tf_float)) + return tf.stack(mean), tf.stack(var) + else: + #S, N, D = shape_as_list(Xnew) + s = tf.shape(Xnew) + X_flat = tf.reshape(Xnew, [s[0]*s[1], s[2]]) + mean, var = f_conditional(X_flat) + return [tf.reshape(m, [s[0], s[1], -1]) for m in [mean, var]] + + if stochastic: + mean, var = multisample_conditional(Xnew, full_cov) + else: + mean, var = f_conditional(Xnew, full_cov) + + return mean, var + +class MultikernelInputLayer(MultikernelLayer, InputMixin): + @defer_build() + def initialize_forward(self, X, Z, multitask=False): + """ + Initialize Layer and Propagate values of inputs and inducing inputs + forward + """ + if self._shared_Z: + self.feature.Z.assign(Z) + else: + for feat in self.feature: + feat.Z.assign(Z) + + X_running, Z_running, W = self.compute_inputs(X, Z, multitask) + + if isinstance(self.mean_function, Linear): + self.mean_function.A = W + self.mean_function.set_trainable(False) + + return X_running, Z_running + + +class MultikernelHiddenLayer(MultikernelLayer, HiddenMixin): + @defer_build() + def initialize_forward(self, X, Z, multitask=False): + """ + Initialize Layer and Propagate values of inputs and inducing inputs + forward + """ + if self._shared_Z: + self.feature.Z.assign(Z) + else: + for feat in self.feature: + feat.Z.assign(Z) + + X_running, Z_running, W = self.compute_inputs(X, Z, multitask) + + if isinstance(self.mean_function, Linear): + self.mean_function.A =W + self.mean_function.set_trainable(False) + + return X_running, Z_running + +class MultikernelOutputLayer(MultikernelLayer, OutputMixin): + @defer_build() + def initialize_forward(self, X, Z, multitask=False): + """ + Initialize Layer and Propagate values of inputs and inducing inputs + forward + """ + + if self._shared_Z: + self.feature.Z.assign(Z) + else: + for feat in self.feature: + feat.Z.assign(Z) + + return (None, None) diff --git a/doc/notebooks/simple_example.ipynb b/doc/notebooks/simple_example.ipynb index aeebc20..66b4aaf 100644 --- a/doc/notebooks/simple_example.ipynb +++ b/doc/notebooks/simple_example.ipynb @@ -12,16 +12,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/aboustati/miniconda3/envs/gpflow-v1/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: compiletime version 3.5 of module 'tensorflow.python.framework.fast_tensor_util' does not match runtime version 3.6\n", - " return f(*args, **kwds)\n" - ] - } - ], + "outputs": [], "source": [ "# useful imports\n", "import numpy as np\n", @@ -38,8 +29,8 @@ "outputs": [], "source": [ "# dgplib imports\n", - "from dgplib.layers import InputLayer, OutputLayer, HiddenLayer\n", - "from dgplib.models import Sequential\n", + "from dgplib.layers import Layer\n", + "from dgplib.cascade import Sequential\n", "\n", "from dgplib import DSDGP" ] @@ -55,7 +46,10 @@ "\n", "from gpflow.kernels import RBF, White, Matern52\n", "from gpflow.likelihoods import Gaussian\n", - "from gpflow.mean_functions import Linear" + "from gpflow.mean_functions import Linear\n", + "from gpflow.utilities import set_trainable, print_summary\n", + "\n", + "gpflow.config.set_summary_fmt(\"notebook\")" ] }, { @@ -73,12 +67,14 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -112,21 +108,36 @@ "cell_type": "code", "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Logging before flag parsing goes to stderr.\n", + "W0723 13:57:01.752855 139838450616128 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0/lib/python3.7/site-packages/tensorflow_probability/python/internal/distribution_util.py:1846: add_dispatch_support..wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.where in 2.0, which has the same broadcast rule as np.where\n" + ] + } + ], "source": [ "# Layers\n", - "input_layer = InputLayer(input_dim=1,\n", - " output_dim=1, \n", - " num_inducing=M, \n", - " kernel=RBF(1, lengthscales=0.2, variance=1.)+White(1, variance=1e-5), \n", - " mean_function=Linear())\n", + "input_layer = Layer(\n", + " input_dim=1,\n", + " output_dim=1, \n", + " kernel=RBF(lengthscale=0.2, variance=1.) + White(variance=1e-5), \n", + " num_inducing=M,\n", + " mean_function=Linear()\n", + ")\n", "\n", - "input_layer.q_sqrt = input_layer.q_sqrt.value * 1e-5\n", + "input_layer.q_sqrt.assign(input_layer.q_sqrt * 1e-5)\n", "\n", - "output_layer = OutputLayer(input_dim=1, \n", - " output_dim=1, \n", - " num_inducing=M,\n", - " kernel=RBF(1, lengthscales=0.2, variance=1.)+White(1, variance=1e-5))" + "output_layer = Layer(\n", + " input_dim=1, \n", + " output_dim=1,\n", + " kernel=RBF(lengthscale=0.2, variance=1.) + White(variance=1e-5),\n", + " num_inducing=M\n", + ")" ] }, { @@ -156,17 +167,9 @@ "cell_type": "code", "execution_count": 7, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model Parameters Initialized\n" - ] - } - ], + "outputs": [], "source": [ - "model = DSDGP(X=X, Y=Y, Z=Z, layers=seq, likelihood=Gaussian(), num_samples=100)" + "model = DSDGP(Z=Z, layers=seq, likelihood=Gaussian())" ] }, { @@ -175,90 +178,27 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - " class prior transform \\\n", - "DSDGP/layers/layers/0/Z Parameter None (none) \n", - "DSDGP/layers/layers/0/kernel/rbf/variance Parameter None +ve \n", - "DSDGP/layers/layers/0/kernel/rbf/lengthscales Parameter None +ve \n", - "DSDGP/layers/layers/0/kernel/white/variance Parameter None +ve \n", - "DSDGP/layers/layers/0/mean_function/A Parameter None (none) \n", - "DSDGP/layers/layers/0/mean_function/b Parameter None (none) \n", - "DSDGP/layers/layers/0/q_mu Parameter None (none) \n", - "DSDGP/layers/layers/0/q_sqrt Parameter None (none) \n", - "DSDGP/layers/layers/1/Z Parameter None (none) \n", - "DSDGP/layers/layers/1/kernel/rbf/variance Parameter None +ve \n", - "DSDGP/layers/layers/1/kernel/rbf/lengthscales Parameter None +ve \n", - "DSDGP/layers/layers/1/kernel/white/variance Parameter None +ve \n", - "DSDGP/layers/layers/1/q_mu Parameter None (none) \n", - "DSDGP/layers/layers/1/q_sqrt Parameter None (none) \n", - "DSDGP/likelihood/variance Parameter None +ve \n", - "\n", - " trainable shape \\\n", - "DSDGP/layers/layers/0/Z True (25, 1) \n", - "DSDGP/layers/layers/0/kernel/rbf/variance True () \n", - "DSDGP/layers/layers/0/kernel/rbf/lengthscales True () \n", - "DSDGP/layers/layers/0/kernel/white/variance True () \n", - "DSDGP/layers/layers/0/mean_function/A False (1, 1) \n", - "DSDGP/layers/layers/0/mean_function/b False (1,) \n", - "DSDGP/layers/layers/0/q_mu True (25, 1) \n", - "DSDGP/layers/layers/0/q_sqrt True (1, 25, 25) \n", - "DSDGP/layers/layers/1/Z True (25, 1) \n", - "DSDGP/layers/layers/1/kernel/rbf/variance True () \n", - "DSDGP/layers/layers/1/kernel/rbf/lengthscales True () \n", - "DSDGP/layers/layers/1/kernel/white/variance True () \n", - "DSDGP/layers/layers/1/q_mu True (25, 1) \n", - "DSDGP/layers/layers/1/q_sqrt True (1, 25, 25) \n", - "DSDGP/likelihood/variance True () \n", - "\n", - " fixed_shape \\\n", - "DSDGP/layers/layers/0/Z True \n", - "DSDGP/layers/layers/0/kernel/rbf/variance True \n", - "DSDGP/layers/layers/0/kernel/rbf/lengthscales True \n", - "DSDGP/layers/layers/0/kernel/white/variance True \n", - "DSDGP/layers/layers/0/mean_function/A True \n", - "DSDGP/layers/layers/0/mean_function/b True \n", - "DSDGP/layers/layers/0/q_mu True \n", - "DSDGP/layers/layers/0/q_sqrt True \n", - "DSDGP/layers/layers/1/Z True \n", - "DSDGP/layers/layers/1/kernel/rbf/variance True \n", - "DSDGP/layers/layers/1/kernel/rbf/lengthscales True \n", - "DSDGP/layers/layers/1/kernel/white/variance True \n", - "DSDGP/layers/layers/1/q_mu True \n", - "DSDGP/layers/layers/1/q_sqrt True \n", - "DSDGP/likelihood/variance True \n", - "\n", - " value \n", - "DSDGP/layers/layers/0/Z [[0.5653737345052243], [0.006100823167344727],... \n", - "DSDGP/layers/layers/0/kernel/rbf/variance 1.0 \n", - "DSDGP/layers/layers/0/kernel/rbf/lengthscales 0.2 \n", - "DSDGP/layers/layers/0/kernel/white/variance 1e-05 \n", - "DSDGP/layers/layers/0/mean_function/A [[1.0]] \n", - "DSDGP/layers/layers/0/mean_function/b [0.0] \n", - "DSDGP/layers/layers/0/q_mu [[0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.... \n", - "DSDGP/layers/layers/0/q_sqrt [[[1e-05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0... \n", - "DSDGP/layers/layers/1/Z [[0.5653737345052243], [0.006100823167344727],... \n", - "DSDGP/layers/layers/1/kernel/rbf/variance 1.0 \n", - "DSDGP/layers/layers/1/kernel/rbf/lengthscales 0.2 \n", - "DSDGP/layers/layers/1/kernel/white/variance 1e-05 \n", - "DSDGP/layers/layers/1/q_mu [[0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.... \n", - "DSDGP/layers/layers/1/q_sqrt [[[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0... \n", - "DSDGP/likelihood/variance 1.0 \n" - ] + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.varianceParameterSoftplus True () float32 1
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "print(model)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "model.compile()" + "print_summary(model)" ] }, { @@ -271,18 +211,19 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "-358.7546941568934" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" + "ename": "AttributeError", + "evalue": "'DSDGP' object has no attribute 'compute_log_likelihood'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute_log_likelihood\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'DSDGP' object has no attribute 'compute_log_likelihood'" + ] } ], "source": [ @@ -291,7 +232,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -301,20 +242,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "43.509194680408335" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "model.compute_log_likelihood()" ] @@ -336,20 +266,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "samples, mu, sigma = model.predict_all_layers_full_cov(Xs, 10)\n", "plt.plot(Xs, mu[-1][:, :, 0].T, color='r', alpha=0.3)\n", @@ -361,20 +280,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for _ in range(10):\n", " mu, sigma = model.predict_f_full_cov(Xs, 1)\n", @@ -408,9 +316,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.7.3" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..244cd89 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,4 @@ +pytest +tabulate +tensorflow==2.0.0-beta1 +git+git://github.com/GPflow/GPflow@awav/gpflow-2.0#egg=gpflow diff --git a/setup.py b/setup.py index a74e569..23c0865 100644 --- a/setup.py +++ b/setup.py @@ -1,10 +1,11 @@ from setuptools import setup -setup(name='dgplib', - version='0.3.1', +setup( + name='dgplib', + version='0.5.0', author='Ayman Boustati', - author_email='aboustati@turing.ac.uk', + author_email='a.boustati@warwick.ac.uk', license='Apache License 2.0', packages=['dgplib'], - test_suite='tests.test_module_suite' - ) + python_requires=">=3.7" +) diff --git a/tests/test_multikernel_layer.py b/tests/test_multikernel_layer.py deleted file mode 100644 index 49c1e16..0000000 --- a/tests/test_multikernel_layer.py +++ /dev/null @@ -1,380 +0,0 @@ -import unittest - -import numpy as np -import tensorflow as tf - -from dgplib.multikernel_layers import MultikernelLayer -from dgplib.multikernel_layers import MultikernelInputLayer, MultikernelHiddenLayer, MultikernelOutputLayer - -from gpflow.decors import defer_build, autoflow, params_as_tensors, name_scope -from gpflow.kernels import White, RBF -from gpflow.mean_functions import Linear -from gpflow.models import Model -from gpflow.params import Parameter - -class MultikernelLayerTest(unittest.TestCase): - @defer_build() - def prepare(self): - rng = np.random.RandomState(42) - num_output = 3 - num_inducing = 10 - kern_list = [RBF(1) for _ in range(num_output)] - Z = rng.randn(num_inducing, 1) - X = rng.randn(20, 1) - - layer = MultikernelLayer(1, num_output, num_inducing, kern_list, share_Z=False) - for feat in layer.feature: - feat.Z.assign(Z.copy()) - - layer_shared_Z = MultikernelLayer(1, num_output, num_inducing, kern_list, share_Z=True) - layer_shared_Z.feature.Z.assign(Z) - - return X, Z , layer, layer_shared_Z, kern_list - - @name_scope('multikernel') - @defer_build() - def prepare_autoflow_functions(self, layer): - class LayerAsModel(Model): - def __init__(self, layer): - super(LayerAsModel, self).__init__() - self.layer = layer - self.a = Parameter(3.) - - @params_as_tensors - def _build_likelihood(self): - return -tf.square(self.a) - - @autoflow((tf.float64, [None, None])) - def predict(self, Xnew): - return self.layer._build_predict(Xnew, stochastic=False) - - @autoflow((tf.float64, [None, None])) - def predict_full_cov(self, Xnew): - return self.layer._build_predict(Xnew, full_cov=True, stochastic=False) - - @autoflow((tf.float64, [None, None])) - def predict_stochastic(self, Xnew): - Xnew = Xnew[None,:,:] - return self.layer._build_predict(Xnew, stochastic=True) - - @autoflow((tf.float64, [None, None])) - def predict_full_cov_stochastic(self, Xnew): - Xnew = Xnew[None,:,:] - return self.layer._build_predict(Xnew, full_cov=True, stochastic=True) - - return LayerAsModel(layer) - - def test_build_predict_unshared_Z(self): - X, Z, layer, _, kern_list = self.prepare() - layer_as_model = self.prepare_autoflow_functions(layer) - layer_as_model.compile() - #Variance only and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict(X) - self.assertEqual(m.shape, (20, 3)) - self.assertEqual(v.shape, (20, 3)) - #Full covariance and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov(X) - self.assertEqual(m.shape, (20, 3)) - self.assertEqual(v.shape, (20, 20, 3)) - #Variance only and stochastic - with self.subTest(): - m, v = layer_as_model.predict_stochastic(X) - self.assertEqual(m.shape, (1, 20, 3)) - self.assertEqual(v.shape, (1, 20, 3)) - #Full covariance and stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov_stochastic(X) - self.assertEqual(m.shape, (1, 20, 3)) - self.assertEqual(v.shape, (1, 20, 20, 3)) - - def test_build_predict_shared_Z(self): - # layer is now with shared Z - X, Z, _, layer, kern_list = self.prepare() - layer_as_model = self.prepare_autoflow_functions(layer) - layer_as_model.compile() - #Variance only and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict(X) - self.assertEqual(m.shape, (20, 3)) - self.assertEqual(v.shape, (20, 3)) - #Full covariance and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov(X) - self.assertEqual(m.shape, (20, 3)) - self.assertEqual(v.shape, (20, 20, 3)) - #Variance only and stochastic - with self.subTest(): - m, v = layer_as_model.predict_stochastic(X) - self.assertEqual(m.shape, (1, 20, 3)) - self.assertEqual(v.shape, (1, 20, 3)) - #Full covariance and stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov_stochastic(X) - self.assertEqual(m.shape, (1, 20, 3)) - self.assertEqual(v.shape, (1, 20, 20, 3)) - -class WideMultikernelLayerTest(unittest.TestCase): - @defer_build() - def prepare(self): - rng = np.random.RandomState(42) - num_output = 9 - num_inducing = 10 - kern_list = [RBF(1) for _ in range(num_output)] - Z = rng.randn(num_inducing, 1) - X = rng.randn(20, 1) - - layer = MultikernelLayer(1, num_output, num_inducing, kern_list, share_Z=False) - for feat in layer.feature: - feat.Z.assign(Z.copy()) - - layer_shared_Z = MultikernelLayer(1, num_output, num_inducing, kern_list, share_Z=True) - layer_shared_Z.feature.Z.assign(Z) - - return X, Z , layer, layer_shared_Z, kern_list - - @name_scope('wide_layer') - @defer_build() - def prepare_autoflow_functions(self, layer): - class LayerAsModel(Model): - def __init__(self, layer): - super(LayerAsModel, self).__init__() - self.layer = layer - self.a = Parameter(3.) - - @params_as_tensors - def _build_likelihood(self): - return -tf.square(self.a) - - @autoflow((tf.float64, [None, None])) - def predict(self, Xnew): - return self.layer._build_predict(Xnew, stochastic=False) - - @autoflow((tf.float64, [None, None])) - def predict_full_cov(self, Xnew): - return self.layer._build_predict(Xnew, full_cov=True, stochastic=False) - - @autoflow((tf.float64, [None, None])) - def predict_stochastic(self, Xnew): - Xnew = Xnew[None,:,:] - return self.layer._build_predict(Xnew, stochastic=True) - - @autoflow((tf.float64, [None, None])) - def predict_full_cov_stochastic(self, Xnew): - Xnew = Xnew[None,:,:] - return self.layer._build_predict(Xnew, full_cov=True, stochastic=True) - - return LayerAsModel(layer) - - def test_build_predict_unshared_Z(self): - X, Z, layer, _, kern_list = self.prepare() - layer_as_model = self.prepare_autoflow_functions(layer) - layer_as_model.compile() - #Variance only and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict(X) - self.assertEqual(m.shape, (20, 9)) - self.assertEqual(v.shape, (20, 9)) - #Full covariance and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov(X) - self.assertEqual(m.shape, (20, 9)) - self.assertEqual(v.shape, (20, 20, 9)) - #Variance only and stochastic - with self.subTest(): - m, v = layer_as_model.predict_stochastic(X) - self.assertEqual(m.shape, (1, 20, 9)) - self.assertEqual(v.shape, (1, 20, 9)) - #Full covariance and stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov_stochastic(X) - self.assertEqual(m.shape, (1, 20, 9)) - self.assertEqual(v.shape, (1, 20, 20, 9)) - - def test_build_predict_shared_Z(self): - # layer is now with shared Z - X, Z, _, layer, kern_list = self.prepare() - layer_as_model = self.prepare_autoflow_functions(layer) - layer_as_model.compile() - #Variance only and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict(X) - self.assertEqual(m.shape, (20, 9)) - self.assertEqual(v.shape, (20, 9)) - #Full covariance and non-stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov(X) - self.assertEqual(m.shape, (20, 9)) - self.assertEqual(v.shape, (20, 20, 9)) - #Variance only and stochastic - with self.subTest(): - m, v = layer_as_model.predict_stochastic(X) - self.assertEqual(m.shape, (1, 20, 9)) - self.assertEqual(v.shape, (1, 20, 9)) - #Full covariance and stochastic - with self.subTest(): - m, v = layer_as_model.predict_full_cov_stochastic(X) - self.assertEqual(m.shape, (1, 20, 9)) - self.assertEqual(v.shape, (1, 20, 20, 9)) - -class MultikernelInputLayerTest(unittest.TestCase): - @defer_build() - def setUp(self): - self.rng = np.random.RandomState(42) - input_dim = 2 - output_dim = 2 - kern_list = [RBF(2) for _ in range(output_dim)] - self.W0 = np.zeros((input_dim, output_dim)) - mean_function = Linear(A=self.W0) - self.Z = self.rng.randn(5,2) - num_inducing = 5 - - self.layer = MultikernelInputLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel_list=kern_list, - share_Z=False, - mean_function=mean_function) - - self.layer_shared_Z = MultikernelInputLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel_list=kern_list, - share_Z=True, - mean_function=mean_function) - - self.X = self.rng.randn(10,2) - - def test_initialize_forward_unshared_Z(self): - X_running, Z_running = self.layer.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertFalse(np.allclose(self.layer.mean_function.A.value, self.W0)) - - with self.subTest(): - self.assertTrue(np.allclose(Z_running, self.Z)) - - with self.subTest(): - for feat in self.layer.feature: - self.assertTrue(np.allclose(feat.Z.value, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(X_running, self.X)) - - def test_initialize_forward_shared_Z(self): - X_running, Z_running = self.layer_shared_Z.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertFalse(np.allclose(self.layer_shared_Z.mean_function.A.value, self.W0)) - - with self.subTest(): - self.assertTrue(np.allclose(Z_running, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(self.layer_shared_Z.feature.Z.value, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(X_running, self.X)) - -class MultikernelHiddenLayerTest(unittest.TestCase): - @defer_build() - def setUp(self): - self.rng = np.random.RandomState(42) - input_dim = 2 - output_dim = 2 - kern_list = [RBF(2) for _ in range(output_dim)] - self.W0 = np.zeros((input_dim, output_dim)) - mean_function = Linear(A=self.W0) - self.Z = self.rng.randn(5, 2) - num_inducing = 5 - - self.layer = MultikernelHiddenLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel_list=kern_list, - share_Z=False, - mean_function=mean_function) - - self.layer_shared_Z = MultikernelHiddenLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel_list=kern_list, - share_Z=True, - mean_function=mean_function) - - self.X = self.rng.randn(10, 2) - - def test_initialize_forward_unshared_Z(self): - X_running, Z_running = self.layer.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertFalse(np.allclose(self.layer.mean_function.A.value, self.W0)) - - with self.subTest(): - self.assertTrue(np.allclose(Z_running, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(X_running, self.X)) - - with self.subTest(): - for feat in self.layer.feature: - self.assertTrue(np.allclose(feat.Z.value, self.Z)) - - def test_initialize_forward_shared_Z(self): - X_running, Z_running = self.layer_shared_Z.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertFalse(np.allclose(self.layer_shared_Z.mean_function.A.value, self.W0)) - - with self.subTest(): - self.assertTrue(np.allclose(Z_running, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(X_running, self.X)) - - with self.subTest(): - self.assertTrue(np.allclose(self.layer_shared_Z.feature.Z.value, self.Z)) - -class MultikernelOutputLayerTest(unittest.TestCase): - @defer_build() - def setUp(self): - self.rng = np.random.RandomState(42) - input_dim = 2 - output_dim = 2 - kern_list = [RBF(2) for _ in range(output_dim)] - mean_function = None - self.Z = self.rng.randn(5, 2) - num_inducing = 5 - - self.layer = MultikernelOutputLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel_list=kern_list, - share_Z=False, - mean_function=mean_function) - - self.layer_shared_Z = MultikernelOutputLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel_list=kern_list, - share_Z=True, - mean_function=mean_function) - - self.X = self.rng.randn(10,2) - - def test_initialize_forward_unshared_Z(self): - _ = self.layer.initialize_forward(self.X, self.Z) - - with self.subTest(): - for feat in self.layer.feature: - self.assertTrue(np.allclose(feat.Z.value, self.Z)) - - def test_initialize_forward_shared_Z(self): - _ = self.layer_shared_Z.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertTrue(np.allclose(self.layer_shared_Z.feature.Z.value, self.Z)) - -if __name__=='__main__': - unittest.main() From 904b18aff041529d92260f5c8cf83d504efa6e30 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Tue, 23 Jul 2019 16:34:01 +0100 Subject: [PATCH 02/17] update and test utilities --- dgplib/__init__.py | 6 +----- dgplib/utilities.py | 26 ++++++++++++++++++++++++++ tests/__init__.py | 11 ++--------- tests/test_utilities.py | 37 +++++++++++++++++++++++++++++++++++++ 4 files changed, 66 insertions(+), 14 deletions(-) create mode 100644 dgplib/utilities.py create mode 100644 tests/test_utilities.py diff --git a/dgplib/__init__.py b/dgplib/__init__.py index b3ee708..bff8eae 100644 --- a/dgplib/__init__.py +++ b/dgplib/__init__.py @@ -1,10 +1,6 @@ -from __future__ import absolute_import - +from . import utilities from . import layers from . import cascade -from . import multikernel_layers -from . import utils from . import specialized_kernels from .dsdgp import DSDGP -from .multitask_dsdgp import MultitaskDSDGP diff --git a/dgplib/utilities.py b/dgplib/utilities.py new file mode 100644 index 0000000..ce012fd --- /dev/null +++ b/dgplib/utilities.py @@ -0,0 +1,26 @@ +import numpy as np + + +def find_linear_mf_weights(input_dim, output_dim, X): + """ + Find the initial weights of the Linear mean function based on + input and output dimensions of the layer + + :param input_dim: input dimension of layer + :param output_dim: output dimension of layer + :param X: numpy array of data with which mean function is initialized + """ + assert X.shape[1] - input_dim in [0, 1] + + if input_dim <= output_dim: + W = np.eye(input_dim, output_dim) + + elif input_dim > output_dim: + # Slicing to guard against index column at the end + _, _, V = np.linalg.svd(X[:, :input_dim], full_matrices=False) + W = V[:output_dim, :].T + + if X.shape[1] == input_dim + 1: # Accounting for a potential index column + W = np.concatenate([W, np.zeros((1, W.shape[1]))], axis=0) + + return W diff --git a/tests/__init__.py b/tests/__init__.py index 4cb34c7..494ae1a 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,10 +1,3 @@ -import unittest +import warnings -from . import test_layer -from . import test_cascade - -def test_module_suite(): - loader = unittest.TestLoader() - #suite = loader.loadTestsFromModule(test_layer) - suite = loader.discover('./') - return suite +warnings.filterwarnings('ignore') diff --git a/tests/test_utilities.py b/tests/test_utilities.py new file mode 100644 index 0000000..f228c7b --- /dev/null +++ b/tests/test_utilities.py @@ -0,0 +1,37 @@ +import pytest +import numpy as np + +from dgplib.utilities import find_linear_mf_weights + + +rng = np.random.RandomState(42) + +N = 100 +D = 5 +X = rng.randn(N, D) + + +@pytest.fixture +def data(): + return X + + +@pytest.mark.parametrize('output_dim', [4, 5, 6]) +def test_mf_weights_no_index_column(data, output_dim): + """ + Tests mean function weight computation without an index column in the data + """ + input_dim = D + W = find_linear_mf_weights(input_dim=input_dim, output_dim=output_dim, X=data) + assert W.shape == (input_dim, output_dim) + + +@pytest.mark.parametrize('output_dim', [3, 4, 5]) +def test_mf_weights_with_index_column(data, output_dim): + """ + Tests mean function weight computation with an index column in the data + """ + input_dim = D - 1 + W = find_linear_mf_weights(input_dim=input_dim, output_dim=output_dim, X=data) + assert W.shape == (input_dim + 1, output_dim) + From 733e4bbdc9807a0ddce2b7b01ed65bf6288c74e9 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Wed, 24 Jul 2019 17:51:24 +0100 Subject: [PATCH 03/17] updated and tested layer class --- TODO.md | 2 + dgplib/layers.py | 350 ++++++++++++++++++++++---------------------- tests/test_layer.py | 258 +++++++++++++++----------------- 3 files changed, 297 insertions(+), 313 deletions(-) create mode 100644 TODO.md diff --git a/TODO.md b/TODO.md new file mode 100644 index 0000000..baca709 --- /dev/null +++ b/TODO.md @@ -0,0 +1,2 @@ +# TODO +* Create utilities for dealing with features and kernels \ No newline at end of file diff --git a/dgplib/layers.py b/dgplib/layers.py index 9aed31e..6907997 100644 --- a/dgplib/layers.py +++ b/dgplib/layers.py @@ -1,218 +1,214 @@ -from __future__ import print_function, absolute_import +from typing import Tuple import tensorflow as tf import numpy as np -from gpflow import settings - -from gpflow.conditionals import conditional -from gpflow.decors import params_as_tensors, autoflow, defer_build +from gpflow.base import Parameter, Module, positive, triangular +from gpflow.conditionals import conditional, sample_conditional +from gpflow.config import default_float, default_jitter +from gpflow.covariances import Kuu +from gpflow.features import Mof, SeparateIndependentMof, SharedIndependentMof, InducingPoints from gpflow.kullback_leiblers import gauss_kl from gpflow.mean_functions import Linear, Zero -from gpflow.params import Parameter, Parameterized, ParamList -from gpflow.features import inducingpoint_wrapper + +from .utilities import find_linear_mf_weights -class Layer(Parameterized): +class Layer(Module): """ - The basic layer class. Handles input_dim and output_dim. + The basic SVGP layer class. Handles input_dim and output_dim. """ - @defer_build() - def __init__(self, input_dim, output_dim, num_inducing, kernel, - mean_function=None, multitask=False, name=None): + def __init__(self, input_dim, output_dim, kernel, feature=None, + num_inducing=None, share_Z=False, fixed_linear_mean_function=False, + mean_function=None, whiten=True, q_diag=False, q_mu=None, q_sqrt=None, name=None): """ - input_dim is an integer - output_dim is an integer - num_inducing is the number of inducing inputs - kernel is a kernel object (or list of kernel objects) + :param input_dim: input dimension + :param output_dim: output dimension + :param kernel: GPflow kernel + :param feature: numpy array of inducing inputs or InducingFeature object or None + :param num_inducing: number of inducing inputs, automatically infered if feature is not None + :param share_Z: True if inducing inputs are shared across layer dimensions + :param fixed_linear_mean_function: True of mean function is fixed + like in Salimbeni and Diesenroth 2017 + :param mean_function: GPflow mean_function + :param whiten: True if whitened representation is used + :param q_diag: True if variational covariance is set to diagonal + :param q_mu: numpy array of variational mean + :param q_sqrt: numpy array of Cholesky of variational covariance """ - super(Layer, self).__init__(name=name) + super().__init__(name=name) self.input_dim = input_dim self.output_dim = output_dim - self.num_inducing = num_inducing - if multitask: - Z = np.zeros((self.num_inducing, self.input_dim + 1)) - else: - Z = np.zeros((self.num_inducing, self.input_dim)) - - self.feature = inducingpoint_wrapper(None, Z) - - if isinstance(kernel, list): - self.kernel = ParamList(kernel) - else: - self.kernel = kernel - - self.mean_function = mean_function or Zero(output_dim=self.output_dim) - - shape = (self.num_inducing, self.output_dim) - - self.q_mu = Parameter(np.zeros(shape)) - - q_sqrt = np.vstack([np.expand_dims(np.eye(self.num_inducing), 0) - for _ in range(self.output_dim)]) - self.q_sqrt = Parameter(q_sqrt) - - @params_as_tensors - def build_prior_KL(self, K): - return gauss_kl(self.q_mu, self.q_sqrt, K=K) - - @params_as_tensors - def _build_predict(self, Xnew, full_cov=False, stochastic=True): - # Credits to High Salimbeni for this (@hughsalimbeni) - def f_conditional(Xnew, full_cov=False): - mean, var = conditional(Xnew, self.feature, self.kernel, self.q_mu, - q_sqrt=self.q_sqrt, - full_cov=full_cov, - white=True) - - return mean + self.mean_function(Xnew), var - - def multisample_conditional(Xnew, full_cov=False): - if full_cov: - def f(a): - m, v = f_conditional(a, full_cov=full_cov) - return m, tf.transpose(v) - #f = lambda a: f_conditional(a, full_cov=full_cov) - mean, var = tf.map_fn(f, Xnew, dtype=(settings.tf_float, - settings.tf_float)) - return tf.stack(mean), tf.stack(var) - else: - # S, N, D = shape_as_list(Xnew) - s = tf.shape(Xnew) - X_flat = tf.reshape(Xnew, [s[0] * s[1], s[2]]) - mean, var = f_conditional(X_flat) - return [tf.reshape(m, [s[0], s[1], -1]) for m in [mean, var]] - - if stochastic: - mean, var = multisample_conditional(Xnew, full_cov) - else: - mean, var = f_conditional(Xnew, full_cov) - return mean, var + if feature is not None: + assert isinstance(feature, Mof) + self.feature = feature + self.kernel = kernel + self.share_Z = share_Z -def find_weights(input_dim, output_dim, X, multitask=False): - """ - Find the initial weights of the Linear mean function based on - input and output dimensions of the layer - """ - - if input_dim == output_dim: - W = np.eye(input_dim) - - elif input_dim > output_dim: - if multitask: - _, _, V = np.linalg.svd(X[:, :-1], full_matrices=False) + self.fixed_linear_mean_function = fixed_linear_mean_function + if self.fixed_linear_mean_function: + self.mean_function = Linear() + self.mean_function.trainable = False else: - _, _, V = np.linalg.svd(X, full_matrices=False) - W = V[:output_dim, :].T - - elif input_dim < output_dim: - I = np.eye(input_dim) - zeros = np.zeros((input_dim, output_dim - input_dim)) - W = np.concatenate([I, zeros], 1) - - if multitask: - W = np.concatenate([W, np.zeros((1, W.shape[1]))], axis=0) - - return W + self.mean_function = mean_function or Zero(output_dim=self.output_dim) + self.whiten = whiten -class InputMixin(object): - """ - Mixin class for input layers. Implements a single method to compute the - value of the inputs and inducing inputs for the next layer. - """ - - def compute_inputs(self, X, Z, multitask=False): - W = find_weights(self.input_dim, self.output_dim, X, multitask) - - Z_running = Z.copy().dot(W) - X_running = X.copy().dot(W) - - return X_running, Z_running, W + if self.feature is not None: + num_inducing = len(self.feature) + self.q_diag = q_diag + self._init_variational_parameters(num_inducing, q_mu, q_sqrt, q_diag) -class HiddenMixin(object): - """ - Mixin class for hidden layers. Implements a single method to compute the - value of the inputs and inducing inputs for the next layer. - """ - - def compute_inputs(self, X, Z, multitask=False): - W = find_weights(self.input_dim, self.output_dim, X, multitask) - - if isinstance(self.feature, ParamList): - Z_running = self.feature[0].Z.value.copy().dot(W) + def _init_variational_parameters(self, num_inducing, q_mu, q_sqrt, q_diag): + """ + Modification from GPflow. + Constructs the mean and cholesky of the covariance of the variational Gaussian posterior. + If a user passes values for `q_mu` and `q_sqrt` the routine checks if they have consistent + and correct shapes. If a user does not specify any values for `q_mu` and `q_sqrt`, the routine + initializes them, their shape depends on `num_inducing` and `q_diag`. + Note: most often the comments refer to the number of observations (=output dimensions) with P, + number of latent GPs with L, and number of inducing points M. Typically P equals L, + but when certain multioutput kernels are used, this can change. + Parameters + ---------- + :param num_inducing: int + Number of inducing variables, typically refered to as M. + :param q_mu: np.array or None + Mean of the variational Gaussian posterior. If None the function will initialise + the mean with zeros. If not None, the shape of `q_mu` is checked. + :param q_sqrt: np.array or None + Cholesky of the covariance of the variational Gaussian posterior. + If None the function will initialise `q_sqrt` with identity matrix. + If not None, the shape of `q_sqrt` is checked, depending on `q_diag`. + :param q_diag: bool + Used to check if `q_mu` and `q_sqrt` have the correct shape or to + construct them with the correct shape. If `q_diag` is true, + `q_sqrt` is two dimensional and only holds the square root of the + covariance diagonal elements. If False, `q_sqrt` is three dimensional. + """ + q_mu = np.zeros( + (num_inducing, self.output_dim)) if q_mu is None else q_mu + self.q_mu = Parameter(q_mu, dtype=default_float()) # [M, P] + + if q_sqrt is None: + if self.q_diag: + ones = np.ones((num_inducing, self.output_dim), + dtype=default_float()) + self.q_sqrt = Parameter(ones, transform=positive()) # [M, P] + else: + q_sqrt = [ + np.eye(num_inducing, dtype=default_float()) + for _ in range(self.output_dim) + ] + q_sqrt = np.array(q_sqrt) + self.q_sqrt = Parameter(q_sqrt, transform=triangular()) # [P, M, M] else: - Z_running = self.feature.Z.value.copy().dot(W) - - X_running = X.copy().dot(W) - - return X_running, Z_running, W - - -class OutputMixin(object): - """ - Mixin class for output layers. Does not implement any methods. Only used - for type checking. - """ - - def compute_inputs(self, X, Z, multitask=False): - W = find_weights(self.input_dim, self.output_dim, X, multitask) - - Z_running = self.feature.Z.value.copy().dot(W) - X_running = X.copy().dot(W) - - return X_running, Z_running, W - + if q_diag: + assert q_sqrt.ndim == 2 + assert self.output_dim == q_sqrt.shape[1] + self.q_sqrt = Parameter(q_sqrt, transform=positive()) # [M, L|P] + else: + assert q_sqrt.ndim == 3 + assert self.output_dim == q_sqrt.shape[0] + self.q_sqrt = Parameter(q_sqrt, transform=triangular()) # [L|P, M, M] -class InputLayer(Layer, InputMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): + def prior_kl(self): """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward + KL(q(u)||p(u)) """ - self.feature.Z.assign(Z) + K = None + if not self.whiten: + K = Kuu(self.feature, self.kernel, jitter=default_jitter()) # [P, M, M] or [M, M] - X_running, Z_running, W = self.compute_inputs(X, Z, multitask) - - if isinstance(self.mean_function, Linear): - self.mean_function.A = W - self.mean_function.set_trainable(False) - - return X_running, Z_running + return gauss_kl(self.q_mu, self.q_sqrt, K) + def predict_f(self, Xnew: tf.Tensor, full_cov=False, full_output_cov=False) -> Tuple[tf.Tensor, tf.Tensor]: + """ + Returns the posterior mean and covariance at Xnew -class HiddenLayer(Layer, HiddenMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): + :param Xnew: input (tf.Tensor or numpy array) + :param full_cov: True if full covariance required + :param full_output_cov: True if full ouput covariance required """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward + q_mu = self.q_mu + q_sqrt = self.q_sqrt + mu, var = conditional( + Xnew, + self.feature, + self.kernel, + q_mu, + q_sqrt=q_sqrt, + full_cov=full_cov, + white=self.whiten, + full_output_cov=full_output_cov + ) + + return mu + self.mean_function(Xnew), var + + def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False, full_output_cov=False) -> tf.Tensor: """ - self.feature.Z.assign(Z) - - X_running, Z_running, W = self.compute_inputs(X, Z, multitask) + Returns sample from GP posterior at Xnew - if isinstance(self.mean_function, Linear): - self.mean_function.A = W - self.mean_function.set_trainable(False) + :param Xnew: input (tf.Tensor or numpy array) + :param num_samples: number of MC samples + :param full_cov: True if full covariance required + :param full_output_cov: True if full output covariance required + """ + q_mu = self.q_mu + q_sqrt = self.q_sqrt + samples, mu, var = sample_conditional( + Xnew, + self.feature, + self.kernel, + q_mu, + q_sqrt=q_sqrt, + full_cov=full_cov, + white=self.whiten, + full_output_cov=full_output_cov, + num_samples=num_samples + ) + + return samples + self.mean_function(Xnew), mu + self.mean_function(Xnew), var + + def propagate_inputs_and_features(self, X, Z): + """ + Returns an initialization for the data and inducing inputs for the consequent layer + :param X: inputs + :param Z: inducing inputs + """ + W = find_linear_mf_weights(self.input_dim, self.output_dim, X) - return X_running, Z_running + Z_running = Z.copy().dot(W) + X_running = X.copy().dot(W) + return X_running, Z_running, W -class OutputLayer(Layer, OutputMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): + def initialize_features(self, Z): """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward + Initialize the inducing inputs/features for this Layer + :param Z: inducing input values """ + if self.feature is None: + if self.share_Z: + self.feature = SharedIndependentMof(InducingPoints(Z)) + else: + self.feature = SeparateIndependentMof([InducingPoints(Z) for _ in range(self.output_dim)]) + else: + raise ValueError("Features already intialized") - self.feature.Z.assign(Z) - return (None, None) + def initialize_linear_mean_function_weights(self, W): + """ + Initialize linear mean function weights for this Layer + :param W: numpy array of linear mean function weights + """ + if self.fixed_linear_mean_function: + self.mean_function.A = Parameter(W) + self.mean_function.A.trainable = False + else: + raise ValueError("Mean function is not specified as fixed on construction.") diff --git a/tests/test_layer.py b/tests/test_layer.py index 8c13432..bba1808 100644 --- a/tests/test_layer.py +++ b/tests/test_layer.py @@ -1,142 +1,128 @@ -import unittest +""" +Testing against GPflow's SVGP implementation as reference +""" +import pytest import numpy as np +import tensorflow as tf -from dgplib.layers import find_weights, InputLayer, HiddenLayer, OutputLayer +from dgplib.layers import Layer +from dgplib.utilities import find_linear_mf_weights -from gpflow.decors import defer_build -from gpflow.kernels import White, RBF +import gpflow +from gpflow.features import SharedIndependentMof, InducingPoints +from gpflow.kernels import RBF from gpflow.mean_functions import Linear -class LayerTest(unittest.TestCase): - def setUp(self): - pass - - def test_build_predict(self): - #Run on small toy dataset and expect answer to be similar to SVGP - pass - -class WeightsTest(unittest.TestCase): - def setUp(self): - self.X = np.array([[2,4], [1,3], [0,0], [0,0]]) - - def test_input_equals_output(self): - W = find_weights(2, 2, self.X) - with self.subTest(): - self.assertEqual(W.shape, (2,2)) - with self.subTest(): - self.assertTrue(np.allclose(W, np.eye(2))) - - def test_input_greater_output(self): - W = find_weights(2, 1, self.X) - V = np.array([-0.4, -0.91]).reshape((2,1)) - with self.subTest(): - self.assertEqual(W.shape, (2,1)) - with self.subTest(): - self.assertTrue(np.allclose(W, V, atol=1e-2)) - - def test_input_less_output(self): - W = find_weights(1, 2, self.X) - V = np.array([1, 0])[None, :] - with self.subTest(): - self.assertEqual(W.shape, (1,2)) - with self.subTest(): - self.assertTrue(np.allclose(W, V)) - -class InputLayerTest(unittest.TestCase): - @defer_build() - def setUp(self): - self.rng = np.random.RandomState(42) - kernel = RBF(2) - input_dim = 2 - output_dim = 2 - self.W0 = np.zeros((input_dim, output_dim)) - mean_function = Linear(A=self.W0) - self.Z = self.rng.randn(5,2) - num_inducing = 5 - - self.layer = InputLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel=kernel, - mean_function=mean_function) - - self.X = self.rng.randn(10,2) - - def test_initialize_forward(self): - X_running, Z_running = self.layer.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertFalse(np.allclose(self.layer.mean_function.A.value, self.W0)) - - with self.subTest(): - self.assertTrue(np.allclose(Z_running, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(self.layer.feature.Z.value, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(X_running, self.X)) - -class HiddenLayerTest(unittest.TestCase): - @defer_build() - def setUp(self): - self.rng = np.random.RandomState(42) - kernel = RBF(2) - input_dim = 2 - output_dim = 2 - self.W0 = np.zeros((input_dim, output_dim)) - mean_function = Linear(A=self.W0) - self.Z = self.rng.randn(5, 2) - num_inducing = 5 - - self.layer = HiddenLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel=kernel, - mean_function=mean_function) - - self.X = self.rng.randn(10, 2) - - def test_initialize_forward(self): - X_running, Z_running = self.layer.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertFalse(np.allclose(self.layer.mean_function.A.value, self.W0)) - - with self.subTest(): - self.assertTrue(np.allclose(Z_running, self.Z)) - - with self.subTest(): - self.assertTrue(np.allclose(X_running, self.X)) - - with self.subTest(): - self.assertTrue(np.allclose(self.layer.feature.Z.value, self.Z)) - -class OutputLayerTest(unittest.TestCase): - @defer_build() - def setUp(self): - self.rng = np.random.RandomState(42) - kernel = RBF(2) - input_dim = 2 - output_dim = 2 - mean_function = None - self.Z = self.rng.randn(5, 2) - num_inducing = 5 - - self.layer = OutputLayer(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel=kernel, - mean_function=mean_function) - - self.X = self.rng.randn(10,2) - - def test_initialize_forward(self): - _ = self.layer.initialize_forward(self.X, self.Z) - - with self.subTest(): - self.assertTrue(np.allclose(self.layer.feature.Z.value, self.Z)) - -if __name__=='__main__': - unittest.main() + +rng = np.random.RandomState(42) + + +class Datum: + input_dim = 5 + output_dim = 3 + num_inducing = 10 + num_data = 20 + noise_variance = 1.0 + lengthscale = 2.3 + signal_variance = 0.5 + q_mu = rng.randn(num_inducing, output_dim) + q_sqrt = np.stack([np.tril(rng.rand(num_inducing, num_inducing))] * output_dim) + + X = rng.randn(num_data, input_dim) + Z = rng.randn(num_inducing, input_dim) + + +@pytest.fixture +def reference_model(): + kernel = RBF(variance=Datum.signal_variance, lengthscale=Datum.lengthscale) + likelihood = gpflow.likelihoods.Gaussian(variance=Datum.noise_variance) + features = Datum.Z.copy() + + W = find_linear_mf_weights(input_dim=Datum.input_dim, output_dim=Datum.output_dim, X=Datum.X) + + model = gpflow.models.SVGP(kernel=kernel, likelihood=likelihood, feature=features, mean_function=Linear(A=W), + q_mu=Datum.q_mu, q_sqrt=Datum.q_sqrt) + return model + + +def create_layer_utility(feature=None, share_Z=False, fixed_mf=True): + kernel = gpflow.kernels.mo_kernels.SharedIndependentMok( + RBF(variance=Datum.signal_variance, lengthscale=Datum.lengthscale), output_dimensionality=Datum.output_dim + ) + layer = Layer(input_dim=Datum.input_dim, output_dim=Datum.output_dim, kernel=kernel, + feature=feature, share_Z=share_Z, fixed_linear_mean_function=fixed_mf, + q_mu=Datum.q_mu, q_sqrt=Datum.q_sqrt) + return layer + + +def test_kl(reference_model): + layer = create_layer_utility(feature=SharedIndependentMof(InducingPoints(Datum.Z))) + layer_kl = layer.prior_kl() + reference_kl = reference_model.prior_kl() + np.testing.assert_allclose(layer_kl, reference_kl) + + +@pytest.mark.parametrize("full_cov", [True, False]) +@pytest.mark.parametrize("full_output_cov", [True, False]) +def test_predict_f(reference_model, full_cov, full_output_cov): + layer = create_layer_utility(feature=SharedIndependentMof(InducingPoints(Datum.Z))) + W = find_linear_mf_weights(input_dim=Datum.input_dim, output_dim=Datum.output_dim, X=Datum.X) + layer.initialize_linear_mean_function_weights(W=W) + + X = tf.cast(tf.convert_to_tensor(Datum.X), dtype=gpflow.default_float()) + layer_mu, layer_sigma = layer.predict_f(X, full_cov, full_output_cov) + reference_mu, reference_sigma = reference_model.predict_f(X, full_cov, full_output_cov) + + np.testing.assert_allclose(layer_mu, reference_mu) + np.testing.assert_allclose(layer_sigma, reference_sigma) + + +@pytest.mark.parametrize("full_cov", [True, False]) +def test_predict_f_samples(full_cov): + num_samples = 100 + layer = create_layer_utility(feature=SharedIndependentMof(InducingPoints(Datum.Z))) + W = find_linear_mf_weights(input_dim=Datum.input_dim, output_dim=Datum.output_dim, X=Datum.X) + layer.initialize_linear_mean_function_weights(W=W) + + X = tf.cast(tf.convert_to_tensor(Datum.X), dtype=gpflow.default_float()) + samples, _, _ = layer.predict_f_samples(X, num_samples, full_cov) + assert samples.shape == (num_samples, Datum.num_data, Datum.output_dim) + + +def test_propagate_inputs_and_features(): + layer = create_layer_utility() + X, Z, _ = layer.propagate_inputs_and_features(Datum.X, Datum.Z) + assert X.shape == (Datum.num_data, Datum.output_dim) + assert Z.shape == (Datum.num_inducing, Datum.output_dim) + + +@pytest.mark.parametrize("feature", [None, SharedIndependentMof(InducingPoints(Datum.Z))]) +@pytest.mark.parametrize("share_Z", [True, False]) +def test_initialize_features(feature, share_Z): + layer = create_layer_utility(feature=feature, share_Z=share_Z) + if feature: + with pytest.raises(ValueError): + layer.initialize_features(Z=Datum.Z) + + else: + layer.initialize_features(Z=Datum.Z) + if share_Z: + assert isinstance(layer.feature, gpflow.features.SharedIndependentMof) + else: + assert isinstance(layer.feature, gpflow.features.SeparateIndependentMof) + + +@pytest.mark.parametrize("fixed_mf", [True, False]) +def test_initialize_mean_function_weights(fixed_mf): + W = find_linear_mf_weights(input_dim=Datum.input_dim, output_dim=Datum.output_dim, X=Datum.X) + layer = create_layer_utility(fixed_mf=fixed_mf) + if fixed_mf: + layer.initialize_linear_mean_function_weights(W=W) + np.testing.assert_allclose(layer.mean_function.A.numpy(), W) + assert layer.mean_function.A.trainable is False + else: + with pytest.raises(ValueError): + layer.initialize_linear_mean_function_weights(W=W) + + From f25a4f651fb4e05b63cb4c1c18139d00251c7c9f Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Wed, 24 Jul 2019 21:15:29 +0100 Subject: [PATCH 04/17] updated and tested cascade --- dgplib/cascade.py | 82 +++++++------ tests/test_cascade.py | 274 +++++++++++++++--------------------------- 2 files changed, 142 insertions(+), 214 deletions(-) diff --git a/dgplib/cascade.py b/dgplib/cascade.py index 5cc3b53..54be74e 100644 --- a/dgplib/cascade.py +++ b/dgplib/cascade.py @@ -1,45 +1,48 @@ -import numpy as np -import tensorflow as tf +from gpflow.base import Module +from .layers import Layer -from gpflow.params import Parameterized, ParamList -from .layers import InputMixin, HiddenMixin, OutputMixin -from .layers import Layer, InputLayer, OutputLayer, HiddenLayer -from .multikernel_layers import MultikernelLayer, MultikernelInputLayer, MultikernelOutputLayer, MultikernelHiddenLayer -class Sequential(Parameterized): +class Sequential(Module): """ Linear Stack of layers """ def __init__(self, layers=None, name=None): """ - - layers is a list of layer objects. + :param layers: list of Layer objects """ - super(Sequential, self).__init__(name=name) + super().__init__(name=name) - self._initialized = False #Change into property later - self.layers = ParamList([]) + self._initialized = False + self.constituents = [] if layers: for layer in layers: self.add(layer) + @property + def initialized(self): + return self._initialized + + @initialized.setter + def initialized(self, value): + if not self.initialized: + if value: + raise ValueError("Cannot overwrite initialization for uninitialized models") + self._initialized = value + def _valid_input(self, layer): + """ + Checks if input to the cascade object is valid + """ assert isinstance(layer, Layer) - if self._initialized: + if self.initialized: raise ValueError('Cannot add more layers to initialized model') - if not self.layers: - #Temporary Hack - assert isinstance(layer, InputMixin), "First layer must be an Input Layer" - else: - #Temporary Hack - if isinstance(self.layers[-1], OutputMixin): - raise ValueError('Cannot add layers after an Output Layer') - - assert self.layers[-1].output_dim == layer.input_dim, """Input + if self.constituents: # if list is not empty + assert self.constituents[-1].output_dim == layer.input_dim, """Input dimensions of layer must be equal to the output dimensions of the preceding layer""" @@ -47,37 +50,36 @@ def add(self, layer): """ Adds a layer instance on top of the layer stack. - - layer is an instance of an object that inherits from Layer + :param layer: Layer object """ self._valid_input(layer) - self.layers.append(layer) + self.constituents.append(layer) def get_dims(self): """ Get a list of the dimensions of the constituent layers. """ - dims = [(l.input_dim, l.output_dim) for l in self.layers] + dims = [(l.input_dim, l.output_dim) for l in self.constituents] return dims def initialize_params(self, X, Z): - X_running, Z_running = self.layers[0].initialize_forward(X, Z) - for layer in self.layers[1:]: - X_running, Z_running = layer.initialize_forward(X_running, Z_running) + """ + Handles the initialization of inducing inputs in the Sequential cascade + """ + Z_current = Z.copy() + X_next, Z_next, W = self.constituents[0].propagate_inputs_and_features(X, Z) + self.constituents[0].initialize_features(Z_current) + if self.constituents[0].fixed_linear_mean_function: + self.constituents[0].initialize_mean_function_weights(W) + for layer in self.constituents[1:]: + Z_current = Z_next + X_next, Z_next, W = layer.propagate_inputs_and_features(X_next, Z_current) + layer.initialize_features(Z_current) + if layer.fixed_linear_mean_function: + layer.initialize_linear_mean_function_weights(W) print('Model Parameters Initialized') self._initialized = True -class MultitaskSequential(Sequential): - def initialize_params(self, X, Z): - X_ind = X[:, -1:] - Z_ind = Z[:, -1:] - X_running, Z_running = self.layers[0].initialize_forward(X, Z, multitask=True) - for layer in self.layers[1:]: - X_running = np.hstack([X_running, X_ind]) - Z_running = np.hstack([Z_running, Z_ind]) - X_running, Z_running = layer.initialize_forward(X_running, - Z_running, - multitask=True) - print('Model Parameters Initialized') - self._initialized = True + diff --git a/tests/test_cascade.py b/tests/test_cascade.py index f6db958..4e7052b 100644 --- a/tests/test_cascade.py +++ b/tests/test_cascade.py @@ -1,179 +1,105 @@ -import unittest +import pytest import numpy as np -from dgplib.layers import InputLayer, HiddenLayer, OutputLayer -from dgplib.cascade import Sequential, MultitaskSequential +from dgplib.layers import Layer +from dgplib.cascade import Sequential -from gpflow.decors import defer_build +import gpflow from gpflow.kernels import RBF -from gpflow.params import ParamList - -class SequentialTest(unittest.TestCase): - def test_initialization_with_empty(self): - seq = Sequential() - self.assertIsInstance(seq.layers, ParamList) - - @defer_build() - def test_initialization_with_list(self): - input_layer = InputLayer(2, 2, 10, RBF(2)) - hidden_layer_1 = HiddenLayer(2, 2, 10, RBF(2)) - hidden_layer_2 = HiddenLayer(2, 2, 10, RBF(2)) - output_layer = OutputLayer(2, 1, 10, RBF(2)) - - with self.subTest(): - layer_list = [input_layer, hidden_layer_1, hidden_layer_2, - output_layer] - try: - seq = Sequential(layer_list) - except Exception as e: - print(e) - self.fail("Initialisation with list of layers fails") - - # Test initilisation with incorrect layer structure - with self.subTest(): - layer_list = [hidden_layer_1, hidden_layer_2, output_layer] - with self.assertRaises(AssertionError): - seq = Sequential(layer_list) - - # Test initilisation with incorrect layer structure - # with self.subTest(): - # layer_list = [input_layer, hidden_layer_1, hidden_layer_2] - # with self.assertRaises(AssertionError): - # seq = Sequential(layer_list) - - @defer_build() - def test_add_to_empty(self): - input_layer = InputLayer(2, 2, 10, RBF(2)) - hidden_layer_1 = HiddenLayer(2, 2, 10, RBF(2)) - output_layer = OutputLayer(2, 1, 10, RBF(2)) - - # Add input layer only - with self.subTest(): - seq = Sequential() - seq.add(input_layer) - self.assertIs(seq.layers[-1], input_layer) - - # Add input layer and hidden layer - with self.subTest(): - seq = Sequential() - seq.add(input_layer) - seq.add(hidden_layer_1) - self.assertIs(seq.layers[0], input_layer) - self.assertIs(seq.layers[1], hidden_layer_1) - - # Add input layer, hidden layer and output layer - with self.subTest(): - seq = Sequential() - seq.add(input_layer) - seq.add(hidden_layer_1) - seq.add(output_layer) - self.assertIs(seq.layers[0], input_layer) - self.assertIs(seq.layers[1], hidden_layer_1) - self.assertIs(seq.layers[2], output_layer) - - # Add hidden layer as first layer - with self.subTest(): - seq = Sequential() - with self.assertRaises(AssertionError): - seq.add(hidden_layer_1) - - # Add output layer as first layer - with self.subTest(): - seq = Sequential() - with self.assertRaises(AssertionError): - seq.add(output_layer) - - @defer_build() - def test_add_to_full(self): - input_layer = InputLayer(2, 2, 10, RBF(2)) - hidden_layer_1 = HiddenLayer(2, 2, 10, RBF(2)) - hidden_layer_2 = HiddenLayer(2, 2, 10, RBF(2)) - hidden_layer_3 = HiddenLayer(3, 2, 10, RBF(3)) - output_layer = OutputLayer(2, 2, 10, RBF(2)) - - - # Add hidden layer with correct dimensions - with self.subTest(): - layer_list = [input_layer, hidden_layer_1] - seq = Sequential(layer_list) - seq.add(hidden_layer_2) - self.assertIs(seq.layers[-1], hidden_layer_2) - - # Add hidden layer with incorrect dimensions - with self.subTest(): - layer_list = [input_layer, hidden_layer_1] - seq = Sequential(layer_list) - with self.assertRaises(AssertionError): - seq.add(hidden_layer_3) - - # Add output layer with correct dimensions - with self.subTest(): - layer_list = [input_layer, hidden_layer_1] - seq = Sequential(layer_list) - seq.add(output_layer) - self.assertIs(seq.layers[-1], output_layer) - - # Add hidden layer after output layer - with self.subTest(): - layer_list = [input_layer, output_layer] - seq = Sequential(layer_list) - with self.assertRaises(ValueError): - seq.add(hidden_layer_1) - - @defer_build() - def test_dims(self): - input_layer = InputLayer(2, 3, 10, RBF(2)) - hidden_layer_1 = HiddenLayer(3, 2, 10, RBF(2)) - hidden_layer_2 = HiddenLayer(2, 1, 10, RBF(2)) - hidden_layer_3 = HiddenLayer(1, 2, 10, RBF(3)) - output_layer = OutputLayer(2, 1, 10, RBF(2)) - - layer_list = [input_layer, hidden_layer_1, hidden_layer_2, - hidden_layer_3, output_layer] - seq = Sequential(layer_list) - dims = seq.get_dims() - reference = [(2,3), (3,2), (2,1), (1,2), (2,1)] - self.assertEqual(dims, reference) - - @defer_build() - def test_initialize_params(self): - input_layer = InputLayer(2, 2, 10, RBF(2)) - hidden_layer_1 = HiddenLayer(2, 2, 10, RBF(2)) - output_layer = OutputLayer(2, 1, 10, RBF(2)) - - Z = np.ones((10, 2)) - X = np.ones((100, 2)) - - seq = Sequential([input_layer, hidden_layer_1, output_layer]) - seq.initialize_params(X, Z) - - self.assertTrue(np.allclose(Z, seq.layers[0].feature.Z.value)) - - -class MultitaskSequentialTest(unittest.TestCase): - @defer_build() - def test_initialize_params(self): - rng = np.random.RandomState(42) - - input_layer = InputLayer(2, 2, 10, RBF(2), multitask=True) - hidden_layer_1 = HiddenLayer(2, 2, 10, RBF(2), multitask=True) - output_layer = OutputLayer(2, 1, 10, RBF(2), multitask=True) - - Z = np.ones((10, 2)) - X = np.ones((100, 2)) - - Z_ind = rng.randint(0, 2, (10,1)) - X_ind = rng.randint(0, 2, (100,1)) - - Z = np.hstack([Z, Z_ind]) - X = np.hstack([X, X_ind]) - - seq = MultitaskSequential([input_layer, hidden_layer_1, output_layer]) - seq.initialize_params(X, Z) - - for l in seq.layers: - self.assertTrue(np.allclose(Z_ind, l.feature.Z.value[:, -1:])) - -if __name__=="__main__": - unittest.main() + + +class Datum: + num_inducing = 10 + num_data = 100 + dim = 2 + + Z = np.ones((num_inducing, dim)) + X = np.ones((num_data, dim)) + + +def create_layer_utility(input_dim, output_dim): + """ + Utility function to create layer object. + """ + kernel = gpflow.kernels.mo_kernels.SharedIndependentMok( + RBF(variance=1.0, lengthscale=1.0), output_dimensionality=output_dim + ) + layer = Layer(input_dim=input_dim, output_dim=output_dim, kernel=kernel, num_inducing=Datum.num_inducing) + return layer + + +def test_add_to_empty(): + """ + Tests initializing the sequential cascade structure with an empty list of layers. + """ + input_layer = create_layer_utility(2, 2) + hidden_layer_1 = create_layer_utility(2, 2) + output_layer = create_layer_utility(2, 1) + + # Add input layer only + seq = Sequential() + + seq.add(input_layer) + assert seq.constituents[-1] is input_layer + + seq.add(hidden_layer_1) + assert seq.constituents[-1] is hidden_layer_1 + + seq.add(output_layer) + assert seq.constituents[-1] is output_layer + + +def test_add_to_full(): + """ + Tests adding additional layers to a a sequential cascade structure. + """ + input_layer = create_layer_utility(2, 2) + hidden_layer_1 = create_layer_utility(2, 2) + hidden_layer_2 = create_layer_utility(2, 2) + hidden_layer_3 = create_layer_utility(3, 2) + + # Add hidden layer with correct dimensions + layer_list = [input_layer, hidden_layer_1] + seq = Sequential(layer_list) + seq.add(hidden_layer_2) + assert seq.constituents[-1] is hidden_layer_2 + + # Add hidden layer with incorrect dimensions + layer_list = [input_layer, hidden_layer_1] + seq = Sequential(layer_list) + with pytest.raises(AssertionError): + seq.add(hidden_layer_3) + + +def test_dims(): + """ + Tests the get_dim utility. + """ + input_layer = create_layer_utility(2, 3) + hidden_layer_1 = create_layer_utility(3, 2) + hidden_layer_2 = create_layer_utility(2, 1) + hidden_layer_3 = create_layer_utility(1, 2) + output_layer = create_layer_utility(2, 1) + + layer_list = [input_layer, hidden_layer_1, hidden_layer_2, + hidden_layer_3, output_layer] + seq = Sequential(layer_list) + dims = seq.get_dims() + reference = [(2, 3), (3, 2), (2, 1), (1, 2), (2, 1)] + assert dims == reference + + +def test_initialize_params(): + """ + Tests the Layer initialization utility. + """ + input_layer = create_layer_utility(2, 2) + hidden_layer_1 = create_layer_utility(2, 2) + output_layer = create_layer_utility(2, 1) + + seq = Sequential([input_layer, hidden_layer_1, output_layer]) + seq.initialize_params(Datum.X, Datum.Z) + + np.testing.assert_allclose(Datum.Z, seq.constituents[0].feature.features[0].Z.numpy()) + From 5d455d595d6f28e0e2595fc77bfe9e0ea9cf7994 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Wed, 24 Jul 2019 21:56:19 +0100 Subject: [PATCH 05/17] updated and tested switched kernel --- dgplib/specialized_kernels.py | 69 +++++++--------- tests/test_specialized_kernels.py | 127 ++++++++++++++---------------- 2 files changed, 89 insertions(+), 107 deletions(-) diff --git a/dgplib/specialized_kernels.py b/dgplib/specialized_kernels.py index 4bd0e11..b4a206a 100644 --- a/dgplib/specialized_kernels.py +++ b/dgplib/specialized_kernels.py @@ -1,72 +1,61 @@ -from __future__ import absolute_import - import tensorflow as tf -from gpflow import settings - -from gpflow.decors import params_as_tensors from gpflow.kernels import Combination -from gpflow.params import Parameter + class SwitchedKernel(Combination): """ This calculates different kernels based on the index in the last column of X. """ - def __init__(self, kern_list, output_dim, name=None): - super(SwitchedKernel, self).__init__(kernels=kern_list, - name=name) + def __init__(self, kernels, output_dim, name=None): + super().__init__(kernels=kernels, name=name) self.output_dim = output_dim self.num_kernels = len(self.kernels) - assert self.output_dim==self.num_kernels + assert self.output_dim == self.num_kernels - @params_as_tensors - def K(self, X, X2=None, presliced=False): - if X2 is None: - X2 = X + def K(self, X, Y=None, presliced=False): + if Y is None: + Y = X - ind_X = X[:,-1] - ind_X = tf.cast(ind_X, tf.int32) + idx_X = X[:, -1] + idx_X = tf.cast(idx_X, tf.int32) - ind_X2 = X2[:,-1] - ind_X2 = tf.cast(ind_X2, tf.int32) + idx_Y = Y[:, -1] + idx_Y = tf.cast(idx_Y, tf.int32) - X = X[:,:-1] - X2 = X2[:,:-1] + X = X[:, :-1] + Y = Y[:, :-1] if not presliced: - X, X2 = self._slice(X, X2) + X, Y = self.slice(X, Y) - ind_X_parts = tf.dynamic_partition(tf.range(0, tf.size(ind_X)), - ind_X, self.output_dim) - ind_X2_parts = tf.dynamic_partition(tf.range(0, tf.size(ind_X2)), - ind_X2, self.output_dim) + idx_X_parts = tf.dynamic_partition(tf.range(0, tf.size(idx_X)), idx_X, self.output_dim) + idx_Y_parts = tf.dynamic_partition(tf.range(0, tf.size(idx_Y)), idx_Y, self.output_dim) Ks = [] - for k, p, p2 in zip(self.kernels, ind_X_parts, ind_X2_parts): - gram = k.K(tf.gather(X, p), tf.gather(X2, p2)) + for k, p, p2 in zip(self.kernels, idx_X_parts, idx_Y_parts): + gram = k.K(tf.gather(X, p), tf.gather(Y, p2)) Ks.append(gram) N = tf.shape(X)[0] - N2 = tf.shape(X2)[0] + N2 = tf.shape(Y)[0] Ks_scattered = [] - for gram, p, p2 in zip(Ks, ind_X_parts, ind_X2_parts): + for gram, p, p2 in zip(Ks, idx_X_parts, idx_Y_parts): p2 = p2[:,None] shape = tf.stack([N2, tf.shape(p)[0]]) - scattered = tf.transpose(tf.scatter_nd(p2, tf.transpose(gram), - shape)) + scattered = tf.transpose(tf.scatter_nd(p2, tf.transpose(gram), shape)) Ks_scattered.append(scattered) - return tf.dynamic_stitch(ind_X_parts, Ks_scattered) + return tf.dynamic_stitch(idx_X_parts, Ks_scattered) + + def K_diag(self, X, presliced=False): + idx_X = X[:, -1] + idx_X = tf.cast(idx_X, tf.int32) + X = X[:, :-1] - @params_as_tensors - def Kdiag(self, X, prescliced=False): - ind_X = X[:,-1] - ind_X = tf.cast(ind_X, tf.int32) - X = X[:,:-1] + ind_X_parts = tf.dynamic_partition(tf.range(0, tf.size(idx_X)), idx_X, self.output_dim) - ind_X_parts = tf.dynamic_partition(tf.range(0, tf.size(ind_X)), - ind_X, self.output_dim) + Ks = [k.K_diag(tf.gather(X, p)) for k, p in zip(self.kernels, ind_X_parts)] - Ks = [k.Kdiag(tf.gather(X, p)) for k, p in zip(self.kernels, ind_X_parts)] return tf.dynamic_stitch(ind_X_parts, Ks) diff --git a/tests/test_specialized_kernels.py b/tests/test_specialized_kernels.py index 0b7a353..b08638f 100644 --- a/tests/test_specialized_kernels.py +++ b/tests/test_specialized_kernels.py @@ -1,81 +1,74 @@ -import gpflow -import unittest +import pytest import numpy as np import tensorflow as tf from dgplib.specialized_kernels import SwitchedKernel -from gpflow.decors import params_as_tensors, defer_build -from gpflow.kernels import Kernel, RBF -from gpflow.params import Parameter -from gpflow.test_util import GPflowTestCase +import gpflow +from gpflow.kernels import Kernel +from gpflow.base import Parameter + + +rng = np.random.RandomState(42) + class DummyKernel(Kernel): - def __init__(self, input_dim, val, active_dims=None, name=None): - super(DummyKernel, self).__init__(input_dim, active_dims, name) + def __init__(self, val, active_dims=None, name=None): + super().__init__(active_dims, name) self.val = Parameter(val, dtype=np.float32) - @params_as_tensors - def K(self, X, X2=None): - if X2 is None: - X2 = X - return self.val * tf.ones((tf.shape(X)[0], tf.shape(X2)[0])) + def K(self, X, Y=None, presliced=False): + if Y is None: + Y = X + return self.val * tf.ones((tf.shape(X)[0], tf.shape(Y)[0])) - @params_as_tensors - def Kdiag(self, X): + def K_diag(self, X, presliced=False): return self.val * tf.ones((tf.shape(X)[0], 1)) -class SwitchedKernelTest(GPflowTestCase): - def setUp(self): - self.test_graph = tf.Graph() - self.rng = np.random.RandomState(42) - - self.X1_ind = np.array([0,1,2,2,1,0,1,0,2,1])[:,None] - self.X1 = np.hstack([np.random.randn(10, 3), - self.X1_ind]).astype(gpflow.settings.float_type) - - self.X2_ind = np.array([0,1,2,2,1])[:,None] - self.X2 = np.hstack([np.random.randn(5, 3), - self.X2_ind]).astype(gpflow.settings.float_type) - - with defer_build(): - K1 = DummyKernel(3, 1.0) - K2 = DummyKernel(3, 2.0) - K3 = DummyKernel(3, 3.0) - kern_list = [K1, K2, K3] - self.kernel = SwitchedKernel(kern_list, 3) - - def test_K(self): - reference = np.array([[1, 0, 0, 0, 0], - [0, 2, 0, 0, 2], - [0, 0, 3, 3, 0], - [0, 0, 3, 3, 0], - [0, 2, 0, 0, 2], - [1, 0, 0, 0, 0], - [0, 2, 0, 0, 2], - [1, 0, 0, 0, 0], - [0, 0, 3, 3, 0], - [0, 2, 0, 0, 2]]) - - with self.test_context() as session: - X1 = tf.placeholder(gpflow.settings.float_type) - X2 = tf.placeholder(gpflow.settings.float_type) - - self.kernel.compile() - gram_matrix = session.run(self.kernel.K(X1, X2), feed_dict={X1:self.X1, - X2:self.X2}) - self.assertTrue(np.allclose(gram_matrix, reference)) - - - def test_Kdiag(self): - with self.test_context() as session: - X1 = tf.placeholder(gpflow.settings.float_type) - - self.kernel.compile() - gram_matrix = session.run(self.kernel.Kdiag(X1), feed_dict={X1:self.X1}) - self.assertTrue(np.allclose(gram_matrix, self.X1[:,-1:]+1)) - -if __name__=='__main__': - unittest.main() +@pytest.fixture +def X1(): + X1_ind = np.array([0, 1, 2, 2, 1, 0, 1, 0, 2, 1])[:, None] + X1 = np.hstack([rng.randn(10, 3), X1_ind]).astype(gpflow.default_float()) + return X1 + + +@pytest.fixture +def X2(): + X2_ind = np.array([0, 1, 2, 2, 1])[:, None] + X2 = np.hstack([rng.randn(5, 3), X2_ind]).astype(gpflow.default_float()) + return X2 + + +@pytest.fixture +def kernel(): + K1 = DummyKernel(1.0) + K2 = DummyKernel(2.0) + K3 = DummyKernel(3.0) + kern_list = [K1, K2, K3] + kernel = SwitchedKernel(kern_list, 3) + return kernel + + +def test_K(kernel, X1, X2): + reference = np.array([ + [1, 0, 0, 0, 0], + [0, 2, 0, 0, 2], + [0, 0, 3, 3, 0], + [0, 0, 3, 3, 0], + [0, 2, 0, 0, 2], + [1, 0, 0, 0, 0], + [0, 2, 0, 0, 2], + [1, 0, 0, 0, 0], + [0, 0, 3, 3, 0], + [0, 2, 0, 0, 2] + ]) + + gram_matrix = kernel.K(X1, X2) + np.testing.assert_allclose(gram_matrix, reference) + + +def test_Kdiag(kernel, X1): + gram_matrix = kernel.K_diag(X1) + np.testing.assert_allclose(gram_matrix, X1[:, -1:] + 1) From 74199955d8e83e215786058e9854cba7efcb5eef Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Thu, 25 Jul 2019 17:45:59 +0100 Subject: [PATCH 06/17] updated DSDGP and added multitask funcitonality --- TODO.md | 3 +- dgplib/dsdgp.py | 264 +++++++++++--------------- dgplib/layers.py | 5 +- dgplib/multitask_dsdgp.py | 26 --- dgplib/weighted_multikernel_layers.py | 169 ----------------- tests/__init__.py | 3 + tests/test_dsdgp.py | 261 ++++++++++++------------- tests/test_layer.py | 14 ++ tests/test_multitask_dsdgp.py | 176 ----------------- 9 files changed, 254 insertions(+), 667 deletions(-) delete mode 100644 dgplib/multitask_dsdgp.py delete mode 100644 dgplib/weighted_multikernel_layers.py delete mode 100644 tests/test_multitask_dsdgp.py diff --git a/TODO.md b/TODO.md index baca709..8a72595 100644 --- a/TODO.md +++ b/TODO.md @@ -1,2 +1,3 @@ # TODO -* Create utilities for dealing with features and kernels \ No newline at end of file +* Create utilities for dealing with features and kernels +* Multikernel layers: additive and concatenated \ No newline at end of file diff --git a/dgplib/dsdgp.py b/dgplib/dsdgp.py index 6cfe0a6..29b82af 100644 --- a/dgplib/dsdgp.py +++ b/dgplib/dsdgp.py @@ -1,15 +1,13 @@ import tensorflow as tf -from gpflow import settings - -from gpflow.decors import autoflow, defer_build, params_as_tensors from gpflow.mean_functions import Zero -from gpflow.models import Model -from gpflow.params import DataHolder, Minibatch +from gpflow.models import GPModel + +from .layers import Layer +from .cascade import Sequential -from .utils import normal_sample, tile_over_samples -class DSDGP(Model): +class DSDGP(GPModel): """ Doubly Stochastic Deep Gaussian Process Model. @@ -28,179 +26,143 @@ class DSDGP(Model): {http://papers.nips.cc/paper/7045-doubly-stochastic-variational-inference-for-deep-gaussian-processes.pdf} } """ - @defer_build() - def __init__(self, X, Y, Z, layers, likelihood, - num_latent=None, - minibatch_size=None, - num_samples=1, - mean_function=Zero(), - name=None): - """ - - X is a data matrix, size N x D. - - Y is a data matrix, size N x R. - - Z is a matrix of inducing inputs, size M x D. - - layers is an instance of Sequential containing the layer structure of - the DGP. - - likelihood is an instance of the gpflow likehood object. - - num_latent_Y is the number of latent processes to use. - - minibatch_size, if not None turns of minibatching with that size. - - num_samples is the number of Monte Carlo samples to use. - - mean_function is an instance of the gpflow mean_function object, - corresponds to the mean function of the final layer. - - name is the name of the TensforFlow object. - """ - - super(DSDGP, self).__init__(name=name) - - assert X.shape[0] == Y.shape[0] - assert Z.shape[1] == X.shape[1] - - self.num_data, D_X = X.shape - self.num_samples = num_samples - self.D_Y = num_latent or Y.shape[1] - - self.mean_function = mean_function - - layers.initialize_params(X, Z)#Maybe add initialization method for model - if layers._initialized == True: - self.layers = layers - else: - raise ValueError("Layers were not initialized") + def __init__(self, likelihood, Z, layers=None, kernels=None, dims=None, + num_latent=None, num_data=None, multitask=False): + """ + :param likelihood: GPflow likelihood object + :param Z: Initial value of inducing inputs + :param layers: list of Layer objects + :param kernels: list of kernel objects (cannot be used if layers are specified) + :param dims: list of tuples for layer dims to be used when kernels are specified + :param num_latent: latent dimension of final layer + :param num_data: number of data + :param multitask: True if multitask model is required (propagates task labels) + """ + if kernels is not None: + assert len(dims) == len(kernels) + 1 + assert layers is None, "Cannot initialise with kernels and layers simultaneously" + layers = Sequential() + for i, kernel in enumerate(kernels): + fix_linear_mf = False if i == len(kernels) - 1 else True + layer = Layer( + input_dim=dims[i], + output_dim=dims[i+1], + kernel=kernel, + share_Z=False, + fixed_linear_mean_function=fix_linear_mf + ) + layers.add(layer) + + super().__init__( + kernel=None, + likelihood=likelihood, + mean_function=None, + num_latent=num_latent + ) + + # Kernels and mean functions are handled by layers + del self.kernel + del self.mean_function + + self.num_data = num_data + + self.initial_Z = Z + self.layers = layers self.dims = self.layers.get_dims() + self._multitask = multitask - self.likelihood = likelihood + @property + def initialized(self): + return self.layers.initialized - if minibatch_size is None: - X = DataHolder(X) - Y = DataHolder(Y) - else: - X = Minibatch(X, batch_size=minibatch_size, seed=0) - Y = Minibatch(Y, batch_size=minibatch_size, seed=0) + @property + def multitask(self): + return self._multitask - self.X, self.Y = X, Y + def initialize_layers_from_data(self, X): + self.layers.initialize_params(X, self.initial_Z) - #Credits to Hugh Salimbeni - @params_as_tensors - def _propagate(self, Xnew, full_cov=False, num_samples=1): + def _propagate(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): """ Propagate points Xnew through DGP cascade. """ - Fs = [tile_over_samples(Xnew, num_samples), ] - Fmeans, Fvars = [], [] - for layer in self.layers.layers: - mean, var = layer._build_predict(Fs[-1], full_cov, stochastic=True) - F = normal_sample(mean, var, full_cov=full_cov) - - Fs.append(F) - Fmeans.append(mean) - Fvars.append(var) + if not self.initialized: + raise ValueError("Must initialize before calling this method") - return Fs[1:], Fmeans, Fvars - - @params_as_tensors - def _build_predict(self, Xnew, full_cov=False, num_samples=1): - Fs, Fmeans, Fvars = self._propagate(Xnew, full_cov, num_samples) - return Fmeans[-1], Fvars[-1] - - #Credits to Hugh Salimbeni - @params_as_tensors - def _build_likelihood(self): - """ - Gives variational bound on the model likelihood. - """ + F_samples = [tf.stack([Xnew] * num_samples)] + F_mus, F_vars = [], [] + for layer in self.layers.constituents: + f_samples, f_mus, f_vars = [], [], [] + for s in range(num_samples): + f_sample, f_mu, f_var = layer.predict_f_samples(F_samples[-1][s, ...], full_cov=full_cov, + full_output_cov=full_output_cov, num_samples=1) - Fmean, Fvar = self._build_predict(self.X, full_cov=False, num_samples=self.num_samples) + if self.multitask: + f_sample = tf.concat([f_sample, Xnew[None, :, -1:]], axis=-1) - Y = tile_over_samples(self.Y, self.num_samples) + f_samples.append(f_sample) + f_mus.append(f_mu) + f_vars.append(f_var) - f = lambda a: self.likelihood.variational_expectations(a[0], a[1], a[2]) - var_exp = tf.map_fn(f, (Fmean, Fvar, Y), dtype=settings.float_type) - var_exp = tf.stack(var_exp) #SN + F_samples.append(tf.concat(f_samples, axis=0)) + F_mus.append(tf.stack(f_mus)) + F_vars.append(tf.stack(f_vars)) - var_exp = tf.reduce_mean(var_exp, 0) # S,N -> N. Average over samples - L = tf.reduce_sum(var_exp) # N -> scalar. Sum over data (minibatch) + return F_samples[1:], F_mus, F_vars - KL = 0. - for layer in self.layers.layers: - KL += layer.build_prior_KL(K=None) - - scale = tf.cast(self.num_data, settings.float_type) - scale /= tf.cast(tf.shape(self.X)[0], settings.float_type) # minibatch size - return L * scale - KL - - #Credits to gpflow dev team - @autoflow((settings.float_type, [None, None]), (tf.int32, [])) - def predict_f(self, Xnew, num_samples): + def predict_all_layers(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): """ - Compute the mean and variance of the latent function(s) for the final - layer at the points Xnew. + Predicts and produces posterior samples from all layers """ - return self._build_predict(Xnew, full_cov=False, num_samples=num_samples) + Fs, Fmeans, Fvars = self._propagate(Xnew, full_cov, full_output_cov, num_samples) + return Fs, Fmeans, Fvars - #Credits to gpflow dev team - @autoflow((settings.float_type, [None, None]), (tf.int32, [])) - def predict_f_full_cov(self, Xnew, num_samples): + def predict_f(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): """ - Compute the mean and covariance matrix of the latent function(s) for - the final layer at the points Xnew. + Returns the posterior for the final layer """ - return self._build_predict(Xnew, full_cov=True, num_samples=num_samples) - + Fs, Fmeans, Fvars = self.predict_all_layers(Xnew, full_cov, full_output_cov, num_samples) + return Fmeans[-1], Fvars[-1] - #Credits to Hugh Salimbeni - @autoflow((settings.float_type, [None, None]), (tf.int32, [])) - def predict_all_layers(self, Xnew, num_samples): + def predict_f_samples(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): """ - Compute the mean and variance of the latent function(s) for for all - layers at the points Xnew. + Produces posterior samples from the final layer """ - return self._propagate(Xnew, full_cov=False, num_samples=num_samples) + Fs, Fmeans, Fvars = self.predict_all_layers(Xnew, full_cov, full_output_cov, num_samples) + return Fs[-1] - #Credits to Hugh Salimbeni - @autoflow((settings.float_type, [None, None]), (tf.int32, [])) - def predict_all_layers_full_cov(self, Xnew, num_samples): + def prior_kl(self): """ - Compute the mean and covariance matrix of the latent function(s) for - all layers at the points Xnew. + KL(q(u)||p(u)) """ - return self._propagate(Xnew, full_cov=True, num_samples=num_samples) + return tf.reduce_sum([l.prior_kl() for l in self.layers.constituents]) - #Credits to gpflow dev team - @autoflow((settings.float_type, [None, None]), (tf.int32, [])) - def predict_f_samples(self, Xnew, num_samples): + def log_likelihood(self, X: tf.Tensor, Y:tf. Tensor, num_samples: int = 1) -> tf.Tensor: """ - Produce samples from the posterior latent function(s) for the final - layer at the points Xnew. + Evaluates bound on the log marginal likelihood """ - mu, var = self._build_predict(Xnew, full_cov=True, num_samples=1) - mu, var = mu[0,:,:], var[0,:,:] - jitter = tf.eye(tf.shape(mu)[0], dtype=settings.float_type) * settings.numerics.jitter_level - samples = [] - for i in range(self.D_Y): - L = tf.cholesky(var[:, :, i] + jitter) - shape = tf.stack([tf.shape(L)[0], num_samples]) - V = tf.random_normal(shape, dtype=settings.float_type) - samples.append(mu[:, i:i + 1] + tf.matmul(L, V)) - return tf.transpose(tf.stack(samples)) + f_mean, f_var = self.predict_f(X, full_cov=False, full_output_cov=False, + num_samples=num_samples) # SxNxD, SXNxD - #Credits to gpflow dev team - @autoflow((settings.float_type, [None, None])) - def predict_y(self, Xnew): + var_exp = [ + self.likelihood.variational_expectations(f_mean[s, :, :], f_var[s, :, :], Y) for s in range(num_samples) + ] + var_exp = tf.reduce_mean(tf.stack(var_exp), axis=0) + assert var_exp.numpy().shape == (X.shape[0], 1) + if self.num_data is not None: + num_data = tf.cast(self.num_data, var_exp.dtype) + minibatch_size = tf.cast(tf.shape(X)[0], var_exp.dtype) + scale = num_data / minibatch_size + else: + scale = tf.cast(1.0, var_exp.dtype) + + var_exp = var_exp * scale + + return tf.reduce_sum(var_exp) - self.prior_kl() + + def elbo(self, X: tf.Tensor, Y: tf.Tensor, num_samples: int = 1) -> tf.Tensor: """ - Compute the mean and variance of held-out data at the points Xnew + This returns the evidence lower bound (ELBO) of the log marginal likelihood. """ - pred_f_mean, pred_f_var = self._build_predict(Xnew) - return self.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) - - #Credits to gpflow dev team - # @autoflow((settings.float_type, [None, None]), (settings.float_type, [None, None])) - # def predict_density(self, Xnew, Ynew): - # """ - # Compute the (log) density of the data Ynew at the points Xnew - # Note that this computes the log density of the data individually, - # ignoring correlations between them. The result is a matrix the same - # shape as Ynew containing the log densities. - # """ - # pred_f_mean, pred_f_var = self._build_predict(Xnew) - # return self.likelihood.predict_density(pred_f_mean, pred_f_var, Ynew) + return -self.neg_log_marginal_likelihood(X, Y, num_samples) diff --git a/dgplib/layers.py b/dgplib/layers.py index 6907997..d501141 100644 --- a/dgplib/layers.py +++ b/dgplib/layers.py @@ -183,10 +183,13 @@ def propagate_inputs_and_features(self, X, Z): :param Z: inducing inputs """ W = find_linear_mf_weights(self.input_dim, self.output_dim, X) - Z_running = Z.copy().dot(W) X_running = X.copy().dot(W) + if X.shape[1] - self.input_dim == 1: + Z_running[:, -1] = Z[:, -1] + X_running[:, -1] = X[:, -1] + return X_running, Z_running, W def initialize_features(self, Z): diff --git a/dgplib/multitask_dsdgp.py b/dgplib/multitask_dsdgp.py deleted file mode 100644 index 6223c61..0000000 --- a/dgplib/multitask_dsdgp.py +++ /dev/null @@ -1,26 +0,0 @@ -import tensorflow as tf - -from gpflow.decors import autoflow, defer_build, params_as_tensors - -from .dsdgp import DSDGP -from .utils import normal_sample, tile_over_samples - -class MultitaskDSDGP(DSDGP): - @params_as_tensors - def _propagate(self, Xnew, full_cov=False, num_samples=1): - """ - Propagate points Xnew through DGP cascade. - """ - Fs = [tile_over_samples(Xnew, num_samples), ] - Fmeans, Fvars = [], [] - for layer in self.layers.layers: - mean, var = layer._build_predict(Fs[-1], full_cov, stochastic=True) - F = normal_sample(mean, var, full_cov=full_cov) - #propagation of task labels - F = tf.concat([F, Fs[-1][:,:,-1:]], axis=-1) - - Fs.append(F) - Fmeans.append(mean) - Fvars.append(var) - - return Fs[1:], Fmeans, Fvars diff --git a/dgplib/weighted_multikernel_layers.py b/dgplib/weighted_multikernel_layers.py deleted file mode 100644 index 4f5f27b..0000000 --- a/dgplib/weighted_multikernel_layers.py +++ /dev/null @@ -1,169 +0,0 @@ -from __future__ import print_function, absolute_import - -import tensorflow as tf -import numpy as np - -from gpflow import settings - -from gpflow.conditionals import conditional -from gpflow.decors import params_as_tensors, autoflow, defer_build -from gpflow.features import inducingpoint_wrapper -from gpflow.kullback_leiblers import gauss_kl -from gpflow.mean_functions import Linear, Zero -from gpflow.params import Parameter, Parameterized, ParamList - -from .layers import Layer -from .layers import InputMixin, HiddenMixin, OutputMixin - -class MultikernelLayer(Layer): - """ - Inherits from Layer class. Can handle outputs from different priors. - """ - - @defer_build() - def __init__(self, input_dim, output_dim, num_inducing, kernel_list, - share_Z=False, mean_function=None, multitask=False, name=None): - - if output_dim%len(kernel_list) != 0: - raise ValueError("Output dimension must be a multiple of the number of kernels") - - super(MultikernelLayer, self).__init__(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel=kernel_list, - mean_function=mean_function, - multitask=multitask, - name=name) - - self.num_kernels = len(kernel_list) - self._shared_Z = share_Z - self.offset = int(self.output_dim/self.num_kernels) - - if not self._shared_Z: - del self.feature - if multitask: - Z = np.zeros((self.num_inducing, self.input_dim+1)) - else: - Z = np.zeros((self.num_inducing, self.input_dim)) - - self.feature = ParamList([inducingpoint_wrapper(None, Z.copy()) for _ in range(self.num_kernels)]) - - - @params_as_tensors - def build_prior_KL(self, K): - if K: - KL = 0. - for i, k in enumerate(K): - KL += gauss_kl_white(self.q_mu[:,(i*self.offset):((i+1)*self.offset)], - self.q_sqrt[(i*self.offset):((i+1)*self.offset),:,:], - K=k - ) - return KL - else: - return gauss_kl(self.q_mu, self.q_sqrt, K=K) - - @params_as_tensors - def _build_predict(self, Xnew, full_cov=False, stochastic=True): - def f_conditional(Xnew, full_cov=False): - mean = [] - var = [] - if self._shared_Z: - feats = [self.feature for _ in range(self.num_kernels)] - else: - feats = [feat for feat in self.feature] - for i, (k, feat) in enumerate(zip(self.kernel, feats)): - m, v = conditional(Xnew, feat, k, self.q_mu[:,(i*self.offset):((i+1)*self.offset)], - q_sqrt=self.q_sqrt[(i*self.offset):((i+1)*self.offset),:,:,], - full_cov=full_cov, - white=True) - mean.append(m) - - #temporary fix - if full_cov: - var.append(tf.transpose(v)) - else: - var.append(v) - - mean = tf.concat(mean, axis=-1) #NxK - var = tf.concat(var, axis=-1) #NxK or NxNxK - - return mean + self.mean_function(Xnew), var - - def multisample_conditional(Xnew, full_cov=False): - if full_cov: - f = lambda a: f_conditional(a, full_cov=full_cov) - mean, var = tf.map_fn(f, Xnew, dtype=(settings.tf_float, - settings.tf_float)) - return tf.stack(mean), tf.stack(var) - else: - #S, N, D = shape_as_list(Xnew) - s = tf.shape(Xnew) - X_flat = tf.reshape(Xnew, [s[0]*s[1], s[2]]) - mean, var = f_conditional(X_flat) - return [tf.reshape(m, [s[0], s[1], -1]) for m in [mean, var]] - - if stochastic: - mean, var = multisample_conditional(Xnew, full_cov) - else: - mean, var = f_conditional(Xnew, full_cov) - - return mean, var - -class MultikernelInputLayer(MultikernelLayer, InputMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): - """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward - """ - if self._shared_Z: - self.feature.Z.assign(Z) - else: - for feat in self.feature: - feat.Z.assign(Z) - - X_running, Z_running, W = self.compute_inputs(X, Z, multitask) - - if isinstance(self.mean_function, Linear): - self.mean_function.A = W - self.mean_function.set_trainable(False) - - return X_running, Z_running - - -class MultikernelHiddenLayer(MultikernelLayer, HiddenMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): - """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward - """ - if self._shared_Z: - self.feature.Z.assign(Z) - else: - for feat in self.feature: - feat.Z.assign(Z) - - X_running, Z_running, W = self.compute_inputs(X, Z, multitask) - - if isinstance(self.mean_function, Linear): - self.mean_function.A =W - self.mean_function.set_trainable(False) - - return X_running, Z_running - -class MultikernelOutputLayer(MultikernelLayer, OutputMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): - """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward - """ - - if self._shared_Z: - self.feature.Z.assign(Z) - else: - for feat in self.feature: - feat.Z.assign(Z) - - return (None, None) diff --git a/tests/__init__.py b/tests/__init__.py index 494ae1a..30e9a2e 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,3 +1,6 @@ +import gpflow +import numpy as np import warnings +gpflow.config.set_default_float(np.float64) warnings.filterwarnings('ignore') diff --git a/tests/test_dsdgp.py b/tests/test_dsdgp.py index 7191f22..72924ba 100644 --- a/tests/test_dsdgp.py +++ b/tests/test_dsdgp.py @@ -1,151 +1,126 @@ -import unittest +import pytest import numpy as np -import gpflow -from dgplib.layers import InputLayer, OutputLayer +from dgplib.layers import Layer from dgplib.cascade import Sequential from dgplib import DSDGP -from gpflow.decors import defer_build, name_scope -from gpflow.kernels import RBF, White +import gpflow +from gpflow.kernels import RBF from gpflow.likelihoods import Gaussian -from gpflow.mean_functions import Linear - -class TestDSDGP(unittest.TestCase): - def setUp(self): - self.rng = np.random.RandomState(42) - - self.Ns = 300 - #self.Xs = np.linspace(-0.5, 1.5, Ns)[:, None] - - self.N, self.M = 50, 25 - self.X = self.rng.uniform(0, 1, self.N)[:, None] - self.Z = self.rng.uniform(0, 1, self.M)[:, None] - f_step = lambda x: 0. if x<0.5 else 1. - - self.Y = np.reshape([f_step(x) for x in self.X], self.X.shape) \ - + self.rng.randn(*self.X.shape)*1e-2 - - def test_contructor(self): - input_layer = InputLayer(input_dim=1, output_dim=1, - num_inducing=self.M, kernel=RBF(1)+White(1)) - output_layer = OutputLayer(input_dim=1, output_dim=1, - num_inducing=self.M, kernel=RBF(1)+White(1)) - - seq = Sequential([input_layer, output_layer]) - - try: - model = DSDGP(X=self.X, Y=self.Y, Z=self.Z, layers=seq, likelihood=Gaussian()) - except Exception as e: - print(e) - self.fail('DSDGP contructor fails') - - @name_scope('dsdgp_optimizer') - def test_optimize(self): - with defer_build(): - input_layer = InputLayer(input_dim=1, output_dim=1, - num_inducing=self.M, kernel=RBF(1)+White(1)) - output_layer = OutputLayer(input_dim=1, output_dim=1, - num_inducing=self.M, kernel=RBF(1)+White(1)) - - seq = Sequential([input_layer, output_layer]) - - model = DSDGP(X=self.X, Y=self.Y, Z=self.Z, layers=seq, likelihood=Gaussian()) - model.compile() - before = model.compute_log_likelihood() - opt = gpflow.train.AdamOptimizer(0.01) - opt.minimize(model, maxiter=100) - after = model.compute_log_likelihood() - self.assertGreaterEqual(after, before) - -class TestMethods(unittest.TestCase): - def prepare(self): - N = 100 - M = 10 - rng = np.random.RandomState(42) - X = rng.randn(N, 2) - Y = rng.randn(N, 1) - Z = rng.randn(M, 2) - Xs = rng.randn(M, 2) - lik = Gaussian() - input_layer = InputLayer(input_dim=2, output_dim=1, - num_inducing=M, kernel=RBF(2)+White(2), - mean_function=Linear(A=np.ones((2,1)))) - output_layer = OutputLayer(input_dim=1, output_dim=1, - num_inducing=M, kernel=RBF(1)+White(1)) - - seq = Sequential([input_layer, output_layer]) - - model = DSDGP(X=X, Y=Y, Z=Z, layers=seq, likelihood=lik) - model.compile() - return model, Xs - - def test_build(self): - model, _ = self.prepare() - self.assertEqual(model.is_built_coherence(), gpflow.Build.YES) - - def test_predict_f(self): - model, Xs = self.prepare() - mu, sigma = model.predict_f(Xs, 1) - with self.subTest(): - self.assertEqual(mu.shape, sigma.shape) - with self.subTest(): - self.assertEqual(mu.shape, (1, 10, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(sigma, -1e-6), sigma) - - def test_predict_f_full_cov(self): - model, Xs = self.prepare() - mu, sigma = model.predict_f_full_cov(Xs, 1) - with self.subTest(): - self.assertEqual(mu.shape, (1, 10, 1)) - with self.subTest(): - self.assertEqual(sigma.shape, (1, 10, 10, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(sigma, -1e-6), sigma) - - def test_predict_all_layers(self): - model, Xs = self.prepare() - fs, fmeans, fvars = model.predict_all_layers(Xs, 1) - dims = [1, 1] - for f, m, v, i in zip(fs, fmeans, fvars, dims): - with self.subTest(): - self.assertEqual(m.shape, f.shape) - with self.subTest(): - self.assertEqual(m.shape, v.shape) - with self.subTest(): - self.assertEqual(m.shape, (1, 10, i)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(v, -1e-6), v) - - def test_predict_all_layers_full_cov(self): - model, Xs = self.prepare() - fs, fmeans, fvars = model.predict_all_layers_full_cov(Xs, 1) - dims = [1, 1] - for f, m, v, i in zip(fs, fmeans, fvars, dims): - with self.subTest(): - self.assertEqual(f.shape, (1, 10, i)) - with self.subTest(): - self.assertEqual(m.shape, (1, 10, i)) - with self.subTest(): - self.assertEqual(v.shape, (1, 10, 10, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(v, -1e-6), v) - - def test_predict_f_samples(self): - model, Xs = self.prepare() - fs = model.predict_f_samples(Xs, 10) - with self.subTest(): - self.assertEqual(fs.shape, (10, 10, 1)) - - def test_predict_y(self): - model, Xs = self.prepare() - mu, sigma = model.predict_y(Xs) - with self.subTest(): - self.assertEqual(mu.shape, sigma.shape) - with self.subTest(): - self.assertEqual(mu.shape, (1, 10, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(sigma, -1e-6), sigma) + + +rng = np.random.RandomState(42) + + +class Datum: + num_data = 100 + num_inducing = 10 + num_samples = 4 + num_tasks = 2 + X_dim, Y_dim = 2, 1 + inner_dim = 3 + X = rng.randn(num_data, X_dim) + Y = rng.randn(num_data, Y_dim) + Z = rng.randn(num_inducing, X_dim) + + X_idx = rng.randint(0, num_tasks, (num_data, 1)) + Z_idx = rng.randint(0, num_tasks, (num_inducing, 1)) + + multi_X = np.hstack([X, X_idx]) + multi_Z = np.hstack([Z, Z_idx]) + multi_Y = np.hstack([Y, X_idx]) + + +def create_layer_utility(input_dim, output_dim): + """ + Utility function to create layer object. + """ + kernel = gpflow.kernels.mo_kernels.SharedIndependentMok( + RBF(variance=1.0, lengthscale=1.0, active_dims=range(Datum.X_dim)), output_dimensionality=output_dim + ) + layer = Layer(input_dim=input_dim, output_dim=output_dim, kernel=kernel, num_inducing=Datum.num_inducing) + return layer + + +@pytest.fixture +def model(): + likelihood = Gaussian() + input_layer = create_layer_utility(Datum.X_dim, Datum.inner_dim) + output_layer = create_layer_utility(Datum.inner_dim, Datum.Y_dim) + + seq = Sequential([input_layer, output_layer]) + + model = DSDGP(Z=Datum.Z, layers=seq, likelihood=likelihood) + return model + + +@pytest.fixture +def multitask_model(): + likelihood = Gaussian() + input_layer = create_layer_utility(Datum.X_dim, Datum.inner_dim) + output_layer = create_layer_utility(Datum.inner_dim, Datum.Y_dim) + + seq = Sequential([input_layer, output_layer]) + + model = DSDGP(Z=Datum.multi_Z, layers=seq, likelihood=likelihood, multitask=True) + return model + + +@pytest.mark.parametrize('full_cov', [True, False]) +def test_predict_all_layers(model, full_cov): + """ + Test the predict all layers method which is called by all other predict methods. + """ + with pytest.raises(ValueError): + model.predict_all_layers(Xnew=Datum.X, num_samples=Datum.num_samples, full_cov=full_cov) + + model.initialize_layers_from_data(Datum.X) + + fs, fmeans, fvars = model.predict_all_layers(Xnew=Datum.X, num_samples=Datum.num_samples, full_cov=full_cov) + dims = [Datum.inner_dim, Datum.Y_dim] + for f, m, v, i in zip(fs, fmeans, fvars, dims): + assert m.shape == f.shape + if full_cov: + assert v.shape == (Datum.num_samples, i, Datum.num_data, Datum.num_data) + else: + assert v.shape == m.shape + assert m.shape == (Datum.num_samples, Datum.num_data, i) + np.testing.assert_array_less(np.full_like(v, -1e-6), v) + + +@pytest.mark.parametrize('full_cov', [True, False]) +def test_predict_all_layers_multitask(multitask_model, full_cov): + """ + Test the predict all layers method for multitask model which is called by all other predict methods. + """ + with pytest.raises(ValueError): + multitask_model.predict_all_layers(Xnew=Datum.multi_X, num_samples=Datum.num_samples, full_cov=full_cov) + + multitask_model.initialize_layers_from_data(Datum.multi_X) + + fs, fmeans, fvars = multitask_model.predict_all_layers(Xnew=Datum.multi_X, num_samples=Datum.num_samples, full_cov=full_cov) + dims = [Datum.inner_dim, Datum.Y_dim] + for f, m, v, i in zip(fs, fmeans, fvars, dims): + print(m.shape) + assert f.shape == (Datum.num_samples, Datum.num_data, i + 1) + if full_cov: + assert v.shape == (Datum.num_samples, i, Datum.num_data, Datum.num_data) + else: + assert v.shape == m.shape + assert m.shape == (Datum.num_samples, Datum.num_data, i) + np.testing.assert_array_less(np.full_like(v, -1e-6), v) + + +def test_log_likelihood(model): + """ + Tests the log_likelihood method. + """ + model.initialize_layers_from_data(Datum.X) + + likelihood_value = model.log_likelihood(Datum.X, Datum.Y, Datum.num_samples) + + assert np.isscalar(likelihood_value.numpy()) + diff --git a/tests/test_layer.py b/tests/test_layer.py index bba1808..35163e3 100644 --- a/tests/test_layer.py +++ b/tests/test_layer.py @@ -23,6 +23,7 @@ class Datum: output_dim = 3 num_inducing = 10 num_data = 20 + num_tasks = 2 noise_variance = 1.0 lengthscale = 2.3 signal_variance = 0.5 @@ -32,6 +33,12 @@ class Datum: X = rng.randn(num_data, input_dim) Z = rng.randn(num_inducing, input_dim) + X_idx = rng.randint(0, num_tasks, (num_data, 1)) + Z_idx = rng.randint(0, num_tasks, (num_inducing, 1)) + + multi_X = np.hstack([X, X_idx]) + multi_Z = np.hstack([Z, Z_idx]) + @pytest.fixture def reference_model(): @@ -97,6 +104,13 @@ def test_propagate_inputs_and_features(): assert Z.shape == (Datum.num_inducing, Datum.output_dim) +def test_propagate_inputs_and_features_with_index_column(): + layer = create_layer_utility() + X, Z, _ = layer.propagate_inputs_and_features(Datum.multi_X, Datum.multi_Z) + np.testing.assert_array_equal(Datum.X_idx, X[:, -1:]) + np.testing.assert_array_equal(Datum.Z_idx, Z[:, -1:]) + + @pytest.mark.parametrize("feature", [None, SharedIndependentMof(InducingPoints(Datum.Z))]) @pytest.mark.parametrize("share_Z", [True, False]) def test_initialize_features(feature, share_Z): diff --git a/tests/test_multitask_dsdgp.py b/tests/test_multitask_dsdgp.py deleted file mode 100644 index cbfec02..0000000 --- a/tests/test_multitask_dsdgp.py +++ /dev/null @@ -1,176 +0,0 @@ -import unittest - -import numpy as np -import tensorflow as tf -import gpflow - -from dgplib.layers import InputLayer, OutputLayer, HiddenLayer -from dgplib.cascade import MultitaskSequential - -from dgplib import MultitaskDSDGP - -from gpflow.decors import defer_build, name_scope -from gpflow.kernels import RBF, White -from gpflow.likelihoods import Gaussian, SwitchedLikelihood -from gpflow.mean_functions import Linear - -class TestMultitaskDSDGP(unittest.TestCase): - def setUp(self): - self.rng = np.random.RandomState(42) - - self.Ns = 300 - #self.Xs = np.linspace(-0.5, 1.5, Ns)[:, None] - - self.N, self.M = 50, 25 - - X = self.rng.uniform(0, 1, self.N)[:, None] - Z = self.rng.uniform(0, 1, self.M)[:, None] - X_ind = self.rng.randint(0,2, (self.N,1)) - Z_ind = self.rng.randint(0,2, (self.M,1)) - - f_step = lambda x: 0. if x<0.5 else 1. - - Y = np.reshape([f_step(x) for x in X], X.shape) \ - + np.random.randn(*X.shape)*1e-2 - - self.X = np.hstack([X, X_ind]) - self.Z = np.hstack([Z, Z_ind]) - self.Y = np.hstack([Y, X_ind]) - - @name_scope('multitask_dsdgp_optimizer') - def test_optimize(self): - with defer_build(): - input_layer = InputLayer(input_dim=1, output_dim=1, - num_inducing=self.M, - kernel=RBF(1)+White(1), - multitask=True - ) - output_layer = OutputLayer(input_dim=1, output_dim=1, - num_inducing=self.M, - kernel=RBF(1)+White(1), - multitask=True - ) - - seq = MultitaskSequential([input_layer, output_layer]) - - model = MultitaskDSDGP(X=self.X, Y=self.Y, Z=self.Z, layers=seq, - likelihood=SwitchedLikelihood([Gaussian(), Gaussian()]), - num_latent=1) - model.compile() - before = model.compute_log_likelihood() - opt = gpflow.train.AdamOptimizer(0.01) - opt.minimize(model, maxiter=100) - after = model.compute_log_likelihood() - self.assertGreaterEqual(after, before) - -class TestMethods(unittest.TestCase): - def prepare(self): - N = 100 - M = 10 - rng = np.random.RandomState(42) - X = rng.randn(N, 2) - Y = rng.randn(N, 1) - Z = rng.randn(M, 2) - - X_ind = rng.randint(0,2, (N,1)) - Z_ind = rng.randint(0,2, (M,1)) - - X = np.hstack([X, X_ind]) - Y = np.hstack([Y, X_ind]) - Z = np.hstack([Z, Z_ind]) - - Xs = rng.randn(M, 2) - Xs_ind = rng.randint(0,2, (M,1)) - Xs = np.hstack([Xs, Xs_ind]) - - with defer_build(): - lik = SwitchedLikelihood([Gaussian(), Gaussian()]) - - input_layer = InputLayer(input_dim=2, output_dim=1, - num_inducing=M, kernel=RBF(2)+White(2), - mean_function=Linear(A=np.ones((3,1))), - multitask=True) - output_layer = OutputLayer(input_dim=1, output_dim=1, - num_inducing=M, kernel=RBF(1)+White(1), - multitask=True) - - seq = MultitaskSequential([input_layer, output_layer]) - - model = MultitaskDSDGP(X=X, Y=Y, Z=Z, layers=seq, likelihood=lik, num_latent=1) - model.compile() - return model, Xs - - def test_build(self): - model, _ = self.prepare() - self.assertEqual(model.is_built_coherence(), gpflow.Build.YES) - - def test_predict_f(self): - model, Xs = self.prepare() - mu, sigma = model.predict_f(Xs, 1) - with self.subTest(): - self.assertEqual(mu.shape, sigma.shape) - with self.subTest(): - self.assertEqual(mu.shape, (1, 10, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(sigma, -1e-6), sigma) - - def test_predict_f_full_cov(self): - model, Xs = self.prepare() - mu, sigma = model.predict_f_full_cov(Xs, 1) - with self.subTest(): - self.assertEqual(mu.shape, (1, 10, 1)) - with self.subTest(): - self.assertEqual(sigma.shape, (1, 10, 10, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(sigma, -1e-6), sigma) - - def test_predict_all_layers(self): - model, Xs = self.prepare() - fs, fmeans, fvars = model.predict_all_layers(Xs, 1) - dims = [1, 1] - for f, m, v, i in zip(fs, fmeans, fvars, dims): - with self.subTest(): - self.assertEqual(m.shape[:-1], f.shape[:-1]) - with self.subTest(): - self.assertEqual(m.shape, v.shape) - with self.subTest(): - self.assertEqual(m.shape, (1, 10, i)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(v, -1e-6), v) - with self.subTest(): - self.assertTrue(np.allclose(f[0,:,-1], Xs[:,-1])) - - def test_predict_all_layers_full_cov(self): - model, Xs = self.prepare() - fs, fmeans, fvars = model.predict_all_layers_full_cov(Xs, 1) - dims = [1, 1] - for f, m, v, i in zip(fs, fmeans, fvars, dims): - with self.subTest(): - self.assertEqual(f.shape, (1, 10, i+1)) - with self.subTest(): - self.assertEqual(m.shape, (1, 10, i)) - with self.subTest(): - self.assertEqual(v.shape, (1, 10, 10, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(v, -1e-6), v) - with self.subTest(): - self.assertTrue(np.allclose(f[0,:,-1], Xs[:,-1])) - - def test_predict_f_samples(self): - model, Xs = self.prepare() - fs = model.predict_f_samples(Xs, 10) - with self.subTest(): - self.assertEqual(fs.shape, (10, 10, 1)) - - def test_predict_y(self): - model, Xs = self.prepare() - mu, sigma = model.predict_y(Xs) - with self.subTest(): - self.assertEqual(mu.shape, sigma.shape) - with self.subTest(): - self.assertEqual(mu.shape, (1, 20, 1)) - with self.subTest(): - np.testing.assert_array_less(np.full_like(sigma, -1e-6), sigma) - -if __name__=="__main__": - unittest.main() From fcba58f02cc2dfa08d22dc2f5b13ec1b2ef04960 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Fri, 9 Aug 2019 11:19:08 +0100 Subject: [PATCH 07/17] streamlined api and fixed bugs --- dgplib/cascade.py | 5 +- dgplib/dsdgp.py | 25 +++-- dgplib/layers.py | 18 ++-- dgplib/multikernel_layers.py | 169 ---------------------------------- dgplib/multiprocess_layers.py | 85 +++++++++++++++++ tests/test_layer.py | 7 +- 6 files changed, 111 insertions(+), 198 deletions(-) delete mode 100644 dgplib/multikernel_layers.py create mode 100644 dgplib/multiprocess_layers.py diff --git a/dgplib/cascade.py b/dgplib/cascade.py index 54be74e..f9ceadd 100644 --- a/dgplib/cascade.py +++ b/dgplib/cascade.py @@ -1,5 +1,6 @@ from gpflow.base import Module from .layers import Layer +from .multiprocess_layers import MultiprocessLayer class Sequential(Module): @@ -36,7 +37,7 @@ def _valid_input(self, layer): """ Checks if input to the cascade object is valid """ - assert isinstance(layer, Layer) + assert isinstance(layer, (Layer, MultiprocessLayer)) if self.initialized: raise ValueError('Cannot add more layers to initialized model') @@ -71,7 +72,7 @@ def initialize_params(self, X, Z): X_next, Z_next, W = self.constituents[0].propagate_inputs_and_features(X, Z) self.constituents[0].initialize_features(Z_current) if self.constituents[0].fixed_linear_mean_function: - self.constituents[0].initialize_mean_function_weights(W) + self.constituents[0].initialize_linear_mean_function_weights(W) for layer in self.constituents[1:]: Z_current = Z_next X_next, Z_next, W = layer.propagate_inputs_and_features(X_next, Z_current) diff --git a/dgplib/dsdgp.py b/dgplib/dsdgp.py index 29b82af..21f1ea8 100644 --- a/dgplib/dsdgp.py +++ b/dgplib/dsdgp.py @@ -1,6 +1,5 @@ import tensorflow as tf -from gpflow.mean_functions import Zero from gpflow.models import GPModel from .layers import Layer @@ -27,7 +26,7 @@ class DSDGP(GPModel): } """ def __init__(self, likelihood, Z, layers=None, kernels=None, dims=None, - num_latent=None, num_data=None, multitask=False): + num_latent=1, num_data=None, multitask=False): """ :param likelihood: GPflow likelihood object :param Z: Initial value of inducing inputs @@ -83,7 +82,7 @@ def multitask(self): def initialize_layers_from_data(self, X): self.layers.initialize_params(X, self.initial_Z) - def _propagate(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): + def _propagate(self, Xnew, full_cov=False, num_samples=1): """ Propagate points Xnew through DGP cascade. """ @@ -95,8 +94,7 @@ def _propagate(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1) for layer in self.layers.constituents: f_samples, f_mus, f_vars = [], [], [] for s in range(num_samples): - f_sample, f_mu, f_var = layer.predict_f_samples(F_samples[-1][s, ...], full_cov=full_cov, - full_output_cov=full_output_cov, num_samples=1) + f_sample, f_mu, f_var = layer.predict_f_samples(F_samples[-1][s, ...], full_cov=full_cov, num_samples=1) if self.multitask: f_sample = tf.concat([f_sample, Xnew[None, :, -1:]], axis=-1) @@ -111,25 +109,25 @@ def _propagate(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1) return F_samples[1:], F_mus, F_vars - def predict_all_layers(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): + def predict_all_layers(self, Xnew, full_cov=False, num_samples=1): """ Predicts and produces posterior samples from all layers """ - Fs, Fmeans, Fvars = self._propagate(Xnew, full_cov, full_output_cov, num_samples) + Fs, Fmeans, Fvars = self._propagate(Xnew, full_cov, num_samples) return Fs, Fmeans, Fvars - def predict_f(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): + def predict_f(self, Xnew, full_cov=False, num_samples=1): """ Returns the posterior for the final layer """ - Fs, Fmeans, Fvars = self.predict_all_layers(Xnew, full_cov, full_output_cov, num_samples) + Fs, Fmeans, Fvars = self.predict_all_layers(Xnew, full_cov, num_samples) return Fmeans[-1], Fvars[-1] - def predict_f_samples(self, Xnew, full_cov=False, full_output_cov=False, num_samples=1): + def predict_f_samples(self, Xnew, full_cov=False, num_samples=1): """ Produces posterior samples from the final layer """ - Fs, Fmeans, Fvars = self.predict_all_layers(Xnew, full_cov, full_output_cov, num_samples) + Fs, Fmeans, Fvars = self.predict_all_layers(Xnew, full_cov, num_samples) return Fs[-1] def prior_kl(self): @@ -142,14 +140,13 @@ def log_likelihood(self, X: tf.Tensor, Y:tf. Tensor, num_samples: int = 1) -> tf """ Evaluates bound on the log marginal likelihood """ - f_mean, f_var = self.predict_f(X, full_cov=False, full_output_cov=False, - num_samples=num_samples) # SxNxD, SXNxD + f_mean, f_var = self.predict_f(X, full_cov=False, num_samples=num_samples) # SxNxD, SXNxD var_exp = [ self.likelihood.variational_expectations(f_mean[s, :, :], f_var[s, :, :], Y) for s in range(num_samples) ] var_exp = tf.reduce_mean(tf.stack(var_exp), axis=0) - assert var_exp.numpy().shape == (X.shape[0], 1) + assert var_exp.shape == (X.shape[0], self.num_latent) if self.num_data is not None: num_data = tf.cast(self.num_data, var_exp.dtype) minibatch_size = tf.cast(tf.shape(X)[0], var_exp.dtype) diff --git a/dgplib/layers.py b/dgplib/layers.py index d501141..4dbe7d5 100644 --- a/dgplib/layers.py +++ b/dgplib/layers.py @@ -128,13 +128,12 @@ def prior_kl(self): return gauss_kl(self.q_mu, self.q_sqrt, K) - def predict_f(self, Xnew: tf.Tensor, full_cov=False, full_output_cov=False) -> Tuple[tf.Tensor, tf.Tensor]: + def predict_f(self, Xnew: tf.Tensor, full_cov=False) -> Tuple[tf.Tensor, tf.Tensor]: """ Returns the posterior mean and covariance at Xnew :param Xnew: input (tf.Tensor or numpy array) :param full_cov: True if full covariance required - :param full_output_cov: True if full ouput covariance required """ q_mu = self.q_mu q_sqrt = self.q_sqrt @@ -146,19 +145,18 @@ def predict_f(self, Xnew: tf.Tensor, full_cov=False, full_output_cov=False) -> T q_sqrt=q_sqrt, full_cov=full_cov, white=self.whiten, - full_output_cov=full_output_cov + full_output_cov=False ) return mu + self.mean_function(Xnew), var - def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False, full_output_cov=False) -> tf.Tensor: + def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False) -> tf.Tensor: """ Returns sample from GP posterior at Xnew :param Xnew: input (tf.Tensor or numpy array) :param num_samples: number of MC samples :param full_cov: True if full covariance required - :param full_output_cov: True if full output covariance required """ q_mu = self.q_mu q_sqrt = self.q_sqrt @@ -170,7 +168,7 @@ def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False, full q_sqrt=q_sqrt, full_cov=full_cov, white=self.whiten, - full_output_cov=full_output_cov, + full_output_cov=False, num_samples=num_samples ) @@ -183,12 +181,13 @@ def propagate_inputs_and_features(self, X, Z): :param Z: inducing inputs """ W = find_linear_mf_weights(self.input_dim, self.output_dim, X) + Z_running = Z.copy().dot(W) X_running = X.copy().dot(W) if X.shape[1] - self.input_dim == 1: - Z_running[:, -1] = Z[:, -1] - X_running[:, -1] = X[:, -1] + Z_running = np.hstack([Z_running, Z[:, -1:]]) + X_running = np.hstack([X_running, X[:, -1:]]) return X_running, Z_running, W @@ -203,7 +202,7 @@ def initialize_features(self, Z): else: self.feature = SeparateIndependentMof([InducingPoints(Z) for _ in range(self.output_dim)]) else: - raise ValueError("Features already intialized") + raise ValueError("Features already initialized") def initialize_linear_mean_function_weights(self, W): """ @@ -213,5 +212,6 @@ def initialize_linear_mean_function_weights(self, W): if self.fixed_linear_mean_function: self.mean_function.A = Parameter(W) self.mean_function.A.trainable = False + self.mean_function.b.trainable = False else: raise ValueError("Mean function is not specified as fixed on construction.") diff --git a/dgplib/multikernel_layers.py b/dgplib/multikernel_layers.py deleted file mode 100644 index 4f5f27b..0000000 --- a/dgplib/multikernel_layers.py +++ /dev/null @@ -1,169 +0,0 @@ -from __future__ import print_function, absolute_import - -import tensorflow as tf -import numpy as np - -from gpflow import settings - -from gpflow.conditionals import conditional -from gpflow.decors import params_as_tensors, autoflow, defer_build -from gpflow.features import inducingpoint_wrapper -from gpflow.kullback_leiblers import gauss_kl -from gpflow.mean_functions import Linear, Zero -from gpflow.params import Parameter, Parameterized, ParamList - -from .layers import Layer -from .layers import InputMixin, HiddenMixin, OutputMixin - -class MultikernelLayer(Layer): - """ - Inherits from Layer class. Can handle outputs from different priors. - """ - - @defer_build() - def __init__(self, input_dim, output_dim, num_inducing, kernel_list, - share_Z=False, mean_function=None, multitask=False, name=None): - - if output_dim%len(kernel_list) != 0: - raise ValueError("Output dimension must be a multiple of the number of kernels") - - super(MultikernelLayer, self).__init__(input_dim=input_dim, - output_dim=output_dim, - num_inducing=num_inducing, - kernel=kernel_list, - mean_function=mean_function, - multitask=multitask, - name=name) - - self.num_kernels = len(kernel_list) - self._shared_Z = share_Z - self.offset = int(self.output_dim/self.num_kernels) - - if not self._shared_Z: - del self.feature - if multitask: - Z = np.zeros((self.num_inducing, self.input_dim+1)) - else: - Z = np.zeros((self.num_inducing, self.input_dim)) - - self.feature = ParamList([inducingpoint_wrapper(None, Z.copy()) for _ in range(self.num_kernels)]) - - - @params_as_tensors - def build_prior_KL(self, K): - if K: - KL = 0. - for i, k in enumerate(K): - KL += gauss_kl_white(self.q_mu[:,(i*self.offset):((i+1)*self.offset)], - self.q_sqrt[(i*self.offset):((i+1)*self.offset),:,:], - K=k - ) - return KL - else: - return gauss_kl(self.q_mu, self.q_sqrt, K=K) - - @params_as_tensors - def _build_predict(self, Xnew, full_cov=False, stochastic=True): - def f_conditional(Xnew, full_cov=False): - mean = [] - var = [] - if self._shared_Z: - feats = [self.feature for _ in range(self.num_kernels)] - else: - feats = [feat for feat in self.feature] - for i, (k, feat) in enumerate(zip(self.kernel, feats)): - m, v = conditional(Xnew, feat, k, self.q_mu[:,(i*self.offset):((i+1)*self.offset)], - q_sqrt=self.q_sqrt[(i*self.offset):((i+1)*self.offset),:,:,], - full_cov=full_cov, - white=True) - mean.append(m) - - #temporary fix - if full_cov: - var.append(tf.transpose(v)) - else: - var.append(v) - - mean = tf.concat(mean, axis=-1) #NxK - var = tf.concat(var, axis=-1) #NxK or NxNxK - - return mean + self.mean_function(Xnew), var - - def multisample_conditional(Xnew, full_cov=False): - if full_cov: - f = lambda a: f_conditional(a, full_cov=full_cov) - mean, var = tf.map_fn(f, Xnew, dtype=(settings.tf_float, - settings.tf_float)) - return tf.stack(mean), tf.stack(var) - else: - #S, N, D = shape_as_list(Xnew) - s = tf.shape(Xnew) - X_flat = tf.reshape(Xnew, [s[0]*s[1], s[2]]) - mean, var = f_conditional(X_flat) - return [tf.reshape(m, [s[0], s[1], -1]) for m in [mean, var]] - - if stochastic: - mean, var = multisample_conditional(Xnew, full_cov) - else: - mean, var = f_conditional(Xnew, full_cov) - - return mean, var - -class MultikernelInputLayer(MultikernelLayer, InputMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): - """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward - """ - if self._shared_Z: - self.feature.Z.assign(Z) - else: - for feat in self.feature: - feat.Z.assign(Z) - - X_running, Z_running, W = self.compute_inputs(X, Z, multitask) - - if isinstance(self.mean_function, Linear): - self.mean_function.A = W - self.mean_function.set_trainable(False) - - return X_running, Z_running - - -class MultikernelHiddenLayer(MultikernelLayer, HiddenMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): - """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward - """ - if self._shared_Z: - self.feature.Z.assign(Z) - else: - for feat in self.feature: - feat.Z.assign(Z) - - X_running, Z_running, W = self.compute_inputs(X, Z, multitask) - - if isinstance(self.mean_function, Linear): - self.mean_function.A =W - self.mean_function.set_trainable(False) - - return X_running, Z_running - -class MultikernelOutputLayer(MultikernelLayer, OutputMixin): - @defer_build() - def initialize_forward(self, X, Z, multitask=False): - """ - Initialize Layer and Propagate values of inputs and inducing inputs - forward - """ - - if self._shared_Z: - self.feature.Z.assign(Z) - else: - for feat in self.feature: - feat.Z.assign(Z) - - return (None, None) diff --git a/dgplib/multiprocess_layers.py b/dgplib/multiprocess_layers.py new file mode 100644 index 0000000..50b90fc --- /dev/null +++ b/dgplib/multiprocess_layers.py @@ -0,0 +1,85 @@ +from typing import Tuple + +import abc +import tensorflow as tf + +from gpflow.base import Module + +from .layers import Layer + + +class MultiprocessLayer(Module): + """ + Inherits from Layer class. Can handle outputs from different priors. + """ + + def __init__(self, input_dim, sublayer_output_dim, kernels, feature=None, + num_inducing=None, share_Z=False, fixed_linear_mean_function=False, + mean_functions=None, whiten=True, q_diag=False, q_mu=None, q_sqrt=None, name=None): + super().__init__(name=name) + + self.input_dim = input_dim + self.sublayer_output_dim = sublayer_output_dim + self.num_sublayers = len(kernels) + + if mean_functions is None: + mean_functions = [None] * self.num_sublayers + + sublayers = [] + for i in range(self.num_sublayers): + sublayer = Layer(input_dim=self.input_dim, output_dim=self.sublayer_output_dim, kernel=kernels[i], + feature=feature, num_inducing=num_inducing, share_Z=share_Z, + fixed_linear_mean_function=fixed_linear_mean_function, mean_function=mean_functions[i], + whiten=whiten, q_diag=q_diag, q_mu=q_mu, q_sqrt=q_sqrt) + sublayers.append(sublayer) + + self.sublayers = sublayers + + @property + @abc.abstractmethod + def output_dim(self): + pass + + def prior_kl(self): + KL = 0. + for sublayer in self.sublayers: + KL += sublayer.prior_kl() + return KL + + @abc.abstractmethod + def predict_f(self, Xnew: tf.Tensor, full_cov=False, full_output_cov=False) -> Tuple[tf.Tensor, tf.Tensor]: + pass + + @abc.abstractmethod + def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False, full_output_cov=False) -> tf.Tensor: + pass + + def propagate_inputs_and_features(self, X, Z): + """ + Returns an initialization for the data and inducing inputs for the consequent layer + :param X: inputs + :param Z: inducing inputs + """ + return self.sublayers[0].propagate_inputs_and_features(X, Z) + + def initialize_features(self, Z): + """ + Initialize the inducing inputs/features for this Layer + :param Z: inducing input values + """ + for sublayer in self.sublayers: + sublayer.initialize_features(Z) + + def initialize_linear_mean_function_weights(self, W): + """ + Initialize linear mean function weights for this Layer + :param W: numpy array of linear mean function weights + """ + for sublayer in self.sublayers: + sublayer.initialize_linear_mean_function_weights(W) + + +class ConcatinativeMultiprocessLayer(MultiprocessLayer): + @property + def output_dim(self): + self.sublayer_output_dim * self.num_sublayers diff --git a/tests/test_layer.py b/tests/test_layer.py index 35163e3..ee2d4f4 100644 --- a/tests/test_layer.py +++ b/tests/test_layer.py @@ -71,15 +71,14 @@ def test_kl(reference_model): @pytest.mark.parametrize("full_cov", [True, False]) -@pytest.mark.parametrize("full_output_cov", [True, False]) -def test_predict_f(reference_model, full_cov, full_output_cov): +def test_predict_f(reference_model, full_cov): layer = create_layer_utility(feature=SharedIndependentMof(InducingPoints(Datum.Z))) W = find_linear_mf_weights(input_dim=Datum.input_dim, output_dim=Datum.output_dim, X=Datum.X) layer.initialize_linear_mean_function_weights(W=W) X = tf.cast(tf.convert_to_tensor(Datum.X), dtype=gpflow.default_float()) - layer_mu, layer_sigma = layer.predict_f(X, full_cov, full_output_cov) - reference_mu, reference_sigma = reference_model.predict_f(X, full_cov, full_output_cov) + layer_mu, layer_sigma = layer.predict_f(X, full_cov) + reference_mu, reference_sigma = reference_model.predict_f(X, full_cov) np.testing.assert_allclose(layer_mu, reference_mu) np.testing.assert_allclose(layer_sigma, reference_sigma) From ca7b1ed866869b329f038212b66241227a5c0156 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Fri, 9 Aug 2019 11:19:46 +0100 Subject: [PATCH 08/17] upated print model utility to handle deep models --- dgplib/utilities.py | 81 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 81 insertions(+) diff --git a/dgplib/utilities.py b/dgplib/utilities.py index ce012fd..c14f043 100644 --- a/dgplib/utilities.py +++ b/dgplib/utilities.py @@ -1,4 +1,12 @@ +from typing import Optional + +from tabulate import tabulate import numpy as np +import tensorflow as tf + +from gpflow.base import Parameter +from gpflow.config import summary_fmt +from gpflow.utilities.utilities import _str_tensor_value, _merge_leaf_components def find_linear_mf_weights(input_dim, output_dim, X): @@ -24,3 +32,76 @@ def find_linear_mf_weights(input_dim, output_dim, X): W = np.concatenate([W, np.zeros((1, W.shape[1]))], axis=0) return W + + +def print_summary(module: tf.Module, fmt: str = None): + """ + Prints a summary of the parameters and variables contained in a tf.Module. + """ + + fmt = fmt if fmt is not None else summary_fmt() + column_names = ['name', 'class', 'transform', 'trainable', 'shape', 'dtype', 'value'] + + def get_name(v): + return v.__class__.__name__ + + def get_transform(v): + if hasattr(v, "transform") and v.transform is not None: + return v.transform.__class__.__name__ + return None + + merged_leaf_components = _merge_leaf_components(leaf_components(module)) + + column_values = [[ + path, + get_name(variable), + get_transform(variable), + variable.trainable, + variable.shape, + variable.dtype.name, + _str_tensor_value(variable.numpy()) + ] for path, variable in merged_leaf_components.items()] + + if fmt == "notebook": + from IPython.core.display import display, HTML + tab = tabulate(column_values, headers=column_names, tablefmt="html") + display(HTML(tab)) + else: + print(tabulate(column_values, headers=column_names, tablefmt=fmt)) + + +def leaf_components(input: tf.Module): + return _get_leaf_components(input) + + +def _get_leaf_components(input: tf.Module, prefix: Optional[str] = None): + """ + Returns a list of tuples each corresponding to a gpflow.Parameter or tf.Variable in the each + submodules of a given tf.Module. Each tuple consists of an specific Parameter (or Variable) and + its relative path inside the module, which is constructed recursively by adding a prefix with + the path to the current module. Designed to be used as a helper for the method 'print_summary'. + :param module: tf.Module including keras.Model, keras.layers.Layer and gpflow.Module. + :param prefix: string containing the relative path to module, by default set to None. + :return: + """ + if not isinstance(input, tf.Module): + raise TypeError("Input object expected to have `tf.Module` type") + + prefix = input.__class__.__name__ if prefix is None else prefix + var_dict = dict() + + for key, submodule in vars(input).items(): + if key in tf.Module._TF_MODULE_IGNORED_PROPERTIES: + continue + elif isinstance(submodule, Parameter) or isinstance(submodule, tf.Variable): + var_dict[f"{prefix}.{key}"] = submodule + elif isinstance(submodule, tf.Module): + submodule_var = _get_leaf_components(submodule, prefix=f"{prefix}.{key}") + var_dict.update(submodule_var) + elif isinstance(submodule, list) and isinstance(submodule[0], tf.Module): + for i, component in enumerate(submodule): + submodule_var = _get_leaf_components(component, prefix=f"{prefix}.{key}[{i}]") + var_dict.update(submodule_var) + + return var_dict + From 4eeeafc281c666c09415a208face37a8faac60f8 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Fri, 9 Aug 2019 11:20:17 +0100 Subject: [PATCH 09/17] multiprocess layers --- dgplib/multiprocess_layers.py | 118 ++++++++++++++++++++++++++++++++-- 1 file changed, 112 insertions(+), 6 deletions(-) diff --git a/dgplib/multiprocess_layers.py b/dgplib/multiprocess_layers.py index 50b90fc..83592e8 100644 --- a/dgplib/multiprocess_layers.py +++ b/dgplib/multiprocess_layers.py @@ -1,6 +1,7 @@ from typing import Tuple import abc +import numpy as np import tensorflow as tf from gpflow.base import Module @@ -25,12 +26,14 @@ def __init__(self, input_dim, sublayer_output_dim, kernels, feature=None, if mean_functions is None: mean_functions = [None] * self.num_sublayers + self.fixed_linear_mean_function = fixed_linear_mean_function + sublayers = [] for i in range(self.num_sublayers): sublayer = Layer(input_dim=self.input_dim, output_dim=self.sublayer_output_dim, kernel=kernels[i], feature=feature, num_inducing=num_inducing, share_Z=share_Z, - fixed_linear_mean_function=fixed_linear_mean_function, mean_function=mean_functions[i], - whiten=whiten, q_diag=q_diag, q_mu=q_mu, q_sqrt=q_sqrt) + fixed_linear_mean_function=self.fixed_linear_mean_function, + mean_function=mean_functions[i], whiten=whiten, q_diag=q_diag, q_mu=q_mu, q_sqrt=q_sqrt) sublayers.append(sublayer) self.sublayers = sublayers @@ -47,20 +50,21 @@ def prior_kl(self): return KL @abc.abstractmethod - def predict_f(self, Xnew: tf.Tensor, full_cov=False, full_output_cov=False) -> Tuple[tf.Tensor, tf.Tensor]: + def predict_f(self, Xnew: tf.Tensor, full_cov=False) -> Tuple[tf.Tensor, tf.Tensor]: pass @abc.abstractmethod - def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False, full_output_cov=False) -> tf.Tensor: + def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False) -> tf.Tensor: pass + @abc.abstractmethod def propagate_inputs_and_features(self, X, Z): """ Returns an initialization for the data and inducing inputs for the consequent layer :param X: inputs :param Z: inducing inputs """ - return self.sublayers[0].propagate_inputs_and_features(X, Z) + pass def initialize_features(self, Z): """ @@ -82,4 +86,106 @@ def initialize_linear_mean_function_weights(self, W): class ConcatinativeMultiprocessLayer(MultiprocessLayer): @property def output_dim(self): - self.sublayer_output_dim * self.num_sublayers + return self.sublayer_output_dim * self.num_sublayers + + def propagate_inputs_and_features(self, X, Z): + """ + Returns an initialization for the data and inducing inputs for the consequent layer + :param X: inputs + :param Z: inducing inputs + """ + X_running, Z_running = [], [] + for sublayer in self.sublayers: + X_sub, Z_sub, W = sublayer.propagate_inputs_and_features(X, Z) # NxD_sub(+1), MxD_sub(+1), D_in(+1)xD_sub + X_running.append(X_sub) + Z_running.append(Z_sub) + + # Hack to make propagation of index column possible + if X.shape[1] - self.input_dim == 1: + X_running = np.hstack([xx[:, :-1] for xx in X_running] + [X[:, -1:]]) + Z_running = np.hstack([zz[:, :-1] for zz in Z_running] + [Z[:, -1:]]) + else: + X_running = np.hstack(X_running) + Z_running = np.hstack(Z_running) + + return X_running, Z_running, W + + def predict_f(self, Xnew: tf.Tensor, full_cov=False): + mu, var = [], [] + for sublayer in self.sublayers: + m, v = sublayer.predict_f(Xnew=Xnew, full_cov=full_cov) + mu.append(m) + var.append(v) + mu = tf.concat(mu, axis=-1) + if full_cov: + var = tf.concat(var, axis=1) + else: + var = tf.concat(var, axis=-1) + + return mu, var + + def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False): + samples, mu, var = [], [], [] + for sublayer in self.sublayers: + s, m, v = sublayer.predict_f_samples(Xnew=Xnew, num_samples=num_samples, full_cov=full_cov) + samples.append(s) + mu.append(m) + var.append(v) + samples = tf.concat(samples, axis=-1) + mu = tf.concat(mu, axis=-1) + if full_cov: + var = tf.concat(var, axis=1) + else: + var = tf.concat(var, axis=-1) + + return samples, mu, var + + +class AdditiveMultiprocessLayer(MultiprocessLayer): + @property + def output_dim(self): + return self.sublayer_output_dim + + def propagate_inputs_and_features(self, X, Z): + """ + Returns an initialization for the data and inducing inputs for the consequent layer + :param X: inputs + :param Z: inducing inputs + """ + X_running, Z_running = [], [] + for sublayer in self.sublayers: + X_sub, Z_sub, W = sublayer.propagate_inputs_and_features(X, Z) # NxD_sub(+1), MxD_sub(+1), D_in(+1)xD_sub + X_running.append(X_sub) + Z_running.append(Z_sub) + + X_running = np.sum(np.stack(X_running, axis=0), axis=0) + Z_running = np.sum(np.stack(Z_running, axis=0), axis=0) + if X.shape[1] - self.input_dim == 1: + X_running = np.hstack([X_running, X[:, -1:]]) + Z_running = np.hstack([Z_running, Z[:, -1:]]) + + return X_running, Z_running, W + + def predict_f(self, Xnew: tf.Tensor, full_cov=False): + mu, var = [], [] + for sublayer in self.sublayers: + m, v = sublayer.predict_f(Xnew=Xnew, full_cov=full_cov) + mu.append(m) + var.append(v) + mu = tf.reduce_sum(tf.stack(mu), axis=0) + var = tf.reduce_sum(tf.stack(var), axis=0) + + return mu, var + + def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False): + samples, mu, var = [], [], [] + for sublayer in self.sublayers: + s, m, v = sublayer.predict_f_samples(Xnew=Xnew, num_samples=num_samples, full_cov=full_cov) + samples.append(s) + mu.append(m) + var.append(v) + samples = tf.reduce_sum(tf.stack(samples), axis=0) + mu = tf.concat(mu, axis=0) + var = tf.reduce_sum(tf.stack(var), axis=0) + + return samples, mu, var From ae5c3ff65e1cff9326a9d6a1e58028234019439f Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Fri, 9 Aug 2019 11:20:54 +0100 Subject: [PATCH 10/17] example noteboks --- doc/notebooks/simple_example.ipynb | 275 +++++++--- .../simple_example_multikernel.ipynb | 381 ++++++++------ doc/notebooks/simple_example_multitask.ipynb | 469 ++++++++++-------- 3 files changed, 701 insertions(+), 424 deletions(-) diff --git a/doc/notebooks/simple_example.ipynb b/doc/notebooks/simple_example.ipynb index 66b4aaf..d85dffb 100644 --- a/doc/notebooks/simple_example.ipynb +++ b/doc/notebooks/simple_example.ipynb @@ -31,6 +31,7 @@ "# dgplib imports\n", "from dgplib.layers import Layer\n", "from dgplib.cascade import Sequential\n", + "from dgplib.utilities import print_summary\n", "\n", "from dgplib import DSDGP" ] @@ -47,9 +48,10 @@ "from gpflow.kernels import RBF, White, Matern52\n", "from gpflow.likelihoods import Gaussian\n", "from gpflow.mean_functions import Linear\n", - "from gpflow.utilities import set_trainable, print_summary\n", + "from gpflow.utilities import set_trainable\n", "\n", - "gpflow.config.set_summary_fmt(\"notebook\")" + "gpflow.config.set_summary_fmt(\"notebook\")\n", + "gpflow.config.set_default_float(np.float64)" ] }, { @@ -67,7 +69,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAEICAYAAACgQWTXAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAYnUlEQVR4nO3df3Bc5X3v8fcHWYBoAJFayQTZwaQ1bhzojTMq0CE3IT8NpNieJG3sDtMkw4RJOuT2B/XEXLgJ0ORC6t5Melt3Uneapg0N5kepRi3OOG0gl1sau4gKcIA6oxCCJecGBSwnwQJk+3v/2LNmWe+Ps6v9IT3+vGY83j3n2fN8n13pc855zpGkiMDMzNJwQrcLMDOz1nGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuSZN0g6Rbu12HWac41K0tJL1V0r9JOiDpOUkPSPqVbtfVCElPSZqR9FNJ09l4Pi4p1/eNpGWSQtKiNtfZkX5sYXCoW8tJOg34J+BPgVcDg8CNwIvdrKtJl0fEqcBZwC3Ap4C/6m5JZtU51K0dzgGIiNsi4nBEzETENyLiUQBJvyDpXknPSvqxpL+T1F98cXaEvFHSo5Kel/RXkl4r6evZUfO/SDoja1s8Sr1K0j5JP5T0B9UKk3RhdsQ9LekRSRfnGVBEHIiIEeBDwIclnZtt732SxiT9RNJeSTeUvOz+7P9pST+T9Ks5xv4pSZPZOPdIele2/ARJmyR9L3vtHZJeXa2fPGOyNDnUrR2+CxyW9DeSLi0GcAkBNwNnAm8ElgI3lLX5APAeCjuIy4GvA/8dGKDwdfvfytq/A1gOvBf4lKR3lxclaRC4B/gshTOIPwD+XtJA3oFFxL8DE8B/zRY9D/wW0A+8D/iEpHXZurdl//dHxKsi4tu1xi5pBXA18CvZ2cFq4KlsG58E1gFvz167H9hSox87TjnUreUi4ifAW4EA/hKYkjQi6bXZ+vGI+OeIeDEipoAvUAirUn8aET+KiEng/wK7ImIsIl4A/gFYVdb+xoh4PiJ2A38NbKhQ2hXA9ojYHhFHIuKfgVHgsgaHuI/CToGI+FZE7M629yhwW4WxHFVn7IeBk4CVknoj4qmI+F627uPAdRExEREvUtgRfNDz6FbOoW5tERFPRMRHImIJcC6Fo8svAmRTKduyaYafALcCi8s28aOSxzMVnr+qrP3eksc/yPordxbw69nUy7SkaQo7n9c1OLxB4LlsLBdIuk/SlKQDFMK3fCxH1Rp7RIwDv0shsJ/J2hXHcRbwDyV1P0FhJ/DaBmu3xDnUre0i4j+Br1AId4D/SeEo/ryIOI3CEbTm2M3Sksevp3A0XW4v8NWI6C/593MRcUveTrI7eAaBf80WfQ0YAZZGxOnAl3h5LJV+BWrNsUfE1yLirRRCPIDPl9R+aVntJ2dnMv5Vq3aUQ91aTtIvSbpG0pLs+VIK0yE7syanAj8DDmTz3Btb0O3/kHSKpDcBHwVur9DmVuBySasl9Ug6WdLFxTrrjOk0Sb8GbANuzaZ5imN5LiJekHQ+8JslL5sCjgBvKFlWdeySVkh6p6STgBconJEcyVZ/CficpLOytgOS1tbox45TDnVrh58CFwC7JD1PIcy/A1yTrb8ReAtwgMKFy7tb0Of/AcaBbwJ/HBHfKG8QEXuBtRQuuE5ROPrdSO3vg3+U9NOs7XUU5sA/WrL+t4GbsjafBu4o6e8g8DnggWza5EJqj/0kCrdN/hj4f8BrgGuzdX9C4YzgG1lfOym8x9X6seOU/EcybCGTtAz4PtAbEYe6W41Z9/lI3cwsIQ51M7OEePrFzCwhPlI3M0tI134abfHixbFs2bJudW9mtiA99NBDP46Iqr/aomuhvmzZMkZHR7vVvZnZgiTpB7XWe/rFzCwhDnUzs4Q41M3MEuJQNzNLiEPdzCwhDnUzs4Q41M3MEuJQNzNLiP++oZk1bXhsks079rBveoYz+/vYuHoF61YNdrus45pD3cyaMjw2ybV372Zm9jAAk9MzXHt34Q9COdi7x6FuZk3ZvGPP0UAvmpk9zOYde1oS6t06Cyjt9/S+XiSYPji7YM5EHOpmbTA8NskNI48xPTMLwBmn9PKZy9+UKxAWypTGvumZhpYX5Rlft84Cyvstfn7FGq658xF+7/aHCaBHYsMFS/nsuvPaVk8z6oa6pC8DvwY8ExHnVlgvCn8/8TLgIPCRiPiPVhdqtlAMj02y8c5HmD3y8t8q2H9wlo13PQLUDqWFNKVxZn8fkxUC/Mz+vqqvqTa+0R88x33/OXU06J9/8VDbzgJq7VQqnX2UOlzymR6O4NadT3P3QxPMzB6puYPq5E667h/JkPQ2Cn/9/G+rhPplwCcphPoFwJ9ExAX1Oh4aGgr/lkZL0UW33Fsx7AAG+/t4YNM7G37tGaf0csqJizp69F4vjCrtvHpPEJt//b8cU9v1w7u5bddeDlfJGwF5/lyPgO/f8r6m6wdesVMB6Ovt4eb3n8e6VYOcvemeXHVU03uCeNXJi45O17zjlwb4+4cmq/bXDEkPRcRQtfV1j9Qj4v7sj/tWs5ZC4AewU1K/pNdFxA8brtZsHmn2CKvW9EO9qYlq6/cfnGX/wcJUQCuO3vMEdq0zhuL0UmmgA4XULXP98G5u3fl0zXryBmmts4BS1eo/ufeEmmcA1c4+8po9Eq/4nCqNu5XXHSppxX3qg8DekucT2TKzBasYCpPTMwQvh8Lw2GTd19YKnnqhlDe0isHQjDxjq3URtPj60vnmotnDcUxdt+3ae0y7ZgiOHm3XU63+YuCWK+5MN65eQV9vz5zqzKPezn0uOvrDR5KukjQqaXRqaqqTXZs1pFao1bNx9Qp6Tzj2kLW3R3VDqZFQaTYY8oyt1kXQevPO5a+tNuVSVOHgvqIg/5lJo+9NcWe6btUgN7//PAb7+xDQ39fLGaf0NrStRvprh1bc/TIJLC15viRbdoyI2ApshcKcegv6NmuLZu/sgJeDp5m7X0ov2JVeNKx0VNxsMOQZW62LoPXeg0bqGqwy71ytbV7V6u/v6+XFQ0eOmeMu3dmuWzVY926cucp7xtGMVoT6CHC1pG0ULpQe8Hy6LXTN3NlRqlIw5FX+2kqBUh5Ejcgzto2rV1Ttc/OOPVXnnRutq3jReOisV7/i3vDnXzrE7OGXj/sa3W61+m9Y8yaAhq+VVNrZFuupVXclZ5zS29aL3HluabwNuBhYLGkC+AzQCxARXwK2U7jzZZzCLY0fbVexZp1SK9Q6rVqgNBsMecZWr89KR63VzkYGq+xESo+8K+3I5jLeevU3895V21FXq7vazukzl7+p4b4bUfeWxnbxLY023y2UHwJqxlzH1sjrq51pzOW2voWiHV9D9W5pdKibWdulvIPstDnfp25mNldzucZgjfHvUzczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OE5Ap1SZdI2iNpXNKmCutfL+k+SWOSHpV0WetLNTOzeuqGuqQeYAtwKbAS2CBpZVmz64E7ImIVsB7481YXamZm9eU5Uj8fGI+IJyPiJWAbsLasTQCnZY9PB/a1rkQzM8srT6gPAntLnk9ky0rdAFwhaQLYDnyy0oYkXSVpVNLo1NRUE+WamVktrbpQugH4SkQsAS4DvirpmG1HxNaIGIqIoYGBgRZ1bWZmRXlCfRJYWvJ8Sbas1JXAHQAR8W3gZGBxKwo0M7P88oT6g8BySWdLOpHChdCRsjZPA+8CkPRGCqHu+RUzsw6rG+oRcQi4GtgBPEHhLpfHJN0kaU3W7BrgY5IeAW4DPhIR0a6izcysskV5GkXEdgoXQEuXfbrk8ePARa0tzczMGuWfKDUzS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBLiUDczS4hD3cwsIQ51M7OEONTNzBKSK9QlXSJpj6RxSZuqtPkNSY9LekzS11pbppmZ5bGoXgNJPcAW4D3ABPCgpJGIeLykzXLgWuCiiNgv6TXtKtjMzKrLc6R+PjAeEU9GxEvANmBtWZuPAVsiYj9ARDzT2jLNzCyPPKE+COwteT6RLSt1DnCOpAck7ZR0SaUNSbpK0qik0ampqeYqNjOzqlp1oXQRsBy4GNgA/KWk/vJGEbE1IoYiYmhgYKBFXZuZWVGeUJ8ElpY8X5ItKzUBjETEbER8H/guhZA3M7MOyhPqDwLLJZ0t6URgPTBS1maYwlE6khZTmI55soV1mplZDnVDPSIOAVcDO4AngDsi4jFJN0lakzXbATwr6XHgPmBjRDzbrqLNzKwyRURXOh4aGorR0dGu9G1mtlBJeigihqqt90+UmpklxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCckV6pIukbRH0rikTTXafUBSSBpqXYlmZpZX3VCX1ANsAS4FVgIbJK2s0O5U4HeAXa0u0szM8slzpH4+MB4RT0bES8A2YG2Fdn8IfB54oYX1mZlZA/KE+iCwt+T5RLbsKElvAZZGxD21NiTpKkmjkkanpqYaLtbMzGqb84VSSScAXwCuqdc2IrZGxFBEDA0MDMy1azMzK5Mn1CeBpSXPl2TLik4FzgW+Jekp4EJgxBdLzcw6L0+oPwgsl3S2pBOB9cBIcWVEHIiIxRGxLCKWATuBNREx2paKzcysqrqhHhGHgKuBHcATwB0R8ZikmyStaXeBZmaW36I8jSJiO7C9bNmnq7S9eO5lmZlZM/wTpWZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUJyhbqkSyTtkTQuaVOF9b8v6XFJj0r6pqSzWl+qmZnVUzfUJfUAW4BLgZXABkkry5qNAUMR8cvAXcAftbpQMzOrL8+R+vnAeEQ8GREvAduAtaUNIuK+iDiYPd0JLGltmWZmlkeeUB8E9pY8n8iWVXMl8PVKKyRdJWlU0ujU1FT+Ks3MLJeWXiiVdAUwBGyutD4itkbEUEQMDQwMtLJrMzMDFuVoMwksLXm+JFv2CpLeDVwHvD0iXmxNeWZm1og8R+oPAsslnS3pRGA9MFLaQNIq4C+ANRHxTOvLNDOzPOqGekQcAq4GdgBPAHdExGOSbpK0Jmu2GXgVcKekhyWNVNmcmZm1UZ7pFyJiO7C9bNmnSx6/u8V1mZlZE/wTpWZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpYQh7qZWUIc6mZmCVnU7QIsLcNjk2zesYd90zOc2d/HxtUrWLdqsNtl5bbQ6zdzqLfY9cO7uW3XXg5H0COx4YKlfHbded0uqymNBtzw2CTX3r2bmdnDAExOz3Dt3bsBWLdqcF4H5vDYJDf+42PsPzh7dFl5/WYLgSKiKx0PDQ3F6Oho06+fTwFRrGVyeqbi+isufP28CPZG3rPygAbo6+3h5vefV/U1F91yb9X34IxTevnZC4eYPfLy11u97XVKpbGWGuzv44FN7+xwVWaVSXooIoaqrc81py7pEkl7JI1L2lRh/UmSbs/W75K0rPmS6yt+E05OzxC8fEQ1PDbZzm7r1lLNrTuf5qJb7j2mvuGxSS665V7O3nRPxfWtdP3wbn7v9odf8Z797u0P8+Ybv1Gx38079hwTcjOzh9m8Y0/VPvbVeA/2H5x9RaDn2V4j5vJeVhprqVrjMptv6k6/SOoBtgDvASaAByWNRMTjJc2uBPZHxC9KWg98HvhQOwqG2oHT6dP8eoFQVGkqolNTFcNjk/zdzqepdE42PTNbsd9qO6laAXdmf1/NnVuj28ur3ns51xrO7O+bc41mnZJnTv18YDwingSQtA1YC5SG+lrghuzxXcCfSVK0aW6n2jfhvumZOX+Dt6qWSkp3PPWOhFs5hs079lQM9Hr9VlIr4DauXlH39Xm2V2mHBlTdydXbyeepodrOqK+352j/ZgtBnumXQWBvyfOJbFnFNhFxCDgA/Hz5hiRdJWlU0ujU1FRzFVM9WM7s72tq2mAuGj2KK+4Eau2YWj2GPDueySr9lqoXcOtWDXLz+89jMOd7Uml7labWNt71CBvvfKTqdFut9zKPjatX0Nfbc8zy/r7eeTHnb9aIjt6nHhFbI2IoIoYGBgaa3k6lb8JiQMz1G7wVtdRS3AnU2jG1egx5djw9Us3tD/b35Qq4dasGeWDTO/nih958zPvS2yP6+3pRje1V2rHMHo6a8/G13ss8SndGxdq++KE38/Bn3utAtwUnz/TLJLC05PmSbFmlNhOSFgGnA8+2pMIKSk+7y0/Hq80Ht2tetFotcOxURumRaaWpiuL6Vo8hz7TI4QgGq0xDNHP3R63PqJZGdlzFtrXey0bqdYBbCvKE+oPAcklnUwjv9cBvlrUZAT4MfBv4IHBvu+bTi6p9E7biG7xVtUD1UKsXeq0cQ2lf1eaOB7P+W91vo0HZyMXW4k6u2R2IWYpy3acu6TLgi0AP8OWI+Jykm4DRiBiRdDLwVWAV8BywvnhhtZq53qdey3y6h71Z7RpDvfvPu/3eVaqvt0cQzMt73M06rd596gv2h4+sed0O7noavfvF7HjiUDczS0hLfqLUzMwWBoe6mVlCHOpmZglxqJuZJcShbmaWEIe6mVlCHOpmZglxqJuZJaRrP3wkaQr4QYMvWwz8uA3lLAQe+/HJYz8+1Rr7WRFR9dfcdi3UmyFptNZPUqXMY/fYjzcee3Nj9/SLmVlCHOpmZglZaKG+tdsFdJHHfnzy2I9PTY99Qc2pm5lZbQvtSN3MzGpwqJuZJWRehrqkSyTtkTQuaVOF9SdJuj1bv0vSss5X2R45xv77kh6X9Kikb0o6qxt1tkO9sZe0+4CkkJTM7W55xi7pN7LP/jFJX+t0je2S42v+9ZLukzSWfd1f1o0620HSlyU9I+k7VdZL0v/O3ptHJb2l7kYjYl79o/B3UL8HvAE4EXgEWFnW5reBL2WP1wO3d7vuDo79HcAp2eNPHE9jz9qdCtwP7ASGul13Bz/35cAYcEb2/DXdrruDY98KfCJ7vBJ4qtt1t3D8bwPeAnynyvrLgK8DAi4EdtXb5nw8Uj8fGI+IJyPiJWAbsLaszVrgb7LHdwHvkqQO1tgudcceEfdFxMHs6U5gSYdrbJc8nzvAHwKfB17oZHFtlmfsHwO2RMR+gIh4psM1tkuesQdwWvb4dGBfB+trq4i4H3iuRpO1wN9GwU6gX9Lram1zPob6ILC35PlEtqxim4g4BBwAfr4j1bVXnrGXupLCXjwFdceenXoujYh7OllYB+T53M8BzpH0gKSdki7pWHXtlWfsNwBXSJoAtgOf7Exp80KjmcCitpZjbSPpCmAIeHu3a+kESScAXwA+0uVSumURhSmYiymcnd0v6byImO5qVZ2xAfhKRPwvSb8KfFXSuRFxpNuFzUfz8Uh9Elha8nxJtqxiG0mLKJySPduR6torz9iR9G7gOmBNRLzYodrard7YTwXOBb4l6SkK84sjiVwszfO5TwAjETEbEd8Hvksh5Be6PGO/ErgDICK+DZxM4RdeHQ9yZUKp+RjqDwLLJZ0t6UQKF0JHytqMAB/OHn8QuDeyqwoLXN2xS1oF/AWFQE9lXhXqjD0iDkTE4ohYFhHLKFxPWBMRo90pt6XyfM0PUzhKR9JiCtMxT3ayyDbJM/angXcBSHojhVCf6miV3TMC/FZ2F8yFwIGI+GHNV3T76m+NK77fpXBV/Lps2U0Uvomh8KHeCYwD/w68ods1d3Ds/wL8CHg4+zfS7Zo7Nfaytt8ikbtfcn7uojD99DiwG1jf7Zo7OPaVwAMU7ox5GHhvt2tu4dhvA34IzFI4G7sS+Djw8ZLPfUv23uzO8zXvXxNgZpaQ+Tj9YmZmTXKom5klxKFuZpYQh7qZWUIc6mZmCXGom5klxKFuZpaQ/w9KMsCUqoMmmQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -108,26 +110,22 @@ "cell_type": "code", "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING: Logging before flag parsing goes to stderr.\n", - "W0723 13:57:01.752855 139838450616128 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0/lib/python3.7/site-packages/tensorflow_probability/python/internal/distribution_util.py:1846: add_dispatch_support..wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "Use tf.where in 2.0, which has the same broadcast rule as np.where\n" - ] - } - ], + "outputs": [], "source": [ "# Layers\n", + "def make_kernel(lengthscale, variance):\n", + " kernel = gpflow.kernels.mo_kernels.SharedIndependentMok(\n", + " RBF(variance=variance, lengthscale=lengthscale) + White(variance=1e-5),\n", + " output_dimensionality=1\n", + " )\n", + " return kernel\n", + "\n", "input_layer = Layer(\n", " input_dim=1,\n", " output_dim=1, \n", - " kernel=RBF(lengthscale=0.2, variance=1.) + White(variance=1e-5), \n", + " kernel=make_kernel(lengthscale=0.2, variance=1.),\n", " num_inducing=M,\n", - " mean_function=Linear()\n", + " fixed_linear_mean_function=True\n", ")\n", "\n", "input_layer.q_sqrt.assign(input_layer.q_sqrt * 1e-5)\n", @@ -135,7 +133,7 @@ "output_layer = Layer(\n", " input_dim=1, \n", " output_dim=1,\n", - " kernel=RBF(lengthscale=0.2, variance=1.) + White(variance=1e-5),\n", + " kernel=make_kernel(lengthscale=0.2, variance=1.),\n", " num_inducing=M\n", ")" ] @@ -182,10 +180,82 @@ "text/html": [ "\n", "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
name class transform trainable shape dtype value
DSDGP.likelihood.variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].q_mu Parameter True (25, 1) float64[[0....
DSDGP.layers.constituents[0].q_sqrt ParameterFillTriangularTrue (1, 25, 25)float64[[[1.e-05, 0.e+00, 0.e+00...
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (25, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 25, 25)float64[[[1., 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model Parameters Initialized\n" + ] + } + ], + "source": [ + "model.initialize_layers_from_data(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", "\n", "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "
name class transform trainable shape dtype value
DSDGP.likelihood.varianceParameterSoftplus True () float32 1
DSDGP.likelihood.variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].feature.features[0].Z Parameter True (25, 1) float64[[0.80317946...
DSDGP.layers.constituents[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].mean_function.A Parameter False (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].q_mu Parameter True (25, 1) float64[[0....
DSDGP.layers.constituents[0].q_sqrt ParameterFillTriangularTrue (1, 25, 25)float64[[[1.e-05, 0.e+00, 0.e+00...
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (25, 1) float64[[0.80317946...
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (25, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 25, 25)float64[[[1., 0., 0....
" ], @@ -211,42 +281,100 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { - "ename": "AttributeError", - "evalue": "'DSDGP' object has no attribute 'compute_log_likelihood'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcompute_log_likelihood\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m: 'DSDGP' object has no attribute 'compute_log_likelihood'" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "model.compute_log_likelihood()" + "model.log_likelihood(X, Y, 1)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "opt = gpflow.train.AdamOptimizer(0.01)\n", - "opt.minimize(model, maxiter=1000)" + "samples, mu, sigma = model.predict_all_layers(Xs, 10)\n", + "plt.plot(Xs, mu[-1][:, :, 0].numpy().T, color='r', alpha=0.3)\n", + "\n", + "plt.title('2 layer DGP - no training')\n", + "plt.scatter(X, Y)\n", + "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "model.compute_log_likelihood()" + "def log_likelihood_callback():\n", + " return model.neg_log_marginal_likelihood(X, Y, num_samples=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Logging before flag parsing goes to stderr.\n", + "W0806 11:47:55.925436 140433457448768 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/optimizer_v2.py:468: BaseResourceVariable.constraint (from tensorflow.python.ops.resource_variable_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Apply a constraint manually following the optimizer update step.\n" + ] + } + ], + "source": [ + "opt = tf.optimizers.Adam(learning_rate=1e-2)\n", + "gpflow.utilities.training_loop(log_likelihood_callback, opt, model.trainable_variables, maxiter=1e3)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.log_likelihood(X, Y, 1)" ] }, { @@ -266,12 +394,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "samples, mu, sigma = model.predict_all_layers_full_cov(Xs, 10)\n", - "plt.plot(Xs, mu[-1][:, :, 0].T, color='r', alpha=0.3)\n", + "samples, mu, sigma = model.predict_all_layers(Xs, 10)\n", + "plt.plot(Xs, mu[-1][:, :, 0].numpy().T, color='r', alpha=0.3)\n", "\n", "plt.title('2 layer DGP')\n", "plt.scatter(X, Y)\n", @@ -280,24 +421,46 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.variance ParameterSoftplus True () float640.006854127495012341
DSDGP.layers.constituents[0].feature.features[0].Z Parameter True (25, 1) float64[[0.53438085...
DSDGP.layers.constituents[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float642.3178562085177483
DSDGP.layers.constituents[0].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.074805597033129
DSDGP.layers.constituents[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float640.0019556729363524967
DSDGP.layers.constituents[0].mean_function.A Parameter False (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].q_mu Parameter True (25, 1) float64[[0.67832899...
DSDGP.layers.constituents[0].q_sqrt ParameterFillTriangularTrue (1, 25, 25)float64[[[7.34741818e-02, 0.00000000e+00, 0.00000000e+00...
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (25, 1) float64[[0.30371699...
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float640.593223205311789
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.93654088597221
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float640.00019301598179625513
DSDGP.layers.constituents[1].q_mu Parameter True (25, 1) float64[[0.54730136...
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 25, 25)float64[[[5.47589359e-02, 0.00000000e+00, 0.00000000e+00...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "for _ in range(10):\n", - " mu, sigma = model.predict_f_full_cov(Xs, 1)\n", - " plt.plot(Xs, mu.reshape(Xs.shape), color='r', alpha=0.2)\n", - " \n", - "plt.title('DeepGP Fit')\n", - "plt.scatter(X, Y);" + "print_summary(model)" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/doc/notebooks/simple_example_multikernel.ipynb b/doc/notebooks/simple_example_multikernel.ipynb index 5fa57a6..6292223 100644 --- a/doc/notebooks/simple_example_multikernel.ipynb +++ b/doc/notebooks/simple_example_multikernel.ipynb @@ -12,16 +12,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/aboustati/miniconda3/envs/gpflow-v1/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: compiletime version 3.5 of module 'tensorflow.python.framework.fast_tensor_util' does not match runtime version 3.6\n", - " return f(*args, **kwds)\n" - ] - } - ], + "outputs": [], "source": [ "# useful imports\n", "import numpy as np\n", @@ -38,9 +29,9 @@ "outputs": [], "source": [ "# dgplib imports\n", - "from dgplib.layers import InputLayer, OutputLayer, HiddenLayer\n", - "from dgplib.multikernel_layers import MultikernelInputLayer\n", - "from dgplib.models import Sequential\n", + "from dgplib.layers import Layer\n", + "from dgplib.cascade import Sequential\n", + "from dgplib.utilities import print_summary\n", "\n", "from dgplib import DSDGP" ] @@ -56,7 +47,11 @@ "\n", "from gpflow.kernels import RBF, White, Matern52\n", "from gpflow.likelihoods import Gaussian\n", - "from gpflow.mean_functions import Linear" + "from gpflow.mean_functions import Linear\n", + "from gpflow.utilities import set_trainable\n", + "\n", + "gpflow.config.set_summary_fmt(\"notebook\")\n", + "gpflow.config.set_default_float(np.float64)" ] }, { @@ -74,22 +69,26 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -124,25 +123,42 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Layers\n", - "input_kernels = [RBF(1, lengthscales=0.2, variance=1.)+White(1, variance=1e-5),\n", - " RBF(1, lengthscales=0.23, variance=1.1)+White(1, variance=1e-5)]\n", - "input_layer = MultikernelInputLayer(input_dim=1,\n", - " output_dim=2, \n", - " num_inducing=M, \n", - " kernel_list=input_kernels, \n", - " mean_function=Linear(A=np.zeros((1,2))))\n", + "def make_input_layer_kernels():\n", + " kernel = gpflow.kernels.mo_kernels.SeparateIndependentMok(\n", + " [RBF(variance=0.2, lengthscale=1.0) + White(variance=1e-5),\n", + " RBF(variance=1.1, lengthscale=0.23) + White(variance=1e-5)]\n", + " )\n", + " return kernel\n", + "\n", + "def make_output_layer_kernel(lengthscale, variance):\n", + " kernel = gpflow.kernels.mo_kernels.SharedIndependentMok(\n", + " RBF(variance=variance, lengthscale=lengthscale) + White(variance=1e-5),\n", + " output_dimensionality=2\n", + " )\n", + " return kernel\n", + "\n", + "\n", + "input_layer = Layer(\n", + " input_dim=1,\n", + " output_dim=2, \n", + " kernel=make_input_layer_kernels(),\n", + " num_inducing=M,\n", + " fixed_linear_mean_function=True\n", + ")\n", "\n", - "input_layer.q_sqrt = input_layer.q_sqrt.value * 1e-5\n", + "input_layer.q_sqrt.assign(input_layer.q_sqrt * 1e-5)\n", "\n", - "output_layer = OutputLayer(input_dim=2, \n", - " output_dim=2, \n", - " num_inducing=M,\n", - " kernel=RBF(1, lengthscales=0.2, variance=1.)+White(1, variance=1e-5))" + "output_layer = Layer(\n", + " input_dim=2, \n", + " output_dim=2,\n", + " kernel=make_output_layer_kernel(lengthscale=0.2, variance=1.),\n", + " num_inducing=M\n", + ")" ] }, { @@ -154,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -170,127 +186,120 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "model = DSDGP(Z=Z, layers=seq, likelihood=Gaussian(), num_latent=2)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model Parameters Initialized\n" - ] + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[0].kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float640.23000000417232516
DSDGP.layers.constituents[0].kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].q_mu Parameter True (25, 2) float64[[0., 0....
DSDGP.layers.constituents[0].q_sqrt ParameterFillTriangularTrue (2, 25, 25)float64[[[1.e-05, 0.e+00, 0.e+00...
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (25, 2) float64[[0., 0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (2, 25, 25)float64[[[1., 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "model = DSDGP(X=X, Y=Y, Z=Z, layers=seq, likelihood=Gaussian())" + "print_summary(model)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " class prior transform \\\n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/vari... Parameter None +ve \n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/leng... Parameter None +ve \n", - "DSDGP/layers/layers/item0/kernel/item0/white/va... Parameter None +ve \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/vari... Parameter None +ve \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/leng... Parameter None +ve \n", - "DSDGP/layers/layers/item0/kernel/item1/white/va... Parameter None +ve \n", - "DSDGP/layers/layers/item0/mean_function/A Parameter None (none) \n", - "DSDGP/layers/layers/item0/mean_function/b Parameter None (none) \n", - "DSDGP/layers/layers/item0/q_mu Parameter None (none) \n", - "DSDGP/layers/layers/item0/q_sqrt Parameter None (none) \n", - "DSDGP/layers/layers/item0/Z/item0 Parameter None (none) \n", - "DSDGP/layers/layers/item0/Z/item1 Parameter None (none) \n", - "DSDGP/layers/layers/item1/Z Parameter None (none) \n", - "DSDGP/layers/layers/item1/kernel/rbf/variance Parameter None +ve \n", - "DSDGP/layers/layers/item1/kernel/rbf/lengthscales Parameter None +ve \n", - "DSDGP/layers/layers/item1/kernel/white/variance Parameter None +ve \n", - "DSDGP/layers/layers/item1/q_mu Parameter None (none) \n", - "DSDGP/layers/layers/item1/q_sqrt Parameter None (none) \n", - "DSDGP/likelihood/variance Parameter None +ve \n", - "\n", - " trainable shape \\\n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/vari... True () \n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/leng... True () \n", - "DSDGP/layers/layers/item0/kernel/item0/white/va... True () \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/vari... True () \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/leng... True () \n", - "DSDGP/layers/layers/item0/kernel/item1/white/va... True () \n", - "DSDGP/layers/layers/item0/mean_function/A True (1, 2) \n", - "DSDGP/layers/layers/item0/mean_function/b True (1,) \n", - "DSDGP/layers/layers/item0/q_mu True (25, 2) \n", - "DSDGP/layers/layers/item0/q_sqrt True (2, 25, 25) \n", - "DSDGP/layers/layers/item0/Z/item0 True (25, 1) \n", - "DSDGP/layers/layers/item0/Z/item1 True (25, 1) \n", - "DSDGP/layers/layers/item1/Z True (25, 2) \n", - "DSDGP/layers/layers/item1/kernel/rbf/variance True () \n", - "DSDGP/layers/layers/item1/kernel/rbf/lengthscales True () \n", - "DSDGP/layers/layers/item1/kernel/white/variance True () \n", - "DSDGP/layers/layers/item1/q_mu True (25, 2) \n", - "DSDGP/layers/layers/item1/q_sqrt True (2, 25, 25) \n", - "DSDGP/likelihood/variance True () \n", - "\n", - " fixed_shape \\\n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/vari... True \n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/leng... True \n", - "DSDGP/layers/layers/item0/kernel/item0/white/va... True \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/vari... True \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/leng... True \n", - "DSDGP/layers/layers/item0/kernel/item1/white/va... True \n", - "DSDGP/layers/layers/item0/mean_function/A True \n", - "DSDGP/layers/layers/item0/mean_function/b True \n", - "DSDGP/layers/layers/item0/q_mu True \n", - "DSDGP/layers/layers/item0/q_sqrt True \n", - "DSDGP/layers/layers/item0/Z/item0 True \n", - "DSDGP/layers/layers/item0/Z/item1 True \n", - "DSDGP/layers/layers/item1/Z True \n", - "DSDGP/layers/layers/item1/kernel/rbf/variance True \n", - "DSDGP/layers/layers/item1/kernel/rbf/lengthscales True \n", - "DSDGP/layers/layers/item1/kernel/white/variance True \n", - "DSDGP/layers/layers/item1/q_mu True \n", - "DSDGP/layers/layers/item1/q_sqrt True \n", - "DSDGP/likelihood/variance True \n", - "\n", - " value \n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/vari... 1.0 \n", - "DSDGP/layers/layers/item0/kernel/item0/rbf/leng... 0.2 \n", - "DSDGP/layers/layers/item0/kernel/item0/white/va... 1e-05 \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/vari... 1.1 \n", - "DSDGP/layers/layers/item0/kernel/item1/rbf/leng... 0.23 \n", - "DSDGP/layers/layers/item0/kernel/item1/white/va... 1e-05 \n", - "DSDGP/layers/layers/item0/mean_function/A [[1.0, 0.0]] \n", - "DSDGP/layers/layers/item0/mean_function/b [0.0] \n", - "DSDGP/layers/layers/item0/q_mu [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0... \n", - "DSDGP/layers/layers/item0/q_sqrt [[[1e-05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0... \n", - "DSDGP/layers/layers/item0/Z/item0 [[0.5948413798986442], [0.13945092870009101], ... \n", - "DSDGP/layers/layers/item0/Z/item1 [[0.5948413798986442], [0.13945092870009101], ... \n", - "DSDGP/layers/layers/item1/Z [[0.5948413798986442, 0.0], [0.139450928700091... \n", - "DSDGP/layers/layers/item1/kernel/rbf/variance 1.0 \n", - "DSDGP/layers/layers/item1/kernel/rbf/lengthscales 0.2 \n", - "DSDGP/layers/layers/item1/kernel/white/variance 1e-05 \n", - "DSDGP/layers/layers/item1/q_mu [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0... \n", - "DSDGP/layers/layers/item1/q_sqrt [[[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0... \n", - "DSDGP/likelihood/variance 1.0 \n" + "Model Parameters Initialized\n" ] } ], "source": [ - "print(model)" + "model.initialize_layers_from_data(X)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].feature.features[0].Z Parameter True (25, 1) float64[[0.05908349...
DSDGP.layers.constituents[0].feature.features[1].Z Parameter True (25, 1) float64[[0.05908349...
DSDGP.layers.constituents[0].kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[0].kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float640.23000000417232516
DSDGP.layers.constituents[0].kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].mean_function.A Parameter False (1, 2) float64[[1. 0.]]
DSDGP.layers.constituents[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].q_mu Parameter True (25, 2) float64[[0., 0....
DSDGP.layers.constituents[0].q_sqrt ParameterFillTriangularTrue (2, 25, 25)float64[[[1.e-05, 0.e+00, 0.e+00...
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (25, 2) float64[[0.05908349, 0....
DSDGP.layers.constituents[1].feature.features[1].Z Parameter True (25, 2) float64[[0.05908349, 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (25, 2) float64[[0., 0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (2, 25, 25)float64[[[1., 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "model.compile()" + "print_summary(model)" ] }, { @@ -303,32 +312,100 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "-711.4981811794148" + "" ] }, - "execution_count": 14, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model.compute_log_likelihood()" + "model.log_likelihood(X, Y, 1)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:4: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " after removing the cwd from sys.path.\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:6: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:9: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " if __name__ == '__main__':\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:11: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " # This is added back by InteractiveShellApp.init_path()\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "for _ in range(10):\n", + " mu, sigma = model.predict_f(Xs, 1)\n", + " plt.subplot(211)\n", + " plt.plot(Xs, mu[:,:,0].numpy().reshape(Xs.shape), color='r', alpha=0.3)\n", + " plt.subplot(212)\n", + " plt.plot(Xs, mu[:,:,1].numpy().reshape(Xs.shape), color='r', alpha=0.3)\n", + " \n", + "plt.subplot(211)\n", + "plt.scatter(X, Y1);\n", + "plt.subplot(212)\n", + "plt.scatter(X, Y2);" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "opt = gpflow.train.AdamOptimizer(0.01)\n", - "opt.minimize(model, maxiter=1000)" + "def log_likelihood_callback():\n", + " return model.neg_log_marginal_likelihood(X, Y, num_samples=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Logging before flag parsing goes to stderr.\n", + "W0806 11:50:57.157728 139951193995072 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/optimizer_v2.py:468: BaseResourceVariable.constraint (from tensorflow.python.ops.resource_variable_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Apply a constraint manually following the optimizer update step.\n" + ] + } + ], + "source": [ + "opt = tf.optimizers.Adam(learning_rate=1e-2)\n", + "gpflow.utilities.training_loop(log_likelihood_callback, opt, model.trainable_variables, maxiter=1e3)" ] }, { @@ -339,7 +416,7 @@ { "data": { "text/plain": [ - "4.136534479861609" + "" ] }, "execution_count": 16, @@ -348,7 +425,7 @@ } ], "source": [ - "model.compute_log_likelihood()" + "model.log_likelihood(X, Y, 1)" ] }, { @@ -368,36 +445,44 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/aboustati/miniconda3/envs/gpflow-v1/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:4: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " after removing the cwd from sys.path.\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:6: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:9: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " if __name__ == '__main__':\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:11: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " # This is added back by InteractiveShellApp.init_path()\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "plt.figure()\n", "for _ in range(10):\n", - " mu, sigma = model.predict_f_full_cov(Xs, 1)\n", + " mu, sigma = model.predict_f(Xs, 1)\n", " plt.subplot(211)\n", - " plt.plot(Xs, mu[:,:,0].reshape(Xs.shape), color='r', alpha=0.3)\n", + " plt.plot(Xs, mu[:,:,0].numpy().reshape(Xs.shape), color='r', alpha=0.3)\n", " plt.subplot(212)\n", - " plt.plot(Xs, mu[:,:,1].reshape(Xs.shape), color='r', alpha=0.3)\n", + " plt.plot(Xs, mu[:,:,1].numpy().reshape(Xs.shape), color='r', alpha=0.3)\n", " \n", "plt.subplot(211)\n", "plt.scatter(X, Y1);\n", @@ -422,7 +507,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/doc/notebooks/simple_example_multitask.ipynb b/doc/notebooks/simple_example_multitask.ipynb index 21e5b83..85369ef 100644 --- a/doc/notebooks/simple_example_multitask.ipynb +++ b/doc/notebooks/simple_example_multitask.ipynb @@ -4,16 +4,7 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/aboustati/miniconda3/envs/gpflow-v1/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: compiletime version 3.5 of module 'tensorflow.python.framework.fast_tensor_util' does not match runtime version 3.6\n", - " return f(*args, **kwds)\n" - ] - } - ], + "outputs": [], "source": [ "# useful imports\n", "import numpy as np\n", @@ -37,7 +28,12 @@ "\n", "from gpflow.likelihoods import Gaussian, SwitchedLikelihood\n", "from gpflow.kernels import Matern52, RBF, White\n", - "from gpflow.mean_functions import Linear" + "from gpflow.kernels.mo_kernels import SharedIndependentMok\n", + "from gpflow.mean_functions import Linear\n", + "from gpflow.utilities import set_trainable\n", + "\n", + "gpflow.config.set_summary_fmt(\"notebook\")\n", + "gpflow.config.set_default_float(np.float64)" ] }, { @@ -47,12 +43,13 @@ "outputs": [], "source": [ "# dgplib imports\n", - "from dgplib.layers import InputLayer, OutputLayer, HiddenLayer\n", - "from dgplib.multikernel_layers import MultikernelInputLayer, MultikernelOutputLayer\n", - "from dgplib.models import MultitaskSequential\n", + "from dgplib.layers import Layer\n", + "from dgplib.multiprocess_layers import ConcatinativeMultiprocessLayer\n", + "from dgplib.cascade import Sequential\n", "from dgplib.specialized_kernels import SwitchedKernel\n", + "from dgplib.utilities import print_summary\n", "\n", - "from dgplib.multitask_dsdgp import MultitaskDSDGP" + "from dgplib.dsdgp import DSDGP" ] }, { @@ -84,7 +81,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -93,12 +90,14 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA60AAAEBCAYAAACT5ENjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzs3XmcXFd55//Pqa33vVu7ZFneZcvYWLYMZhMBLEOwE8IkkAQSZgbHyjAMSxbLCXtiGTITsgzIOAwmIT8gQEwwxMgYLAM2lmwZL8KyZcuyZe29VFUvVd1d1VXn98e9t7q61S11d91qVdf9vl8vXrirrqquStX33Oc8z3mOsdYiIiIiIiIiUolCZ/oERERERERERKajoFVEREREREQqloJWERERERERqVgKWkVERERERKRiKWgVERERERGRiqWgVURERERERCqWglYRERERERGpWApaRUREREREpGIpaBUREREREZGKFTnTJzCdzs5Ou3r16jN9GiIiUiUee+yxXmtt15k+j4VMY7OIiPhppmNzxQatq1evZvfu3Wf6NEREpEoYYw6e6XNY6DQ2i4iIn2Y6Nqs8WERERERERCqWglYRERERERGpWApaRUREREREpGIpaBUREREREZGKpaBVREREREREKpaCVhEREREREalYvgStxpivGGO6jTG/muZ5Y4z5B2PMfmPMU8aYV/rxviIiIiIiIlLd/Mq0fhXYdIrnrwPOc/93I7DNp/cVCTZrT/2ziIiISCXTvYzMgC9Bq7X2Z0D8FIfcAPyLdewEWo0xS/14b5HA2rEVtm8Zv7hb6/y8Y+uZPS8RqQiqghKRiqd7GZmh+VrTuhw4VPTzYfcxEZkLa7HD/XzuwTgf+Nt/5vtPHnEu8ru2wUi/ZilFBFQFJSKVzFrnnmXXtvHAVfcyMo3IPL2PmeKxk76JxpgbcQZOVq1aVe5zElmYrAVjeOqSP+eLP/sFNT0Zdn7jAa6r+RKRqzfDpq1gpvqVE5Egsdb+zBiz+hSHFKqggJ3GmFZjzFJr7bF5OUFZMKy1jI7lqY2Gz/SpSDUxBmqasYvXMbrzy9TucufNlqyDmmbdy8gE85VpPQysLPp5BXB08kHW2justeutteu7urrm6dREFpCiMprvPnGUWCTEZyJ30ksrD+YvUcAqIrOhKig5rQef7+XVt93PxZ+4l18d6R9/QlmwKeXzlj/7zpP83pd38m+PvnymT6eyWQujA/z9kfO4aPRO3jn6CeK2CY7vgdEBfcdkgvkKWu8G3uuun7ka6NdMrsgsFZXRZO+5he8/eZQ3xZ7mhvBDtDDEd3OvdQLafP5Mn6mILAwzroIyxuw2xuzu6emZh9OSSvJ3P34OMzpArcly50MvOg9q3eG0fr6/l2/tPsyvjgxw6z3PMpLNnelTqlzGMPLGz/DP+bdyrjnKbnsBd+Ve62Rar71Vk/AygV9b3nwDeBi4wBhz2Bjz34wxNxljbnIPuQc4AOwH/gn4Yz/eVyRQjHEyqRs2s3vnDvpSGW7I/pCahhbeeuWF/IirGdv5JbjjdbDj1jN9tiJS+VQFJad0KJ5m98EEv7f0CO/gfr7/+CHiQ6Nad3gK39j1Mu0NMf7udy6jfzjL9l8dP9OnVLms5Qdf/0cS+Xo+GflnLjUv8L3cq51M6723aBJeJvCre/C7rbVLrbVRa+0Ka+3/s9bebq293X3eWmv/h7X2HGvtOmvtbj/eVyRw3MD1aXs2AFeEnoN0H1cM/IThfJiXOl7nXOxHVFYjIqelKig5pbufdOYwrv8v7+O9l3eQsSG+f9vvOwHrBvVQmKx7cIQfP3OC/3LFCl5/fhdnddTzjUdUIjwtY/hO93LWRPp4dehprg//gj12DS90vN5Z03rvLcrmS8F8lQeLiB/ckqy9+VUsIkGnGYAl61j74p0A7O0Z1Y2EiACqgpLS3bf3BJevamVlewPn/dbHWEIfT+TPcZ7UOHOSX+zvYyxvuf6yZYRChutfsYxHX4qTGh0706dWkXK5PE/11/E6+yhm6TreHn4YgPtONMFz9yibLxMoaBVZKIpawe+teyUXnX++E6Ae38O55ghRxngmv0o3EiICqApKSjOWy/PMsQGuWNVWGH/WhV7kKbvGOaB4b00B4KnD/dRGQ1ywuAmAy1a2krew99jAGT6zynSgN0U6H2bduWfDjT9j8dXvZjk9PJ1f7VSNaRJeiihoFVkojIHaFjJX/jEvjDRx0dJmp1HBknXETI5zzBH22rN0IyEiIiV7sTfF6FietUubCxOml67q5ADLGbziAxP31hQA9hxJcvGyFiJh5/Z63fIWwAlm5WTe53Lpdf8dQiHYtJW1oYPOvQwoYJUJFLSKLCQbt7D/8pvJ5ixrlzY56z3c2ci1l72aZyIX6UZCRERK5mUHL17eArUtsGEz697wX7AWnl77YScLVtuioMKVy1t+dWSgEKgCLGquZUlzLXsOJ8/gmVWuPUf6qY+FWbOoqZDNvzj0EgfsUtK2RvcyMkHkTJ+AiMzO3mODAKxd1gyJlkL5zNoHX+Sux2voe9UH6ait142EiIjM2dNHB4hFQqzpaoAlTvCwbmgUgD1HBrh6kxrkFDvQM8RwNjchaAVYt6KFPUeUaZ3KU4eTXLKshbChkM1fe8FfYJ8O8eza/8Urd33OOVAZV0FBq8iC80LPENGwYXVHA2x0ZyGN4Xx3Dc3+dR+iY03HGT5LERFZyPYeHeCCxU1E3VJXHriNjpF+lre+eTwI277FybZu3HLmTrRCFEpdV0wMWi9d3sKPnznB4EiWptromTi1ipTPW/YeG+B3rzqrsPyJDZtZu+ED8PQO9p71e7yyeVDZfClQ0CqywByKp1nWWldYM+NdzFe21wNwODHMhjN1ciIisuBZ6wQUb1m72HvA6eK6axtr6i7hpd6a8b1aN2wuTJ4G2b4Tg25munHC42uXNWMtPHdiiCvOajtDZ1d5jg2MMJLNc86iBucBdxJ+OdBSF+Xpo4Pwm8qwyjgFrSILzOHEMCvb6k96fFlrLcbAoUT6DJyViIhUi/7hLPFUhnMXuQGYu0c4wFkP7ub7iSj0aa/WYi/1pjirvZ5waOJnsbrTCcpejqcUtBY52JcC4Kz2hvEHjcEA5y1q5MXeIX2vZAI1YhJZYA4n0qxoqzvp8ZpImMVNtRxODJ+BsxIRkWrxctyZ/FzVXjRB6gauZ5kT9NNIv21QwFrkYF+aszpOnlBe0VaHMfBSryaUi73c53weJ31m1rKqvZ5D8eHCzyKgoFVkQRnO5OgdyhRKgSdb2V7HoXjRwKiLvYiIzFIhaC0OKNzurqtMNwAH7SJ1d3VZazkYT3FWR8NJz9VEwixrqSt8puJ4OZ4mEjIsbakdf3DHVti+hZXtdRztHyaTzTnfsR1q+iUKWkUWlMNu6e9UmVZ2bGVF+tnxTKt7g6GLvYiIzIYXYBWWonjjya5trLr09QAcPOf3tcWaq3twlJFsfspMKzjZxJfcclhxHIw7VWOF/hxF66ZXHf5PrIUjd3/G+Y6N9Af+OyYKWkUWFC8gXTF5Tat7sV/Z9xDHkmmyY7nxJhm62IuIyCwciqfpbIzRUOO2Pinq7rrq7U6n4JdX3qC9Wl0HC6WuJ2dancfrC+Ww4ni5L82qjonrWdm01fmOvfhN55gnfqJ101KgRkwiC4jXZGll+6RMq3uxX3H878jvMxz79IWsCnXrYi8iIrP2cjx98jIUt7trgzF0NtZwMJ6G39L4AhSyqKunzbQ20JfKaNubIgf7Uly2snXig+69zKqdqwF42S7SPYwUKNMqsoAcTgxTEwnR1Vhz8pPGsOK173GOs53OY7rYi4jILL0cT09swuRxx5OzOuqd7KLGF8DJGoZDhmWtUyzdAc5yP8uDyrYCkExnGBgZm7IJE9u30EU/NWQ4pHXTUkRBq8gCciieZnlbHWaqGwVrWbnnH53j7CLnMV3sRURkFrK5PEeTI1MHra6z2uvVWKjIS30pVrTVEQ1PfVvtlQ0raHUU1ky3n9zoi13bCF19EysXtfNy29VaNy0FClpFFpDjAyMsn2om173YL3nCCVqPv+FvnNJgXexFRGQWjiVHyOXttF3qAZa21tI9OEour7EF4EhyeOoGiS5vSc9h7aMOwNHkCMDE+5middNs2sqq9npejq7Rumkp0JpWkQWke2CUs9dM0ejBvdhHr76Rjt0xTgyOwm+4XYN1sRcRkRk6ZZd615LmWnJ5S+/QKIuba6c9LiiO949wzbmd0z7fVBulsSbC8YGReTyrynXC/RxO+u6466YxhhVtdex+Ka5lTlKgoFVkgbDW0j04Mv0NgnuxX/Tcg3QPjIx34tPFXkREZsLaQmC1tKWuEEBM5o1Dx/tPMSYFRC5v6R4cZclpPoclLbUc71fQCk7VWDRs6GiInfyk+31b0lLLwMgYw9k8dbHwPJ+hVCKVB4ssEIl0lmzOsqhpiiZMHmNY1FRD9+Bo4WcREZHT2rEVtm8pBFaLm2LT7vW9pMUNWpU5pHfIKZP2PpPpLGmu5ZiCVgBO9I+wqKmWUGj6e5TFTfqOyUQKWkUWiGnLaSZZ3FxTOFZEROS03L2+2bWNE3t20FQbof7+j02717eXVdRYQyEQXXq6oFWZ1oLjAyMsbj7FBDzjEyPH+ofn45RkAVB5sMgC4d0cnDLTCixqqqXHbZARPsUspoiICDC+nAQ4/vPDLLF5J2CdZq/vjsYawiGjIAw47gZVp8u0Lm2ppWdolLFcnsg0XYaD4vjACBcuaTrlMYs1MSKTBPu3RmQB8Up+Z5JpzVvoS43Ox2mJiEg1cAPX47adJSbuPDZNX4RwyFmKotLN8UzrTNa0Os2rMvNxWhXtxAzWQhdK0Pt1LyMOBa0iC0S3e3PQdZpMa5e7DqR7QBd6ERGZIXfrtBO2jcUm4Tx2ii3TFjfXapzByRrGwiHap2oqVGSpyl0BGBodI5XJnTbIb6yJ0FgTUaZVCnwJWo0xm4wx+4wx+40xN0/x/CpjzA5jzOPGmKeMMW/1431FgqR7cJSWuii10VN30fPWiXQP6kIvIiIz4AasuZ2300M7S173X0+71/eS5lplWnE6KC9pqcWcpvFhccflIPP+/qcrp8ZaFjfXjH9e2m8+8EoOWo0xYeALwHXAWuDdxpi1kw77S+Bb1trLgXcBXyz1fUWC5sTAyGnXswIsKqwD0Qy4SJBpQllmzN3ru/fyD5LDsLilzikN3rB52r2+l7TUciLgARg45cGnyxqCu4UQBL6D8IyaSrqdrAsTI+6kylSdrCU4/Mi0XgXst9YesNZmgG8CN0w6xgLN7n+3AEd9eF+RQDkxMLNN3Lsaa9zjgz0wigSZJpRl1jZu4fgrPwy46zO95kwbt0x5+OLmWgZHx0iNjs3nWVYcL9N6Om31UWKRUODH5sKWStPdzxR1sl48tNf5vLZvmbaTtQSHH92DlwOHin4+DGyYdMwngR8ZY/4n0AC8yYf3FQmUnsFR1nQ1nPa4mLthd2Gv1mk2hxeRqlaYUAYwxngTynuLjtGEskxw3B03CpnDU4wdS1qcCdLjAyOc09VY9nOrRNZaTgzMLGg1xmivVuDEoBe0TlM5VtTJesmDO+nOdZLbeTvhq6fuZC3B4Uemdapvz+RpkHcDX7XWrgDeCnzNGHPSextjbjTG7DbG7O7p6fHh1ESqg7WWnsHRQhZ1Wm5JTVdTjdMgQyU1IkE11YTy8knHfBL4fWPMYeAe4H/Oz6lJpSqUbracfilKpzse9QW4G+7g6BijY/nTj82urqYaeoeCvXSndzBDQyxMfewUeTM3cF1i4uQI00eLAlbxJWg9DKws+nkFJ8/W/jfgWwDW2oeBWqBz8gtZa++w1q631q7v6ury4dREqsPg6BiZXL5wkzClopKajpGXiadGVVIjElyaUJZZ6xkcJWSgo2HmQWuQg7AeNzN9uq7+nq7GmsKfCareoVE6T/d5uRPui0wSgG7bcspO1hIMfgStjwLnGWPONsbEcNbF3D3pmJeBXwMwxlyEE7Rq5BOZIW8mu6PxFC31vZKaDZvpGNhL36FnT7k5vIhUNU0oy6z1Do3S3lBDOHT68cIbj/oCHLT2ugHoKSeUi3Q2xQId5IOzh/xpJ+DdCffOi98IQO8Fv3fKTtYSDCUHrdbaMeADwL3AMzhNHZ42xnzaGHO9e9hHgfcbY54EvgH8obX61onMlHdT0HG6gdENXDvMAH3WXaqmgFUkiDShLLPWMzhK56kmR4u018cwBnoCXB7cMzS7TGtnYw2JdJZsLl/O06povYMZOk61p63byZoNm+n8tQ8C0HPB756yk7UEgx+NmLDW3oOzHqb4sY8X/fde4Bo/3kskiPpSbqb1NJuXezOUHWaAIeoZsVFqt29R4CoSMNbaMWOMN6EcBr7iTSgDu621d+NMKP+TMebDOKXDmlAOuJ6hzIwDsEg4RHt9sDOH45nWmQX63mfbN5SZUfOmatQ7NMoVq9tOfdBGJ6Palcm5fyaj+xjxJ2gVkfKaUXlwUUlNx5pPwXMQv+yPWbbr753ndcEXCRRNKMts9Q6Ock7n6bvUezoaY8EuDx7KEA4Z2upnFrQWrwMOYtCay1vi6Qydp5uABzCGhpoIddGwMzGi+5fAU9AqsgB4NwXtMyyp6Vj5O/DcL+m78iMsq81ATbMu+CIiMi1r7cya5BTpbKxxsmAB1TM4SkdDjNAM1gDDeNAa1GZM8VQGa5ndd0zrgMXlRyMmESmzvlSGppoINZHwqQ/cuAVqm+n41VcA6E1l4NpbYXRA296IiMi0htztW2Za6gpOn4VgZ1pP01RokkVusNYT0M+sLzW7xlXesQpaBRS0iiwIfanMqUuDPdbCyAAde/8ZgPjQKNx7i7a9ERGRU/IyprMLKGLBzrQOjc54DTAo09o7OMP+HEU6G2sKf06CTeXBIgtA39Do6TsHw3j34LEwPAR93/1ziPyntr0REZFT8rJZs82CDY2OMZLNURs9TSVQFeodHOW8RU0zPr4uFqaxJhLYzGHhOzbLQP+XBxPlOiVZQJRpFVkA+oZO0yK+mDE0vu0zxMho2xsREZmR2e456hzrjEtBDMKcNcAz77bsCXJ2ei4TI12NMeLpDGMB3iZIHApaRRaAGZcHA1iLufcWOhikDzdo1YbcIiJyCuNZsNmVbjp/NnhB2MDwGJnc7NYAg/OZ9QyOlOmsKlvvUIZYOERz7cwLPTsbY1gL8bT7HdO9TGApaBWpcPm8JZ4apaNhBjOTxdveNMboO/edTmnwrm0KXEVEZFo9QxmMgfYZbt8CFJatBLEZk9dMabaZ1q6mmsCuaXWWOsUwM6382rGVzv3/DrjrYb17HDWWDCQFrSIVLjmcJW9Ps0erp3jbm2Vr6Eu5G3Jv2Ow8rhJhERGZQu+Qs31LJDzzW0Nv2UoQy4O9QH1GE8pFOhpjJNLZcpxSxZtt1Rgj/XTt/xYAvYMjhUl5NZYMJjViEqlw8dQM9mgtttHJqHZ8+0n2dw8VmjMpYBURken0Ds6woqeINy4FMQiLp5xy1RmPza72+hjJdIZc3hKe4f6u1SKeytA+0++Ye+/Smf4UPAq9//o+CD+oxpIBpkyrSIWLp5ybgVkNjMbQVh8j4a0B0cVdREROIZHOzDoAq4+FiYVD42NNgPS5QeuMM4eutoYYeQsDw8EM9NvrozP/A8bQft0tzp9VY8nAU9AqUuGS7s1Aa90sB8b6KOlMjtGxXDlOS0REqoiTBZvdOGOMoa0hSiIVvKDVy7S2zWINMIxPQPcF8DNLpDK0zeY7Zi3ND3ycMDni1t1aSP05AkvlwSIVLunOxrbOZnYSaHUH0mQ6y+Lm4O2fJyIiM5dIZ2lrmN04A7hVPcHMGjbVRohFZpf/8YLcoGWnM2N5BkfHZt7oy226ZB7ZRlt0A4nLPgD17c6aVlDGNYAUtIpUuEKmdZZBa/HAuLi51vfzEhGR6pDPW5LpzKw6B3ta66OFcSpI4qlZ7J9exMu0xgOWafW+IzPOtBY3lny23dny5h1u12A1lgwkBa0iFS6ZzhIJGRprZvfr6gW5iVTwZsBFRGTmBkacLvWtcwha2+pjPN89VIazqmzx2Za6urw/E7SSam+f1VmVoLuNJdsO7XSCfDWWDDStaRWpcMnhLK310Znva+bygtb+4WANjCIiMjtz7YQLThAWtAAM3O1b5pJpdScG4gHLTs91DTDG0N4QG89MK2ANLAWtIhUumc7QUje3dUYQzK0IRERkhqwtrK9sa4jNuslNW32U5HAWG7DmOPHU6JyC/LpYmNpoKHCBfmIuOyG4grpuWiZS0CpS4ZLp7JxLtiB4zR5ERGSGdmyF7TcTH3IzrfVR2H6z8/gMtdXHyOUtAyNj5TrLimOtnd2eo5O018cK29kFxZzKg10dDeN720pwKWgVqXDJdJa2WTZhAmc2tyYSIqnZSRERmcxa2P9j2HU7iUe+DkDro38Lu253Hp9h5rQwQRqgzOHg6BjZnJ1TeTC4JdUBm1D2vh+zbSoJwd7bVsYpaBWpcE558BwHxvpgrjUSEZEZWL4egMQLjwHQ/sTtEx6fCW+bnCAFYd64OpdGTMDENZoBEU9laK6NEA3PMvSwduLetgErQ5dx6h4sUuGSw3PLtIIzo6l1ICIichJj4LrbAIg/lCRGhnpG4aqbnMdn2PCmeE/woOhzA865ZlrbG2K8HE/7eUoVL5HOzL40eMdWGOmnbc1HnNdIjcJjf+VsebNxSxnOUiqZMq0iFWx0LEc6k5tTOQ04Qau6B4uIyLQMJGiinUEnTp1lc9ZCN9wAZQ4La4DnWh5cH8xM66wy09bCSD/s2kb7k19yXuPBr8Cubc7jyrgGjoJWkQrW785ct8yhEROo456IiEzDWqfp0q7bSdgmWo271+qu253HZ7umNUDlwaVsEeT9ucGRMbK5vJ+nVdES6UxhgmNGvD1ZN2ym/emvOK+x70HYsFl7tQaUglaRCpZ0mw7MvTzY6bgnIsFjjNlkjNlnjNlvjLl5mmN+2xiz1xjztDHm6/N9jnKGHd4NQKLxPNrXvNIpDS56fCaaaiOETLDKg0vphAvja2GDFOgnUtnZrwF2A9c2nAmVPpoVsAaYL0GrBkaR8vBuAlrn3IgpSjIdvP3zRILOGBMGvgBcB6wF3m2MWTvpmPOALcA11tqLgQ/N+4nKmWMMnPsmuOom4jXLnIDiutucwPXcN804MAiFjFPuGqQALJ0hFg5RHwvP6c+3FzouByjQT2VmPwFvLWzfQp3JUMcICdsE27eoNDigSm7EVDQwvhk4DDxqjLnbWru36JjigTFhjFlU6vuKBIE3CzvXNa1t9THG8pbB0TGaa+f2GiKyIF0F7LfWHgAwxnwTuAHYW3TM+4EvWGsTANba7nk/SzmzNjoBQGL3fU4g5TVnmmUmq7U+GqiqnmQqS0t9FDPHjJ/XcTko61pHsjmGs7nZ7TnvBqzs2uaUCD/ZSrxmPez6sPO8Mq6B40emtTAwWmszgDcwFtPAKDIH3prWUhoxgTPAikigLAcOFf182H2s2PnA+caYh4wxO40xm+bt7KRi5Cz0F3epn0Mg4GyvFpxxJjk8h6xhEa+sOChBq7e/6qzuZYxxugS7a1jbG2pItF7i/FzbooA1gPzY8maqgXHDpGPOBzDGPASEgU9aa7dPfiFjzI3AjQCrVq3y4dREFrbksJdpnXsjJu91VlHv23mJSMWb6o5uck1dBDgPeAOwAvi5MeYSa21ywgtpbK5qA8NZ8nbue46C82cPBWgLl0Q6O+dxGYo6LgckO+3155j1Uie3EgBjaPP2tlWGNbD8yLTOdmB8N/BlY0zrSX/I2justeutteu7urp8ODWRhS2RzhIJGRrmuG7Gm9VUB2GRwDkMrCz6eQVwdIpjvmetzVprXwT24YzVE2hsrm6lNhUCp39CkJoKJdOlZVpbC2tag/GZJUupGnMD1Pb6qPNdVcAaWH4Erb4NjCIyUdKdzZ3rupnxTd+DMTCKSMGjwHnGmLONMTHgXcDdk475D2AjgDGmE6cq6sC8nqWccV7g1FZC5tDbXi0oTf8S6WxJn1csEqKpJhKY8mDvHqSlbu6BfltDsErQ5WR+BK0aGEXKJJnOzHk9K0BbnbMCoDCbG5AbCpGgs9aOAR8A7gWeAb5lrX3aGPNpY8z17mH3An3GmL3ADuBPrbV9Z+aM5UzxKnFKClobYmTG8gxnc36dVsWy1rpj89w/L3CDsIBMKCfnsqZ1ko6GGEOjY4yOVf93TKZW8ppWa+2YMcYbGMPAV7yBEdhtrb3bfe4t7sCYQwOjyIwk01la5zozuWMrLcP9wGudmxKvE19ti7NORESqmrX2HuCeSY99vOi/LfAR938SUIVMa0MJE6T1491w62N+tEupXOlMjmzOlhSAAeNrNAMgmS6tPweMr7lOprMsbp7bkilZ2HzZp9Vae4+19nxr7TnW2r92H/u4G7BiHR+x1q611q6z1n7Tj/cVqXbJ4Tk2e7AWRvqJPLKN5kjWGTC81vEj/cq4iogI4M+a1vGlKNVfvullR0tZ0wrOGs3AZFpL7M8B482r+oaC8ZnJyap7OkxkgUumM1y8rHn2f9AYp8Me0PazPhK7HoHYtkLreDUyEBERcDKtNZEQddESAgo34A1CEDbeVKi08uD2hhqeOzHkxylVPG8Cfq79OWA80xqE75hMzZdMq4iUR0nlwW7g2kqKJI3OYwpYRUSkSCKdoa3UgKKoPLjajWdaSw1ao4H4vMDZc77UcuqOgO1tKydT0CpSoUayOYazubnvneeuYW01gyStG7Ru36LSYBERKYinsiXt0QpBKw/2GleVvqZ1OJtjOFP9jYWSw5m5T8C7lGkVBa0iFarf7bY3pxbxXtOlXdto61xGovUSpzR41zYFriIiUpBIZ2gvoQkTUAhIghBQ+NFUCMbXaAbjMys90+p9x7SmNbgUtIpUqGQp2xAY43QJ3rCZ1nOvcl5r01YncK1tUYmwiIgAzprWUktdI+EQzbWR8e3Vqpg3Npey5yiMZw6DUO6aTGdpqSv9O9ZSF5zmVXIyNWISqVDjs7lzHBg3OhnVtp/sZ3B0jGzeEtWaVhERKeJprkI4AAAgAElEQVStaS2Vs+9oEMqDMzTWRIhFSsv7BKt5VWl7zns6ArRNkJxMmVaRCpXwYzbXmMLee8l0VgGriIgU5PKW5HDpa1rBKZcNRgBWeqkrjFdRVXsQlhnLk8rkSl7TCt7ESHV/XjI9Ba0iFap/2Nvw3Z8GGd7riYiIgNM7wVpnz9BSBWXfUb8y017gW+3Nq7z+HH4F+lrTGlwKWkUqVGEvuBJnJ8cbZFT3wCgiIrPjZfn8yLS21cdIpKp/nEn4lGkNSvMqb8K81MZV4GwTVO1BvkxPQatIhUqks0TDhvrY3Dd8h/ESpCA0yBARkZnza89RgJb6KAPD1R9QJH3KtEbCIZpqI1UfhBUm4H3KtMbTGax2QAgkBa0iFap/OENriRu+Q3BKkEREZHa8ycx2P9a01sWcpn+5fMmvVcn8WtMKThCWrPJM63jVmD/NvjJjedIB2NtWTqagVaRCJdNZXxoXFIJWrWkVEZEihUyrL42YnLGmmrOtubxlYCTrS6krOJ9ZtS/dSfq4pjVIe9vKyRS0ilSohE8t4htrIkRCRplWERGZIO6uQW33s7FQFQetXuOqNp8yra2ByLQ6f78WP9YBu68RhLXTcjIFrSIVyilBKv1GwhhDa320qm8kRERk9hLpDDWREHUl9k6A8e3ZqnmC1M81wM7rVP/YnExnCYcMTTWRkl8rSHvbyskUtIpUqP5hf8qDwbmZ6K/iGwkREZm9RCrjy3pWGA/kqnl7NS9r6Nea1ta6aNU3SUwOZ2ipi5bcnwPGOxAraA0mBa0iFcqv8mBwS5Cq+EZCRERmz689RyEYpZvjnXD9+sxiDIyMMVbFzav86s8B45nWeJUH+jI1Ba0iFWgkM8ZINj8+MJbY3r21TnubiYjIRHEfM61ed9hqLnf1mib5tabVe53+Kv7M+oezvqxnBdyMrfadDyoFrSKVZsdWkvd8GnBnrq2F7Vtgx9Y5v2RLvYJWERGZKOHj9i1NtRGMgf4qLt0cLw/2L9MK1R3oJ9NZ37L5YeMEroWSau3XGigKWkUqibUw0k/yl3cBToaU7Vtg1zYY6Z/zBToIe8GJiMjsJNL+ZVpDIUNLXXU3FkqkM4RDhuba0psKQfE+6tU7PieHM/6UB+/YCtu30F4fc9a0+jChLwuLglaRSmIMbNpK8qLfA6Dt27/lBKwbNsOmrc7zc9BaFyWVyZEZq951MyIiMnNjuTz9w/5lwaD6l6Ik3PWZfjQVgvHmVdW+Drjk8mB3Qp9d22jNHHMyrT5M6MvC4s9UkYj4xxiSl/whPPlLWkzKeayEgBXGZ3P7h7N0NdX4cJIiIrKQeXuO+pVpBWipj1V1pjXpY4NEGA9aq/UzG8vlGRwZK6x3njN3Qh+g/efPc2QwDkdKn9CXhUWZVpFKYy3JR78JQJsZdB7bvqWkmcSWAGxFICITGWM2GWP2GWP2G2NuPsVx7zTGWGPM+vk8PzmzEj5v34K1tNZFx9e0VmH2y6/90z0tVV4e7DWY8uU75gaubWaQpG1yHlPAGigKWkUqibtGI3lgNwCttzznzCTu2lZS4NoagE3fRWScMSYMfAG4DlgLvNsYs3aK45qADwK75vcM5UzzOrD6kml11xu2emtaq3S9YSKd9a1zMEBzbYRwyFTtvqNJP4NW9zvVxhBx3KC1xAl9WVh8CVo1myviE2OgtoXE0tcSC4eoi0WcmcQNm6G2Ze5rWusVtIoEzFXAfmvtAWttBvgmcMMUx30G+BwwMp8nJ2eet9dlyWtai9cb9ux2xpkqXW/olAf7l2k1xlT1OmDv79VSaiMmbxJk1zbaVl3MKDGG1/+Pkif0ZWEpeU1r0Wzum4HDwKPGmLuttXsnHafZXJGZ2LiF/vhTtCa7x5s9lLqm1V1PUq2zuSJykuXAoaKfDwMbig8wxlwOrLTW/sAY8yfzeXJy5nnbhpScaS1ab9jy4MMM5JaQ23k74aurb71hIp3xNdMK1b0lnbckqeRA353QZ8Nm2jquhxf3EL/mL1kezpc0oS8Lix+NmAqzuQDGGG82d++k47zZXA2MIqeRnLx3XokX5NaG6t/AXEQmmOqiUUhHGGNCwOeBPzztCxlzI3AjwKpVq3w6PTnT4mmfMq1QCFxbH3oXlhCD1NNaZQHrSDbHSDbva6YVnM+/WieUvWDcl0B/o5NRbXv6OOCUai/fVF3l53JqfpQHTzWbu7z4gOLZXB/eT6TqJdKZ0rvtFWmqcdbNVOtsroic5DCwsujnFcDRop+bgEuAB4wxLwFXA3dPtXzHWnuHtXa9tXZ9V1dXGU9Z5lMynaU2GqIuFi79xdzyzVYz5Ly2bay6ss2En0F+kbb6aGF9cbXx7jl8u5954Dbaf3UnUFQ5VoVrp2VqfgStM53N/ehpX8iYG40xu40xu3t6enw4NZGFqX8462tbfWO8Td+rczZXRE7yKHCeMeZsY0wMeBdwt/ektbbfWttprV1trV0N7ASut9buPjOnK/MtnsrQ7kcAVrze8ILXAZC8+L1Vt96wEID5XR5cFxvvuFxlkukMxkBTrQ+Fne7a6ba9XwMgPqS9WoPGj/Lg2czmAizBmc09aXC01t4B3AGwfv16ffsksJLpLJeu8HdgrOZmDyIykbV2zBjzAeBeIAx8xVr7tDHm08Bua+3dp34FqXaJlE9NhYrWG7asfT/86mGSr7gRmoeqar2h71sEuao60zqcpaUuSijkw3fA2/ImE4WHIfnvH4LIj7RXa4D4EbQWZnOBIzizub/rPWmt7Qc6vZ+NMQ8Af6LZXJHpJXzuUAhOswetaRUJDmvtPcA9kx77+DTHvmE+zkkqRzyd8We7GyisN2ztTQHQP5KtukBifH2mz+XBDTGGszlGsjlqoz6UaleQZDpb2HLPF8bQ8rZPwsPbiWuv1sApuTzYWjsGeLO5zwDf8mZzjTHXl/r6IkEzks0xOpb3fTa3tS5atc0eRERkdpLpLG1+Ba0AxhQmW5PpbNUFEuVa0+qN9dU4qZwcztLi5+dlLZH7/oIWhkhor9bA8SPTqtlcER/53rjA1VYf4/nuIV9fU0REFiZnTau/k6PN7trFalyKUq41rcVb0i1urvX1tc+0fj+rxorWTrfXfZnEeX8AbXXOmlZQxjUA/GjEJCI+Kte6mZb6KP1VeCMhIiKzM5bLuw3//J0cjYRDNNVGqrKqJ5nOUBcN+17C620Hk0hV3/ic9LOppDFw/ClYso7WzmXOOuBrb4Ul65zHFbBWPQWtIhWmnLO5g6NjZHN5X19XREQWlqRbiurbmtYirVXaPyExef90n3gTB/1V2N3f1zWt1sKSS+H4HtpTLzgTI/feAsf3OI+rRLjq+VIeLCL+8QYuv8uDvcF2YDhLR2ONr68tIiILRyLlrs8sR9BaFyNZpZlWvzPTMD42V1sH4VzeMjDiYzbf7R4M0PrzX/FM3kJ8m7oHB4gyrSIVJlGuTKv7eskqnAEXEZGZ88YZX/ZpnaS1PlqV40winS2U8vrJa+xUbSXVA8NZrPX5XsYNXNvNIHHUPThoFLSKVJhytdVvcUt0qnEGXEREZi6eKk/vBHDGmmrsn5BIZ3wflwHqYmFqIqGqa17lTVz4+h1zmzG1mUFGqGHYxtQ9OEAUtIpUmGQ6QywSojbq769nW/FWBCIiElheVq9ca1qrMdOaLNOaVnA/s2qaULa28PdprYv5E1QWdQ9uW7MegMRlm53uwQpcA0FrWkUqjNe4wPhc7lIoD1bQKiISaF6mtRyZQ29Naz5vCYWqo2wzn7fumtbyBK1t9bHqWdO6YyuM9JM8+8MAtNRFnKCytgU2bpn76xrjvMaGzbSt/B147pckrvooy2ozzuMqEa56ClpFKkxyuDwlSF5jp2qcARcRkZnztm+pi/m7fQs4E6R5C0OZMZpryxPkzbfB0THytjxBPlRRptVaGOmHXdvoP9EFXEjr7n+EPW7DJGtLCy43OhnVthfjgLs2W2taA0NBq0iFSaSztJRhNrepNoIxzmbfIiISXPFUeZoKQdEWLuls1QSthVLXMgWtbfUx9ncPleW151VRh9/kQzuBC2l96p/gah87/BpTKGuPpzMKWANEa1pFKkx/mToUhkKGlrrqXGskIiIzF0+N0t5YpqxhXfUtRfHKqdsbyremtWrKg93ANUkjAM2kfM+Gels1VUV2WmZMQatIhUkOZ3zfo9XTWhetqhsJERGZvXgqQ3tDefbrHt9erXoCimRhK7pylQc764BtNTQTchsmJW0jzaSImLzvjZK8iRFvMkGCQUGrSAWx1pIoY4fClvpY1e0FJyIis9OXytBRhs7BUJ1N/wqZ1rKVB0cZy1tSmVxZXn/eFHX4TXa8kpa2Tmctq88dfiPhEM21kar6jsnpaU2rSAUZyebJjOXLuG4mqplJEZGAczKt5RlnWqqw6Z832dtWrkDf/cwSqQyNNQv41ryow2/i2MW0pTOFNa5+d/hta4jpfiZgFvBvhkj1SaTLt+E7OCU1B3pSZXltERGpfMOZHOlMroxBqzN+VVPTv0Q6QzhkaK4tz21zcXZ6ZXtZ3mL+bNwC+TzJL/7CmYA3Bq69FUL+7z2vyrFgUdAqUkEKs7ll7OqoxgUiIsHVlxoFKFt5cCwSoiEWrqrSzYTbINHv/dM9Xga3KoIwd5/WRPpaVnc2OCXB995S+j6tk7Q3xOgeHPHt9aTyaU2rSAXxBvly7QXXUhdlYGSMXL4Kmj2IiMisjXfCLc84A+4EaTWVB6cyZVu2A0Udlxf6Z2YtjCRh1zYS/QO01UVh+83OmtaRfn+bMdVHSaQW+Ocls6KgVaSCeDcTZVs342ZwBxb6wCgiInPS544zHWXa8gacCdJqquqJpzJla8IE412JF/xn9sBtYCF75WYGcxFaH/0/sOt2WL7e921v2lUeHDgKWkUqSLJQHlzeoFUXehGRYIoPeZnW8mx5A85YU03lwcl0lrYy7dEKRWPzQs4cWutkUx+5nWTWWX3YzqDz3PL1vr9dW0OMdCbHSHaBd1yWGVPQKlIprCWe8vaCi/paRuMpzOYq0yoiEkjzUx4crapxJp7OlG0yGSAaDtFUE1nYe9sa42RTr7qJ5C/vAqDVDLnP+f923r+HJuGDQ42YRCqB17gg+x6aaiJEQ8bZ08znxgWtha6O1XMzISIiM9eXyhANl68TLjjb3lRLptVaSzKdKduyHU9LtWSnDSRoBKCNQdhwk1MijPG1RLi9YTw7vbSlzpfXlMqmTKvImeaV1OzaRmL/I87A6G7O7X/jAi/TqplJkWpnjNlkjNlnjNlvjLl5iuc/YozZa4x5yhjzE2PMWWfiPGV+xVOjtNXHytYJF5wO+P3DGWwZKoaKjeXyZX19gKHRMbI5W7au/p752sLFWlveZoyHd5OwTQC0mSGwOIGrz/u0tirTGjgKWkXONK+kZsNmEr3HaEvscQLWDZt9b1xQ6FBYDbO5IjItY0wY+AJwHbAWeLcxZu2kwx4H1ltrLwW+A3xufs9SzoR4KkNHY/nWs4JTHpzNWdKZ8q033P6rY1z4se3c8IWH+NWR/rK9j7fOtJzlwTA/64D/dedBrrntfq657X7/t4ux1plwP7Kb5OpfB6D18t+AR253Atc3nDRvVpL2atomSGZEQatIJXAD14Rtos24jQt8DlgBmhW0igTFVcB+a+0Ba20G+CZwQ/EB1tod1tq0++NOYMU8n6OcAX2pTNn2aPW01pW3f8LBvhR/+u2nOLuzgSOJNH/x3T1ly+omytwg0VPufdQP9qX45N1Ps6i5lv7hLB/8xuP+ZlyNcbKpGzaTOOftALRd95fOBHxdq+/3M+PNqxS0BoUvQatKkERK5M5QJmh01oCAM2Pp8yAcNtBcGxkfGMtcuiUiZ8xy4FDRz4fdx6bz34AfTvWEMeZGY8xuY8zunp4eH09RzoR4KlPWJkzgrM+E8m3h8n/v30/OWu5835X82aYLefJwP/c+fbws7xVPl3crOk9bfZREGSeUP3/fc0TChjvecwWfePtadh6I89Pnuv19k41bnAn44SyxcIj6mogzAe9jbw6PN4kQX8gdl2VWSg5aVYIkUiKvpGbXNhKhdtpe9R5nZnLXNn8D1x1bYfsW2rxN37333bHVn9cXkUoyVVpjyouJMeb3gfXA30z1vLX2Dmvtemvt+q6uLh9PUc6E+FD5g9ZyNv0bHcux/enjbLpkCSva6nnH5cs5u7OBrzz0ku/vBeOBd9k/s/oYAyPZsqw37Rkc5XtPHuW9r1rNouZa3vHKFbTURbn7iaO+vxfGkExlaa2POuumy7R2OhoyNNVGiKdGnQc0CV/1/Mi0qgRJpBRuSU3myj8mlYs4s4fuGlffGhcUNXtqzZ5wyoPL1OxJRCrCYWBl0c8rgJPuUI0xbwL+ArjeWjs6T+cmZ4K1jI7lGBwdc8qDy3jdL+f2aj/d18PgyBjXv2IZAJFwiLetW8pjBxNlyezGC2tay92IKYq10F+Gz+yBfd1YS+Ezi0VCvHXdEu7be4LhMqw7TpR5iyBvEr6zIUZfKqNJ+IDwI2j1rQRJJLA2biH5mo8DbgmS15zJr5KaomZPLakDJJ9/uGzNnkSkIjwKnGeMOdsYEwPeBdxdfIAx5nLgSzgBq891glJR3Jv8xFBR1rCMN/mt9eXrn/CDp47R3hDjmnM7C4+98aJF5PKWnz7nf/l6Mp0hZKC5trxBq5fJjZdhjeb9z3azuLmGi5c1Fx57+6XLSGVy7Njn/69+Mp0tfAd8VzQJ35E9Rt9QRpPwAeFH0OpbCZLWzUiQxYcndSj0O5B0A9dWhuh391BTwCpSnay1Y8AHgHuBZ4BvWWufNsZ82hhzvXvY3wCNwLeNMU8YY+6e5uVkISu6ye+7738D0PHct8p6k9/iNf3zeXs1ay2/eKGP15/fRTQ8fgv7ihWtdDTE2PGs/wFYPJWhtT5GKFTesbJc3XAzY3l+/nwvb7xw0YRtjjas6aCxJsIvXuj19f2wdmKm1e/vV9EkfMfQPvpefEKT8AHhx87Ssy1Bev10JUjW2juAOwDWr1+vqRIJlEJb/YYyzk5u30KrGSaZb3Ae275FF3mRKmWtvQe4Z9JjHy/67zfN+0nJ/PNu8oH4L7YDr6R9/7fhVeW7ya+NhqmNhnzPtB7sS9M7NMr61W0THg+HDK+/oIsdz3ZjrfV1D1onACtvlhWKGwv5G7T+8uUEQ6NjvOGCRRMeD4cMl69qZfdLCf/ebMdWGOknkf41517GK9utbfG3GZP7ne548CPszl/gPKZ7marnR6ZVJUgipXJnJsEduPyemSxq9tS6/EL6TRP5q8rQ7ElERCqPe5MfxykPbWew7Df5bfUx37cj2X3QCbCuXN1+0nNXrm4nkc5ysC990nOlSKSyZd/uBooyrT5/Zo+/nASm/szWn9XOvhOD/qyjdTP6duc2kqkRpxlXucp23XuaTgZI0ETOGt3LBEDJQatKkERK5K01cgeq9vqo/2uNivZPa730WqfZw+s+5W+zJxERqUzuTX6fdYLWDjNQ9pv8tvqY76Wuu1+K01wb4dyuxpOeu2xlKwBPHEr6+p6JdKbs293AeKa1z+eg9YlDCc7qqJ+y+/GVq9uw1snGlsydGBla/wHGbIi2hz5TnrLdokn4jrMvJU+I5Cv/pybhA8CP8mCVIInMVdFao8SSlcBqWh/8NDzqXuit9e9Cv9G5mLe7Le4Tw1nayjXTPvm8/fx7iIjIzBXd5MeX3Ub4sKFlw3ucm3woW8a1vSHm+76juw8mWL+6fcr1pectaqQuGuaJQ0l+4/JT9QOdnUQ6wytWtPr2etOpi4Wpi4Z9z7Q+eaifDWtOzrICXLaqlXDI8NhLCTZOKh+eE2NIvvoWeOgBWhlyHvP7+1U0Cd++7J2w/wn6NvwpHbGsJuGrnC9Bq4jMUdFao8SDe6lnCTWPfrF8DQWMKcwYJ9IZMCfPVpfMXdNSOP9yrWkREZHTK7rJ7xu+hrb4CULXbXXaaJbxJr+1PsrRo8O+vd7Q6Bj7u4e4wd22ZbJIOMS6FS2+ZlqttSRSWVrL1WtikvaGGHEfs9PH+0c4PjAybdBdH4tw0dImnjzs02dmLYmffB64nDYz6DxWjt4Z7iR8x4E+AHpTGc7Xmtaq58eaVhEphRu4JmwTbbgX+TJefNu9EqQh/9vqF2eOC2U6akUvInJmbXQCh3gq45SJ+r2t2hT8DsD2HR8AYG3Rti2TXbaylb1HB8iM5X15z1QmRyaXL4yb5dbe4O86YC+Av2zV9Jnii5Y088yxwdLfzB3vE3vuBaDtv37HmYAvV9muMXQ21gDu/YwC1qqnoFXkdCZfaMvUJClBI23GLacp47oMrzux32uNgAmt6Nm1DT7Vqlb0IiKVwJjxoNX9uZza6mP0D2fJ5f0Zy/a6gdWFS6cPWi9d0UIml+e5Ez4EYYw3RZqPRkzg7NMe97Gkes+RJOGQYe0pPrMLlzbTOzRKz+CUG3vMnJvRT57zGwC0NtSM3w+UKaPf0eBNwpd47rIgKGgVORW3SVIhgPQyh341SSpea9RwDm3nXlnemUmgo8GZmYyn/N/0HZhQ8lyggFVEZGrlnhgt0pfKFMaAcmurjzpN//zoTAs8c2yA5toIy1pqpz3mwiVOcLbvuE9Bq9fVfx4aMYHTiDGe8i8A23d8iDWdDdRGw9Mec9GSJgCedTPZJdm4hfi57wCcf/9yZ/Rb62OEjP/NqyaYx99POTUFrSLTyecnlrrm8/6XuhatNUpGlzizuWWemayLOfvnlSXTCuOBeDF19BMROVnRxOj+7iH+dedL3PO1/4P9ya0Tj/Pp+jkh01pmXqDn176jzx4b4MKlzafcg3V1Rz2xSIh9fmVa3axn+zytaW1riBX2bPfDvhMDnO8GpdPxMtfPHPMhaMVp8gjQUud+ZmWcsA6HDO0NMXrLsdwJGPjRZ/na//sH/v2xQwyMZP1PXMisqBGTyFS8ZkLXujcOu7aR3XkHUZPzv9TVbSgQ3/WjiWuNynihb6+PlWdNaz4P996C3bmN3IbNRDbdCvfeUvYulSIiC05RD4Cfxlv5o2dfwUg2D1zEOw7u4bOvGyMajfjWzG4slyeZzs5b0Npe3PSvRPm85dnjg/z2+pWnPC4SDnFuV6N/mVY34G6drzWt9TGGRscYHctRE5k+OzoTqdExDsWH+e0rTv2ZtTfEWNxcw7N+rGsFkukMzbURIuH5yYt1NNSUpTz4UF+KP9y5hhfS9bD/KS78+Yv8y9n3sehxd8lTPg8h5f7mkz5tkcmKmwndewt913yCGzMf5sLRr/KezM0c3/Cxk7dzKVE2bxkcGaO1vvwzk+DO5vqdad2xFe7dwq7UUl5rvsLlj2zks9u+hK1p1n6wIiLFvG3ANm3lpUs/zPv3XMCasQM8EPswH279GXel1vG1r37Rv2Z21hayhh2NsXmpfPHWgfrRWOhQIk06k+OipafOGgJcsKTJvzWtaW//9PnNTid9WNf6fLfTI+N0mVaAi5Y2s9evTOs8ToyA833u9Tlotdby0e88RU++mX+9dA9fiX6Ol4/38Ec7O8hftdlJaNx7izKu80xBq8hkRc2E8jtv58O3fZ6f5l/BO8M/47H8+bzv8/9GbiznHOtTqUiyUII0fzPgfpVsAc7nsP/HvPzwXbznsTVEGtq5pvEY2w6t4iuPxZ0LvLa7ERGZUBJsgU8m30qMMe6MfY7VoRN88E9v5bVtCf7uhSXEP7my9GZ27vv1DI4A0NUYm5cSxzYfM6373QDs3EUzC1qP9Y/Q70Pgl0hlMAaa6+anPLjDx5Jqr9vyhTMIWs9f3MSB3pQvTbOS6cy8ZaYBOhtrfC8P/uGvjvPIi3H+/LoLec27/ow3hp/gM9E7edyex3c6N49XkGlXhHmloFVkKsbAtbfy/+V+jZ/lX8HHIl/js5/+LLd1bueZ7GLu+vwHfF3jmkzPcwmS30ErwPL1fHbsdwjbDP829IdsG/xfvCm0m9vir+eF3pS/7yUishBN2hbswed6eOC5Hj4UuYvFxtmexPzoL/j4e9/OIHV8dexa58/NNWAter/uHbcDsOjpO+flhrvNrRzyo+nfi+4YcnZnw2mPvWCxE6Q91116tjWeztBSFyUcmp8qIT/XAe87PkRdNMzKtvrTHnt2ZwOZsTxHk6Xvq5tIZwr/9vNhUVMN3YMjWJ++y9Za/u7Hz3HhkibetX6lE6AC7wj9nCvNs3z2rocY2fll7YpwBihoFZlKPs/Y9lu4feztXGH28Xvhn8CP/oK3f2gbl8WO8Ld9ryL3qXbftnMpNHuYrxKken/3gsMY9l52C/+ZfxU3hv+TxSaJMbD1qiyhcIQvP/iif+8lIlJu5eoYOmlbsH/65y/TRYL3LD8KH08UHj/ve2/jtaE9fCf3OnLWzL2ZXdH79TzzIACL9t45LzfcddEwNRF/mv691JeipS46o2DIK4f1Y11rPJUpZD/nQ2ELFx/G5+dODHLe4kZCMwi4vcmAF32YYE6ksvO2RRDAouYaRrJ5BkfHfHm9Jw/389yJIf7gVWcR/tEthfs884kEH4l8mz5a+G7uNU4FmTHKtM4jBa0ik+24Fe54HT98+HGO0MWNv/suzNJ1sGsb5r6/5MbfehvH6GBnfq1zvA8Df7zQ7GF+ZifbG2IMjo75tgE7wHcfP0LU5HlfZHvhsa6aLO+4fDn//ssj42tOdIEXkUrmle/m3etjYRnIraf+czPlBpLP5Zfzs/wr+IPIj6j5ox1OU5drb4Ul6+D4Hn77ghhH6eQX599c2jZo7vt10wpAl0nOS4bIGKezqx8TpC/1plnd2XDKzsGepc211EXDvgRgvUMZOhrnZ4sgoPBevaXumYoTgJ7T1TijY9d0+Re0znd5cFeT85mVvM+s61u7D1EbDfHrr1hW2N3BW8N6degZLjYv8v9y12G33zJecefXtQG0xc4pKGgVKSptnMsAACAASURBVGYtjAzA8T38S+g3Wd1Rz5sO/QMc3+PcSMSaeOOhL9BImrvzr3b+jA/buSTney+4QrMHf7Kt+VyeHzzyLK83j9Nqiga9Xbfz34/+JZmxPP/26KHqbRevQUZk4Sr+fbUWRpJOkHjH6yYuA9l3D9zvw82pex38eu7XiJHhd8P3OyWI1jqB6wVvhQ2befPvfoiWuih3ha8trZmd+349tpUmUtSa7LxtQ9Za70/Tvxd7U5zdcfoyV4BQyLC6s8GXAKxvaJSueQxaW91S5L4S92odyeY4khyeUTk1QFdjDY01kZI/s8xYnlQmN8/lwc6+vd0DpQetmbE833/yKNddspSm2qjTi8NrurRrG2bpOv5rZDv77Qp2PvyAc43w89pQtN4dOPmeKeD3GgpaRYq5M9JHXvEhHh1dyTv77yT8iFsC/P6fQmaQ2t1f4C2LB/lh9M2MXvnHpc2Au+Lz3KGw3ccSJIBHDyY4NlrD28O/gKtugk8k4co/AuCcvp+yvrmf7z1xxP99bivB6QYZEalcO7bC9pudpkjWsvulOF89vJS7I9cycuxZ+HSbc81ys5+MDji/4yV08WX7FsZ2fokfhN7Imy5ZRfvVvz9xHNl4C2zaSk00wq9dtIgdz/WQe8scm9kVdR/uab+Crq5FhRLk+Qhc2xuiJY8zI9kcR/uHWT3DAAxgjU9Bq5Npnb+sYcjdd7TULele6pv5GmBwsuJndzZwoMTPrNCfYx5Lqhd5mVYfOgg/+lKcwZEx3rpu6fiDodB4xvX9P+WtS4doYJj/yL9mPKFRfG2Yq0nr3Y8l03z9K3/P1x563llrvOPWwN9raJ9WWRi87QG8/4aJP/tZ5mQM3297D7CP60MPO495pVTuhevXV7+Nu/55N4+e/xFeE7Ilb+eSTGepiYSoi5W2L9tMjTfIcAfGEj/D+/aeIBbK8+arLofr3HUeb/0sHH4UBg5zff9dfHzgfTyb+AEXLlsHNc3+/ptNPn+/vxOnel9vkIEJM7Lax02kwrldzzmym55MlA8cfxu7XowD5wHnsZRf5+9j/5erQvucm9INNzljAcx931R3HHnw/Jvp3RPjhsuXw1r3NYvHEff/33jhIu765REeP5Rk/er22f8dC+PWTXQfPJ9FIXeNK6WPW6dlLR0NNRxJJAs/z+X9Xo6nsXbmARg4x25/+jjZXJ7oHPcLzYzl6R/O0tEwf5lWcNa1ltoN98We2QWt3rGPH0qU9L7eBEXnPAatXnlw98BIya91/7PdxCIhrjm3Y+ITG7cUvr91N93PtX+5hXtyG/hU5KvUHt9T+hpx775201ashS8+dJS//+mPyLjXok8+arhx+cv8affnnGzjpq3jSYANm+fvnucM093UQjN5hreUGd+FojiT9ZO/hh/e7MyM79gKuZz/M035PN/7+WNcZp5nVajbeawwA74FNm1lw5oOIiHDQy/0ORePErdz6R0anb9mDzu20vH4FwF3gCllts797j30Qh/rz+6i/m1/PfHCueoqSHXz1vAuwuS4O/fq8RnJvE/raSfPPubz7vejqFSnXL8nk5qqFLIyG7SPm8iCsHw9J2wrv7nzHJ588RifjtzJozU38a+LvkGdGeUPMn/OzvyFzrHediClVoxs3MLdkWtpro3whgu6xq8jU4wjrz2vi3DIcP+z3SX8JQHrrPnrckspKfdtgztud3hZwxLGGS9jurpjdgFYLm85FE/P+v08XlnzfGZawdnCpdTy4AOz6LbsObuzgcOJYUayuTm/r5chns99WlvqosTCIV8yrTue7ebqNR3Ux6bI6XlNl+69hXeEH2SQeu7PX+485zVlmtObboUvv8m5bwH+xvwBfzP2O7w59Bg/jv0JOz76et5x+XK2HVrJh1s+T37n7fCpVt8agS4kCloXEu+L/cObx2/Ct9/sPFZtN8be38/NZHXv/Dof+9Qt/M6OBj720AiHHv4ODCfgf5/rb7npjls59IW380yqkbedHXa6OS5ZN7GUyhgaaiJctrKVX7zQ58vFom8oQ2fTPMzmup9n5547nPcdHJ37DZhbVhcfGuWZYwO8+pwOuLfopsQYuHYrLFlHpxng6tAz3Je/wvk83/LXE4+dq/tvddaSuP8+O/f3cOMnPst7f97CtkfiZDNZ5+/0Q+/3pEzNEq6d9LrFGddqKoUWKbP+4Sz//thh/uoHe/k/P9rHoy/FfdvK4iTGMPKmv+bG2G3EbTPfjP0V743cR9eSs3jNwPf51opvs8z08YHMB+m1zfDol3y5WRzO5Lj36eO8dd1SaiLhwrlMpaUuyvqz2uYetHrVII/cTndikEXeHq2P3F6+a1NRBUrH0QcYHB1j5J65Xw9f8oLW2QRgPjQW8poHds5z0NrRGBtvXDhHL/amWNxcQ0PNzAsq13Q1YK2T2Z4rL9iez+ZVxhi6mmroKXFN68G+FAd6U7zxgq6pDygqtX/VshCLSDhdhGF8/ftsWQvDSTiyG3bdzvavfY4v/vQA7w7fzz9G/5FzQ0c5e/dn+NxvreNP3nI+3+texN+N/db4ny9DwDqcyXH3k0fZes8zfG77s/z8+R5f9u/1g8qDFwqvOcSR3c7/AAywy9l3jeXrq6c8YMdWp2RrxXrYdBtPrP0z3vfzK0jlI1xsDvJvdiP/kbuGb+z8Ky4JxaG+wwmCSv27u02YHjjhzES/8YY/cAIPb83CpJLWV5/Twf/dsZ/+4SwtddGSPv/eodHCuoyycmf0Wy2Ef5aj94e3QvRbs78Bsxaevw+OPsbDPZ3AWl7d/U149nbnu/gGZ8aw8PkBG0OP81dj7+HQ0WOs/KfXO48vv8I5dq7NRUYHCv8+X3voeT7200fo5CwWmQSfTbyC7X/1Vb52xQGaH3d/T3KjTobhjbfM/v2K7djq3HzVNsNwv/O7WOzTbc7/L1nnHFMNv5ciZWSt5RuPHOKz25+lf9hZLpHN5fnH+/ez4ex2PvfOSzlrFpm207xZ4Xfyth8+y5ODzfxT9H9zWegF5/lIDBavo/PELr54xWt4+xNXcnPoo3zZfmL8NUq4WfzxMydIZXLccNnyGR3/uvO7+Jt79xFPZWafwXKv+UNjYdIPhenadStEflDeDI2XOQY6HroPeD/xR77Jsqvn9p4v9aVob4g54+wMrfFhCxcva9g5jwGY936lrml9sTc1qywrjGdlD/SkON/d63a2eguf2fwG+l1NNXSX2D34Fy/0AfDa86cJWo1xxvMl6wgff4obVqT46rErSXRdRdvxR5z7ndl+v42B624DoGfX17l571msMwf4VOROQhtudJ7fdTsGw/94y19z8Kmf8Q/H38HVob28OrzXCaJ9/D2+b+8JbvnuHnoGR4mFQ+St5YsPvMDFy5rZ+o51XLqi1Zf3mStlWhcCb4DddJuzpgacWVIvYL3qJudLXw03xpNmnY7+xyf471/+KY12iHtit/Ddmk/w49if0sQw781sodu2wkefh7APa0HdgXZH8w2cZY6z5osrx2fUb/zZxEBnx1au6ft38hZ2HegreUF879Do/A2MxhC6bivtDNBLi/PYbC96D2yFnDM4PbTvKE2kufSZv3WeW76+8D7UNsPidcD/z955h0dRrm38N1vSe28kBEILHUKXElCIqNjFiuVIE8WugA1FCPqJYgXsHXtBpakUlRIIHUINEEJ6QkhPNrsz3x8zk2xCyu5mk+A5e1+Xl2TKvu/Ozlvup9wPjNXskW8V+9UQWYxV8mfZ+D3U0Nw/MvQ8Y7yHSzW7+Md5NqtHnOJt/escMgRxf5InRklTK5bQUu+CeR7rkd/qjsX6yD4gq1G3haf1f1xV0IF/L6pNIk9+v595Px4gNtSLH+4bzuEXEtg/fwILru5JSmYx17y9hf1nz7e8MbN0k60n8vh4Wxp3a9dwmXZ37TUZu0Crh8Ez6Hb9Mzx2WVf+qOjCRlO/2mtaIGL0894MQrxcGBJtWY6qet2OUwU2tYcgkDdUDj0OEpRn2Nohhcr87C8UA1Agedvc5qn8MjpaqByswsfNCT93pxYJC7WH11Buz4lyg4lyg+11R2XSalm5GxX2qNVaUFqFTiPg5dJ26sEgizG1tORN0skCAjycawweDSJ+HnSV1b2vufZmqk0Sv/Z/t2Xq3gpxXWK8iVJceU3/Dk6CCS5/Sdn3zwRnL4T1T/FC4Rw6uZbzuPuLlAy8366Cau/9dZKpnyYT4OHMl/cO4ciCBA7Mn8Brk/tyrszADcu38cu+zBa30xI4SOvFDjNlQ0AOt6yP1iSs9QZCfkklu9IKOZlXemEohD1yFFWr0+AZSBI8stODymojH+r/jxiNPFgiNbl86rSYUlx4vvoOWP+U3TbolUaRrSWBxGv21j7ShMS6YjoKael3ZAlOgsiutMIW5TiJotR24cFQQ7ADhCIKJC/5mDWTnloWKOcABPdml9iVAZpj6ARRJqjqxsT8ukHTiQ4JIErIrs0BCe4FOQdbRuoEgZLRz/N09d30EE7zlv4NuZyDVssV2iRe1H3IX2Jf3jNdIRPIwTNkr+imxba1p7RZk8eac7DmsEkS2Ct25oAYTYWkWJnVUOjWNig5FIwd+JfCaBJ5+Ou9fJN8lgfGxvDFvUMYEOmLRiPg4azjjmEd+eWBS3B31nHbe0kczS6xvTEzg1PV6nnM+/Eg0ZpcntR9Jc9HzxbKcwSAoKnxFt5V+j7RQhYLdPdjfPpci9R3C8sMbDqax6R+YWg0ls0LfSJ8cNFr2H7ynFVt1UCSyP3jDQACUUhraysHK3OQSlrzJS+b21RrtFqL6AB3ea9iI1RvZ5vntCrCT7Z6W8+XGzhXZmiafDUATxc9gZ7OnMq3/Zmp0QCWvtv2guxptV2ISZIkkk6dY0gnv+ZrAY+VPaqxYV50Dfbg531ZLdM2kSQOfbuAr01juEu7rmavq+a4kpAot+nijevQ//DKXePILKpkiXhLy8iyGT7acoqFqw9zRe9Qfpo1nOExAWg0Aq5OWq7tH8Fvs0fSL8KHB7/aw9qDWS1qqyVwkNaLGaqyYdJyeH8crHkSVoy88Lo1c1pn8THbCBdVVPPEd/sYuuh3rl+2lbFLNnPl/A9JyVAWQFGUY/o/mtjydhXi+r04ku1iT+bpvqSLJgMGTQNX2eIco8nkAd1P/CYO45+tf9ttAd6Wmk9ltcgYzd7ag/U/WyEtzkOnEksqe/7+rUU5TkUV1RhFqW08rWY5GQE+3uSFjbV+A1ZD2mZQmn2cY1IE/TUn5HNRw+uqX6oy8ZcvRoi+hHjNXraKPWVSl3NQ3iDaavGXJBBFXl+6kBx8SdR/IBPW4N41ns+bdZsYr9nJ68brSBcDa0PqW+ptNQt/A/jRNIIhVe9wjWEBVxkWMrzqTd4zTkTMOgjvjbZvLm19mHt+1blANaJUnHd4XP+HIQhCgiAIRwVBOCEIwpwGzjsLgvC1cj5JEISObdk/SZJ4btUhft2fxbyJ3Xl0fLcGN7sdA9z5evowXJ203PPxTts9KmYGp3e3ZXK6oJzntR/gEtINpv8tGycVoykxl8p/CwJObl48GVvIyQo3VqkbVHWzaCVWH8zCKEpc3S/M4nucdBoGRvkqysZWQpkPclM2AxB035rWL3ljvs70uxKAgk7X2NRmhcFEdnEl0TaEhke3sOxNXqkcIulpRV6oPaCSZFtLBdkiwqSipc9MLhHUtp5pkGu1FpZXU2W0QURKkkg/V0FWUSVDo/0s3gcJgsCkvmEkpxWSUWQjYVY0N17fK+JJBQ8M9ak1nCUtryWuUCMEOiDKjzuGRvHp9jT293qyxUKgG47k8MKvKYyPDeaNW/rX5tmbwc/diY/vGUT/SF9mr9zLlhP5LWrTVjhI68UOdfBk7IIdK5CyD5IiRvKT6RJWmYaRKfnJ4Yn2Jq5mG+H0H+dz7Ttb+HHXGW7XrOejXgeY77ueXIML17y5mQ0p2TJhtZcqrCRR+es8Xqq+mQHCMW7WbpSPH/weKs7JxHXwdKZ5JRFGPkulyUh6z5ZZmhTRp03rV+FCFUOHjJBrjTa2uCubn36aVA5I0XL4qY3kSw1BapMcEDMiGRDVU84/Md+AWdN/SWK/2AkJDf0EhbTuWFE3MqCmMPdcSFpOvGYvVTixXYxVP8S277ExEdbMIe+XZ/msuD/XuR+k35BLIWyg7NlVEdyL+fpP0CDxkvFmeREY0gKirEIUYe1cJAkWVt/Kw9WziBKyeUP/Ju/ol9JHk8pC4+08ID2KISulVUOEJeBQn7l86zmF37btIWd+R/mdtYdX2YF/LQRB0AJvA5cDscAtgiDE1rvsP0ChJEkxwGvAS23Zx/f/PsUXSWeYOaYz00Z1bvLacB9XPrxrEPmlVcxeuQejycZ1RhBIH/IMbxmvYaImiVHaA7WEVTnP5YvrbgTj5zL+1kfp7lHBW79uk0VJEhLlfHwrIxp+3pNJTJAHsaFeVnV7SLQ/R7KLa+pgWgxlzs/uIJPHEB9X2+d8K9tkyEz8Jz4FQEGnq21qs6beaKBtBCynuIqyKtvCbAuUGq3Net7sDJX05dtonKkpd2PDM2tpfduCsqo2z2cFCPWWtUhyiqx8ZopzZvtJmYQNifazakxP6ivnpdcJm7VmrRcEDhtDWC8O4u6ofLyvXFhrOAuPAxefuuNF+fdjE7oR4OHMUz8dapFIUsb5Ch7+eh+xoV68fnN/tE14yN2cdHx45yCiA9yZ9mkyBzOKbG7XVjhIq40oNxg5cLaIXWmFFJVXt15DHQbV/HOv2JmrDQuYaFjMQ9X3Mbv6AUZUvclDumfI1QTYvVYpCYkU9J/NlJ0dKMjL4Qv9AuZf4k78bU9y1+OvsbbDJ3QTzjDz023syqyUQyGn/WV7XUpVLXjNHL5KOkEevjzRpwLNkOny+YoCWXTp0eNw+Us4P5bCDL9dJBs7sy16uu3fVZm0JEliQ6E/I/xKcdFK8ma/scVdsST315ygAheOSh1stlrnlbSx2INirQvwlGX1JbA+tEWS4NCP7JFiAGQBEyV3lbPJda8VhJpjQ9yzcaWSDaKSG7b7U+u9kGZqmO8f1lGNnvt7VMrKnhGDZHEn9xD5fcw5SNiQG7lLu47fxCEcE8NbXuph4yLZSJO0jOVuU3nPdCVTnDfzjdMLTNJuY6J2Bx/rX2ae7gt+MwzgCd2TiJe1TojwrrRCrnl7C1e8+Q+P5yUwq/pBhlW9xYOGWeRV6+3jVW4CkiSRcb6CHafOcSyn5KJRGHQAgMHACUmSTkqSZAC+Aq6ud83VwCfKv78DxglttENfdyibRWsOM7F3CI+P72bRPb3CvVl4bW+2nSzg1d+P2dawJPH8B9+jReRp/WdKZ+ZdaJSsB41G4P4OpzlZ4caaz5fIB2vSQiyLaDhbWM6O0+e4pl+Y1UQorqMvkgR70m3I642fS2bIWNydtHi56JossWM3KOuMu7MOZ51G9hra0OZpG8rdqGipGFNBaVWbhwYDNeXvbC17cyq/DK1GINLPujxgkIl+fqmBogrb9rUFpTaIhdkBoT4yac0qqrD8JjPnzJ6t6/F21ROze5FVqV6R+1+nn2cxq/Zm1n6mlYast0tH4+Gs454775XHpmo4u/ePRseLl4ueZ6+K5UBGEZ9uO21xW+aoNonMXrkHkyjx9q0DcHVqXhvG203PZ/8ZjI+bE/d+kkyOHWrjWgMHabUSJ/NKmb1yD/1f+J2r3vqH65dtpe8L65ny4Q52pdmYb9IUlJIhHxvHc53heXIlHxboPuRPp0f59f7hTB/dmTWVPblqd38OnLWv1UOU4IHcK8iU/PnQ6f/kAuuqh0qjwW/mOj52eolgoZAHDA9QdMefthNWNRQZqHTyZZl0PYOdzzA0mLpWp7h7Qaer6cNNDy4hwMOJD/4+VftZ1mzQzSat1B8XkF7hTLz/udrNPly40JqFPvXrPwSAvVH32BxuVSur34YhNYJAgIczldUiZQaT1R5W1s2Dslz26gcQ7e+Gz9ApNTmudB53oWWw01hw9cOlMpcRruls9LoaycUPjBVwbI113nllw1UeN4svz/fkCs02og8urQlD5t4/4bEjsljC4BkgCEzV/YY7lbxuvE4W+bKVxKl5utkHOOYXz5LzY7jC7TDzeRetR6Ds6R00HUGAabrfeFz3NT+V9WLFP6dta8+83Xp/r9xxhskrtpFXUsWL1/RkQ9xOfnWax1Ttb6wRB5OwLZY9PR5vFcEVUZT4Jjmd8a/9xYjFG7hpxTbGv/YXQxb9wSvrjlJc2YqGPAcsRTiQbvb3WeVYg9dIkmQEigD/+h8kCMI0QRCSBUFIzsvLa3HHKqtNPPPTQfpE+PDqTf2syn+7YWAEtwyO5J1NqfyekmNdw5LE2s9f4Y8Cf2ZHZxE2/6TlobKCwOW3P0JnfQFvHfFAnK/WZJ4hG8IsiGj4ZZ+cC2aparA5+oZ7oxFgT1phzXexZt7MKqok1Me1liy3hW1CCaGsUcO1RYSpwPpyNypaWvamoMzQ5srBULsXyLcxp/VUfhmRfm7otdbvx1oqxlRQWoW/e9s/s1BvV0B+z62C4pjYk11Nv6qdaHZYkeql7B8nVfxESlYxJ3JKrNY3OZFbym8HspgyLApvNzOyr5LXJnBF71BGdQ1kyfpjZNsQnvza78fYlVbIout6WzW+grxceP/OOIorq1my/qjV7bYEDtJqIURRYsXmVCYs/Ys/DucweVAHlt8+gA/ujGP22BgOZxVzw/JtLPg1hWpbw5bMoQowrZ3Dq+ndmG+8i3Ga3ax3foI7dH/QWZNFrwOLmZPQnR/vG4FOo+HW97fb1V3/4ZZTbE0t4HndxwzUHJcPqgu7ksPqL5Twpv5NcvHh2Vdfl49bq2JqnpO3di7fut1MjsmTh8RP5XBjqLU61StV4rL1FSb7nWDj0Vwyz1dYb+Uyy8/ctOcIAGPOvFk3hLT+xGEW+hR5zbP4uTux1yve5nCr9qoFF2BrCJLZ99+r602/SN9aj3T3iQ2Xkxn3FAyaCiG9ia/ezNnCCk6Uu8re0G4TrTd2CAKrQ2ZSghu36/6Qj5n/XoIgGxqUHFbf0GjuGtOb1eJQjqYr4ewbbMwzTUhEGjyTp7MuwV0q4wXTUjRDZ8CjR+V31GwDfp/2Z64IzGPJ+qO2G5VUg466QZUk1n72CnN/OMCImADWPDiS2wuX0+nga/QamsBc/Up+dZqHu1DJLfv6sP2kjYqjjSC3uJJb3tvOE9/tx1mvYf5VsXxyz2BeubEv/SN9eWvjCS5dsrndcl4cqEFDE1H9ydiSa5Ak6V1JkuIkSYoLDGykHIQVcNFr+fzeIbw/JQ4XvfXK789dFUvvcG8e+WYvaQWWb66Lq4w8e6ILPdxL+c9/ZtYVVbNg7tZqBGZ1yuOIFCnXnAb5aTVX81Q5/vPeDAZE+tDB19XiPgOwMRH3t3vTTZfDnjOFyjo3B5Z0s1hHIquooiaEsq3h7+Fks9fwdH4ZgZ7OeNiQV9rR3x1BsJ2A5ZW0oaq/GVydtHg462zO3T5pQ7kbFZ1qiL71YkyV1SbKDKZ28U6r73ampZ5WM0dJafwCjkkR9BOUkleWGnqV+ePKuK5oEFn1xkNW65u8s/EELjot/7kk2rJ+12le4MWre1FtEnnh10NW3bv5WB7LNqdy86AOTOpreX69ih6hXnxx7xCen9TL6ntbAruQ1otd7KGlMBhFHv5mL4lrjjCuezCbH4/nhat7kdArlHE9gnlkfDc2PTaGO4ZG8cE/p7j7o50251AAZiRuOcuSi3nDdB03aTeyXP8aXoIyIHWuSpL2XGJDPfl6+lC8XPTc9dEOmbyZf5YNOJZdzMurD3GpJpnJw3vUze9c8ySsGFVTH7Pv/F3c572dn8t6snXxFbD6ydpQX0tIpCDIeY9DZlK1/T3eWfUXccJRhg0bfSERaeA53Zy9BEmS+GZnum0qvpsWgwQbxH50FdKJEPKbt5wroU+CRkPPMC8OZRbbHG5VUGpAI8gS/W0JdWGxqYj5mDnkjphPXkkVvcLNyubEN1H/dOw8mPYXY7T7ANgo9pPDyZu6pzFIEl+t/5tOQiaDBdnY0GDesYt3Tambew2f4+6s43Xd3bX519aMD7NF7rugWeyQejBHtxJ/oaT2PV03T8mbnQnPnUcYOpOFxfMI1Ffy4Fd7KK+qrtumOkaa+J41Bh2leHnKdy/ycEon+jllsCLyT9k66+Jdm8MKdNVk8IPTc0RozzP1010cyrSPMetYTgmT3trC/rNFvHx9H365/xLuGhHN6K6B3DAwgvemxPHTrBF4uOi444MkPt+eZpd2HbAJZ4EOZn9HAPXrFdRcIwiCDvAGWiFk6EJ0DfYk0EbFdBe9lnduG4BGEJjx+W4qqy0TX3lpzRHyDXoW3zkevSo2YmWo7KTgXCKFHN4yXiMP3R3LmxaUU+aNI1lFHMku4Zp+YdYZViVJDj8uyWKAeIC9qRmIa+bI80xZrjw/WOBxzSqqbD/S6u5ksxLu6fxym0SYQH5PwrxdbSKtoiiRV9JG9dMbQJCXbWq4oihxugWktYOvK4IgP3fAqjVSFY5qj5xWd2cdXi46yzyO9cQL9//wf4ho6F/jnLFCI0YQCLr6BYZpUlglDpdvs5CwphWU8fO+TG4dEmmzeFWkvxuzx3Vh9YFsNh7Jteie7KJKHv56L92CPZk/qadN7QL0j/S1KKTYnmgxaf03iD20BOUGI1M/TebnvZk8PqEby24f0OBC6+6s44Wre/HyDX3YmppvGXFtzCOpLKI/Rz/DS+VXcZVmK4m699G6+8kKuiCHVQb3lutgCgIRvm580nMvlRXlzPx8l7yI21j2wmAUeejrfXjqRRYPMSJcnljXIu3qW1NgWc1hvW+gJx00+TxXdgPVO96XhaHWzoH3L22eRG5MlDf7ExbxnWkUWfgzW/cDgqtX0wNf6VOHYTcwUrOfr//cjmm7QhgmLLLMUiaKUycOIgAAIABJREFUUHGekqRP2Cl2J16pJcqO5c0rryqfHxvmxYncUgwm2wwE+aVV+Lk7N5kA3xqwOQRJ2YQdzpK94LGhnvJ71lx4nBJWHC4U0F04I5PW+rlklkCSOPH9CyQXezM5uhJhfhOCWfEyUWbITHx2v8ndxu9YXd6DY70eraP+a0mb6iJXuOppEn9OZoBwjMnaTfJ5VeFPVUtOqB0zPkOnsKT3WU7ll7JgySu1C6KSv837lzY+RlWDjkK8C56PZOquDnhpq3lXWIhLtTKuxsypVUZWCHPA0Fv5VPMcnpRy54c7rPJINTQ3ncgt4db3tiNKEt/PHM5Ngzo0mJfXr4MPvz5wCWO6BfH0TwdZsv4okkPBuD2wE+giCEK0IAhOwM3AqnrXrALuVP59A7BB+pf8WB383Fh6cz+OZBfz9E8Hm33Hkk4W8EXSGe4aHk3fSN+6Jy1ZK5T1VLdjOfd1KeKA1Im/xD7K/U3co8wb33//FTqNwMS8D60zrJrVaO+vOU6J5MKJ7b/I54J71RWRaqQPBqNIXmmVHELZDj+vv4czBbYYR5G9hh0DrM/NVNEp0LayN+fKDRhFiWCv9iH6QZ7O5BZb/8xySiqpqDbZRlo3JuL8x9OEebvK64WVe0j1N26P8GCAMB9XMs9bQFrV/ezgGbBjOXtSDgPQL26UHGWnOIQsGivKM7pas4XTUgi7pK4Xlp9rBMs3p6LVCEwb1cmSr9copo7sREyQB8/8fLBZ3mE0icz+ag+V1SbeunWATZEu7Ql7eFovarGHP1JySLWxTldhmYFb30vi7+N5LL6uN7PiY5oVT7gprgOv39yf5LRzTRPXZuoq7jhdyOPHejJYOMwr+uVoBUkWIJr4sjyowuPksErVSyVJxOhyeVXzOvvOFvH0TweQ1thWO3TpH8dIySpm8c1DCZj0Qt0SJqpF+u7VtaJLkoSLqZjntB9z3BTCx+HzZdKXtFzOH2zKCm22qBtWjOEd49X0F44zUnMAjq5u3oIsCODsxa3aDWThzyaxn6JWO6/5iVb9DQTYIvakGh3xWrNSNxa+obGhXhhMos3vWX5p+6jtqcYXqzytZr9XyqZvAIg9tLT598y8DMuQmYwZNYadUg9Ktn9sfR6wIPB1fhQ6QeT6W6Y2H+Knqa23eI9uDW5U8o7xKvmcpQuy2SL38o5Kiqq1LNR/IIuEmS9yY+bUfdeV+4Zf/wDTIs6ysrgPG7duk4nrmjnyOMlIblrIRaOBaX9hkLTMNDxEPt68q32JoKG31I1EcPGpR5gXEzZ0Mp/GpWESJaZ8uMOyjaP53KT8l/rDC9zy1p8IgsDKaUOJDWta+dTNSceKOwZy48AI3txwgnk/HrBZpGntwSzSz5XbdO//MpQc1fuBdcBh4BtJkg4JgvCCIAiTlMs+APwFQTgBPAJcECl1MSO+WxAPjO3Cd7vO8vXO9Eavyy2pZPZXe4j0c+PR8V1ta6wmLWIG1wXlEEoBbxqvlYdtffE583sSEqkadB/fnfVmPNsJ2POG9eXRlPE8QJA9QbvFLvLx5girMpZziiuQJAjzdmmX+s3+Hk7klxmsM15JEiWV1eSXVsn5djaSbbWEi7W2GFVgpr08rcFeLuTaEB5coxxsLWk1W9s7IpeDsjZyrb3q2qoI9XaxXIhJFTsC9ooxdBIy8Zn0omIgsjDVy2xfc8XQXnhoTazUX1drQFeqDDQ03jLPV/DdrrNMjuvQYsOIk07Domt7k3m+gie+39/ouy5JEi/+dpgdp86x6NrexAR5tKjd9oA9SOtFK/ZQZTTx3KpDXPfOVralWpfXdbawnBtXbCMlq5h3bhvIzYMjLb73qr5htcT1452UGxTiapaTZp7DWZOfokwOJ3JKmPZpMhFOpbzr9CrOgnL/elk6noQG8juVxXH88MHM1n7Pd7sy+HzrcasXx+TT51i+OZXJcR24LDa44XxOFeYlAhISuXT4EMZqdrP0ZBg5kk/tdZcvbrx9M0/Sjxm+ZBAoe1lDZc9Ss544UYRjqxmn2U0ghaw0ja1Rdm2WRCkKtJxNZpP/LXhSxkBlU8CQGRdKjTcCtXRBSmZxs9c2hLxSg81hci2BqvBnFWk1I4gpaVmEk4f37jebf8/M8mBJSCS+WxBGScOWzo9anQdcZTTxfV44l/UMI8DTpW6/GgrxUz2agK9Qyh3a31m1N4PTP8632uOxK/ZJVprGcrd2LT006fK7XX+Ra2jMCAKP9Cikqz6POdVTKdr+mfzugax2nNDAGDEzaElr5/Gc8S52SD14Wf8ufTUnL4wmUELW6xPmmKse4f07B5FdVMl/Pkmmor4hzVzQxXxuen8crJ3DqR/mc8vOzkiSxMpu/9D54JvNPytAr9Xw8g19uG9MZ1buSGf2V3swGC3P95ckiff+OsmMz3fz+p/HLb7PgVpIkrRakqSukiR1liRpoXLsWUmSVin/rpQk6UZJkmIkSRosSdLJ9u2x9XhwXBdGdgng2VWHGlznz5cbuPeTZIoqqllxx0DcW1Jzc8wckMApeRkzYgpJlrqR1O1J2fBknnduDkFgXfj9FOLJLdo/5WPWiqMpe4RoIRsfStgjKaR1xcjGDbtmYzlr3esAhBz/0iZDdksR6OGMwShSXGlh2pRCttPUeqP+bjaT7egAd4orjZyzsuapShiD2tHTmlNcaTXZVmu0drK23I3Z2h5Vsou09HSr8zPVHNz2yAMGCPF2tVyISSGckgR7xBg5n1VJ/7E4XcBsX+M+8UWuDsrl17LuFAUOkqMR181rdLy9+9dJJAmmj26Zl1XF4Gg/nkjozm/7s1i85sgF740kSSxZf4yPt57m3kuiuaa/9WJwFwPsQVovWrEHZ52Wr6YNJdDTmSkfJvFNcuOWWHPsP3uea97eSk5xJZ/cPZiEXiFWt31V3zCWTu5H8ulz3PtJMhUfTKpdYAQBxi+Uy7ckLYPnfWrqR6YPfobbPkhCbyjkY9M8WZW1fr1QaHgCUSadh3Q/EK/ZwwvGKezq8YTFi2NplZFHvtlHuK8rz1xVP8K7GShtP6f7lGp0vFR9S+05c69NQ9BoqI6ZyFuma+gjpDJGs68mpLNJQqOq2GYfQB8ay03azWwQ+5OVlSGHUzYVImw2QUtnk9mY7cwozQH0gpIbJSFvUCxAdIA7zjpNTbistcgrriSwHSZ5vVaDn7uT9dZc5dkdliLpoVFyFi1Z1MxI1cAoXzxddGx0G1+7OFiohPlHSi7nygwXGpIa8+SvnVubdzZkBv/RrUZHNct2lVlVs9VoNPHUZ78TQgEP6b6XD1q6yEkSzoYilghLKcCL+dVTas+FD7pwbJiLL62dy+dbj7PSNI6Z2p+5WrtVvkbJcW3yGSh/D4zy5fWb+7MvvZAH3/gCk0msHZOv9pAFXUym2rlJ6wIZuzixbRW37OyMUe/OlwGfEHPwNas2vIIg8ERCd+ZeLi+m936aTIkFysIVBhOPfrOPhasPc0XvUF68pm3FHhz490CrEXj95v508HVlyodJLN+cSmW1CUmSSD59jhuXb+NIVglv3zqAHlbWRr0AggCuckTD5I7lBDoZeLNsrLxWOXkqET6KwJsyRiSTiY9++4tIIYcRGkUsxZrokhqj9nIEAfq75rDbebB8Ludg48RViUIipDdZKX8BEHb0U3ltdG4m9cbOUI2yeZbkaJqR7VN/vg9AxyPv20y2O9qohpt7EXhaq6wh+gpO5ZfhotcQ7GkD2VbW9o5CDoV4UiS5W2VgUXNw28MID3IkwbkyQ/M57mYe0ox+D5GPD/07hdbdY1sKdV+j0XDLDTdQhRNfZQXD5pcaJf25JZWs3HGG6waEE+Fre+h7fUwf1Ynbh0ay4q+TPPjV3pp3+GxhOfd9sZu3Np5gclwH5k3sYbc22xr2IK0XtdhDBz83vp85nKGd/Hniu/3M+X4/pY2E7EqSxE97Mpi8YjvOOg0/zBzOsM4XOIQtw8ZEJmW9ySs39GXbyQKmnh5DafYJeXMoivDeaCivaxXOqXTitg92UFleymfaBUSGBdcSL0sUDpWBqBEklurfIVQo4L4PN5Gn1lFqQtVXkiSe/fkgZwvLee2mftYr9SkLa5Qml6na3/hBHMku7wkweLoyEcyRBZoaspRKEj+lu5AuBfGg7gf56yk5rk0SAXPv3bS/uEm7CRENP5hGWqZIq3h5U6QocvBjjGYvPFsof94Oy3MadFoN3UM8SbGBtIqiRG5JFcHtJJAR7OVCjrVS6ZJExW9PcVIKI1ZQSKulmzDl3dV9eiWjNPvZeDRPtggqatSWKGF+tfMM4T6uXBITYFl76juieEWDhCJu0W7ke9NIMoY+Z3E+28cfvsORMg/mx+bgMT/7QkNSc/2YsIjeoe7cr/uJH8WRrDINUz9c9gSrY0OSoKJQ/ux189haGsp8452M0+zmsYjD8My5mhxXa3KCE3oG82znk6wvCODRxFcxrZ4Dq5+AkixZ0GVJF/hzoTw3mSo5IEZzk+FZjGj5UniGroUbZUObs6fVG97pozvz0vW92XIin2vf2dpkVMLJvFKufWcLP+7N4OFLu/LmLf3/dXk3DrQt/Nyd+OG+EYzuGsTiNUfoPX8dAxb8zg3Lt1FaZeSjuwcxrkewfRqLnwsTFuFSXcR08Wu2pBawuTgMjq+Rx+zR1WA0yvPChkVse2MKe0q8mBZTjGZ+oeUldlSoof+eoRDciwEjLud4uTtFA2eBe5BMQBta6yRJFpvLPkCWJO9jQoUC20ToWgg1/DHHkhxNs/3O6eMHAOh40IJonkag1mo9aTVpVT2t7UPAVOKXa2UdzFP5ZXT0d7eqjFQNlD1klCCXkkqTgqwysOQUV+Hjpm+3+TrUR1blblaMyWxfsKeTrBPTP+FOmytAqNf3Cvfhkhh/3jNOpFLSy+caeGdf+/0YJlFi5pgY69ppthsCC67uxSOXdWXNwSwGL/qTuBd/55KXNvLnkVyeTOjO4ut72/ZuXCSwB2m96MUevF31fHjXIO4b05mvk9MZ+8omPtl6mkIlXKTaJLI1NZ87P9rJQ1/vJTbMix9nDadLsKdtDZpZCq/LfYuXr+vNtuouTDY8Q1oJ8IKvvHCY4agYwQ07OlFwroBPNC/QfdiVtTmj0LzCYb2cQe/5GSwfkEGRAWa+9QOVfzSdQ/vljjP8sDuDB8Z2Ia6jn/Xfd+1c2VscHsd9Q/0J0ZznudxRmE5vlYlr+k7YuQJO/FHXKixJVK2exxvHfOnpUcrY5zfULuqWbMiVDQTr5hGlyWWo5hDfmEYjVhRbpsy6bp6cBwuM1u6rJctWTl6xoV6kZBXXhmRY+HoXlMliDyHtEYIkSYR4OZPdmFGjkXtYO5ejO9YioiH2loXWb8JEEaqKia/eTG5JFYcyzsuEVd1MNeFxTT9Xzt/H87kproPlwlWqJRRqCOZ03S8IwBufrGz+HQGyiit5LS2KeL8CJtz+qOWGJPPPWTsXcg4yS/szccJR5lRP5ZgYDjtWyGOjXCllsSkR0rZC2EBObPuZ+3YFEy1ksdT7a7TTN4NWa1kkQn0IAnff+wCPdzzFT6U9mLrFg+Idn0HcVJmMlhfA3y9D9gE26kZyi+Ep3IRKvnN6nu4aJUqlvACqSmza8E4eFMnn/xnC+fJqJr31D/NXHeJEbimSJCFJEifzSnnx1xQSlv5NVlElH901iAcv7fKvXmAdaDt4u+p5/844vpk+jP9c0okJPUNYeG0v/nhkNCMsMXBZAyVP/o5h0UQJ2SzY60x1Voo8jrIPwKtdIWkZ0tHVLM3tT5C2hBtun2X9vKEifi48chi6XUH/XDnKY1/Xh+CRIxDap2FjsFnqTaYUgCdleAiVzUchtQJUb6XFarjKczolhhBCAa6CweZ60+E+rui1gtWe1pySSnzc9Djr2oeAqUTf2kio0/ll1ocGQ509ZMe+o+XP6nyHVWt7bkllu3mmQcnZhroVNBqDsi/Yc6YIZ52GbqFeNleAqIEkMct9I/n48IVpnHys3rM7lFnEVzvTuWNYlM0Kz01BEARmj+vCuodG8fiEbsR3C+LxCXKFk5ljOjery3OxowXJHTIkSTIKgqCKPWiBD1WxByBZyZ35APhMEXs4h0xs2xR6rYYnErpzaWwwC35N4blVh3hu1SF83fSUG0xUGUV83fQ8fUUP7h4R3TIlV3VhAkhaxo0sI0Dfl9nGB5hoSGS67ldu0m4imEIyA4bzlfONrDgViI9UxBdOi+inSZUXlfrW0+aUdOspl8be8DSvlC/hgcPduX9POG+VLsEF5PNmBPf3Q9k8+/MhRncN5MFxXWz7vmZtu0sScwuW8OCRWL7ODOTW3BW110bEyW27+ih1NAU+ze1EuhTE55MHI5iJ5lhMBtS8gfA4Juu1PHwkhKRt7zEMRVHVxefCichsgt7otozenl4Exdwqfw40/Pwbw8ZEehS6sbI8hqyiylqxCxfvZidAVeyhzRUKNyZCZREhXrdyIKOo9nk012flt06JmgLHITbUG3pa8XtBjbDQ6GUJkA4blz9EL92BWjXqhnI7lWPfJKcjCHBjXIT139nsnQ9LSGTKW+/yUUYYd3+3gO7XP13395YkWQ25sggSEnl+VQpGQc/zMakIm1+qeXetqufm4g3uQejLcnnL6Q2urFrIXYYn+db5ecKFArm+qyTJnpqcA6T7XcIUwxx0mPhA/wqeva+tbUsdJzZYhGdNn4XXMzcw33gnE6pe5pHt33K5tgw3BFKkSD40TuSHypF0dy/lY+PzhAiFtfcHt2zDO6yzP78/PIqX1h7h8+1pfLz1NJ5KVEdJlRGtRuDqfmHMSejebrlkDvy7MTjaj8HRVhpebYEg4Hz5Qp7ZPo57qx9jqfF6Hi+XxenUKKrvM33YIfVgwRWxuDjra+6zlYCR+id9zx5C4H12nznPqJNLaozFsoK42Weapc+kSZcTJSjlMNQIDVv7YAPUsWyxGq6yHp2WQuioyZaPrZ1rU591Wg2Rfm6ctsHT2p4EzGqij+yAOXOunMt7W5/SZr6Pixo7F5LXczr8KgjKszicPKe4iiBbwpLthEh/OdQ27Vw5wy25QRDYm15Inwhv9NoW+vCUd3bokWVc4vM2r1Xcw8R+XQlNekM+n5BIZbWc9uLr5sRD42wUhLMQnQI9mBVvX0/uxQC71Gn9N4k9DIj05cf7RvDL/ZfwZEJ3Lu8dypRhUbx96wC2zBnLvSM72af0iDlxBeK1+1jnlcgwzSFeNd7I0Kq36VL1KSMy7ufNk8FMcD3Mr85PyYQVZM+TmhtjKRoQYrlyyqMsuKY3fxT4c4fzG5zd/q2SQ7sMafBMvvCdyawv99ArzIu3bxtgu1fDvG2NhklTHmWI93kSjbeSoYQmMWQGmMQ6hdhziip4Iy2S0V0DuaRLYN1nZ00i/OAZEBFHwqnFeGqNfOs7TRbHSGqi6LuLNzn9HmRXiTfjugfXtYBbSlgVr3rsmc8BOJxZZJXinhrGEtKW4cFmkQBBuf+QX2qgenXjggEXIH4uh/3H4emsI8LX1brfS4VGQ+CMNfQXjrPWNEg+NnWz/FnmghtmSrZGk8i3yWcZ7XuOsD1LrfvODRh1HrjnLjx0JuanBCOunVdHLZc1c+SogKRl/PLpEtYeymZ2h1Qi9y+t+4ws3UCpoXpluTB4BiHPneQTp5cowZUbq55jT/fH5HdVicLY6nUl12beRhkufOL0ElGaXC6QBrBlwylJ8P6l3KH7g2+dnsdXKOFx4wx6VX1I16pPuNKQyGpxMDP1v/GT39t1CStAjnUhyQ3B192Jxdf34e8n43nxml5cPzCCaweEs+CaXmx5ciyv3tTPQVgduPihkMJLtbu5WbuBd0yTWG0aXHP6mBjOguo7iIvy5bahHeveaytZDI/DU6igq5DOno3fynOGcvwCCEJNabo0KYQoQSF/IbWl8toKHs463J20loUHmxmUT+uiiY5LsD6apx6iAzxs8LRWtVu5G6gl+hY9MwVnCyswihLRATaqwsbPBRcvXDY8Q6i3C6fPlctGyqpii0Sw8kqq2i2cGiDU2xUnrYbTFpZ3qzKaOJhZTL8OPs1f3ByUPYYwdCaLpl6LsdrAo0e6URl3H7h4YzSJPPX2pxzJLmHJjX3xdtO3vM3/QbTY0/pvRe8Ib3pHeLdeA+rEa4awqlTed3qV42I4/4i9yJV8CBCKGOt6kujqY+DuD+XUhhgBjJ5jOYGCBoVYbh8ahY+bnse+3ce46lcYr0kmSDjP1uMTOZx1kFFdA3njZhvyWJtoWxAE/s/rOxKKbufR6hl8pl+MXl1gwwZCQiKSJDF3xbdUG3wvLHBszYIaX7uQuSIw6Z9NfJ87kvlFh/AaapYHo3rsFC8jCYms3nIaSUrhyuKVsMnJekuuQti6G5+GLZDy5ZOM0/1kcf6NGprbpuHBZgaVkC3rgank7via8KGW5wylZJXQI9Sr1shh7QZow0JI/oArtIN50XgHp8QQopd0AZ8oyNwtPz9RrFWyBf7q+DDZxZXM138MlYPqeGAtgvqeKPf47HiVedHOzDnejc+3/s4U1TN/NrmmVNPZgBE8kxRBP+E40zOfByueUR2Yk2YlnL2nJo2VTguZbniY6/b2J17zGJ2FTA5JHdma24soIZsP9f9HZ01WTT25FnlpVEGXDLk8x4BQF37NfopdUleSxO6USq7EaDIY656GX+UZyANc/aDCTH7Azd9uIi6h3q7cPjSqxZ/jgANtjnrpOM+NeYEjL7zDrOrZTBF/J0go5H3jFThTzSvB69EIw5r/zOYgCDUlOgZsOcFvpiGIkiCX3WpIoV+SoLIYY9YhzhLExFEjQDLKfY66xPr5s4UI8nKxzGuozJVFA+/n3Ba9HEI50sponnqIDnDj7+N5iKJksWE+r7iSzoE2aprYASrRt6ZW66l8uexetK11bZV3hqRlRDn3Jq3AtTaSbcjMJt8ZSZKU8OD2I/pajUCEnytnCiwrkXYosxiDUWRglG/zF1sCZY8RCSzscpzHjnZh8r4+XD16CL+/8hXbzgfzUFQa8d2a1+5woGH8z5LWVkW9BY0JiyAxHKrLIbAnXfIO0UWTIV+rc5OPQ60wU3mBbA3taoGYkIW4snco/VNX8EZyGRtN/SjBlc4lmbx8/XCuH2hFfqAlkCRY/SSReRtYoK/m0eqZPGO8m0Td+/J8JxpAFHnt3RVsOBfFs51TZUn7lkCdSBMSmbytP1+YLuVn0wjuUEMZ1d/E2Uu2GipE6JdTV9HdvZSYA6/Kv5WNbXtc+SJRWz8kRYyq6Ycli2tucSUagbav06qQn5CtYwDIlvwIt7DPoihxOKuYGwfaEKILskpt8gdQXsAVHsd48Tz8Kg7lgfKf5Hd/8PS6AmQAScv48m9XAohh3NDBkGBjiKp6j+JtnnxmGWtcF/JixR3EbFvMcG2KfD64N0U6P+45OhQTObyqX4ZOEFsWUhevqAGbbQJ6TVjEb788wwc7/uFHcQR/i32IFrJ4zPVX7hW/xUVQlXYlmbjauGmr+e4uPnLEw+l/IOcgGgEGCUcZpDlae91jBfBaDzCUyoRVncPM847beMPrgAMXFcyNUOMX4vreaFY6HeXp6rtZaRqLAT39heMs9fqSqP1HwbXSfuG4AvQXjrOSsZyUQolp7COVPmb2fRDjDg0d/d0hrmXkryUI8nS2nIDFz+X0mULYslXud0uMdcie1iqjSFZxJeGKWE9TEEWJvNL29bSCIpRoRXjwqXx5L2mzp9Vsze34z27+KBIgx7KyN4Xl1VSbJILb0dMK0NHfXa4xawF2p8mRRAMi7URaoeYZXX/Xwzh/uoQFh4N54dfD+KFhYZfj3HbPg461swWwDyNyoC7qhyJqNDDsAQjsCU71JsHgRqSnp/1Vtw5rS6AQtvB9S3npEh07Em/j8Oid/Gqczk3576BtjfGTuQuA68PPc7/2R74yjWVa9SOkiqFkZ53l2Wcf4Y20KG4Kyebu/9xvn0GsfM/ewil6Caf42DQBccWo2gLPScvkDbcitHRm2/fsPnOeq6p+s1mZ0LzdWCGNFEkhrRaGMWUXVxLg4YyupfkU1kLpc7Age9FyJF+L+5x2rpxyg4nYMBvLR2i1ENAd3PwJrUxlkHCEn03Da5tOWAwfXAbvX6r8nUiaGMSf4gBu1m5EP9EOIiLK4iwMmcFSMZEoIZup1Y/ypXEsRZI7WzJFrt7WmVO5xazQv0Yn87yqlmjIaTQXhCn7OBl5VP8t/0R/xvHRW1nv/CT3S1/KhHXIDMXLukL2AltYhqlRxM+Vn2/3Kxq/5venZYGX4Q/UncNsEX9ywIH/VqgigOufguwDuLp7ssRpBXt857DDeSY/+r5BVNVR+5WYMSt9M0Aj1y3eLXaRQ4TXzml4XoqfS1qv+wAl38+WVA47wWJPq4LT51QCpojVtOD5qZ9xKs+ysNFz5QaZgLVjTivIysXWqPufyi/F21WPb0tCT5V3JErIIR9vSiRXi/ZGOTUlgtqX6Ef6uXGmoOyCOqUNYfeZQiJ8XVsnHUVJz9vm/AB/Oz3ITueZDsJqBzg8ra2FeqGIxM+FqiKlHquyEVQWoAZhT6GEBvL5rBI7sqW9mEtl0SWTyKNZ7+InlLDIeCu/G+TcGwGRu7VreGrWUll8qaUw824LQ2dyb/DVPPTNfjZnaoh/QbGi1fv+X/xzHi0mrtP+DQknW0RYSVpGbOQi1pwOoWTg/XgmvSWfb+Y3zC6uatt8VqjT5+CBs2EbZEdeBUnPyOeb6bNajzY2tAXh9feslj2uC/y4SbuJx40z2C72YJj2sFx3MOegfN3aOSDBR6YEdIhM0f0u55s2FA5nLZRwO98dy/ncaRGzDfczz3gv84z3AhAkVPGlfgGDho2FhK21hg9oucfVfG5QvZ8JcuhfnTlBPaaOYXuN1cp6JWdCess5xeufqvsd1bbBdvEnBxz4b4W5EWr3FFLwAAAgAElEQVT8Qlj/FO5Jy3AXkFN91CgFO0VMcVYO7e80ZBJeO3Xs8ZnETec31xxvCKfPyUqqHf1bTv5agiBPZ3JLqpAkCUsUTE/llyEIctnClkJV0z2VX8olXZpXks4olJ9ZmAVe2dZEmI8r21MLmr9Qwan8MqID3C16vo1C2R90VHKg06Qgeq2dq9TvblxJWVU5bs+cVoCO/m6UGUzklxqarBcrSRK70goZ2qmVQsDNSlB2EPLkYzaKiTlQCwdpbU2Yv5g1oXkzazeDqiHIPUgWaFFrL4b0ts/m2Bz1N8otDLexqD1RhA8uQxDgHt1aJmqTWG+KQ0JgsOYwPTTp8IeHffpRj5hPNEkkrj3KspJJjNHskz9ebUcUqVz9NF+bxjBek0yocM72ycSs3dio6+H0Lo72eoQ4nckikpFTVFmjeNdmMOuz3/j5OO1YT074ZRCRaZFAR0pmMVqNQJdgG0OQoFbZErhKu42Fxtv41DReJq05B+XcydjrIGk5+ZIX35iWcpXHUYIG3Nzy3E7zPqyVPZfBwnm+cnqRzWIfjkqRhAn5jAsHt8j41jH0mN9vlpN9Qc1X9b2011itn7rg4iWrFWcfkAnrBEX8rbHv6FhsHXCgLszX1oTE2rUb7LvGqsbg8Dg0ly+mX85O9hS7ypEYrj6NtpOWX4aLXtOuSrgAwV7OlBtMlFYZ8XRp3hN4Or+MMG9Xu9T8DPJ0xs1JWxM+2xzUkinhvu1LWiN8XMkurqTaJFqkbnsqr6xlJMxsfYhy7QPVkBYzhV5JC+DANxDQDe5Z0+Ctaj3Z4Hb2tEYpXvW0grLGSaskkXG+gpziKjk02N7pLvXXWfOKHeAgri2Ag7S2JeoTR1ef2jw1NWx13Tx5Ixl1if29oA2INLUaVFKSkSx7kcYvImSBn+wpA3jm3IVenZb2x+z5OmlhVtAhni3uwQaxP+O0e+RJ47IX4b0xfJ0RynlGcMc9s+G4oWX9UNqNVSbtQ1klxFn4OTkllW1TnqE+4uXC98L6pwjyGi+H9tykvH8bm64HfCiziJhAD3kzYctkr07oO+RSDS4RcUxOLeT9s3GkiqGy8FB5AZzdDsDrxuuoQs8s73/AZah9QlTNawuHDQSTASHnAGO0+xnDfrm0S5eJtaVtoPUNPc0tcvZAQ1EXo+co8463w5vqgAO2wFw3wRz29qyYrXEDIn14/c/jlExfgKdr45oIaefKifRza/d6x2rYaG5JlUWk9VRBud3qWAqCQEd/9xqhouaQoZDWCJ82NijXQ5iPK6IkVxlozuNcYTCRWVRJx5Y8M0GQQ9nd/Ikqk3UOTkdMgux35DXZUCI7IxqIHLhYPK1RynNKKygnrmMDe6uNiVBxnt1hswEYGOkjR2+5NlAa0Va0dXTj/xAcpLWt0ZCHRV3wzDfF/3ahE/NBq5Jxc1ji1bG1XWXzcEv6u3ws/B8LjbcxLETALWkZHPiGwrIqXjXNZlgnP4Z19ofOdphMBIEQLxd83fSkZBZb9DmV1SbOl1e3fXgw1JZgSVpGiFMfsoosUAncIEvfp2RdyvDOAbWiQhbUo62D+hO6JDH1l2f58mwAzxun8In+JQS9C2Qf4JAYxZemcdyq/ZPOBZuhqgdMSGx5uJ3ah8Ez5FzRpOWycUVCNrRkJEPHSxq+rzXQlotcfeNZfaL6b553HHCgPdCWnhXlc/pH+iJJsD+jmBExjYe8puaVEhPYgqgYO0ElMzlFlXRupj+SJHEqr5RJ/cLs1n50oDuHMoosuvZsYQXuTlq8XNt3i6x6ejPPVzRLWtPOyfm6LSb6Y+fB6Cdxf280gacLSfvzXdAX1NZRb2TtzSmuxMtFZxfPeEsQ4euGTiOQmteAgUKS5FJ2Gcns9uuMqz6S7vsSYWcjtY5bgraObvwfgYO0tjfqbxT/mzaODailqnk/NYu5PfN9VAgCuHihD4nl+cwPmVI9h8czRvC6fi+msiIer55NqeTG/Kt61uZ+2GEyEQSBnmHepGQVN38xcLZQDlWyRM3Q7jAjReF/HyS52ABZTagEblwEx1aTn5VGTtVIeoZ61qrJNiOF3yDMQ2LXzSNgzzIe6ryABal9+cjtbu6p+Ih8yYvp1Q8TQBEP6b6Xr7WnMUftw6bFdcP2Qd5wtrVFtC0XubaMunDAgf92tINnRa0tuTutsFHSWmEwcTq/jKv62I/82Qp1nVO9mE2hsLya4kpjbR6uHdApwJ21B7MxGEWcdE3vOTLOVxDu69qy3FA7wJpnpopM2cU7rdXCtL/o+NRrnBZD5GNNEFaQ84DDfdvXMw3gpNMQE+RRo71xASLiZNKaVUlfYT+6nctrj9sbjnXW7nCQVgdaFw2opdZZzO1NWFXEz4PRcxi5di5PbP2al4y3cNTQAYATUgTPXxVLt1Az9Vs7TSaxYV58vPV08zkokkS6IpDRwc+1fTzrym8R+c9UfmEY1ZIWfUMkSa3dln2Awz5XQQ7E/n47aFNk6+uEFpafUd6PKZfNIunLPbyQchnrtR04bIqgAie+cVqAv1ACg6aBq6/9Q+brk0VoP4uoY5FzwIF/J9rYs+LtqicmyIM96ecbveZoTgmihO1K73ZEqLcrgiB7MZuDGsarCijZA9EB7phEifTC8mY9vZnnK9rHmFwPqhBUhgXP7GS+HUmrKMK7o4jWDGWDqb987N1RTRLXs4XNe4PbCj1CvdjWkICVIMCERCpMGlL+iWKa5jf5uCqE6FhvL3o4St440PqIn3th+GFbyO4rYY8ztL/wjn4pblQRKBTxevfD3Dm8Y6s0GRvqhcEoNhyaomKjHDqWroTzdPB1kz17G+2Ut2gplJC2DkIuIhqyJP+GS7qov9eQmRwqkM/FatLkc81YXy2C8n7odVrevrU/93U4Q5noRJzmGKucnqGfJlW+Ln0bjH6yZW01BgdZdMABB1qKNp5HBkT6sOdMYaPlPVIyVaX39ietTjoNwZ4uFnkNU3PltTEm0NNu7atk7qQFZW9UT2t7w0WvJcDDyTJPa34ZQZ7OuDu30BelEFayD9DZSyIfH4oCB8lRVe8qJQTrQVKEjSIugmcG8vueXVzJuTJD7UFJkvdY6+ayv9gDIzoGao7J59J3tk9HHbAaDtLqQNugPUiBKMKKkQgCTNTuYJXzM6x0WsjVpxfIifctqbfZCHoqFm11s3ABJAkqiyBpGWd2r8dFryHwn/lyuHRlUav0qdF+KDlXHXoOA+BM9//I/WiMuE5YRIoYRTh5+AjKwr9unn36rLwPep2WJ3qc4xff1/jA6RW6a9Ll827+8qJpr/YccMABB/7liIvyo7C8mmM5DefvpWQV4emsk8nERTBvhvu61qTFNIXUvFKcdBq7EsfOQbJ39XhuSZPXlVUZOV9eTXg7izCpCPdxtYi0Hs8paZmivwqNRhZjCulN5ysfAyD1iq9r6w03YKQurjBSWmW8aEhrD8VIUxMivFEpMVlRCEnL2ZZyAgGxpt4xmbtg9ZMXxRhxoGk4SKsD/51QSZla73PIDFl0R0VG61jWogPccdZpGietZl7L9MxMIoxnEHY0kUvaWjDLweow4UEA0jvf0rgyr2J9TZGi6KF6WdXSTA2RXFshSVBVIisVhvSGZwvlPql/W1CSxwEHHHDgfwEju8q5rH8dy6t7QonmSckspkeYFwK0TzRPPUT4WkbATuSW0inAHa0dFY+9XPSEertwvCGCbwa1f2E+7Vu6RUW4r2uz4cGiKHE8t5SuwXbyTN+9Gqb9Redgmfyl5pfLUVV3r27w8vT21OdoAD1C5eeQklls5ihQSuW5BfKXqQ99hFP4CqUQ3Eu+KXNXO/bYAUvhyGl14L8TgiBLmIfHyQn2CYtrz2XshJjLWoX86LQauod4Ni3GpBDXM3+9Q6SQKx9rjxxKJQcrVAKdRuBMYUXD/VDKF1VkHeWkFMbE+DFgqpAJq2p9tacyprnqtKpsC3I78fOavt8BBxxw4H8Eod6udAnyYPOxPKaO6iQfVDbppu3LOVI9nJuGdKqrbNyOlQnCfVz5bX8WJlFqkpCm5pXSM8zb7u13DfbkaHbTnlaVIF4sXsNwH1f+PJyLKEqNli3KOF9BucFkP9IKoNHQwdcVJ62G1LyypkWY1BJBF4EQE4C/hzPBXs7yPkyJEgMgaRlFkjt7pRhmaX+Wj03/G9bNBZfGax07cPHAQVod+O9F/FxZwhxqJ6PLF9f9uxUQG+bF6gPZSJLUsPqgJCGtmctZaSCDNXItNLvX87MUgoBWkK256efKG25fIZJHYh9C3KMhNswbeqpiWq1AJB1S8Q444IADFmFU10A+255GhcGEq5O2Zr48UOxB+R4t/ZMfB+3Wto/maQDhvq4YRYmc4soakaH6qDKaOHOunEl97a943C3Ek20nC5okzbWCRu1fJgigY4A7VUaRrOLKRj2ZKhG3K2lFNsJ3DHBrWqODWqJ/MeQBqxgQ6cv2kwVIGxIRqopk4pq0jC1iT0Q0jNbuky9cN88+ZfQcaBM4fiUH/rshCHUX6fp/twJiw7wpqqgms6jywpOSBGvmcD7pM0pwk0NzB8+wf5itlejg6yaT1sYQP5eUqNsBJW+3RkyrlTyfDmEkBxxwwIFmMbprIAajyD8n8msPCgKb/W9CQGSk5oB87CIw/KmeuKYUhNMKyhGl2hxUe6JLkAcGo0haQeNiTCdyS/F10+Pn7mT39m2BqnR8Irdx4ngsVyWt9n9mnQM9miWtZwsrcNVr8XXT2719WzG6ayBZRZUcP1ct769WjARgg9gfT8roF+IMg6fL5xxaGf8aOEirAw7YGapSY4N5rZsWQ0Yy6bFyfm0HPzcQkMOY27ouqBk6+LmR3kzeTEpWMZ4uutqwKQeRdMABBxxoVwzt5I+/uxM/7D5be1CS2JS0iz7CSfwEJRy2HY2iKmrrjjZuIFXJWXNlaWxBtxDZE3ksp/EQ4dS80lZp21aofUltirRmlxDu44qni/1JY+dAD9IKyjEYL1QNVpFxvpyIi6CurTlGdwsEYFPgraB3g5yDlEnOrDEN5nL34+hyD8DhVbLToB33Xg5YBwdpdcABO6N7iCeCAIcyi2oPSlKtIEBGMicrZItzxyPvyQIBEXG1ocztgI7+bpwrM3C+3NDwBZLEocxiYkO95IXJYZV0wAEHHGh3OOk0XNM/nD8O58glPiSJwl+eYV+JB2Mi9fDceTk0uJ2jeQDCvWVxozMFioG0gb4cyS5BI7QOaY1RvLdHmshrPXmRkdYADye8XfVNejuP5pTaRzm4AXQJ9sAkSk22n37u4igRZI5Qb1e6BXuy+Vg+OMnljlabhlCGKze6K6HBokkOG27t8osO2A0O0uqAA3aG+9b/I8a1jH1q0XdVyXjT4hrl4CPHj6HHSKcDS5Vco/YtbN1d8Q43uJhvTKRq9TxSsorpHe5d+33aWYnSAQccaBiCIPgJgvC7IAjHlf/7NnBNP0EQtgmCcEgQhP2CIExuj7460HLcGBdBtUniq51nQBBYmdcREQ3jrryljmJ9u3qUNibiuuFpwn1cZQLUyDpyOKuY6AB3OT/XznBz0tEpwJ1Djaj7ny83kF9qoHOQu93bthWCINA50L1R0lhZbeJ4TklNmRd7o8EyfmbGBpXQxlxERF/FuB5BbD91juPRdyBKAl+YxhEtZBFXtA6CesKjR0Fr//fMgdaDg7Q64IA9oXhTB1YlsTs1E9Ek1io3Viqe1wmLOCJF0lnIQC8olr52Dk3proRNHamveqx8n0NJ6zEYReKifOt+H4fH1QEHLkbMAf6UJKkL8Kfyd32UA1MkSeoJJABLBUHwacM+OmAndA/xYlz3IF7/4zhrD2bxdloEl8UG06eDYquo0SBoJ4+SWX3yLpoMuVZqI+tISmaxLPbXSujbwYe96eeRGli7UvPkXNeLydMKal5pw3m4KVnFGEWJfh1aZ+h2PPAWzhpTbc3TesaGjMIKqoxiq3l6W4J7L4nGTajm+d3OLA1ZxF6pCzO1q+TtVvTIdt93OWA9HKTVAQfsCWVzMKBzOEVGPSef7ykvzINnyJuGjYnw7iiOih3oIZyR73l3FGxY1K7dDvJ0xtdNz9H6uT7K99kdcRcAA74bWls64SIQ9nDAAQcaxNXAJ8q/PwGuqX+BJEnHJEk6rvw7E8gFAtushw7YFS/d0AdPFz0zPt9NtSgxb2KPuhe051xt5u3tUrSV1KwCTNuXX7COFFVUk3G+oqbOZmugb4Q3eSVVZBdfKJSoejMvOtIa5EFeSRVFFdUXnFMjulqFtEoSOkMR3aXTpBzcU0tYzYwNxxURqJig1vvNbIWfhzMPd8nhH7E3b6RFcbkmiRu1m+WTB39wGN3/hXCQVgccsDc2LWagt2yV3C12kY8JyIT12GqKsk6ShT/dxt8r1znNPgDHVoPYuNBBa0MQBLqFeHI4q4HwYEFgl9twOgi5BAlKyLODsDrgwMWMYEmSsgCU/wc1dbEgCIMBJyC1kfPTBEFIFgQhOS8v7//bu/vgquo7j+Pv7w3kBsgTCUmIAYPIMyishOeugGBFbLXUwtB9AtSxdpedaWd2VtFO1XVd0Y51nHWLosNU260du1umtLooD13AtYBQRZGnIAECKEFCAgokJPntH+fkkfBwc3PvPUk+r5k7995z7uX85pfD/Z7vOb/z/bV7YyV6fVLDrFo8hWV/fRNrfngz1/UJzhBXoCFxHWxHqSaZUpd7URypv5o3IkZDXcG70gqwo7TyonXFx8+Q3C0UmDla69UPvS1upYDUjtIK8tLD5KWntP+G/b/Z8Lye7KpIwj2W2XjS2h8htu/4l34bA7a/+Rb97b38V95rvNT9pzzXbyP26CnIGwVflXkXDBJ43CWRU9Iq0p6cg/MVDPzoOTI5w3Y3xFu+5UWoqoQht7On91QAhq1b5CWsfW+AobMTPk/YsL7p7Dt+hrq65mcfXV0d2/YdZqzta1wYgEqUIl2Zma01s52tPO6K8N/JB34BLHLOtXoE55xb7pwrcs4V5eToYmxQXZPZg9tvyKcwO4AJhH+VbnDIq3Jc7AqaxxHnGpPWa9JjFl+G56fTPcnYcaTionXbD53ihoIMuiUF69C4PtH+8+FTF63bcaSS0f1iOKrfjBHjZ1BBGp+T5S0LpzdME1Ncdoa89DAZG34cyDoXlpREUeYZbiuoIuWB9d5x1vc2ecdd4fSEH3dJZLolugEinY7zTlAWhfaxuW44zn+PA6Y/zJ7wQfj9LoaFSr3P378xED+cw/qmcba6ltJTZxsPepyjZOUTnKguYuzgvnBPRePwINAVV5EEcc7NvNQ6MztuZvnOuc/8pLTsEp9LB94EfuSc2xyjpkpX12RY6aBxi+H/oLjf3dy65RFvfTgdqk7z8en59EkNk5sa9j6fktHu9+GmdE9ieH46H7RIAM9fqGXn0dMsmjKgXbfXHnLSwhRm92TbwVPcf3Pj8oqz1ZR88RXfGdsvdht3jhGHXwdG83HddeQnlXsjwz735v/df/wbDA593ngFtuGAJ0AW+SPZ6o+zQqHAHHdJZKL6i6lCoUgLZtAjE8Y/wNTQDg65vhxw+d49rT28s6Hvb95ADqfIww+aAZnY+kb/bO37B5sH8/WnrwFg2rfu8xYEoRKliFzOKmCB/3oB8LuWHzCzZGAl8Jpz7jdxbJt0NWZevJjwfdK+8a/kZ6RQnDHFjyNewsqWZWzd/SlFhZkxL/Y3cWA2fz5UwZdVNQ3LPj5aSXVtHWMLLzqMDYSxhb3ZfuhUswJSG/Z5Q/UnDsyOzUb9kw2jdv+UZKtj64QXvL+ZP0KsbvOL7D96nEFntgS/zkXLBFUJa4cU7V9NFQpFWpr2EBjckvQBAOvqbvLuaZ36ILX/s4RNJ3owNa8Keyw48+cBDM9PIyctzIa9ZV5b/vgUrF7CugujGJKbSv+sns2n7tHcZiJBtRS41cyKgVv995hZkZm94n9mHnAzsNDMPvQfYxLTXOn0pi9pSGpGXpPBB6UVfhx5GGY9RenoH3DkfAoT9z4d82J/M4blUl1bx6Z9jfdnb/NP1gY1aS0qzOLkV9UcOnm2Ydn6PWVk90qOWeXg+pMNKRPv4y8G9GFzycnGk9ZDZ7PX9eMsKYwKlQQ7YZVOI9qkVRUKRZpqGAb1IgUT5zE8P411ve7w7ml9+2F2nO9LJalMvWVWcObP85kZN6d9xqadB6h980E4X0Hl5ld5/8AJZlSvg1dmNJ+6R0QCyTl30jk3wzk32H8u95dvc87d57/+pXOuu3NuTJPHh4ltuXRqfoybdH02B0+e5Wjl+YblW/p7I3kmhnZ7y2KYBI0t7E1Gj+6s3d04an5ryUkG9ulFdmo4JtuMVtEAL5neWlIOQE1tHf+79wTThuaSFIrhsYN/smHiwGx2HTtN5fkarwjT+dO8VzcSgEmhXYE48S6dX7RJa7tWKBTp8JoMg2LWU8wcnse2M705OvoHkJLBhrTZhAy+Niin8fNBuWrpHFMzjlNR14OPtq6Fkk2sTp1DDUnMPPsWHN0OBWN1RlVERNps8vXecNY/fXrSW+AcW959h0zOMMS8Qk2xTIK6JYWYNjSHP+4to6qmlqMV59hY/AUzR+TFZHvtYVBOKoXZPXn9fW+qvC0l5VSeu8DM4Zc97G4fZkyoXE2dg20lJ71bmrYs40/dJzGgZxUFE+cFZsSYdG5XTFrjWaFQZfWlU2gyDGr++GtJMuMFdzfnpvwzv/3gCGP6Z9K7V3Lj54OSAJrxl3f/I0k4/rN2JheO7+GF8nGMshJusmLvM4pHIiIShaF5aWT1Sua9T78A57jw1sNs+DzMxD5VhB47FZfbZuYV9af8q2pe3niAV987CMCCyQNisq32EAoZiyYP4IPDFWw/VM7Tq/eQkxZm6tA4DFx0jptSPidMNevX/AGS06jJu5Et5wqYlFEOX38yMCPGpHO7YvXgeFYodM4tB5YDFBUV6fBYOi7/h7sgswfzx/fnV1sOc6ziPKXl53jm7tEJbtyl9U4Nc9/NA3lpo1HhUil1uTze/ZnGOFRZGszqgCIi0iGEQsakgdm8W/wFVbV1rD3dnzJ6M3f22MbRRxDTJGjKoD7cPqovz68rxjmYNaovBZnBmp+1pblF/Xl2zT7+5pWtnLtQy/Pzx9AzOQ6TgJiRcseTfLN4BSs/682D5T9ilyvkDD2ZPHUyvPOIV1ArCCPGpFOLdniwKhSKXMHiWwZxY78MNuw7wV9NuJZJ18eo0l97cI4f1r7GQDvGxrobmZ+0numhJre5fVWmIUAiIhKVeeP6U3amiuUbDrCiYgzXZvVk2jB/eG6cbpt59JsjmTY0l3u+dh2P3zkypttqD73C3VixcBx33JjPwskDuHP0NfHbuBkLv/NtzpLCL2pvZemF79InNZnppT/za12c1nGBxFy0p2iWAm+Y2b3AYWAueBUKgQf8gg/1FQqzzWyh/72FKvggXUVuWgq//fspnPyyisyeyVf+QqI4B6sfImX7i/w+OQzdetCrtskE7D2y4Ia53tQ9utIqIiJtNHVIDreOyOPZNfsAePzOkc0LCsUhxvTNSOHlvyuK+Xba07gBWYwbkBX/DTvHqJ1PMymUxU9q5gPwbNXzpG7fFPzpbqTTiCppdc6dBGa0snwb0FChEPhlNNsR6QyCWpWwgRmkZELBWHrVVMHxnc3Xn/OqFjKttZmtRERErt6/3DWS3LQwM4bnMn1oHAoKSds0zIqwjJcnLea/s0Zw4q0nmRN611t/278pYZW40Oy6ItJo+hK4dy2ELnFF+Mi2+LZHREQ6pfyMHjw55wZuGZaHKekJriazIqTe8QQLTr/EP3X/DSHzhwO//bCGBktcKGkVkebMIOT/NEx4AB6t8J7r14mIiEjXMX2Jd0XVn+6GCd+HH8en0rNIvTiUHRORDsUMBs2EfkUwa6lfFGOpty5F97OKiIh0OaFQs3no41XpWaSeklYRudj0Jc2ntqlPXBWUREREuqZWjw1UhEniQ8ODRaR1LYOQgpKIiEjXpmMDSRAlrSIiIiIiIhJYSlpFREREREQksJS0ioiIiIiISGApaRUREREREZHAUtIqIiIiIiIigaWkVURERERERAJLSauIiIiIiIgEljnnEt2GVpnZCeBQotvRDvoAXyS6ER2I+ity6rPIqc8i1xn6rNA5l5PoRnRkis1dlvorcuqzyKnPItcZ+uyqYnNgk9bOwsy2OeeKEt2OjkL9FTn1WeTUZ5FTn0lnov05MuqvyKnPIqc+i1xX6jMNDxYREREREZHAUtIqIiIiIiIigaWkNfaWJ7oBHYz6K3Lqs8ipzyKnPpPORPtzZNRfkVOfRU59Frku02e6p1VEREREREQCS1daRUREREREJLCUtMaAmc01s0/MrM7MilqsW2Jm+81sr5ndlqg2BpmZPWZmR83sQ/8xO9FtCiozm+XvS/vN7KFEt6cjMLODZvaxv29tS3R7gsjMVphZmZntbLIsy8zWmFmx/9w7kW0UiZRic3QUm6+eYnPkFJuvrKvHZiWtsbET+DawselCMxsBzAdGArOAn5lZUvyb1yE855wb4z/eSnRjgsjfd/4DuB0YAXzX38fkyqb7+1aXKBPfBj/H+41q6iFgnXNuMLDOfy/SkSg2R0+x+QoUm6Oi2Hx5P6cLx2YlrTHgnNvtnNvbyqq7gF8756qccyXAfmB8fFsnnch4YL9z7oBzrhr4Nd4+JhIV59xGoLzF4ruAV/3XrwLfimujRKKk2CxxotgsMdHVY7OS1vgqAEqbvD/iL5OLLTazj/yhEJ12qEOUtD+1jQPeMbPtZnZ/ohvTgeQ55z4D8J9zE9wekfai39Krp9h8Zdqf2kaxuW26TGzulugGdFRmthbo28qqR5xzv7vU11pZ1iXLN1+u/4BlwBN4ffME8CxwT/xa12Fof2qbKc65Y2aWC6wxsz3+2UsR6eAUm6Oj2NwutD+1jV9UC9kAAAGbSURBVGKzXJaS1jZyzs1sw9eOAP2bvO8HHGufFnUsV9t/ZvYy8IcYN6ej0v7UBs65Y/5zmZmtxBvKpcB4ZcfNLN8595mZ5QNliW6QSEuKzdFRbG4X2p/aQLG5zbpMbNbw4PhaBcw3s7CZXQcMBrYmuE2B4/+nqzcHr3iGXOx9YLCZXWdmyXiFRFYluE2BZma9zCyt/jXwdbR/Xa1VwAL/9QLgUletRDoaxearoNh81RSbI6TYHJUuE5t1pTUGzGwO8O9ADvCmmX3onLvNOfeJmb0B7AJqgH9wztUmsq0B9YyZjcEbTnMQ+F5imxNMzrkaM1sMvA0kASucc58kuFlBlwesNDPwfv9+5ZxbndgmBY+ZvQ5MA/qY2RHgUWAp8IaZ3QscBuYmroUikVNsjppi81VQbG4Txear0NVjszmnYfYiIiIiIiISTBoeLCIiIiIiIoGlpFVEREREREQCS0mriIiIiIiIBJaSVhEREREREQksJa0iIiIiIiISWEpaRUREREREJLCUtIqIiIiIiEhgKWkVERERERGRwPp/86DoDwZQDrgAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], @@ -131,25 +130,38 @@ "outputs": [], "source": [ "# Layers\n", - "input_kernels = [RBF(1, lengthscales=0.8, variance=1.)+White(1, variance=1e-5),\n", - " RBF(1, lengthscales=0.2, variance=2.1)+White(1, variance=1e-5)]\n", - "input_layer = MultikernelInputLayer(input_dim=1,\n", - " output_dim=2, \n", - " num_inducing=2*M, \n", - " kernel_list=input_kernels, \n", - " mean_function=Linear(A=np.zeros((2,2))),\n", - " multitask=True)\n", + "def make_input_layer_kernels():\n", + " kernels = [\n", + " SharedIndependentMok(RBF(lengthscale=0.8, variance=1.) + White(variance=1e-5), output_dimensionality=1),\n", + " SharedIndependentMok(RBF(lengthscale=0.2, variance=2.1) + White(variance=1e-5), output_dimensionality=1)\n", + " ]\n", + " return kernels\n", "\n", - "input_layer.q_sqrt = input_layer.q_sqrt.value * 1e-5\n", + "def make_output_layer_kernel():\n", + " sub_kernels = [\n", + " RBF(lengthscale=1.3, variance=1.) + White(variance=1e-5),\n", + " RBF(lengthscale=1.4, variance=1.1) + White(variance=1e-5)\n", + " ]\n", + " kernel = SharedIndependentMok(\n", + " SwitchedKernel(sub_kernels, 2),\n", + " output_dimensionality=1\n", + " )\n", + " return kernel\n", "\n", - "kern_list = [RBF(1, lengthscales=1.3, variance=1.)+White(1, variance=1e-5),\n", - " RBF(1, lengthscales=1.4, variance=1.1)+White(1, variance=1e-5)]\n", + "input_layer = ConcatinativeMultiprocessLayer(\n", + " input_dim=1,\n", + " sublayer_output_dim=1,\n", + " num_inducing=2 * M,\n", + " kernels=make_input_layer_kernels(),\n", + " fixed_linear_mean_function=True\n", + ")\n", "\n", - "output_layer = OutputLayer(input_dim=2, \n", - " output_dim=1, \n", - " num_inducing=2*M,\n", - " kernel=SwitchedKernel(kern_list, 2),\n", - " multitask=True)" + "output_layer = Layer(\n", + " input_dim=2,\n", + " output_dim=1,\n", + " num_inducing=2 * M,\n", + " kernel=make_output_layer_kernel()\n", + ")" ] }, { @@ -158,7 +170,7 @@ "metadata": {}, "outputs": [], "source": [ - "seq = MultitaskSequential([input_layer, output_layer])" + "seq = Sequential([input_layer, output_layer])" ] }, { @@ -174,20 +186,9 @@ "cell_type": "code", "execution_count": 10, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1. 0.]\n", - " [0. 0.]]\n", - "(2, 2)\n", - "Model Parameters Initialized\n" - ] - } - ], + "outputs": [], "source": [ - "model = MultitaskDSDGP(X=X_augmented, Y=Y_augmented, Z=Z_augmented, layers=seq, likelihood=lik, num_latent_Y=1)" + "model = DSDGP(Z=Z_augmented, layers=seq, likelihood=lik, multitask=True)" ] }, { @@ -196,222 +197,279 @@ "metadata": { "scrolled": true }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " class prior transform \\\n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/var... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/len... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/white/v... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/var... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/len... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/white/v... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/0/mean_function/A Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/0/mean_function/b Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/0/q_mu Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/0/q_sqrt Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/0/Z/0 Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/0/Z/1 Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/1/Z Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/whi... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/whi... Parameter None +ve \n", - "MultitaskDSDGP/layers/layers/1/q_mu Parameter None (none) \n", - "MultitaskDSDGP/layers/layers/1/q_sqrt Parameter None (none) \n", - "MultitaskDSDGP/likelihood/likelihood_list/0/var... Parameter None +ve \n", - "MultitaskDSDGP/likelihood/likelihood_list/1/var... Parameter None +ve \n", - "\n", - " trainable shape \\\n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/var... True () \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/len... True () \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/white/v... True () \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/var... True () \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/len... True () \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/white/v... True () \n", - "MultitaskDSDGP/layers/layers/0/mean_function/A False (2, 2) \n", - "MultitaskDSDGP/layers/layers/0/mean_function/b False (1,) \n", - "MultitaskDSDGP/layers/layers/0/q_mu True (100, 2) \n", - "MultitaskDSDGP/layers/layers/0/q_sqrt True (2, 100, 100) \n", - "MultitaskDSDGP/layers/layers/0/Z/0 True (100, 2) \n", - "MultitaskDSDGP/layers/layers/0/Z/1 True (100, 2) \n", - "MultitaskDSDGP/layers/layers/1/Z True (100, 3) \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... True () \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... True () \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/whi... True () \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... True () \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... True () \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/whi... True () \n", - "MultitaskDSDGP/layers/layers/1/q_mu True (100, 1) \n", - "MultitaskDSDGP/layers/layers/1/q_sqrt True (1, 100, 100) \n", - "MultitaskDSDGP/likelihood/likelihood_list/0/var... True () \n", - "MultitaskDSDGP/likelihood/likelihood_list/1/var... True () \n", - "\n", - " fixed_shape \\\n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/var... True \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/len... True \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/white/v... True \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/var... True \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/len... True \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/white/v... True \n", - "MultitaskDSDGP/layers/layers/0/mean_function/A True \n", - "MultitaskDSDGP/layers/layers/0/mean_function/b True \n", - "MultitaskDSDGP/layers/layers/0/q_mu True \n", - "MultitaskDSDGP/layers/layers/0/q_sqrt True \n", - "MultitaskDSDGP/layers/layers/0/Z/0 True \n", - "MultitaskDSDGP/layers/layers/0/Z/1 True \n", - "MultitaskDSDGP/layers/layers/1/Z True \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... True \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... True \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/whi... True \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... True \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... True \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/whi... True \n", - "MultitaskDSDGP/layers/layers/1/q_mu True \n", - "MultitaskDSDGP/layers/layers/1/q_sqrt True \n", - "MultitaskDSDGP/likelihood/likelihood_list/0/var... True \n", - "MultitaskDSDGP/likelihood/likelihood_list/1/var... True \n", - "\n", - " value \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/var... 1.0 \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/rbf/len... 0.8 \n", - "MultitaskDSDGP/layers/layers/0/kernel/0/white/v... 1e-05 \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/var... 2.1 \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/rbf/len... 0.2 \n", - "MultitaskDSDGP/layers/layers/0/kernel/1/white/v... 1e-05 \n", - "MultitaskDSDGP/layers/layers/0/mean_function/A [[1.0, 0.0], [0.0, 0.0]] \n", - "MultitaskDSDGP/layers/layers/0/mean_function/b [0.0] \n", - "MultitaskDSDGP/layers/layers/0/q_mu [[0.0, 0.0], [0.0, 0.0], [0.0, 0.0], [0.0, 0.0... \n", - "MultitaskDSDGP/layers/layers/0/q_sqrt [[[1e-05, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0... \n", - "MultitaskDSDGP/layers/layers/0/Z/0 [[-1.8489154421545457, 0.0], [5.46206764656862... \n", - "MultitaskDSDGP/layers/layers/0/Z/1 [[-1.8489154421545457, 0.0], [5.46206764656862... \n", - "MultitaskDSDGP/layers/layers/1/Z [[-1.8489154421545457, 0.0, 0.0], [5.462067646... \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... 1.0 \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/rbf... 1.3 \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_1/whi... 1e-05 \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... 1.1 \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/rbf... 1.4 \n", - "MultitaskDSDGP/layers/layers/1/kernel/sum_2/whi... 1e-05 \n", - "MultitaskDSDGP/layers/layers/1/q_mu [[0.0], [0.0], [0.0], [0.0], [0.0], [0.0], [0.... \n", - "MultitaskDSDGP/layers/layers/1/q_sqrt [[[1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0... \n", - "MultitaskDSDGP/likelihood/likelihood_list/0/var... 1.0 \n", - "MultitaskDSDGP/likelihood/likelihood_list/1/var... 1.0 \n" + "Model Parameters Initialized\n" ] } ], "source": [ - "print(model)" + "model.initialize_layers_from_data(X_augmented)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].feature.features[0].Z Parameter True (100, 2) float64[[-2.67277756, 0....
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].feature.features[0].Z Parameter True (100, 2) float64[[-2.67277756, 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (100, 3) float64[[-2.67277756, -2.67277756, 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "model.compile()" + "print_summary(model)" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "-2542.5719769461843" + "" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model.compute_log_likelihood()" + "model.log_likelihood(X_augmented, Y_augmented, 1)" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def log_likelihood_callback():\n", + " return model.neg_log_marginal_likelihood(X_augmented, Y_augmented, num_samples=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/aboustati/miniconda3/envs/gpflow-v1/lib/python3.6/site-packages/tensorflow/python/ops/gradients_impl.py:96: UserWarning: Converting sparse IndexedSlices to a dense Tensor of unknown shape. This may consume a large amount of memory.\n", - " \"Converting sparse IndexedSlices to a dense Tensor of unknown shape. \"\n" + "WARNING: Logging before flag parsing goes to stderr.\n", + "W0808 18:37:51.556109 139652235097920 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/ops/array_grad.py:502: _EagerTensorBase.cpu (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.identity instead.\n", + "W0808 18:37:51.648337 139652235097920 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/optimizer_v2.py:468: BaseResourceVariable.constraint (from tensorflow.python.ops.resource_variable_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Apply a constraint manually following the optimizer update step.\n" ] } ], "source": [ - "opt = gpflow.train.AdamOptimizer(0.01)\n", - "opt.minimize(model, maxiter=1000)" + "opt = tf.optimizers.Adam(learning_rate=1e-2)\n", + "gpflow.utilities.training_loop(log_likelihood_callback, opt, model.trainable_variables, maxiter=1e3)" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "70.1612154856445" + "" ] }, - "execution_count": 15, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "model.compute_log_likelihood()" + "model.log_likelihood(X_augmented, Y_augmented, 1)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "samples[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/aboustati/miniconda3/envs/gpflow-v1/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:5: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \"\"\"\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:9: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " if __name__ == '__main__':\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:15: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " from ipykernel import kernelapp as app\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:17: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7AAAAD9CAYAAACFk5vtAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeaxt2V3Y+e9vrbWHM9zpTTW8qnIVtikw2NimgpOmQxwQLruTNgWoW3YratPqCCEljZRWSo27I5wmUbDijkLS0AONLIgiQRLiVJvgpnBiHBIaaJcpTMU2hQuDh1fTG+50hr33mvqPfc+p+6recO+7wznn3vWRrurdfYZa995zzt6/tX7r95MYI0mSJEmSJEmSJEky79SsB5AkSZIkSZIkSZIke5EC2CRJkiRJkiRJkmQhpAA2SZIkSZIkSZIkWQgpgE2SJEmSJEmSJEkWQgpgkyRJkiRJkiRJkoVgZj2AO3Hu3Ln44IMPznoYSZIkyQnx2c9+9kqM8fysx7HI0rk5SZIkOUw3OzcvZAD74IMP8tRTT816GEmSJMkJISJfmfUYFl06NydJkiSH6Wbn5pRCnCRJkiRJkiRJkiyEFMAmSZIkSZIkSZIkCyEFsEmSJEmSJEmSJMlCSAFskiRJkiRJkiRJshBSAJskSZIkSZIkSZIshBTAJkmSJEmSJEmSJAshBbBJkiRJkiRJkiTJQkgBbJIkSZKcQCLyURF5WUT+401uFxH5xyLynIj8gYi8fddtHxCRL+18feD4Rp0sEustzrtZDyNJklPGzHoASZIcrieevsRHnnyW5zfG3Lva4fFHH+axt12c9bCSJDl+Pw/8NPBPbnL7e4A37ny9A/jfgXeIyBngQ8AjQAQ+KyIfjzGuH/mIk4Vgg+Xy6DJfH3wd6y13de/ioZWH0ErPemjJCeOCo3IVIzsi1zmr5eqsh5TMgRTAJskJ8sTTl/jgx55hbD0AlzbGfPBjzwCkIDZJTpkY42+KyIO3uMv3Af8kxhiB3xGRVRG5B3gn8MkY4zUAEfkk8G7gF492xMmiGDZDro2vkUtOr+hxeXyZXtbjnv49sx5ackJ87Pe+ykc++Xu8PP46Z5dyPvCOb+R73nQ3vaxHprNZDy+ZsZRCnCQnyEeefHYavE6MrecjTz47oxElSTLHLgJf2/X913eO3ez4a4jID4vIUyLy1OXLl49soMn8CDGw1WzhouOu3l28YfUNdE2Xl0cv086FJMnBPPH0Jf6n//uzvDh6mSiRyxuKn/43L/GpL77EterarIeXzIFDCWDTPpskmQ/Pb4x3/tWAWW+/rjueJElyeGKMPxtjfCTG+Mj58+dnPZzkGFSuYtAMKHXJSrFCYQpWyhVGbsTQDmc9vOQE+PtP/iGVHyCqIdgVol+hspFf+K0X2ag3CDHMeojJjB3WCuzP06YX3czufTY/TLvPhl37bN4BfAfwIRFZO6QxJcmpc+9qBwApX0TnL6Pzl0FvTI8nSZLscgm4f9f39+0cu9nxJGGr2cIGSy/vUZoSgHPlOSKRa+O0OpYc3AubW4gegDfglyFmIJGXNyI++jRRkhxOABtj/E3gVp9a0302McbfASb7bB5lZ5/NTnGIyT6bJEnuwOOPPkwnH5Orbe5vatbCGJ1f5dLGNt/54U/xxNPpGjRJkqmPA//1TpbUnwU2Y4wvAE8C7xKRtZ1J5XftHEtOuRADQztEROiZHkray8he1qOX9bhWX0urY8mB3b0aQAVi6LbBazQQhbtXuihRKYBNjq2I04H32SRJsjem3OIx99u8nW0aL/xM9u18VZ/h0oZJBZ2S5BQRkV+kLch0TkS+TpvxlAHEGP8P4BPAfwY8B4yA/2bntmsi8neAz+w81U9MCjolp1vjGypfUahiuvoKICKsFCu8MHiBxjfX3Za0YoxEIoJQ+xofPLnOU0GiG/ihP383P/Vvr6Jj5A3yR5xnk5fMKv/FX/weSl0ybIbQm/Uok1lamCrEIvLDtOnHPPDAAzMeTZLMn7YC8e9zIfsjvjGs80x8mIf5Ou/hGf4v/SDBr00LOqUANklOvhjj+29zewT+2k1u+yjw0aMYV7K4Rm6E845+2b8u8Hri6Ut8+Nc/x5X6jzlXvMSPvevPnOrzjA+e2tfYYLHBToPXrXqLq9VVfPQoUeQqZ61cY61YYylfSm2IaPdY/6ffuEo5votLv/2bPFg9x2oeufgNr+ee8vME/U7W3TqNa8hNPuvhJjNyXAHsrfbZvPNVxz99oyeIMf4s8LMAjzzySCpzlySv0lYgHvDn8z9kqIR/lj/Et0fNd8c/4JvNH/P5pn0LpoJOSZIkyZ0Y2RGRSKlLMpVBjPzbT/8Gv/ipZ6jsGqGjeWmwfqqzfUa2LWYViWjR5DonhMDADthutumZHkv5EiLCZr3J1fFVNutNVotVLnQv0M26s/4RZmpoh3jf8J6Vy6y+o0du/ix0z+KbIVdf+o9kZ99ILDtUvkoB7Cl2XG100j6bJDliz2+MyfSAu7nC5+UCo7DMU+p+KhEekueBCoCVTkpXSpIkSfYnxEDta7ToNkU4BPiTT1P/+3/EX4m/yo/oX8NEQFWntn3byI4Y2AG5zjlbnuVs5yxGDLWvaXzD+e55vunsN/G6ldfxwPIDfMvZb+F1y6+jl/Wofc1Lw5fYrDdPdTuigR2Qbb1IvnkJk/fhgT8H9/8Z9NnXo7Mu6mv/HypGxi5Nxp9mh7ICm/bZJMns3bvaoTv6U7yyfM3dQ6zvZZTnXMm6XOAymBG4EpFZjzRJkiRZNDZYrLfkKkeLhpe+AH/0SZ5vSr4a7ucR9SX+fPgyn9YP4XFcOmXZPo1v2uBV5awUKwCM3ZitZouxHdPNuiznyxj1yqW3Uooz5RkAXHA0oWHQDIgxslKsIKfshO2DZ+zGlBtfQbxFnX0jnHsDiIbtF8nWHqK5/EXyasQ4O12vr+R6hxLApn02STJ773z4HC8+81UA/ti/AcjArvFCdpaH1Z9SqE1qzrAxsrMdaJIkSbJwalfjgqOf9zH1Njz/FPiaL3Qe4ePbb+Q+ucKfjX/C78o9DFSDBMMTT186FWnE1ls2602MMiwXy0BbtGloh9OWQyvFCoUuXvNYrdoV7bEd09Vd6lBT+5qtZmsaCJ8Wla/wrsFsPI/JOtA7j+/fRYgOg5B1zlHFQLH9AoPu8qyHm8zQcaUQJ0lyhJ54+hIf+70/4V55mW36bPtz7Q2x4KvhbiQGvkG1Bb9TT9gkSZJkvyrXbkMxyqAHL8PmJejfw/d+97vwZPx2fBMXGHGRqyAVEU5NGvGktdBqsTptLTR2YxrfIAgd07lh8DrRNV2QNpjNdT7tdXra0mQ/9ntf5n/4+V/nl37zWf7xf7jCx//kKn+08RzPbf4p61phCJD3MFvP46OndvWsh5zMSApgk+QE+MiTz1L7bVbVFlfCKvi2hYEg/Km/nxCF+/WLdDLh8UcfnvFokyRJkkVT+QqkDWDN5iWwY1i6wHve8a1E4AvhIWzM+Mb4MqLbwOI0FA2cpP52TGcavMYYGbkRNlhKU9LLbt3zRStNoQt89PSzPrnOqVzFoBmcmr66Tzx9ib/3a5+jP7qEJvCchZ/63a/w6T+8zMAOuCwRb0fQO4cZXwNbt6/J5FRKAWySnADPb4y5V70AyvFiuIudLehEoNe/l7EUPJBt8aH3vuFUpHMlSZIkh2cSpGnRZMEj2y+0N6w9BEpzcbXDS5xhIy7zUFxHqyEQTkXGz2RlumNe+VnHbkzjGowydE13GtjeStd0ibTFm/pZn9KU1L6ePv9J9/ef/AKVt9wnV9iQEivwcn2WX/itKyxlS4yzDlvNFrFYQdsKPd48Nb+b5LVSAJskJ8C9qx3uUZeIRF5wr3Ssurja4dd/9D1811u+iXc+qHnnm9KekSRJkmR/bLC44MhUhhlvwmgdij4s3wvA33zXN9LJFF+KF7kQR6ypTTp5OPEZPzFGKl9R6OI1q68uOgpdXBfY3kqmM4wyVL6iNGWbShw8Izc6FVWJX9gc0GXISqgYYLDkDOISL2/VnOuco9e/myo4BgRCDOTVOrVPKcSnVQpgk+QEePzRh7k7u4xExQvhHgA6mebxRx+ml/fIe3fh6gGj4ZUZjzRJkuTWbEiF5uZN4xtCDGQ6IxtehWodeuehe4ba1zz8wBY/8i7F8717KUPgW8pN/se/9PoTn/FT+YoQQ7uHdUcTGnzwaGnTgvdTSbjUJS44bLB0TRejDdZbtu32UQx/rtyzmnFBrqCBSik2/BIigbuXlunlPfr5EqZ7Hm/H1NpQjDZSCvEplgLYJDkB/vK33cV/8oDH6S7WL3FxtcNP/sCbeextF9uiEGsPADC+8qUZjzRJkuTmNqoNnh88n4LYOVO5ComCFo3efh4Q6Kzh8z5f3/o6W3aLP/eGNf7a+76F73nL6/jvH+nzXd+0NOthH7mxG7dp1fqV/upjO8YGS6YzSl3u6/lKUyIIYzem0EW74q0MlatO/Grjj7zzAe432zjAkrMZlyiN5vHv/TYKXaCVRnpnwQ6pTEE23sAFhw9+1kNPZuBQ2ugkSTJb42bI+azi4je/kcf/8vej1PVzU/mZ1wMRu/mnMxlfkiTJXihRjN2Yr2x+hfv691Fm+wsAksM3SZMVJegYMcOrIAqWLzJwI65UVzhXnuOu3l084z/HljGUw6uM7HDWQz9SPvi2rVDWv+5YExoUCiXqusB2L5QoSlNSuYp+1p/2jI0xMrKjW1YyXmQ+eL774WXWvlryH7+kqZuMYvkCP/7db+H7334f0BYPi+UKmTKMTc5qtQkxUPmKnrp1kazk5EkBbJKcAOPhyzg7YrV/32uCV4De6kNEZWg2LxFjPHXN0ZMkWQzLxTJKFJcGl/jK9le4b+m+21ZwTY6WCw4fPQqFacboZgh5l9BZ5er4KgrFhe4FlvIlevkSW90zdLZfYjS+eqLPN5MV0Vzn1x1rfFvsanda8X50TIexGzN2Y0pdMrADMpVhg21XdtX+guJFYIMl1Jt885mc1739dbz/nm+l+4bvZqVcnd4nVzku75NLxpbOEOeQ0SZ1r06fEXMkxIAL7rr3xVFIKcRJcgKMr34JR6B39sEb3t4t+ki5jBu9zNie/LYGSZIsrn7e58HlB9GieXH4Io1vZj2kU81FN93TaZptGG9AZ41qpyrsUr5EN2uDtbXOGlVvDWVr4uDKiU57tcGiRE1XSaHdE1v7mlzney7e9GpGGXLVttEpTYlRhtrXWG9PbNVdGyxhvEFwY9AGXZ5BKU2uXgmCMp1B1iE3HYIuaCSgR1dP9Gts0bjgWK/W2Wq2jrz9Uwpgk2TBPfH0JX7yY5/kD1/Y5PFPDHji6UuvuU8v66E7a7h6K33YJ0ky9wpTcHfvblxwXB1fnfVwTjUfPCEGtNKYwWWIDoplNrUQQ2QpX5oGcavFKqF/AR89YfjSiT3fxBhpfHNdSq8LjspVGGXoZb0DrTznOsfHdm/nWrGGUYYQw4mdzGl8g663aXyDUhm6XMGIue53mKkMRJByCW1yxiGQ15s04WT+ThZN7Ws26g0ikZV8ZU+tow4iBbBJssCeePoSH/zYM1BfJgTNl7b7fPBjz7wmiC1NSd45g2vGVM3Jr2aYJMni62U9lvIltpqtlDkyQzZYfPCICGZ4GRCaziqVd2il6eev7AHt6A66cwZvNDJ4+cSuGLrgiMTr0iTHbowLbeucg6ZPTvbONr5BRCh0QSTigjvyla3jFmLAB4eMruIU6KyD5P3rVrah3R+sRUPRp4yRquhihldPbFC/SMZuzGa9iRLFWrG2773fdyIFsEmywD7y5LOMrWNZb2HJqUOfsfV85MlnX3Pfbu9uLJ568+szGGmSJMn+iAjnOucAeHn88oxHc3pZ31aE1t5jqi3QBleutP1PTUFpXim0lemMolzD6RIz3mR4Qgs5TapkT/ajhhjaSs0ImcoOvPqUqQxBpquLkyq8k32wJ4kNFuwIXw8IEYwpUcVrA1hoX18x61EGh817yGi9nUw4BX1y51XlKrabbXKVs1asEWJgZEdH/v9NAWySLLDnN8ZAoMOIYSyZ1GVrj1+vXLqXiGC3UgCbJMl8mqRmTuQ651znHEM75Moo9bGehSY0BAK6GaLtCLI+VufYYMl1jpHrA42yXCNmJareprKDGY36aE32v04C1bEbt31yVXZoxWtynU/fC7nOyVU+3Qt7klhvieMtnK9AFCbrIHnvxgGsyohZFyMGm3UQVxHrAS64GYw8qX3NVrNFrnKW8iUGdsB6vc7IjY58UiEFsEmywFa7GUbGFLpiHPpM3tL3rr62eES+dA8CVFsvHu8gkySZCRF5t4g8KyLPiciP3eD2fygiv7/z9UcisrHrNr/rto8f15iHdshmvXldb8eznbMsZUtcHl8+lpn95BUxxmlwYJoRqt6GzipDJQgyXRncrdc5wx9vwb/7wtd43//2a3znhz91w9oMi+zV1YAb3yAISqlDDWB373udPO9JW4H10UMzwLkaiJjOKqLMDQNYIwaKHqI0QWdEQI2unLigfhH44Nlutqd7vtfrdcZuTMd0OFuePfLq4ymATZIF9cTTlxhUjg4DNJatsAxApoXHH334Nfcvlu/FoBiPXkrpNklywomIBn4GeA/wJuD9IvKm3feJMf6NGONbY4xvBf5X4GO7bh5Pbosxvve4xl2akkjbd3S3e/v3okVzaXCJEE7WHsB55uIrLXSy0TVA8FkXm7XFi27UKuZTf7jJJ/+0IljLKgMubWzfsDbDopoUtZoEsDHGNqjcuV4/rDY3pS5RoqaTNrnO0aKne21PChccYgdYie0kQLF8w+AVaCdLsi7KFGid4QAZXE6FnGZgu9kmxkjXdNlqtgA4U55hKV86ltZZKYBNkgX1kSefxYbIGX0NRWAznAGglxsee9vF19y/LFaQrEM9ujatbpgkyYn1HcBzMcYvxxgb4JeA77vF/d8P/OKxjOwWjDIUumDsxgztcLoSq5XmYv8iNliuVqkq8XFpC+zsBLDDyyAabwoaZdCib1is5Wd+4yu85Luo6FmWAYi/aW2GReRiGzxOAtXpimgELfrQqq+KCF3TpQlN21dT5ZSmxAXHyJ2MTIQYI7/6zCX+9r/4DD/9G8/xq7//Av/+K6ObBrBKFEpppFwj8w5nSmR07cStSs+7sRvThLbf8aRlzkq+ctO/21FIAWySLKjJPtdzcgUErvmzAGyOb/xBnpscVfTx9RaNS7OVSXLCXQS+tuv7r+8cew0ReR3wEPCpXYdLEXlKRH5HRB672f9ERH54535PXb58+TDGTdd0CTEwtEMGu/ZQ9vIePdNrWzWkLJJj4YPHBouJDtMMQGl8sUQTfbv/9QYXrC9uNGzGVUQiKzIEac9JN6rNsIimKdU7P/skfVhEDr366qRNT+Obto2RMihR1K4+EdWIP/b01/hfPvEHbI8GKOXYqOBn/sPz/D/P3LxomxGD6p4h9zVNXiL1dgpgj1GMkaEdIgg+enKVc7Zz9lgqD++WAtgkWVCTfa4r+goBxXo4e93xVytNic6XCW5IdUJmb5MkORTvA345xutSM14XY3wE+K+AnxKR19/ogTHGn40xPhJjfOT8+fOHMphMZ5zvnKdjOtS+vm4/7Gqxig2WQXMyiwPNGxccLjgyW6GbMeQ96qzdm5np7DUFnADuWelRxRIrGcu8EsDe7Ny0aFxwaNHTNMna14gIkXho6cMTWrUrupMALdc5StS0pc6i+we//gUyN2yLhEWPJWfTZfzUJ79808cYZYjFMrlqU4iVHWLTpPyxqXw1nTwREZbypSPv+XojKYBNkgX1+KMP08k0fTUgBMUwrtDJ9A33v0KbelN2z+BcTVNvHvNokyQ5ZpeA+3d9f9/OsRt5H69KH44xXtr575eBTwNvO/wh3twkfRLadLWJ/k5/yG2b+lkfBxssMUZUPUS7GkyXeqeYUKay1xRwAnj8Xd9MMD2qaFgOY1DuluemReOCm66+utDuEZadDbCHHcBOnnMSwBa6QIvGeXciVh1f2BrRkzFaGiJCg6Gmwwsb9U0fo5UmFktkKsfGgPIWmya0js3k8zjS7n+90WfAcUgBbJIsqMfedpGf/IE3s1aMacg4u3KWn/yBN99w/+tE3jlHDI56cDipfkmSzK3PAG8UkYdEJKcNUl9TTVhEvglYA35717E1ESl2/n0O+E7gC8cy6l200tP9sJMZf600PdObFhBJjta03+l4ExGFNzmNaQPYQhU3fMz3v/0+/tu/8BZ0XrIkFXcvqduemxZFjBEf/XXpwyGG6arsUewBnFQjnuyDVaJw0Z2IFdh7VnK6scFLRBNoyGhizr2rry0ONmHEgDaYvEcQwcaAH19LnwfHoPHNtO+uEkXHzC6r4vh22yZJcuje+9Z7WHquA2qZH/+B771t5bdO7wIBsIOXjmeASZLMRIzRichfB54ENPDRGOPnReQngKdijJNg9n3AL8Xrr/6+Gfg/RSTQTnR/OMZ47AEsQC/rUfuagR2wnLeV1vt5n81mk5Ed0ct7sxjWqWG9JRLJx9fa/a86w+ocEaEwNw5gAR79tjdwdfAgjK7wn/+5b+TbLi5+8Aqv3f9a+5ra13RMh+Vi+Uj+n5NV3cY3dLMumcoYxuGJWIH9a9/9EP/6X38OL2BiZBhLSlPccrXeKNPuOS6W0SrDhoger+ODx+gU1hylkR0RYkAQSl0eS7XhmzmUv7SIvBv4R7QnyZ+LMX74Vbf/Q+Av7nzbBS7EGFd3bvPAMzu3ffW4yvVPyp4fVr+uJJkF5xtsM6K3ev+ePkjypXtQCNXg5gUSkiQ5GWKMnwA+8apjP/6q7//2DR73/wJvPtLB7ZFRho7pMHZjuqaLUYZ+1keJYrPeTAHsEbPRIq4ic2NQGmcyap1R6OKWq4153sPnHbKBp6o3iTHO9GL3sEwqEBsxhBiwwbYX86Y8kvRheKUy99AOKU1JvjOB0PimLbAlZmF/t49+ywXOvXSBX/78VYrakXXW+J+/9y23XK0XEYwyuKxLrgusOEyz1aZ2pwD2yNhgaUJDCIHc5HSzm6+SH4cD/6V39Zr7Xtoqh58RkY/vnq2NMf6NXff/77h+L814pwfdsRraISM34lzn3Ew2HyfJYairTbxvKIq1Pd0/751rT3zjK0c8siRJksMxXYVtBqyWq2ilWcqWGLohm/UmK8XKrId4Ik1a6IgdY3wDOsObAi9CqcytA1iVQ7GMCp443qQJzbSi7iJzwSEIWmkqV7Wpw0ofWfA6MXkPbDfb9LN2H7j1lvVqna7p0s/7R/r/PwohBkIz4u2vW+Lc+W+guCb03/gO7n3o/ts+tg1gS3JtGKHoVNvTyYXkaFSuwnrbbuPIejOPnQ7j/76QveYikc16k8pVt79zksyhv/XEM3zP3/tXfP75a/z0b13jbz3xzG0fk5drGJXRjK5eV9kzSZJkXilR036Yk7TJ1XKVXOVsN9vpPH5EfPS46MiDR7kGdEG10yojU9ktA1gtGso1dIzQnIx0V2hXoSY/tw22rdCssiMPYI0y0yC2CQ2lbld8tWiasJgVeH30YIe4GPCxLYylss6eAqNMZUTTaSsS6wzqbRq/mL+HRVH7Grfzd5rl3teJwwhgF7LXXIiBQTNgM1VjTRbQ33riGf7p73yVZblCBDbsKv/0d7562yC2KJYhK2jqzRTAJkmyMEpTIgi1a6uTTladRm7EyKa2YEchxID1FuMdKng8YHf2vd5uNVWJQnXWiMFDs01tb15VdlFMCyntbD2b9H9Voo6keNOr9bIemcoYNAMCAaPb1OJJUZ1FE2IAO6TxHvEWbUp01msnP24jUxnkHRCFKIOrttqAODkSLjhqX0NkWh1+1o57/Xdues1lKkNE2Gq2sP5kzAwmp8cv/m47Z7Sq1hHgWli77vjN5KZAmx6uGaTZyiRJFoYSRa5zKt+utk76DxaqYOiG6Tx+BJx3+ODRdoyKkaD0NIC93YqjEoUulolao5rhiTjfTH6GXOX44NuASY6mdc7NrBQrZCqbVoOdFJVaxBVuHzzUIxoF2tcok2OK7p7282qlUVm7J150hrMjrFv8SZJ51fiGsRtTmnIuVl/hcALYhew1V+iC5XyZkRulVdhk4fid2dZlvQkIW5y97vjNGGXIimVwI+yu3opJkiTzrtAFIYZXAgmdt2mVrp4GtsnhcbHtcVrUQ7QogspodIbRhkzfOmjTotFFh6hzTL1NHRY/uGhCgxJFpjNqX7er02KOdW+vEsVKsUKhCxrfUPsaH/xiBrDRI3ZEJQrtLFFnmHzv+9m1KTG6g4gm+AZvUy/YozK0Q0IM9PP+bScYRnbEerV+5FkBhxHALmSvOa00/axPJhkDO0h7aJKFonc+QLpqCxeFQVi+7vjNKFFk3VWcszRVmrhJkmRxFLpAiWK8a/Ktk3UQEUZ2tJBplPNs2gPWDiFGvDFYU5Cr/LZpnkoU2nQJOkPVJyPjp/HNdS1tGt+Q7VRkPk4iQtd0KUyBD77dG76AGQghBrRvsKFBB0c0XUy+9/RUJQrJuygxeInY0cYRjvb0ijEytEMyySh1edv7Tz6fj7oy9oED2BijAya95r4I/PNJrzkR2d0S52a95p4Skc8Bv8Ex95rrZl1KU1L7OgWwyUJ5/zvapIeOGuFiQaC47vjNiAhZeZYYHM346pGPM0mS5LCItL0Ha19jgyXEQKELSl0ycqN2j1ZyaJx34B2Za4BIs1MwRyuNVrcPYFXWIZoSZSvqBb/GCjEQYmiLB8XIyI1A2v2As2hh0zGdNpU4NG0Qu4ATBM41eFfhIxjvkM7qnva/ThhlUHkfowQXIi5Nyh+JSfrwUr502/e99RYfPaW5faB7UIey63xRe83lOqfQBWM3ZmAHe/rjJMk8+LuPvZkYI/qLFXUs0WJ4/zvu5+8+dvu3U9E9jydgR9eOYaRJcjQmhUtul8qYnCwd02Hk2hQ1JYpznXMsFUu8MHiBYTM8lgun08IGC64mCx6Uptn53RplMHLry0cRIS/6jHSBsutYO2j30y7oNdak6KFWbdXfylXt5MmMXm8iwnK+TOUqrlZXqVxFx3RYKpZmMj+ARnEAACAASURBVJ47EewAFzzEiA4WOqv7as2iRUPWIdMFPnpCc3L6Dc+TrWYLgOV8+bb3rXzV9kXew0rtQZ3qBqiZalM/tOh2FTbtoUkWxBNPX+JTz75ILhXKLPEP/stv21PwClD2zyMIzfDlIx5lkhydoR2yUW+ktNFTZrL9Z/d+2J7p0TEdNu3mQu4FnFfWW1Sw6GDxomiytvrupAjm7eSqJBR98J5YD6YFhxbRpMeollf6v866F2auc852ztLP+gztkKvV1YV5/YcYiHZMAAgVgkKVK/ua4JgEsDrvE6Mj1sOFfo3Nq61mi1KX5Ca/7X1rX5Pr/FgmEU51ACsiFKZAK02MMaURJwvhiacv8cGPPcPVzXWMOK6NCz74sWd44umb1U67nu6cRSE0w7QCmywmGyy1r+lms0nfS2arm3VZzpcRhMpXaKVZzpex3qaWOofEB4+NFuM9ylYEbXCmRIvec9XdTGfEYpkseGK9vbD9SmHXCqxotptttNJ0s9m3E+mYDhe6F1gultvPxQWpxOuDBzfGBotqakRn6HxpfyuwaieA1QYRRai3FiaAXxSNawuFLRe3X31tfDPd1nEcTnUAC+0M1qR/19iN275USTLHPvLks4ytp8MmCs+QJcbW85Enn93T48vuGUSEplk/4pEmydEYNkOUqLnpR5ccPxEh1zmNb4gx0s26ZCpju9lO5/FDMOkBm3uLcjVBF1idk+3sgd0LIwZf9iF6aBZ7BdZHjxY97YdZ6nLaD3bWMpWR65wQQ7s3dwH46MFWNESMr8HkqGLptqnpuylRSNZFK4WWDGeHKYA9ZNt2G0HoZb3b3rf2NYKkAPa45Cpv02EQmtAs5Eb45HR5fqOt8LamrhGBrbB03fHbybIllM5pqs2UfpksnMY3NKGZWfGUZH50TZcQA2M3nrbUGbvxdVWKkzvjo8dFh7FDFIIThTPtlqu9BhlaadTOyo1qRgsdwLrgMMpQ+YrGN/Tz/qyHNDUJYJWohSlKGmIAN8Yrg7FjoinQOxXF90NnHZQYtNK4anuhX2PzZlJ9ONf5niZrjjN9GFIAi1aaTGcYZXDepdmbZO7du9o2kV5R6wiw6dauO347ZdFHTEFjB2mlIlk4AztAiZqbZurJ7ExamEx6FPayHoIwaAYL2VZknrjg8MGT1SMUilopVN7dUwXiCSUKVSzhRVD1Yq+OhRjQotmsNzHKzFX2h1aaQhcYZfDBs91sz/3v2kWH2Kp9Xbkan/XI1f5XtPVOJeJMZTg3mPufe5HYYGl8Qzfr3ja12wc/rdJ9XE59AAvtKqyItP3lbJq5Tebb448+TCfTLMsmIGxwhk6mefzRh/f0eK00ynQJzWhamCJJFkHt62nxlLT6mgDT1LaBHVCakm7WpfEN6/V6yqg6gMl+1dyOiQSavIuIRu987YUShTIlQWeYZnGDCxcckYiLbfpw13Tnrvp5pjK0aDqmQySy3WzPeki3FEJAXEMIHgke8qU7SsnWosG0AVZwFteka/jDMj3fmtunD097Rh/j+yIFsLyyDzbGSOWr6Wb9JJlHj73tIj/47RfpmSEeRc0yP/jtF3nsbRf39Pi2d1qP6MdYly7wksUxaAbTi7QkgfbzrGM6VK4iEumYDh3TQYlKBZ0OwHkHwWFcQyDiinbSaD8BrBaNzjo4nSELvAd2MhHigsNHP1fpwxOZavcm++DJVY4Lbq5Tib2vCb4hSgTvIO9N69Hsh1YaUywhShEl4qpU2+OwjOwIo82eglIXHILsaw/zQaUAlvaNn6kMpVS7ZL7AlfKSk++Jpy/xLz97iY4MCEEzCF3+5Wcv7bkKsRJFkfXxrqGygyMebZIcjtrX1108+uBTmmgCME1xm/SBDQQyyWhCk14jd8gGC77GREdA4UwHhUIrvefsBxFB6YKoS7StcK5ayG0rNlhijDS+IVf5sRWp2Y+O6bTp9G4ItBM781zQKdgRMUaiDxADUq7cUQBrxCB5B2UKvPf4avMIRnv6uOCmr/e9pAXbYDHKHGtmVApgaT9kM5VN9w8sShny5HRqqxA7OmpETQFk+6pCDPAnW4ovXlrne37yV/jOD39qz8FvksxK5ap28mXn4nG72Waj3ljIC+LkcE0qUk8mnwWZbgvaarZSsbp9irFNl1XWktmaaDKcaSf597PCokWTZV2CyRDf4O2orT67YGywBNqqzIUpjnWf316JCMv5Mlpptu32dBV2Hl/7PniirfBA9GNEgSr6e17Z302JalOITReJDjteT1mUh6DxDTbY6zq13EyMcVrk7DilAHaHUQazU8lsnmetkqStNuwppKaJJSC7jt/eE09f4hN/OMZGT0eGXNoY76uPbJIct8nqxyR4HdkRTWgrge6nb+BpIyLvFpFnReQ5EfmxG9z+QyJyWUR+f+frr+667QMi8qWdrw8c78j3r5t10aLbqpkqpwkNS9kSPnoGKdNkX0IM+OCR0GDcmJB1CLpEkD0XcII2qDKmIJiC6C2hWrzCgTZYfPD44FFKTVN151Guczq6M+3HCczlvuO2AnENRLRzRJWjs94d/V610kjeRedLaO8I9dbCvcbm0X5a4rjY7hE/7omddObfoZXGKIOWNoBd1L0aycm30snIsWhxjFx53fG9+MiTz7LhlogRlmUDYN8ruElynGpfE4mUuiTEwNAOKXSR9sLegoho4GeA9wBvAt4vIm+6wV3/WYzxrTtfP7fz2DPAh4B3AN8BfEhE1o5p6HdsOV8mxICLjhBD+5oxZbs/dg5XoubV5HdobI24GqdLoimne2D3I896oEt0DPhmu91bu0CstwzdEEW7+jwvvV9vppf3CDFMg9h5DGB99OBrmuBQrmqLfOV3XtVZZz0+/9KY3/rSVT788c/wXR/5N2lC/gAmrxslak+rqsNmiCDH/t5IAeyOSe52qUust3O9+T053UQglzEaSx271x3fi+c3xmyHJQRYUtvXHU+SeVT7GiWKTGcM7ZBI3FNj9VPuO4DnYoxfjjE2wC8B37fHxz4KfDLGeC3GuA58Enj3EY3z0GQ6o2M67QVybNPOS10Siam2xT742K44GjtCIVijIO+0RZn2uUpmdAblUrvPsdpauMWBYTPEektucrTSlLq8/YNmKFdtP+TGN9S+nstK3JMV2KAM4iuUMmQHKIz1a5+/wr/83FXGDkrGvLA1SFllBzCpPjxpMXq7+zahoZf1jj0bKgWwOyb7OsqsnWVMKUfJvNoYWUq20RIYsnzd8b24d7XDBn0E6DG87niSzJsQA7WvKXWJD56xG9MxnWPfb7OALgJf2/X913eOvdoPisgfiMgvi8j9+3wsIvLDIvKUiDx1+fLlwxj3gUz7c0rbCkaLRolKk9L7MEkhNs0IRGhMCaL2VYF4IpOMmJVEUYir5nJF8GZijFytruKCQ6FQouZ+BXbaVYNIjBHr7dyl1ProEVdjtUY5C6bEmDsvjPXTn/oyW74goCkYAyFllR1A4xtijO3WytucZ0d2hBZNNzv+vsgpgN0xSY0RhI7pMLTD2z8oSWbg3tUOK2qDCGz75euO78Xjjz5M0MvEqOmo9nW+nz6ySXKcat8W1StMwdi1WQLTICU5qF8BHowxvoV2lfUX9vsEMcafjTE+EmN85Pz584c+wP3SSpOpbJoyXPuaQhc0vknFXfbIR4+nXYGVCL7oEwh7TinczSgDugQUyg6xcXEC2JEdsdVsUegCF93cr75CW9Sol/UItGngNtrp5+a8CDEQXY0VwNfErHOg/ZMvbNRUsSBGoVA1WtrXWMoq279JvYlJPHSrom0uOGywM9vKkwLYXYwyuOBYypaofT13b/okgTYAPZdvIcDWTgC7nwD0sbdd5Mf+0tsRndNVQ+5dLfjJH3jznvvIJslxql09XfkZuzGFLua2iMqcuQTcv+v7+3aOTcUYr8YYJ2X3fw749r0+dp6VO/s1oV1NmEx4bDfbt3pYssMHT3AW7cYggst6aPQd9+nUWZcgoOx4YVKIXXC8NHoJFxznO+fpZ/2ZrDLdiV7Wo5/1296cURi78VztAQ8xIK7CR8A7pOgfqH/oPSs9xpTYaNBYutJeu6essv1rQkMkTierbtUWZ+zGCEJpZjOxkwLYXYwy+Oine6sGTUojTubPY2+7yPd/axejhW3WuLja2XcA+thbv4G3PXgXj715lU8//l0peE3mkg+eJjSUpmS72SYSF+Yicg58BnijiDwkIjnwPuDju+8gIvfs+va9wBd3/v0k8C4RWdsp3vSunWMLYXflzEkxkl7WowkNG1VqvXQ7NljEN2TeEZTGmbytKHwHAayIoLKSIBrdjLHezv1KuA+el0cvc626xlq5xnKxPO01vCg6pjMd77wVc/KugegJElHBgelg9J0HsH/zXd9E1H0sBRmWjoxTVtkdanyD7HS22Mv+11znM3tfpE1Eu+QqZ8gQBApVMLRDzjP7lKgkebXXr1r6F9b4dz/yg/SWLuz78ZnO0HmPUI/aAhVzvq8nOZ0m6cMuOGpf08/6c9mDcR7FGJ2I/HXawFMDH40xfl5EfgJ4Ksb4ceBHReS9gAOuAT+089hrIvJ3aINggJ+IMV479h/iDilp251Min/ZYKcTHwM7YGRH9A9QNOakc8GBqzGuJpoSrzMM+9//Cu3fQmUlGIMODrvTC1Yzn1kUMUa2mi226i16psfdvbtvuQo1r3Kdt++BUKOVxgU3N+f54IZtarp3ECOqXD5QEPQDb3+AavwWnvn3v4vxV3mg1/BXHk1ZZXdi8pnp8bcMYCdVrme1+gopgL2OUQZBaHxDL++xXrUNkVO6WjJvmmoTpTVZZ/WOHq+VJs97jKqrNHZML08VXZP5U/sa69uVg9KUafV1n2KMnwA+8apjP77r3x8EPniTx34U+OiRDvAI5TqfFiNpfEOuc7pZFxssla/okwLYG4kx4qJrV2Bdje/0cdqQK3VHQYZCoVRBUBnKO4Idt1Wi51CIgc16k7Ebk5scI2ZhW3UpUXRMh816EyWKMszH/t22AnFDIBK9RUSQvH9HkyO7PfrW1/M2/zBXXhzz/je9joe/NQWv+2VDW/ArVzk+3jqArXzVFjVTs5sUWZx8iGMgImQqo/ENS/kSkZiKOSVzqWm20QeoxKpEYYoVvHM0ddoXlswfHzy1r/HRk6uc5Xz59g9Kkh25btNeXXAMmsE0hTLXeZtS6ecnpXKe+OjbIjt2jHYWZ3KiLu+ogBPsXFdlJegcHRzODuYyhTjGyGa9iQuOjmlbBmUqW+iMj37Wx0fPdrM9N9eyPnqwFZEI3iKALg62AgtgTIEUXZREXL2VtgncgUnLJSXqlgWcYozUrp5+xs5KCmBfJdftzEOhC5Qohm4+3vRJMhFjxNoBWdZHqTt/C2edNWJwNNXCZAYmp0jtaypXkaksZQgk+5apjFzlKKUYuAGb9SYhBgpdIAiVT211biTEQIgBbQcYpbBKI6a9HrrTFGKtOwRTEH2DzOEKrA2W9XodGyxL+RJKFCGGdqvNAmfg9fM+5zvnEYSRG81FIacQA/iGxntMdARR6ENI59eiUcUKKkQaO0gB7B2ofU2msvb9r/RNg9NJoadZV+U+lABWRN4tIs+KyHMi8mM3uP2HROSyiPz+ztdf3XXbB0TkSztfHziM8RzEZLYtxEDXdBk2KYBN5ksIHu/GZMXBPvSLzlk8ATdeP6SRJcnhGbvxdO/ijVZBRnbEteraXFyUJfNptVxlJV+hYzo0vmFoh9NenpWr5nIlcNZCDLjg0PUYkbaAE7rtB3knwZwShc47RJ1BaAh2vn7vYzeeFvZaypcIMUxXohZ59XWiMAWZytioNubietYHD64iKIXYCtEZ5hAmKJUoTLmGxEBTbxFCCmD3wwePC27aMuqW6cOumoueyAcOYEVEAz8DvAd4E/B+EXnTDe76z2KMb935+rmdx54BPgS8A/gO4EM7FQ9nZvIBPUkjaUKTUo2SuVI3A4JryIuVAz1P1j2LINTDlw9pZElyOEIMrFfr7eprduOLm0mBp0UssJIcn9KU7UqsKMaubeMyeU2lDKvXmgSwmRtDjLis165GHiCYy/I+URnaXrCjuWmlY4Nlu9kmUxnL+TLbzTaXx5cZ2iGZyk5Ev+nJz1H5isvjy7MeTps67CqczlGuQukccwiBkFEGXfRRonHNEBfn4zW2KCZbLCbZB7dKH258c12l91k5jBXY7wCeizF+OcbYAL8EfN8eH/so8MkY47UY4zptI/V3H8KY7piStlCBi6+c5EZuNMshJcl1quFVfAyU3YPN9eSdcygUdphSiJP5stVs0YSGs52zN5wJjjFig51pAYlkMUxWCpSoti2TbzDKUJqSylUp1fBVQgxYV2FcDQiu6GLE3HG9BQBtStAZiEKawdwEsCM7QhCWi2XGbtwGrpLRMZ224rk+ASuwumClXKGX9eYiY8XHdgXWGgWuhuzOa3nspkWjiz7a5IRmG5cWnvalCU2793VnQvhmE1aVr+YifRgOJ4C9CHxt1/df3zn2aj8oIn8gIr8sIpMG6Xt97LHSovHBTzfyz8vm9yQBaEYvEQmUnYO1eCq6K4hS1PXsT2pJsttk9XUpX7rh7U1oU/xmncKULIZe1mv3vbpqunI/qS5bubQXdrdAINgK5dsg05kOghyoyI4WTcy6REDbChvszM851ltqX9PNuvjgWa/WiTHSL/qUpjwx++6VKJbyJS50LjD2Y7ab2RZtjDGCszgxiB0jee9QUrW10qi8hzIlvhlh0/t6XxrfkKlsmnF6s0mF2rVtduZhcue4ijj9CvBgjPEttKusv7DfJxCRHxaRp0TkqcuXjzYNQiuNjx4RoWu6aQU2mSvj7ecB6PTvOtDzmGIFpTLceD2tQiRzY+zGjN2YteLmGQaTZusnYY9acvSMMm3fV4GhHbYpcsqQqzyd318lhEDwNZm3YHKc0m0xowO0OTHKIFmHKIKyFS64mZ5zQgxsNjvtZXTJlfEVRm5EL++xlC2xUqycuM+WczsZVy8OX5xO4syCdzUxWLwIyjWQdQ9lBRYgK5ZRugRX0TSDQ3nO02Dyfsx1jgvt/tcbbc0JMdCEZi5WX+FwAthLwP27vr9v59hUjPFqjHHyjvk54Nv3+thdz/GzMcZHYoyPnD9/sJWn2zFippX4ulmXxjfTTf1JMmujwRUEKLoHC2CLfAlMhrOjFMAmc2Oz3kQQVsub9zie9PVM+1+TvSp1SaELal9PL+BLU15XtCfZ2Qvnxm0PWJPjd9KvD1KNVykFWQ8RwQQ383POZBJjpVihCQ1jN2YlX+FC58KJ/UwpTMFKvsK16hqb1ebMVsCDq4CIj4EYAjHv33S/5X5lWR+yLuIttt46lOc8DSaff7nKb1nAaZKtUpjZ73+FwwlgPwO8UUQeEpEceB/w8d13EJF7dn37XuCLO/9+EniXiKztFG96186xmZr88XzwdLN2E//IplnaZD401VUEobN8wBVYU5CZLrbZnps9ScnpFmNkq9min/VvehJ1weGjP3ErJMnREhF6WY8YI9vNNpWrpi11ZrkiNW9ccETboH2DNSUcoIXOhEIheYcYAhICttkmMJsANsZI7WsK3Vbn3aq38NHTz/snNnideGDlATqmw/YMz/nRjgEhuBotIHnn0FoVaaWRchmJDjvePJTnPA1qX0/Pt7cq4DRyo7nqjXzgADbG6IC/Tht4fhH45zHGz4vIT4jIe3fu9qMi8nkR+Rzwo8AP7Tz2GvB3aIPgzwA/sXNspiYf1DbY6Ydc2gebzIu62kSLIS9uvkK1F0YZdNYjuAbbpAmaZPYmF1Yrt6iwPZktnocqiMliKXTBUr6ED56hHSIi5DpPAewuIQaiG5HFiFeaYAq00gcLYEWhsx7RFIi3xGY8s1Y6ta8JMdAxHYbNkPV6nV7Wu+l++5Okn7X7ezebzWnV2eMUYiDaMTEGcBZEkHzp8AJY0ajuGZR3VKm//Z6EGKaxzqRy840C1EnBu8mi3jw4lHX7GOMngE+86tiP7/r3B4EP3uSxHwU+ehjjOCxaaZSotgehdCl1SeXbP95BChkkyWFo6m1E52TZwfYhKFGYok+1fYnGbgFnD2eASXKHNutNjJhbXkxOZosP66InOT1ynaOVprIVIzdipVihNCV1XU/T0k+zEAN1qNH1CI1ipDToHCM33hO3VyKCmJJgCjJXE9yobadyzGKMjNyorbaKcLW6ilGG853zp+LaTkRYKVZYr9YZ2RHdrEuIAUGOZfU5xAC+wcWIxAYBdLl8aM+vlcZ0zyHBU9cbh/a8J9lk8i7X+XRy+NXZTyM7YmiHaNFzNXF88t+xdyjX+XSGqmM6uOBmMmOVJLvFGLF2gD6EtJs2gF0meI+tUoZBMluVrdi226yWqze9mNo9W5wk+6VEcaY8w1K2hA22DVpV3lYo9qlqaYgBHzzaDVEiuLyLiBz4/aZEobKSoA0aR9xZBT1uW80WLjhKXbJerVP5irV8bS4qqh6X5XyZXOW8PH6ZzXqTK+MrbDXHs180xgi+xipB+4YAmFvUOtgvLRrVWQMEP16f2Sr/Iml82z4nUxkuOLTo686/NlgGdkCuc9bKg7VuPGwpgL2JTGXTi6WO6bQzky6lGSWz9a+e/hqfee55PvXsFt/54U/xxNM3rHm2Z3mxCtFTV+uHNMIkuTNXq6ttgFGcuel9JpOIqf9rcqeUKEpTokS1fUB30ogb38y8tcusxRhxrsHY9lrH7ewLVepgl4oKhcl6OGUIIYAdH3sA64Kj9jW9rNdOXoSG5XyZpeLkpw7vluuc1c4q1lsujy6jRdP45lj+Hj568A1eDNpViDaY7PDaFWnR6HIZ0Tl+fC3V9riNGCONb6YTVDbY16y+DpoBShTL+fLcZSnM12jmyOQCyXpLrnOMMozdeMajSk6zJ56+xAd/+bP4UFHHLpc2xjz+Lz53oCA265wh4KnHab9IMjvWW7aaLVaKFYy++c6WSfuc/5+99w6P67rvvD/n3DJzp2DQWMAqqheqUKblFsfyRrFcElvWZjdxYm82m3edd583T/ZJNk7iTbHXm33tjbyJs4k3G6e8m8SxnWKFkWPFcpHlJstqVBcpiRQbQBBEm3rnlnPO+8fBjECaBSAGICTez/PwIXCBmbkAZu6c3/l9f99vr2IXMi5MPMcj5+QI05BYxS+5EesL241YGUWaNHF0ijCG1MvjCnfJLrFCCFyvgBEORmucNFrx4qLjoOpK125WYMg5uQtONu4Ih5JXYl1hHWW/jOd4GMyK5CHb+eoY5UhkGmGcfE9HQYQQeLk+HCeHDmuZavIsxPql14HSCm30CfOvkYrsKKVbWJUGZ1kBexrmz8F6jofv+DSSxgW/Q5tx/vjwXU8jTRsHRajtIH2iDR++6+lzvs+gMITBIQ2nenWaGRmLphpVMRj6z2JMFqkoi8/JWDKe9Agcq6xqJA18aaNiLnQzJ200adLC1xojHVvA9mDe3BEOUrrg5TACZByufAGr2vjSJ0xCYh3jSW9VGdKsFEIIHOEQeHYMqbMhGKbhsq9vDQadhmjhQtzC8Qs9d7TN5frAy6PiahaPdRYiFXXlw53Nu46c3hhDI27Y54obnM/TPC1ZAXsGPOlZyQN2DjbRSbajk3HemA0TAuoINKEJTjh+rri5PpCSJJzJNmcyzgvGGKpxlcANzvhG2QlbXy0W/hkvbzrKqiiNbHHj+ERpdEFfB7XRpHGIp2K09EilZ+dXlygdFELY+/CKaECmEYlaubVURyLbSlp21tlYR+oLdZbelS6pTnGFS6ITil4RZRSNpLGsj6uMwqQxqZSQhgivuCR361ORcwPIlRFJSBRn3h5nIlZ2I0cIccIsLNgNn9UeL5UVsGdACtkdAu/kx2V5sBnnk5KsgzC0dG/mdvyggpQOabvW3azJyFhJWkmLSEVnjM6BeWHrF5jkL2N5KHiFrrLqcO0w0kgM5oKWESujMDrCS9okbg7jF6yz6xIlxGBVbXgBBo1UCaleOSOnMLUd304cUN7NXxCxOafDEQ7KKPu/VvjSp+AWupL65cKkCQJNKgROmkKu2PMNSd/xkUE/JDFRK1OWnY5EJWijT5h/nf+3CNNw1bkOn0xWwJ4BRzhW8mA0ecdKaepx/XyfVsYFSsGT9DGLAOqm1D0+UDj3NwAvGMSRLklUvaA7Dxnnj2pcxREOff6Z4xRiFeMIJ5t/XQRCiLcKIfYKIV4QQvzaKb7+S0KIZ4QQTwghviaE2Drva0oI8djcv7tW9syXH9/xGcwPsrawFmUU9aSOFHJFZgFXK4lKII1wVULquuDklhyh08ERDnglMCB1iopXxshJG9016JJCYowh5+Yu6OtI52cPU/s3SE1Kca4bWo/ry7YWUGmIMfZ5JlEYd+lpCifjSAeZH0AYRZyNRp2WSEUIrMN4om0x29kcTnRCqtNVKx3ukBWwZ6DzIlda4UirA491nMmIM1acXbtHSbSxHVgEdWUX+1LAh370mnO+X9ct4kgPlTTRWQc2Y4WJVUyYhhS94hkXlB2DndW8G7zaEEI4wCeBtwFXA+8RQlx90rftBnYaY64D/h74nXlfC40xN8z9e+eKnPQK40iHSq5CyStRj+t40rug398TnSBUhNSKVHrg5nrWIfOkB7kCYDAqRaWtFSlg26mVQnal0IIL/jqSd/MU3ALKKNppm1SnCCEo+SWUUbTS5VEa6rnNIZPaDFjj9X4G1hEObnEtRqfEzYme3vcriUhFXflwR87fMa9tJS0EgrybP5+neFayAvYMdOY+UmPNBjov+GwwPGOlueOevSTKUHDqGCTNuQ5sJfC4bcfGc75fz83heAWSpIW6gDsPGeeHVtIi1emCuq8AOffCXngukpuAF4wx+40xMfA54F3zv8EY83VjTGe1+gCwaYXPcVXQn+snNSlRamWtKzmfuZqIVYwTt3ExpL6NvY/VJwAAIABJREFUN+lVRqqUEuEG4AQIFaGT9oqMrbRVu9uEkEIiEFkMF1DyS3iOh0J1N206c8HNpLksrwGdttFaI0wMRiByhd53YIWDW16LEYK0MZkpy05BohKUUd330466yZEOkYqIVETBK6y62JyTWd1nd57pDJd3dgl9x0ciszidjBVnbNY+5/IiJNWCGFvAzraW9ibjSAfpFkjShDQzPMhYQVKd0kyadtF0lsJ0vltixoLZCBye9/mRuWOn42eBf573eV4I8bAQ4gEhxG2nu5EQ4v1z3/fw8ePHl3bG54mSX8KXPs20abMRL8A5WKVtIeMkLRuh45eQQvZMaiuRCMdHeHlk2kalyy8hTnVqzd/QXVPOzMX8JTzp4QqXdtruyqzLfhkpJLW41tPiTxsNKiJFI5VCCnDO4ntwLggh8IMBhOOStiYyb49TEKrQdlidPMYYEm3jQo0x1OM6rnQpuKvfoTsrYM9AxzmvY/fuSrcbeH6h7tBmnB829AeAoSCbKFziORdie/zccaSD6xfBRMRJVsBmrBxhGpLohMANztgROTlsPaP3CCHeC+wE7ph3eKsxZifwk8AnhBCXnOq2xphPGWN2GmN2rlmzZgXOtvcIIejL9XXllBeiykobTZrGOGkbxxiiXMFG6PTIJVYKieMVUEIidYpQ8bIXF53CzJM2CjFzMT+RjkmPRDIbzTIZTgJQ8Ss9dyVWRkGaoIxG6hgQy1LAAgR+P8LNk7Zns7X6SWijidKIvJu38uG5dJW2atOak/WXvNXrPDyfrIA9C65wuxdZV7rknBzaaGvFnpGxQnzg1isIPElOxKTCI8Uj8Bw+cOsVS7pfKSRuroRJU5IoK2AzVgZjTDdzM+fkzvhmOT9sPWNRjAKb532+ae7YCQghbgF+HXinMaYbhGqMGZ37fz9wH7BjOU/2fDOQH8CRjpVPzpmaXEgoo0jTEDeNENIh8Yu9L2D9AC0dtFaQRmi9fL9jY0z3b+k7PgJ7jclczF/Cldagq+gXCdwAgyHVKZ7jkXfztNN2z7qwtgNrI3ScpI2QHo6/PF2+XL6CcPKkUfWCz3Y+mXbaxmC6862ximklLbTWNJNmt1H3ciArYM+CI63NuDHGhnHPGQFkL4qMleS2HRv5r++6krKXEiufDf1FPnr7tUuaf+3g5QYROiVKMoftjJUh1jGxihf0ZtlxS8w6J4vmIeAyIcQ2IYQP/ARwgpuwEGIH8MfY4nVi3vEBIURu7uNh4A3AMyt25ucBT3qU3FLXqPFCGxXSRpMmTXJJjJY+xi/aorNHM4pSSKSTB8cDzLJ3YMM0pJE0yDk5+vw+Ep30VBL9SmD+76Lk2bGk+fOwBtMzUzNtNCaNSKSDk4QYL4+7TIXSV5+t8uUXWnz7mQO84xNfYdfu79u3u2BpqzaudLvvp/WkjsFQ8KziovM8eDmQvZLPgu/43Qwxz/Fwpdvdne0YA2RkrAQ/cs0A9z1XIOjbxMd+5Id6dr9+oQ+NJmpVe3afGRlnop1aY5WcmztrARurOJtbOweMMakQ4ueBewAH+HNjzNNCiI8ADxtj7sJKhkvA3839fg/NOQ5fBfyxEEJjN7o/Zox5RRewAAPBALPxLGEcknNyFNzCBfO8U0ahkjaeapN4OYzn40q3Z0YunZEs49lxGOIWSi9fAduIG2ijqeQq3XXby6WzhLbzohgDjg/O8izVXekiENaF2BU4wumOzPnSdq0jFfXk96aNRqsII13cJMT4hWXZTNi1e5SPfGEvb3bzXOxo6vXjfPDOJwF6suH/ciZRNh6nk4GcqIRqVKXklV42suH5ZAXsWejsUsQ6xnPsHEUrbWGMITUpDlkBm7EypHETrRPy+d7OjQS5AYyQqCwzLWMF6My0SiHPmut6cth6xuIwxtwN3H3Ssd+a9/Etp7nd/cC1y3t2q4/ADSh6RcIkpJ22aav2qs9C7BXaaHTaxksi0vwAOPmeqh4kslvAGkAmLZSx6rZeL5yVtrm+OSdn4w9VvPrnX5MQZg9DOA3tKnQl7ALyFRi8GMrrev6w86OjPMfrzn8LIbqeL71AGw1pGyUd/CTGFIZwRe9LkDvu2UsYG2qyhHQ0fU6dI7Hijnv2XvAFbCNpIIUk71j58Gw0izaaofzQy654hayAPSsdyUmsYopesevaluqURCXZwipjxYjas2idkgsGenq/fjAAwiFtV5dlMZGRMZ/OTKsQ4qwRHZ1RjZdN5yTjZc9AboBYxdSiGjmZu2AK2FjFkEZIlZDkbIempwXs3IYVfgmDQCZt0jkZca8LmbZqE6nILswR1OIajnC6C/dVRTgDrWmYfA5qRyFuQq4IfRuhshmkC/WjMPYolEdg/XUgezf95zleNzYnTK077WQ4SeAGeNIjUhGpTpfcLdVagU5RrodM22i/vCwdWJvYIJk1FRyhKInqvOO9pxpVSXRCwS1Q8Favc28raZHohLJfRghBrGJmohmKXpHAe3le47ICdgH40sqIjTHd4N9ezgZkZCyEqHUcjMLLD/b0fr1cBaQkjapoo3tm2pGRcSo6CyJHOGfNY4xUhC/9VZ9Hl/HKoeAVqPgVjjaPMt4ap+SXXrYLvMUQ6xiSJo5WxH4JTG83joQQONJBe3lcIdBakczJfHtNI7adppJfIpyL6xnIDay+zdnZI/D4ZyBqgBfA8GWw4XorG64dhdmD9viGHdA4DlPPg0pg46t6VsR2NimqcbUr6XalS5iGDOQGaCSNrl/BUlBpZOOZ5v43XrAsI3gb+gNGZ0OqZgCNoCJnu8d7TaxiIhXhCKf7e6rkKqvueaaNppW28KVP4AakOu06Tq8JXp7O8ZCZOC0I3/G7BasQ1kzEGNOdFcjIWAnCxgQCyBeGe3q/Tr4PR7okUe2Cc97MWHliFSMQ3Wvp6Uh12s1tzMhYKVzpMlwYZm1hLZGKugu91YAxZlnmRrXRtkhJmjgIIj/AddyeFxie9DBe0WbCqjYqaS6LkVM9qZN38l31nCOcs6o9VpS4Cfu+Dvd9FKZegOIQ9I3YbuvgxbD+Wrj4ZtttNRoOPwTBAKzbDq1JmHi6Z6fSuQZro7smPiWvZCXlcxvavZARa9VGG2O7/EKAX1oWSbdNbHBomRKpcegTDQKPJSc2nEwnM1UKyWB+kLJfJtYxzVUYR9hKbDxO0S9ijKEW12inbSp+5WWtMMk6sAugOwc7ZybSMRRRRnWPZWQsN1FrGo0kyPe4gM314UpnbjdcAavojT7jFUWkou6i6GwOp51FUzamkbHSSCEp+2UCN6AaVxmMByn6xfN6TrGKqUbVbqRUpYcZmjZCJ8YJ67jSI54z2Om1xNORDsIrgJNDpgntqPcd2DANiVXMQGEAY0w3a3pVoDU0j8O+e+HFb0CuD3b8GxjYbGdgj++FI4/A1teBX4TKRigMwpGHYfRh24kdvASm94FXgKFTRjMvis5GYkdR6EiHwA1oJk3aqk3OyXXzQZeihNFJGzAIHYMQiNzySIg7c66/f88kaeozkgv5L2+/oufzr825zZdOxzVwg657ed7Nrxq361SnhGnYzfudiWaIUmvMVfSKq65bvBhWx294lXPyCzzn5LqzAW3VzgrYjBWh3Z5CSEm+0GMJsRcgnTxp2kalbXBX4ZxQxiuCRtzAEQ5GmAXF57iy912gjFcoxpxofLNEiWXgBgzmBzlcP8yB2gGuHrr6vCz2jDHc+eghPv613YxXI0b6yvzfb97E7TdcTMnvTeSFNpokbuAlLYTjk/glfOH0fDbVEQ64PsLzQSeIpN3zDmw9tnFwnegcw9mvNcuO1lYOPL0Ppl6EsUdsIXrj+6C83n5PvmIL2oP3w7GnYfNN9rgXwJbXwpGH4OjjsPm1kDTtzGxhCIL+JZ9e4Ab45qXEjY6BU6QiKn6FVtoiVnE3O3TRP/5cBmyiDTKN0RhEUFm20ZDbdmzk5iveypP//CUEkmu2D/X0/j//6EE+/tVHGZ/VbOgb4AO32gK55JWI0ohm0uzpBtNSqMd1K98XDtPtacDOPbvGXdUzuwshK2AXiO/4NJNmV2bRkabEKs6MbzKWHWMMcXsGR3jkir0tYB3h4PgF4nYdnYSQX/obYkbGyUQqQhlF4ASEKjzj/Ks2mkQnFL3z2/XKWGVoBY1j1vhGxXYeMG6ASuHkQkg4tovl5sHNQb7PXtvyfQt6KEc6DAaDJDrhUP0QR5tH2VDasAw/1Jn53CPP8ZG7v0uUpiACjtarfPTuGgL4qVdv70kRoLQijWoEaYSRDipf6vp99BIpJI5XRAkXqVNM2kLr3nZga1GNglvAczy7eD/fGdKNCVuQpm0Q0hoyrdsOO94HwUlFjl+ANZfb768egcome9zxYMONcPA7cOwp2PRqa/x0fI8tbpdIpzBNVNLdUOgUsAj7d4t1TJ5zK2CVUaAiNCmOThFC4vkLex2eK75XwPX6aLeOEUVNyPfG/HLX7lF+4x8fpp22QTj49af46127MeEPctvrdlL0it152PO9cdJMmlaB4AS00hYSq3rqqBJe7t4SPSlghRBvBX4fmzX3p8aYj5309V8C/i8gBY4D/84Yc3Duawp4cu5bOxl0q47OBTDR1nk45+S6u1WxjjOZW8ayoo0mjuoI6eHOOUT2Ck96SLeI0tNzMp+MjN7TTttIIZFSgjqzQUzmPpxxAlEDZg9BbQx0YmcFHd/+Xxia+9iDTsEVt+ysYPUIpBFENTt3iIHCGigM2OJg7dWQO30XM+fk2FTexGx7liP1IwRuwECPFsJnY9fuUX7nnmc52hxDiBRXu2w1UyQIjqZl/ssXnsSXAT++87IlP5Y2mjRpkEtjEr+ImVvj9BopJI4foIXEQcPcGqpXhElIrGMG84MnyDnPS4MhatguaeMY5MpQGoGJp+zz7cp3fH/x2qGy2T5vJ5+H8oaXlARe3po8HXsa2rMwfLktZqf327nZHuBIhyR9KbqsTp1YxXjSW9IcrI3QiUmNQaoE4+Rw3eXdVHClixcMEDVGabeOv7QZsEQ+dNfjtFULpGKNrnKRHMNo+NZ9u3jLVklhZAettEUzaZ7X969Y2XlcT3hEOuoeT3VKzsm9IjaHl1zACiEc4JPADwNHgIeEEHedFHq+G9hpjGkJIf4D8DvAj899LTTG3LDU81huPOkhEN3onJybw0usjDiL08lYbrRWqLiF4+Vxe/xck1LaolglhPEsy7svmnEh0plF6+QKetI74+5vJyd2Vec2Ziw/cRMm9kBzwnavSuugf4s1tDm5KDHGdrum99kcTbDFrXRsB1a69vjUPpg5CBPPwNhuKA5DYdgWBOX133e/UkguqlzE3um9HK4fJu/ml32mctfuUT7wd4+TmAjpR3ipx41mnEA0EWjWiwkeZBsf/qfH8GXAu29c2uJcGYWOQ5w0IimPAL2N0OngCAchHLTrIWIrJ+2lhLga27972S93DXZKXm9k1ouiNQ2jj9iPhy6z86rjT0DSgrVX2efw6RDCPhePPATVQzBw0Utf69tkn7+Tz1kpcfO4nZuV7pnvc4E4wsFgmAqnCNygqzQM3KC71j0XM6yuhFhKnLSN9grLkgE7H0c4eMUhOJYS1sdgZMeS73PX7lGqUR3ptSiZiEvlODMUecpsY1v7EFPHHke6eQqD22gkjZ7ED50LiUqoRlUwMBPPIIUkcAO0sG7cq8rQbAn04jd7E/CCMWY/gBDic8C7gG4Ba4z5+rzvfwB4bw8ed0XpzMHG2u5CedLryoo7xzIylgudhiRphJfvXxbZh5evYHRK3K73/L4zMhJtd/U96dFO22fc/TXGLGneKuMVQDgDx56xnVPp2gV9ZZMtRE9Ga6iP2UK3ftQWsoUhOzsoJLi+vZ2bt3OGgxcDwnaypp63ndo0hgPftq6vm2+C8roTHqIv18fmvs0cqB5gvDHOtv5ty/rjf/iup0m0RrhNtnGUN8pD5EjZzzqqusggM1whD7FHXcQdX35qyQWsNhqdtnF0QpQrIIXEd3vfPZJCIoVEewWMPo5MQlKV9GQMS2lFI25Q8ksIIUh1SskrrbxMMqpb0yUvD5tuskXr4e/ZTZhgyBakZ5vrLw5DMGi7q5UtL3VhpbSvhfEnoDZqTZ2OPATHn7MZsUssTDrFlsF0lYXNpElZWtVXrONzLmBNGqGli4hDTGFo2Qs7KSReeQNCa9rNiZ48x37nnj0Ip4VPxLXmGKku8Yy+nNT4NAd2kBRiZo4+ytDcJlDHx2GlUFoRqYjZ9iypSbumieW5zN2SX3rFFK/QmxidjcDheZ8fmTt2On4W+Od5n+eFEA8LIR4QQtx2uhsJId4/930PHz9+fGlnfI54jkeq065rXt7N40iHMAmz+JGMZSVJmijVJp8vL4scystVEEYRtWs9v++MjEhFNjoH+9w90/xrrOOu02rGBUj1CBx+0EqFhy6Di95o3VZPLl61st2nx/4adn8axh+3BWt5PeTLVqoZVKy8OG7Z4nb6Rdu9mtwLzlxhPHQ5DGyzs7R774b7/xDGHv++01oTrGEgN8BYc4zRxuiy/gpmwwRkC9epcRWjBCS8aNYzka6laCQ57TJCjZw7w9H67JIfL1IRIm7gGEPkl3CksyzyR0da93HjW/dTkSbEPYrSaSQNYh3T7/efPwdzrazRkpS2ePXyNianXbPF65or7b+FMHCRlb83jp14vLLRKhAm99oZ8DVX2NfKzIEln74nPfJunpyT62Z1g91U7BiXngvKKNAxynERaQx+YdnltUIIvOIaHOkS1cd7EgV0tDqLkG22MkO/Tsgbww4OsFUc59dv3srgptcQ6pTm2EN4wiNMwx78JGen03E9Hh7nQO0Ak+Ek9biOMoqR0ggbShsYCoZece+pK9rbFkK8F9gJvGne4a3GmFEhxMXAvUKIJ40x+06+rTHmU8CnAHbu3GlW5IRPwpc+TZrdOdi8k8eXPtW4ykA68LJ39MpYvbTDKkrH+PneGjh1yOf7MEIShVOZKVlGz4mUte1PdYpAnHFXulPsZvLhCxQnZyW9I9edvqMUzsCz/2TnYv0ibNppXV0Lg7bLeia0sgt/IazRk05shEkS2rzNfV+D7/4B9I1wr/tGfvN7LmOzIRv6A37xhy/m8i1lDtcPk6qUrZWtPf/xf2PXkyBihNNghEm2mhqP6Ct43myi4lZRxiFnXAqpYb1XJ6ysI9HJOb9ejDHESYgTVXGES+QX8KW/bBJPV7p2c8GAYxQ6bi65AaCNphE3yDm5bgSMI5yVdTBPIysbjuqwcactXsNZaBwHk1pVwPClC7+/0lqrIpg9aDNi57P2autWPPkcrN9uN22mX7QqBe/c5e1CCPr8PmIVE6kIY+xSu7PmbSQNlFaL/r0aYyCNURpyOoYVkBAD5INBPK9A2jhGpCJyp1JwLIL1A5pmWGW7OsqQUYzi44k2W3KTvLU0iDCvo7n2GqrHnqBS3oAuryNMw56PHCQ6oZVYZ+gwDbnriX385feeZ7KWMlwO+Lkf2M47r7uIklciWMLzYbXTiw7sKLB53ueb5o6dgBDiFuDXgXcaY7rbOMaY0bn/9wP3AUsXqi8TrnQRCOs+hn2xDwc2k3M2WvouaEbGqdi1e5T3/9lXefbwNP/7gRl27e797n8uP4CWDml7ZlmC5TMuXDryYd/xiXVsr6Nn2CDpuDdmmygXKKU1sOlVpy5ejYFDD8CDf2IllNt+EG7693DpLTC47ezFK1j5pjfnTOy4dsFfGLSdre23wc0fhK1v4MXDY7Tu/T3eVv9bLuEQo7Mhv7lrD3sPlan4FUabo0w0J3r6o+/aPcqnHzhgZYqywQ2MkWoP5YRc7j/LiJhgUM5QkVMUTMpW2eKnXj+8pO6SMtaB2I1ChOMT58rL+vpzpQsdB9q0TRI3lvye007btFWbwA0QiPNjrDnxjC1eN9xon8Ng51XDachVbKd0MQgB/VvtZk140voy3wcDW6F62M7bDl8BGJh4tic/SmeDUWOzX1OTdjum5zIyp1QCKkHpCIHEzOUMLzf3HdR8c3+Trz36DG/5xJeXtHaKVcxPvK7CDnmMS/UUsfCJhMHzFW/fsYHGsaeJn/sKa4cuh3w/zWNPIRG0klbPfp5Up8y2ZzneOs5YY4yjzaPc+fgePnnfXo7PuhhdZGK6yMe/eJzv7I1f0cUr9KaAfQi4TAixTQjhAz8B3DX/G4QQO4A/xhavE/OODwghcnMfDwNvYN7s7GqjE1bcGWYHKysue+XuwHZGRi/ZtXuUD975JFFzAqTgSDPgg3c+2fMiNp/vBykw7Vp31zUjoxdE6ZyjsLQd2DNJxxL1kgNmRsYJzB6Eh/4UXvgqFNfAzp+BbW+0HdheUtkAO3+G/3D0R3hSb+ZqcYifc7/IreIB2knCr/39szx9IKDgFthf3U8r7s0CtXOtR8ZI2eIGDnGdHieWCikVLyYX8T11Pcf9zbSFYEuhyr/dPsQPbPa62afnQicDViYhQkhUvrysrz9f+lZCLF2cJCJNGkvuwNZi+75V9srUkhoCsbIz9O0a1MetFL0zPx3O2NlsY6z52Lnkt1c22Rnw2YPf/7WOOdTYbiudH7rUyo17ICWWQuJKlzANaSWtrhmRFPKcNkt0EmKMQacJAjBeYdkVNrt2j/L/3n2I8bhIUUTUG8eXtHaabE1y02bBz21NKeYCnhAbeaHvWm659V/yxjf/a8TGG2lP70Xt/zqDa7cTJXXi+gTKqHOWXs9HacVsNEs9qXfjoSp+hb+5v0XYXI9J1mGSYdBFwsRwxz17l/yYq50lb4EYY1IhxM8D92BjdP7cGPO0EOIjwMPGmLuAO4AS8Hdzu3qduJyrgD8WQmhsMf2xk9yLVx1Fr0hbtanFNSq5Cq506cv1UYtrNJIG/bksQzOjd9xxz17CRNGXm8UgaOh+QqW445693LbjTKPmi0PmK0jhEkWzqHN0GszIOBWxjvGl3+2ynGnhksXnZHwfUQOe+5LNvHQDuOJttsu1zB36vXWfPbyLEY7zU+69vMN5kEvMOH+h3sJv7trDh955CRdtbPP87PNsLm+mf4kGe/ZanyDcFhvkGDeqI7SNy/ecrRyIL6dFmY++ezs/dM0A7YnryD//FUrJcQ62Zqi2qwwHw+fU1dr12GH+8mvf5bXh8ww6fcT9Td63c/lef7YDGyC8AHSMXqKHSKIS6nHddl+FIFVpd222Yky9YAvNwXnmXpMv2M5pYchmu54Ljgd9G22ndfgKqxzofs2FjTdaRcLoI7D5NTZeZ+JZ8EvWCGoJFNwCYRqijCJMQsjbmeJ22l70mJFOQzQaTIwjJPglG6e2jNjXE0w4g2zjEANyiiPRlkWvnXbtHuXDX3iSqt7HTrGXf20Occn1N/OJN74VJ9dH4AUkbkDp0rfQbFdpH91NobKJvFemOfUcfaVhK18+x00h+/hPUI1mQbYQUoFx2Foo88tvugxnZoZLiPFJmKRCXiRIDO3Zudl//5U72tiTV7gx5m7g7pOO/da8j285ze3uB67txTmsFELYXY9qXGU2mmUwP0jeyXfd2ip+JZO+ZfSMsVlrAlASdZSW1Ez5hOO9wssP4AmfNGmj0/AVfdHLWDmUVl030M7O/ekKWG00bdUm5+Re9gHrGT1AazjyILz4LTunuuFVcMnNS5rxWwwb+gNGZ0OOsoZPpu/kdvktbpJ7+Y/O5/m75Gb+4Gs+n//5qzlUP8SR+hFaaYtN5XN3Ax6bDUHGeM40V3GUYd3mQXcDe80mtPT4sRvXcMs1g8QqRgxcTLz2KpL936JSG2d8YItdf+QWIKGex67do3zoH59kRNbIoRiNPO78xousCy7iPTuHzvlnORNSSKRXJBUujo6QabQk9Vo4lyVb8Su0VRtPeiur4GjXbOdz6NKXZO/tmo24EdJ2ZBcibT8dA1ttB7Z62ObAzidXhpHrbQE78TSM3GBnY48+Dhf9wKlduxdIx8ypmTS7qkPf8QnTsBuJthCUVpC0SbTG0QaEwAmWv9Fj10gOo3oYiWatnOQIi1s77do9ygf+/nESHZILGtyUjjKtcvzR4xG3rRnl3deVaCUtwjQk5+SoXHILYX2c1ovfYHD9Do7WXqTenMApj5z9wU7z+L/0t49gnAY4IY6IGFFtNuuQy+uPcvTuu/gFr0HOtJFoYjwmTD/jDDJqhvmrz/4F7/vB7fY51LfpJTfrVwivrJ9mhfAcj0qugjaaZtLElS45J0e0xAtxRsbJbOgPAENBNtE4RHMFrD3eO1y/iOvmSNIWuoczGxkXNt3YMcfrGs2cboOvMSclfCUErGcsgaQNR5+AB//YyoULQ7Dz38GVb1ux4hXgA7deQeBZs5qQgL/WP8wu/Xr6RIv3Ol9he+0+hoMhLu6/GM/xOFw/zJHakXN+vJF+H+HOsF5OcamqMil9dst1aJMjcPL8zrt/gIH8ADknR6hDkuErUbkCxfoEhFVq8eId5O+4Zy9hmpATET6KGZEjSuB/fvUUktUe4UgHpzODrBUiaXdHss6FRtLozuxqo5c9o/f7mHoepHdiXuvsQZthnO+zMuCl4BehuNYalulTdKpLa62BWW3M5hyPXA86hf3fsDO4Z0KlVoJ84NvW+Xv8STtTO4cQgoJbsLOX0SxaawRiUZJYjQYVkZAidAII3EVutJwLdo3kMG7WoIzDWjENqEWtne64Zy+JMuA0uYpDbDUNHpPrOSAC/vr+aQIvsIW8gelwmqoUBJfeikhamOnnKTgB8eRe4jQ+J+n1h+56EiObCNnEJeVGPc5OM8ZOsY91zDKl8zymLuIL6jV8Nn0zj+pLmaIPgcYl5bN7sDP/x56Gg9+2svZXEBduARvOWonH2GP2xXvwuzbcfIHzf570CNygK7HovMh7oXXPyOhgF1GSggxJhUtkcgSewwduXaQhxFmQUiL8IiqJUXMmZRkZSyVWsZ2nEi6pTk/bfY1URDttU3BXxtwNTAtQAAAgAElEQVQjYxVz6H549i67CL/yR+2sa3n9ip/GbTs28tHbr8XpbrgI7tM7+Jx6MzWKvDP/OO4LX2UoP8TWvq0U3SIH6gd4ZuqZc9rIfv/NQ0i3xsWqxjBNnnP7mdTrMPEQYZTvziVWchV86RPm8rTL63GakwRRjXpUR5+qwDkDY7MhQigKhHhGM0secBmfXb5se5sF66D8ANDIpEWkz23dFKmISEXknTypTpFCrmz3NW5BY8J2uDrd1zS2xSTYDZfi2qU/zsBWULHtwp6KoUtszvGxp+3GwJbX2Y2fyeegfuzUt1GpzZCtH7O31cp+fPh7cOA73dsVvAJ9uT7r9Jw0kEIuap1rO7AhCRInjTGuj+Mu/4hSZwOqpSuExqNfVAk8vai1U6dbK90aN5nDNMnzHWcTJi0yMeMxHAwzHAwzGAwSeAGT7UnaA5txN76atHqYPYea/K+7HuTWj3+ON338S4uev63FNZAN+kSDm8whduhRtjFBisMj5gr+Qf0gn9G38FVzE/dzHZ/Vt/ANfQPTpsKlYozrxXM2R3jjq+zf9/BD0Jxa1DmsZi7clcLobjj0nXkHhL3YVDbbfyPXnVVGWfSKtNM2zaRJ3ssj2oJm0qTkl5b33DMuGG7bsZFUxbzwtYhq4jPSX+FXbr2qp/OvYI01pFfCNI8Tt8/dECQjYz6drmuiEwzmlLPV2mhqUQ1Peln3tccIId4K/D7Wn+JPjTEfO+nrOeAvgVcBU8CPG2MOzH3tg9jcdgX8gjHmnhU56eErrDnNhhvBPb+z0J3r7AfvfJIwURgkj5nLmZFr+ZOLH4GnPo8oraewcQfXrrmW0fooh+qH2D+7ny19WxZsJFSNqszExxhUKdepKaqOw+NmKyatAN4JXSPP8RjMD9JMmtTK65l8/mk+fee3+Xw8xtr8fn711h0Lfn/Y0B9wrD5FHy0QkhmRxyiXDf3LN0LiCAchBMovIwzINCKeM/lZ7PhVmIQorQj8oOuUu6IjXLW5gmR+l7V6GMKqnVGtbOmNbLM4/FJBWlzz/WtT6cC6a+a6qd+yr50NO+DQd21X1ctDa8pGVLUm7cdewXZsN+x4yXhKK5vDPHMAxh6F8gi5keutc7wRGGGIVYwjnQXH6WhjO7BKOnhpjPGCM+aA94rOa+BjX46oJUXWOCG/fuuli1o7begPGK1OMyCn2KIaPMQlNEUeoypsrNgushSSwA0YKY5wsHaQY61jbNj2Bp54/Ls88tSDNPQww94MB1tjfPBOecK5nYnPPPQsODWG5CyvUkfZqpr0iZh9Zj0PmMs5KgvgJThyHG0A42KMx/NqLYf0Gq4Uh3md3AN7vwibb7JRY2OPwejDNot4oPcRYCvNhduB7Ug7Nu60cwP9F9kdromnYf+98MwuOMtCvvPEjVSEK1x8x6eVtEj0ucthMjJO5h3bB9i5ucitN1zKd371h3pevIKVdbn5PtAx8RIcLTMyOnTic3JOrntNPFUHNlIRBkPJL2X+AT1ECOEAnwTeBlwNvEcIcfVJ3/azwIwx5lLg94D/Pnfbq7GJAtcAbwX+19z9LT+VjbDltee9eAX7HH77dWv47Xdfxcb+AAFs7A/4xdtv5vLbfs3KOx/5/+DRv0I0jrGpbxPrS+uZjqZ54vgTC4rZacQN/urhR/nUN1/ksrTFBjnFU3ItU2YtRgenVNz05fro8/u475jiGwdbDIQT5Ggz3phZlNPqL7/lcgb8iCIxqXGYpUDeyfVc4TOfTidZ54qAQaYxabT4KJ1Up92Z1458eEW7r8bYYq8w/JK03RiYPgDtGVtwDl3Su8dbt93+P/7kqZWCpbWw9fXg+HDkYZjcC/1b7Pz40/8AB+63xczef7bqwxe/aSWlnZGhpG0L2oGtNp5qYBvUjyJaUxTcAgqFQODMXQYWGqejjLJzzo6HjJsYv4hcodLjth0b+eYvv413vno7Ozd73HzZ4uTlH7j1CrxcnSvNUXLa8Ji7Dp2U8Ai+7zXiSpd1hXWkJmU6qvG7+zcgTZNNusnaVIPTJmRyQe7An3loL//1Sw9QpsGN6ijX6mN4IuFJsZ6vOJcx7iuEP00+3+CHt5dxnBDh1sFpIr0pYifkcbYQXPMWK2/fdx/s+7qNcgoGbeTT7KFF/S5WIxduB3Zgq921iup2EH7wYhjaBrOHYeZFK6GYfhGufw8MXXzau+nIiFtpi7JX5nh4nCiN8PzMxfVCIVYxyijyTn5ZFuBxVCdREaVc/7Iu8H2/jNGaVlbAZvSAbtSY9AjjEE96pzRn6siMlztW4QLkJuCFuYx1hBCfA97FiVF17wI+PPfx3wN/KOxF5l3A5+Yy218UQrwwd3/fXaFzP290vC061/UwCdl+UZs/+/cbKPgF+rw+yn7Zrh92/DTs+YI1zWkcg9f/AlvKWyi4BcYaYzw/+zyRilhbXNstruZ3GmtRjdHGKH/53RfwQofX8zzT+DzGFlABDj4fvf3aU25aDgQDfObJBjtNiavMLCOmzn5ZIUzaC3Za/ZEb1tGYXceL30uIQxe/2M9vvPn6ZdkknY8nPcJ8H0IIpIpJ4tainYhjFdNO293fq0CsSGevSzgDafvEfNfamO1u5vpg+HL7HOkVfsF2zo49ZWds58/cdsiVrRvx0cdtgWI0JKEdmSuPgDtgu7Cl9eBfZeXGx/fYNW8aAwY23QTFIXv+9aNwfA/5La+jlbZopS186eMIh1jFC5o31kZDGpEISTEN0bnSiqYceNLDLa9Djz9OqzoKAwvfVLh1+yAHmxtJvz7Fccdj1AxT9tbykXeeWuVQ8ksMBUNMtiZ5pBmwiTVcJieo6Tzl1FB3GozVJk/7eIlKGG+N89GvfBsnDXmNOcKVjJMIh4fYwrOin4aTILRkbbCOX/wXO/iXN27jHy4+zIe+8BChSjBohNvm9us28ZNvu5o0auEeewqOPfPSXLaZywwuDPU+hmwFuXAL2OLwqW3GN4T2InT4QSvF+O4n4Y3/yWbDnQJHOhS9Io2kgStcHOlQi2uZjPgC4bMP7+V/3vsMx2pt1vUFfOCWG7n9xi09u/9du0f5sy99iR9gisOjNcaHR5dtcZEP+jEYVFRDG70sTrBRGjEZTlL0i123yGzm8ZVJrGIrPROCRCenlAcbYyVpK5rZeOGwEZg/NHcEeM3pvmcuEq8KDM0df+Ck257ywiOEeD/wfoAtW3p37TsfGGOoRlWbeylsDmaorExVoxlvjDMhJgjcgOFgmHUj19lO8aHvwcFvsfdv/jO/cuDVPFEvsb7f471v9HG3jRHrmJHiCNpowtRu5hgMY40xEpUwOZvnVp5iREzxT/JSZujHqCLamNNe7wtugdGaz3o5yDVmiovMDC+KtSCjBTutJirhNVtyXN8coJLr49br38AlQxf18Dd6ajzpgV9EuHlE0iJN6osuYKM06spZE52Qc3Irq+BoTFiX4c6Mq9ZW4qsT25Ut9WD29WT6N9vHndhjO2uVUzw33JyVjGoNswds8XrpLbaYlt6JygZjrFw4qts52NoRW9A2B61Uec0VcPRxZH2ccmmYVtKimTTpz/UvWGmYpm3QKYoEaUDlyiv6ni+EIFfZDEA4+yLwgwu+bSNp8PoNgm2X+RwavJEv3/ROLu4/fUMLYDg/TKpS1lYE989cxjo5y41mP2OqxKNykHKpSTWqUvJKXQl2Z4xmIpzgq08fJY3a/Av9AhcxQWoEj4jNPCxGQGp+462v5iduvIqCV+g+3//Vq7bxrhs2MhvN4gmPxCT40ifRCc1CP5VLfsh25uvjNvKpMGTNuoy2z42XaWxitnI8GS+wso+BbdC3AXZ/Gh74pDWSGLr0lDcpeAUSndBOrZwlTMMl5T5lvDz4/KOH+Mg/PUaYKDCS8VrIr//jQ0jh9KTI7ATbj5gJZNFwpBXYoHsWNkOxWPK5CloIktbUshSw2mhGG6PEOuYLT77I//nOESaqmvWlYX7l1muWfdc/Y+UwxpDohMANuu6Lp4pdCNMQg8mulS9jjDGfAj4FsHPnzoW5IK5SGkmjW2DORDO0VZs+v4++XB8SSapTO68azXCodohYxWxevx3WXMGD45qjT+zivWYPf8Q72T+7kT/8UsQvvs3nuouOM9OewXd8yn6ZKI1oJA0ARoojXFNweG3zBQ6Lfh6WWzFpAMY/o2OqFJI15QGOtwo0yXGxmeLrADJipDy4oJ830QlpVMcxGuXmcd08gbP8Lr6e9NBeAeMVcMJpVNxcVAFrjKGVtohVTMErELjBys/PN49DMGBnXQGqh2xH1i9Babi33df5jFxv51PHn7Bjb/OzZ+cjpVUWngkhTry9F9gOb1Sz8ujNr7Hd5MnnyJXXE7gBU+0ppLCvhY7HwZnQcROlFEbHuEIS5/pwxcqWHvnKNiSCpHZ0wbO7xhhqcY382KMkOiVadxWD+bO/roQQrC2s5WfecAn/4549fDO9hneLh3ibeYpx9RqOJQ6ffuhRfmzH1aQ67Rahs9EsqUq569vP8Va9h02mzjEzwLiT5zG5DrRkbWEN//amHac8f9/xybt52mkbV7okOiHv5m094ubJXXyzlYhPPAO1o/bvOvqIPXb1bSdmDC+FNLLZ3TpZdvO9C3cG9mxICRe/CbbfDnEDHvusnRs4DWW/3B10j1VMLVq8pX3Gy4v/8ZUn0arBtXI/r3Oe4jJGiXSd/37PEz25fxvErRgQsyCgpgcIE7WgGYpzISgOYaSLas8uKVj+dHz6wad53598jff/7hf5oy8+z7GqAtnmaH2KD975+KId+jJWL7GOMRh8xydS0Sklwq2kRSNpkHNyC84UzFgUo8DmeZ9vmjt2yu8RQrhABWvmtJDbvqJoJS2mwikiFRGmtoO5NljL+uJ6+vw+Sn6J/nw/G8sbubT/Uop+kcONw4zVx9DC4RefuYTfS25DIXmPcy+vFs8QJfB/vtlkW2UbRa+IL33rxu14DOeHuWzgMkYK6/gvVx2jLCO+zSU0yWFUeUFu8z9/8zU03TJjosQa02a9mCHvKf7jLacpak4i0QkmquJoRZIvL9sYzMl4jofwApT0kFpD0lyUd0hnI8FgqOQqlP3yymZHJ6FdFxbXvHSsesQWra4PpXXL99iOa71bSmttt3Rst3UMbk3bOdalUNlkC+Qtr7Xd5fEnrGw5bcPMAYpeEW00Zm4G92zxR9poTBISo23mLxLyfSt+vQ/61iPdHEn9aPe1fTYSndCqj9M3dZBGaQjRv5W+XN+CbutIh/fcuJ3AF+yRw3yF6yiJNj+q95BLHP7igQNMtCaoJ3Wm29PMtGdApaypjvKmxv1cpGfZp4c55uQ5KPtIdBGdDPIrt7z6jMV3ySshsPPgBoNA4EqXalSlpROrOt30atucKw5bpcCxp+Gxv7aS4tFHTx/XdCq0sq7GU/vsbfd9Hfbda/O7x59c2H0sgawDeza2vt7uKOy/D574W3jVT59StiGFpOyXraRFOVSjqrW7zxZmr0iMMRytzXKDu4+1OiLUAevkFKkMebHRm53XjgysJGfBSGaonHC81zh+BSkd4qiOTiMrOekBu3aP8ltfeIimGucHeZJrxBQTZj0v6vXsZYC6A2HqLnhuK2P1007bSCG7s1I598QOa6pTmkkTX/r0+QtbFGQsmoeAy4QQ27DF508AP3nS99wF/DR2tvXHgHuNMUYIcRfwGSHE7wIbgMuAB1fszFeYSEVMtCZQRjGYGyTWMX1+H/35/u/7Xle6lPwSl/Vfxp7pPRxqHGI2mmW0Ngls4Ivqtbzd+R7/xvkKl+sjfGb2Fm7/g6f5wK1X8CPXr6Me15FCknfzVnlw4Dvc6I/iXH0dM6NrEXWfDX2D/MqtV571enj7DduYbu/ghW+P4zVnuTGoccUbX8st1wyc9WfWRqPTGN2ukTOSyCtSdldGCeEIB8f10bkibs0g49aicjJn2jNMR9NsLW+l5J2Hca3GnDlXp4Bt116S4Wrdm+icMyGldRqe2gfT+600FABhjZv6N9t52MUihC1uwJpGjT0Kcd3+PNP7CSqbbA6sjrqbkwXv9I7VSitIQ2KdIFWKA8j84Iqb9QVeCb8wQNw6TiNuLGjErxE3UJPPEURNJkeupFJat6hNkkquQj10EE6LJ8wGtupL2Sn288N6H0/MbKDPLeC4Ob781FH+5pu7Wd/Yxxv8aVJ3iCdjn8iNCIXDqFqPVv0MBGVuv3HzGR9TCtkdaTTG0FZthvJDVKMqzaRJzsnheAFsfYOVl3vBS87T+75uu/GNYzD5vJ2Z7huxKoP5JKF9/jcmIJy2KoA0ss8d6YN05zZylv9akhWwZyNfsZ1Yrewf+KnPw03vP2W7vdPCT1RCM20yG82ytrDMF7KM88LnHn6OinucIR0SaEMqEsI04CJvGtk3RKKSJRsVbOgPGJ0NKblNlHFoq3L3+HLgBP12fiJtoZPWub0BnoSVQT9OW0xyndzPNWqSY2YQIxQ75HOM6D4eYjPjMsfYbKMHP8XpUVoR69jGLrjBgmREGYunM9eac3Ndh+H5Zh8daZYQgr5cX+Y8vEzMzbT+PHAPNkbnz40xTwshPgI8bIy5C/gz4K/mTJqmsUUuc9/3t1jDpxT4f4xZpE3sywSlFdPhNLGOWVewi9TUpNao6Qx4jsel/Zcy3hpnpj2Dk5tAheu532zngFrP2+X3eK18FoAvz76aD95pC7ROUbpr9yifu/teXtP6GmtzmsqNb+K3f/JqLh+4nKFgaEHn7js+79h+Ma3B17DtgOAdfcNMXFQiTEM7x3uGWcNEJ6ioik5DpDCYQv+KzaI7wsERDmmujA+4UZ1Wxw33LEQqYqw5RsEpsL64/vxcP1pTtljNzRVCtTFA2JnSYGBlHLSFgOFLrSFp3LS5yY1j1uBp9qB9/x6+/Nxnccvr5qJ7XrBdu0PfRcwcIO9bWWrZL9NMmmccN1LGZsBGxpBLI3QuwPWXX6J+Ml95eobH9irWpIf4z/v+mf9061vOuDmkjaYW1/Crh4mlQ9y3iS35U3jmnIX1xfUcax0mcVt8I7mEDabKVeIQfbT50Mf/is1ei3aiuNx4jIgqT4WDHJElKv4Me/QWJtUgGJ/AKfKhH71mQY8ZuAGt1KahCGP9J0p+iZn2DM20aTeMO/LyymZb44w9ZuOV2jXrUqxTO88986LdkCmttbFLjXFbuKrIHndc+zrwii9J6d28LYxX4FqSFbALIRiAS94M4RSMP2WL2IvfdGL21xydedhaXKMW1bIC9hVIohM+8fVH2SCPss0cY4+7jiaCIWeabXqSsCW47Df/AceUeM9rNvPbt117To/zgVuv4IN3PkFAgwSXiFNHKvQKL9+P63ikSQu1QJnN2bjjnr2EqskV/n5erQ8ihGFK+hwxg/SbAa6SY1xjRqnLgL6BSk8e82SMMcxGsydI1NqqTX+uPzOQWgY68uG8k6ce1/Gkd4J8uJW2SHVKJVdZWdnfBYgx5m7g7pOO/da8j9vAvzrNbf8b8N+W9QTPI0or2mmbmWiGVtKyUlSvzHQ0je/4C9rgCryATaVNlNwSiBSncAQVD3E4Xcefqrfzs87dXC/3I9F8IXkDf/6l73Lb2m18+cWUT9zzPG/R36Yk2nynvY1Hdld5X3/IztctXJHQ6QZXg36ioJ9Sq8bx5nHCYJBW2jqjuiFWMXF9AhM1EDKHCIbIOytUwEoHiUTl+5DC4KQR0QLHrqbDaVKdMlIcWVE32y7GWLlupzA0BupjtpiN6lBamHy7ZzgeBHNKgeKwLUyax6050+ijVhLcN3Ju9z14iZWDpiGU1kD1CPl1V9JIW91rd6Si07oRWwfiNqnjkk/bKL+44u+5u3aP8qF/3Mt1boURVyHaB8/qJfJ3j+znf9/7Zd7afAyZE5QGcuy89vvVGGfjV2/dzgf/ISTSR5nyEr4Yb+eHeI71TFKhTi0p4uNikEyYMokbUZIxh9mAU9yG+P/Ze/Mou67y2ve31m5O31TfSSrJ6izJsi25Axsb2xjTBIMhBAhkJDfNJbkvGS8Q4gSSvMRkhEDshPfy3r03ucnlAskNwQaMbcBYYGywca9eVt9WSdVXnTp1ut2v9f7YqrJkSbZKKkm2ozmGRpVO7XPOPs3ee83vm9+c1Qad+QJ/dPvlp61OE0KQsTJUVIVQhTihQyFRiAvKoYe2jslbNqw4H7a4IJail/tjkyd0LCGXRvxdd8rx9zzbHnf3M21xcSNZiF2NrUzskm1l5ib3+DRxcfV2ukg3w6K3xwHVU4djl+Jk8eUK3FEkjEQ862LYlL0ybuCSnKvh6It4XaARNCjXR7hNHKGOzWFRxIiSjNJEVjaYr0fZYk7S8NP87+firK0zIbF3rukhUiG7HgvwQovOQpE/etfKcyazNQ0bYWUJ/QqRf3rV8FfDnz24jYGyg21NcpXcS0pF7JBd1FSCZtGgj2ayusB8JllujvL+m68/J+ZR31y/m79/YjsjUy7tBYvfunEBt1zaih/6tGXaLsa3zDGmZ1611kQ6Os5cZdrFMmEkLho3XcQFRS2oMeFMzBSzmpJN+MpHaXVa8SDTsAyLtkwbbfZyRtxDGPYYkRZEUZFvRLfxUfk4q+UhesQ4E7UCjN7E1p9u5INqjBYxxRa1hJdEJ2MK/vWZEr/3ttmdj1JWCp1qpm6naQpc0rUx6sVenMAhbaZPSRj8yCdySwjlQSKNmW49byNPUkgMaeAmiyAtpO/ie5XXNNip+bXYaVVaF270wKvEBjXTKRaNUiyhnD6fncv519OBlYoJSa4bBtbD0OaYYHdePnu32XRzfJ/qMBQWQG2UpFthyhBxHBSCUIWnvHukI/AbeIakGPoE6RyZ8xl1xLSXiGJAdoCGHjlCv3vqqKkHNw1w9/c3sIDDFKmxJezipz9v0NU8Ouu11/T2f/OjLYw0DtFnW/xP/yZu0nuYLyaY0hkECiEiKoZgTOTZFSwjxOL5P3orCSNB3p69SilpJKnLOkEY4EfxOS1pxAZPgQpOPM6z7bDknTG3Cb04G7gyGMcotSwBIwlBPZYP2zlougTaL3114yelzjmZvUhgZ4PmxdB1eVzVGtwUd2YvuTmWchyDjJWhNdXKqDPKiDNCr9V7QXb3IuYeSismnUluTvexpD7Ok2IZPaqOgUeA4qCRYU00Sacc5oBoB23z788fPuMu7Hsvb6ewJ4mVmcfn77jtnMqlTGlipPK4jXE8/+zkvH/24Laj5D1gmbmXVl3hkNHJbt3JlG5jNQdZIkZwDA9p5fjtFWmWLIg7Iq82UzNb3Ld+L3/5yAu4YUTGcElUazz0430ofw2rlxYYdUZZ3rx8VgvWi3h1+JGPJS3cKJ6DnSaqx5o2XZx7vYgLienYCoAFuQUzM3GT7iSGMM6IyH32XZfzuQciPH0Ywy4RhR61oJUH1E3cwiZWij4WJ6rg16g1XFqF4nm1khfUcsYSLlqFjJZnv+CzpU3KylDLNKPqZYqBS8Ov4SbyVPwKTYmmE64boQp5ZEsfP//Z83R6BzGtJjqyDZZ1nL+xioSRoGqn0WYSM3Ro+DUiHWFw8n3wIo8xZ4xABTQlmy5c9FZjIv6ZOupIWxmIF/ZKQ6Er7kS9HmCYsfS3dBBK++Ns2J6rTlivnhRO+agUNBnPv1aHoWMVmElS9RLkW6gFtRlTslMhikLCoIEyTCzfwS3mznvBeNozZEy1E2qLNlF61aipe9Ztx4vqLDVGiIB+3UrDS5+xR8eda3q4c00P4844137pPrRR5Wm1iCU6TWCGRNokgcIH+sIFRCqJMDxydu6M1yVCiJkEgFCHuKFLykzF88uRd/Lzm5SxHH0a3VeeuE3gxjPX5X6ojx41g2p7uZGndaxCqA6C34BFN57R/p8uLhLY2cAwYeGNIAzY9xhs/kZcfVvxfjCPPyibU8002U0M1YZoS7aRfr2c1OYYWmu8yAPiqmqko/PmZHgyPLhpgHvX7Waw7NBdTHHXu5bPaceyETQYn9jNxzum2HooSQ2batjOId3FanGAjK7hGZJFaoQD0oHIJtJnnizh+zWi0CN7kkXIXMOUJpadRWofx5s6q8f6xvNx5xmjxgp5ELTigOpmIFwE2mRP8iruvj7NwsJhbKVp9uqUyv3UCwvmjMB6kceXH19PwCQrRYkOXSevQ3At9v78Wd639P0ciTx2jO9gSdMSColzI2FWWsVSKh1fWN7Ms7eBClBaYQiDRtggbaZncmCnTZvO1ft8ERdxuvAij0bYoCnZNENep2NBztQU6OVuCww3jmBaFSIZMOl185B6Gy9Ya/nLG1sg28BJ9/B0YwEb1VJ8s44QAURZuvKzL+zYhk3aSlPOtODKQ+QDl3G3SpAJCFVIxa+ccMw9sKmPf3j0RXp1nV6h2Oum+MZjfbSnF543I72EkQArjbLTJCsVSl4l7tidBJGKqPpVIh1RtIukrfSFkQ8D1MbiqBwrGXuj1EZiR+Jic2x89HqCNOI5WcOK41OOvPjy3OMr16TVkXib9pVxg8a046iVcj/oKDYyNWySXoWkaqbiVejMdMZRaFqfdH0ShQ2UjiAIMbRAJ8+/sem0l4instRFmnY9CdKhO9920u2HKhXarDG6dZmSSDOgukDbZ22e2ZJsQURFMOpERoNdqhm0ARigJSiJ1gbC8EAbZ11UTxgJTGkSqYhG2CBlpmaMt3Kcob+JlYSOlTHRndgXd2mnDp+4nWHHI5bnuAt7kcDOFnYalt4Wt8/Xfw12fT8+wC/7IDQtPG7TRcVFbBnbwoGpA6xqXXXOCci5Jm+vRKhCyt6JkSue9CgkCuedxE7npjpBfBEcKDtznps60hhBjO/l8nTE0Oq1HD6wlNEpQUchyfbKfK4MK3i2pEWUKRoTlKMchjhzwuI1xolUSOo0TT3OBkIIEslmtFJ4XvWUF6XTgdIAil7zAN16giO6nYPhInSU4W8/fCU3rciAV6V2cIIpPGqw6S8AACAASURBVLJKY1eHqddHaU42nzXJU1ox4UxQdoe5Uo2wWNVJqYiECMkIl3TDo2fLt9ntz+dP9krG6j+nLXkJn7197Zx9V2Ip0mamvBJCeiACsimD373pMj5x9eVkrMwFK/REKiLSEaEKZxaNtmFjCAOBQAp5Rvs2HaswfU5ImanYtMl72bTpIi7iQkFrzaQ3iRPEi9FjjZrcMI4gOZvO3nS3JVIRX3thE//4zPNMlMfoSPfwh++6iluv7IaJ/dx6Sxd/8Og4nm4gjQZaWSRlnj9614pZP+d0AsJYsoCTSJP1HZp9hxHlg47JesWvzKgeAhXwhUc20xJNkjQ9TCUZFTkczzivTvCWYSFNm9DKkFIB2q/jBM5JF+71sI4XetjSRiAu3PiB34idV1uXxf+fJq9mEoq9s5foni809QI6Jh1Dm+MmTPeaWA6daoqlwuN74ricwY0gLdAq7janivHonGHFndnGBMVMC4OpLEEUoNGEOsQSJ7525TfwoxChHIQAnS6edwIbe4lswwmTjKomFokB2hLj/OHtt52wrdaaXFrRE41TUA7bRTvlKCaaZ2ueKYQgCosQphFmFUSIVgli8y8JCISM0MrmE9csOavngrghIYVEyDhWx41ckmYSz/NoBI2zaxTYmXi2ukOBW44VCMf+LZE/L7OwFwnsmaIwD95+F6z/apyV9dIDsPZXX56LIDZ0mpedR1+1j5JbOm1nwTPB+SBvx2KavH5/6xH+x08PMVxx6MynuHFpJ0/tG2J4KqAr13JaUQBng+lMsnpQ50s/fhZHe7GNt7ZAmzgBfOb+LcDZvw9RFDE+sZf2oW1U7BS9q67mgXetIWWmyNpZPvfg8+zcdJisTtGtK3TKMcpiPr983cIzfk6/PkpIRDJ78mrhXCOVLKIA3y3NdNLOGMJjhbkPm5Atail1FTvqffiqRXHGmpEgTDXx4t5DfHXHEIXGS2zL1vnlWxN89OqzO4HX/TojlX7eYQ1wrbcXhyxjIs9BWpgkw5pkmWf2jVEb2cR79ALusy9l1Onnc98N0foaPrj2RIO22eDBTQPc9Z31hKIMMkCjQJtUGxF/+5MXqQUTfGztWnpy5y82yI983Mg9TjUBzMyrvjIfz5IWtmFjS/u0ux1u5MbROconYSRQKKre0c5JonjRtOkiLijcyCVUIRpN3s4fZ1rkRi4JIzEn31FDGvzGdVdxy4pmxhpjtKfamZ/vQKHxij28460L+cvUAPf+5OeM1kI6sh3cddtVZ3yNSppJ7EQBJ5EhDEo0+Q1KgU9FVujIdMx0yQAe2tJHxQ1YIhskCBAIRnQLaPOcRbSdDFLIuEOUaUKMaaygQSNq0EzzcduFKpZAamJ382KieNxc/XlFZTD+OR01UxkE34lJXq7zwuzT6aJpYdx99Wtxh3Vg/ct/Sxbi23NdsVy4bVksDVVRbOZz+HkI/biBUx8l65QRyQxO6GAaZpxt/AppsNKKJ146yGPP7qTq1bnBnMTIhCzrPb8kf/qYumfdTvq8Lq60BvjtyyS3rz4xaupzD27A98bplROEQtJHGzpKY8m5Mc/sKaYYKIMOiwizjuBokViqoz9S/PK1i8945OyVsA0bL4zzd73Qo5gsYkubelAnaSbP/lwnZVz8uEC4SGDPBmYCrvp12Ph16H8Onvw7eNunIfey83BPtoeRxgh9U30UE8VzJh+8Z90unMADFHFigoETRHzqvs186r7NFFMWd79/1ZyQyUbQ4N83bOfvf7IDx4E8HgVMSpWQ726sEQLIiMFK6ZyQ6Ac3DfCldVsZqY/QVlB89LoOrrukwLjbj2EL0AKlbIhyaJUkUknu+vbZk9hRZxRzYCNpt8LhRTfQ2rqMjnTHzGf6xTuv4wv+MAf3DBKIGgv1MKuvbj2rk1G9MoAErOz5uTgm0i0gJaEzERPYU8wjvRZSlsTUoyxkgCEK9IcLQSVIWfEJ05IWKTPFD8dzPLpxiJIwuEKEZBuxgULCSJ3xZ6W04n+v38wzP/8BtzZ2UafA46xkWKYYESksy6Dr0sv49S3jfFBt4Xq5h0JY4avmGiqM8/lH1p81gb1n3Q5CMQkipFVX6dQOnbqGrWFP0MG3XhhDi418+7nnGCklz4li4s8e3Ma/P3+YSIdguAgRkU9aCARTDUVnPssfvHM5H1yzAI0miALc0EUIgSWtGdlvnTqGMMjb+Vclsn7kE6oQW9r4ykcgmHQnEQiyVvZiJvZFXHA4oYMTxl2+rJWdURnMGJ3M4VylEIIFuQVx4dMdJ1ABGSuDIQ201qy9RPEP81ZStIu0pdtOK5vyVLClTcbOUsu0E1bGSPp1OsKAASuIcy+tLE7kIIXkH584gq3AMutktE9dJ6iQA22ds4i2k2G6QxQmiwgkplOe6Ywfi3pQR2tNoAIMYZBL5C5cIawyELuvWqnY7KY+Hs+Uppvj217vkEZMVnuujiNSCvPjLmvpYNxF7rw8nnV95Xl+wVtj+fHEfgg9zNAj7dVxzCR5I3/SOdgHNvbzlSd2UhAuOR0w5sP9PxukKzd83vPep5UR2w4ZqGf6CFITTHlTxxVCHtw0wH3r97PQHKVDV5kSCfpVJ+gk2ZQ5J/s80w0OQIc5QJCyDP7qgyu444quOb9GJowEbvhyUVlpRcbOMOlO4kf+hZsjnyNcJLBnCysB1/5naF4CW74BT94LN356pkInpaQ338ueyT3smNjB0qalc/qlqfpVDk0dYsTdjky9PGupVTI+QKIMYFJ2Au761tmTuJpf41/Xb+L/fWwfRc9hLaMktEKgCDDQwABF9osCypzCCTlrWZLWGl/5+JHP3Q9v5LtbdyJMB2EJxqs2X3/iCD1+xNsNmKrXmZA2o4bEMapABCIiiNJ8/nvbz2g/Htw0wD3rdjHq7OQziaeY6u4g07X6OPIKMSn7/TtuYnR3hfroDiwhKa45u3k/rzqKRJA6T526RKoZhEnoTBFF/hnPGX1obTcvbfkxaeHwYrgCP2pGIvnihy6f2cY2bP7+2SlaozRpUaZqWHREZQST3LPuzD4rgG+8uIt//elP+Yi/E61tvm2soN8ooBG0prP85g2L+cozuwjtKt/Sixn1U7yPl/hIuI37jLVMuUnu37Cfj1y1+IyeX2vNcH0IIQN6oxJr5QG6lEOGkLxscCtb6Jts5duPL2eULFp2MFBmToo902MEA2UHUCDdeKaGCK1NppworvlKxXCtzJ9/70WcqMa7LzumQKKZqahPGz+4URw3kjbTp5Q+N4IGgnjeNYjizo4lLYqJ4sWs14u44HBCJy7QEMdMHCuhc6P4dnuOHVJNaTIvPw+qsUFUza/RkmqZidrLWTmaU81n3VG0DCterGbbcAwTO3TJO2Ua+S5K3iSBCmhLtZE0kwyVXdrNEYT0yUeCcZEhUAng3EW0nQymMLGkhZduJjJMEm6Nuls+zok4UMFMlrQburSn2y+cfDhwYnfWaaOb8uGY/FlpyJ9fQnbWSGSh82hhPVWM5c96el7xJMUBKxmT2MCNY3UCl4wzxVgyByIuAL0SX/7xLrKRg2MJepVPhQyuL86rTP2VyOR7qKaasCrDlOqjdGW6Zq5N96zbDrLBPDFJSrgclq3UgliZUG4Er/HIp4fp132+Rv1sac8orIAZ0vpa7tFvFFwksHMBIWDprWAnYcPX4akvw+UfhZ61IA3a0m14kceR2hF2TOxgcXHxWRuZ1Lwa/dV+yn4ZKSRtmSLDlRCBBCKEUUcmGqgogQ6aQWUJ1NmRyYpfYbA2yP1P7eYq9wg9xjgRETUSCCBNRKBTrFAuTZHDZrMV35xisKJe87FfiVCFeJGHH/kEKsAJHe750SZ+uP0wSEE2kFwRjrNG9tMdTdL8dMTnO7Nscadih8kowWajlU1GL/2qgwDFZGP2i+gZaXZYZ0XqEGZQ56tH0rx9IMW1808chE/YWdLZTmpTh1C1cdzqEEHrpWfsvOe4YxiYJDOzD9E+E5jpFgxhEXg1lF+P5xlmiQc3DfDApgO8zz6Eh8ketQyhbT7+lgUnfPeGJzVVo4fLRY2GMOmSU7TqCQ5XzkyW8t2NR7j7kSe4Q+6iQzl821xNn8ihwzSd2Wae+PS7saTFl743ghYpZGKcn9mdpKIaN6t9vFe/xJNyKf/3T7bx4bWLzqjSX/ErtBU0lBusFodJKkm/7sbFpKqTzKfEdXI3vx1N8s/G1QzaAuUbOEHqrI7Pl8cIfDAaCNlAiAiNBcpCAJZwERqEEggEIgj52uNbec/SDJE0se0sQkgiFcV5rlE8B20JCyEEjbCBG7kUEoXjvtNe5FELajPHa86O3SbzidlHAFzERcw1vMij6sdz/QkjcdycpdaxNNU27HPyXU2ZKRbmF9KR6aDm14hURN7Ok7EyFBKFOTOtS1tpKukWgkSWKHSRfoMO38XKdDDmjNFX7SNtpulo8mitjZOKDFIahkUBrRI0pa3zSiyEiGdZK6kiykiQCTwmnRJO6Mx0o+t+HSkkNb+GKU2Kidlncc4ZGqX4Z6o5NqcpHYwdV5sWxiNlb2QYp0EFDBPmXxMTWL9O2rTArxEeVRaGKjwusmloqsFq08UTBnnts0/k0No4rzL1V+LpvT6bdoYsCfr4l20P0BB9/OUdV3Pnmh6GqpO0WKN0qikiYbBfd6BVEhBzqkyY7gafDwghSBpJGmEDreMiUNJMYkqTQM0NKb+QuEhg5xK918fD8Vu+Ac/999iyfOUHoDifebl5JI0k+6f288/PP8m3n3MZKSXoLmZnVYHxI5/RxihHqkcAaE+1My/Tw5++vYlvf+9hlkb7aRFVKirBHlFku9XCWNJFBUV00Hq0MzN7THlTDNYGSVZGuaXyPIbpMqwL9KseShQItEVeOLTICTBqXKH30BFN8CO5jHyzy1BtiJZUy2tKJLTW1ILazDxepCNqfo1Ht/fz5LZ+VqsSa9QgSxklazhUdJq9uoN+t5W/u+296P0l7n9iPVfQzxrGaZF1thslNojlOBh8d+ORWclD4wyxCGFVuJr9+MJkQ7iY/T8r8VtvPXGxkzAS2LluhJ0jUmP4E/tx578Vy549gdVa4ztlhJUgYZ8f51YrUcAwEwRBgyg8syzYe9ftRqhR2phgTDdTDboAwRO7xk7YtrtQYLDqM6pbyKkJQLCIMQaNbh7YeJgPrZ1/2s/74KYB/uShn7PQ6OPqcIQtRidbxDyU3wZRgeHJlw1augsFBso2ykkh7FF+ZC6iENbpVSVWygFeqOaoB/XjTF5OB5GKGHfG+c3r5rHlsY0UVIOyzuMYAXtlgcM08TytbA3b+DWe4VejTXzNXMOwZaK8TgbKcMOXHp91VVZrzT3rtuGqEiLRQKCwlaYrqtFBhSZRJS8bJAiRQiNRGGg0ENZskjsmwLBRVgKVakamipBqIkw3EQoDRzsYwsAUJhERZbdMzs6RNJNorZlwJph0JzGlSSFRoCnZdDGa6CJeN6j5NQxhIA05I12dhhd5s85+nS0sw8IyLFJGiklvEoC8nZ/TyLCUmcIwbZxCD/mRnViGhZjYR0vqanKFS5hwJ2gEDX7/6hw/+ZnADTNIOcwYBVJGir+4Y9Wc7cvpImEk0EISpZrJVAcxw7jQf2nzpTihE48i6FgB0p5qv7AO7k4pNjdK5I66r/bHBkgdK08vmubNgFQR8j1sO3CYr+0d4ZD/AgPpy/g/brmMD6/JHkdgu4oJEnWHAEhoxZRMgTbPq0z9WDy4aYC7HzrAkkQHqznEJWKUZ6Nh7vrWRryoQXtB09Eo00WNCZHikOoBlUTAeVUmzDWSZkxgp2XEU94UpjRnTOveyJgTAiuEeDfw98TDl/9Ta/2lV/w9AfwLcBUwAXxUa33o6N8+B/wmEAH/p9Z63Vzs0wXDguugaRFs/w4MbYtnCRbeBB0raE238sSOCl/52VY8XQc7y0A5Oi3poNKK0cYohyuHY6t/O8viwmIyoQ8bvsodI9tYM7/E8/01SjrHAjHBpQxyU5DkKWMez1vzqMkQ6c8+ZHusMca3Nu3g8Z+v55rqFjzT5mm1iowK6JBTtBFfkCNMBlULB+hkQo6wVhzil4hYet2HqAU1hIhn4U4lQZzO5nNCB6UVvvJjsxmteebJrfxquJV5ooQSggHdxDN6DbvMdnwR0Zoz2JIQFFe28MxzzTyjm7leHWJtOMgVoh8lJM/KFPf+ePOsCGxM+EPazEG69BR7RDtO1ESjfHK7f0Ma2LkuMokm6oaBqgxQdyZnTYQgJkOBN4W00ljW+ZFNWVYa20ri+DV8r3pGjzFQdliVOEBCeOwLF4KOSePJKq/xTEiDPt1Fmx6iTZbpUGVa5Dh/+uAmpJCnReQe3DTAZ+7fCMlB3qtfooHJD+UKQr8Fopj8H3vhPG4Wxe8iEvCUOY/3hA3m6RIye4TR+ggSSWYWXegpfwovcHh36iCXL5f8+942/MjjIG30qU7yKUnNr7A3keD+cBW/pLbx8XAr/2JewZhlo4POWRmwBSqeW/3upgMMNYaxDYfuqMwKMcx8JknI2CXS0CC1wNMJXJJ42sTTNiEm6YRFLtsBkQ+Rj54aRE0NENkZokSeIFXAz7TSSBUoR3E+sB/6jBljJGQCN3KpBTVyVo6OdAdNyXMc+aSieF9VBOh4QXkRF3EK+JFPpCNSZgondEiYx59L3TDOKz4fM9qWYdGUaEIKOedkzJJWnL+c7yYa2RnfaGdgcBP2vKvpynQRNkr09kg6b7yWdS88S9VNkMg281fvmDv39dkgaSYxhMH6io3Ydoh/WL+VUnGQ/3JDjTsu7yVU4Uz8VlPyRNOd84pGCdJNMVkd3wvuVKyyS13g/TrPeLLczKZtT3MgXEHejDAah/niDwwMYfKJa1bObPd7N8/nh4+GhPgIrZgkR8pMXDAy+PnvbSdSkoGoi7KRZk04wvNGndAa4MuPV/mVa3Mc+FmNhA45KDrxoyxCW3ziJMqxNxJMacZFOySWYVEP6nHhCH1C1/yNhrPecyGEAfw34J3AEeBFIcTDWusdx2z2m8Ck1nqJEOJjwN8AHxVCrAQ+BqwCuoHHhBDLtD5FGNgbBbl2WPtr8OJXYGQ7jO2CS98Hi97O//PYIZxGO8KcRJpT6KSP4zXz6fs28PnvbafcCI7TxQdRQMkrMVofpRbUSBkpFhYW0qw0xuEXYM+6eA6jdSk9V/wK3nCWLzyyAUTIajXAO8Qu3hvt45JogofsZYwmfBZ+7js0pXL8xR2vbuqktGKkPsJf/fAFhrZu4C16PyNGkqe5hCVyDFtqhlQLLjYKQVvC54PdHjtHJtnoFNmaXMXvLxzHPPIodz09ny31FB25HL978zI+eOWi4w6cml+j5JVwgrjTI6XE1pJ9GzYz+MJjfMQbIBAmm/QCNskuDht5HCQagYhS/M4NV7K0OA+JJHL7EUaDZ8xeXFNwte5jpeinKjK8VDW5b/2+03K5fXDTQPyL0WC13IetQ7ayAB0UMV5lgZ5I5EhmO6jZSZRXoVYZQOXnzVqOGkQ+KmhgpVrP20nGNCyMVAHlTOCeQRbsg5sGEIQsNw4QCoO90RKmZ2pOVnmd/v595tvPMqpbaBMTtIoGixjiOdVzWpLaaelsZExxk9hJZ1DnO9ZlVMI2COPFRco6fr5r+jHvfng7ZSdAee0M2BF7jXFW63FuWJigMbqdw20h87LzTstgJVABE84EZrkfu9zH8pXX8CcrNdpOwYK3ImWc7Xb7l59hqD7ANktjhpfyIbWTX4y28Q1TMqWSEBVxguhVX3ugAup+nU/+67Ns6BulXU5wjR5lqRimWbgEmIypHA1SgCTExtVJQiQ2EaaIiIdhBY1A8vMhydsuWwXSQGgw3BKGMwluhZTfQHsNCqaN39RLJZXn4V0H+cozO5ioN2jJ2vzWW6/g41cvmLtooMCNF4zOZLxQ9KqxS6ZfgygAFcbZhMKAt/zO2T/fRbwpMeVN4Uc+UkiCKEAKedwM5bRU/ny62p6r/FJTxjOlQboZN9VEcmwXxrWfhIENcGQDdF+JOfISmEnecs1y1qb2MaWb+E8rbmVh8+krXeZ6n5/cU+IHW2t8JFR0K589VcW9P3maWjjJbSt6MEU8R3xBu6+BG8+/FufH56Xx3bFL73Sczn8g/N2LPtcqk+XyCIeiZppljQHl8V+f2M3Hrlo+Y1L2zmVZ1FAbz+0eQPkmVrrI59+x5oKRwclGAAhqURP7jDZu0kMsCGv0m5KxRsSjj+/lF2QZ106wM5pPZ7aJP779wu3vXMKWNk7okLfzsbLh6Mzyf3gCC1wL7NNaHwAQQnwT+ABwLIH9AHD30d+/DfxXEa9yPgB8U2vtAQeFEPuOPt6zc7BfFxZ2Gq79ZGxVvvP7sOnfYPcj3FyJeFEvZ1/QSaQspD2OkRpCa5NylECbKQZq8LmHDzNQ7+WqS5JEOsKWNvMzPbRHEfbIrngOYXQ3JHOEl3+E+vxrOFIboNcuY1hTaC3ZYRbZpa/hneFBbuQQnwh2cJ+5iqEETLrqVZ15QxUyXB/me1t242z5OdczyF5Z4CXRwaV6nCDM8iK91ESSznya/3LzYm5b2YoIHH5xbA9+dYCGlebpseUceur7XKYG0XohB6bm8dc/2InSEe9Z3U0QBbG5RVjDwIjngrSmeGQbh7c+S7hnHxltsUEtZp1czIRlorURx+SoFFol+Ng1i/mNt6yd2feeXNzFisImtppJ0kbAKnWYVfIQETZ3f9/ElBa/uLb3lB/fNCkCSJoTrFQDDMs8A2EPkCDS+pT3tQ0bO9+JsAroxmGCyUP4XWtmbd7l+VWiwCXXdP4ydU1pYiebIApxndkT2HvX7caWU7TJcSaiAtUo7vi/mgznzjU9fPq+BEOygw41SEF49OoRXpJlBsuvTRxjmbdPOjnEDXo/h6wcm/RStN8GSAwh+OKHVp/wPZ+eRZnJT6647Muu4Zfn7eaydBmrdJjhZIFxIxnL815jAVVyS3hehfzoXhKJIqFhocI6sut6hIy/2xkrwx+/6zI+90CE6xtssiApfH4h2st75E6+bScJAyAsnrRj7Uc+9aBOoAL+0z8+gTdxhGvlBHlRoV1XaegEO0QBX0iEAS6SETKUZJo6CYQyUEikNkgogaU1OUK+sukIV8y3SB5dBJPMxw6VqQYEdYTfwPKmsNwpNg2b/NtTLqNBByAYdSRffHiS/tGDs3fcjkKoDceSvOow1MfirMFXRPpgJGIjETMR/57IxD8vxvJcxCkQRLEBUMJIIITADV1y9vEOttOjKsfG6bxRIYQgZaZohA28tuWEh57GKPfDvGug/xmee/JR7t84zE+q81lWOMgfL+inbfU1pJIXzmTNlCZfe3oAR+VwMejV42hvNU40xb89O87H1l5B0S5imxfYwbxytJid7YCBjdCYhOVvOSOPiDc6tk6lSIjFvE1uY1znsHCR+IxUHNzIJSMzhCok9Gss785wfXM32aiDD6y6mUvbF13o3QeVZhO9XMsIH1B7+SfnF5BELJJHsIwaG415/NZt1/Gf33r9m8Y53zIsGmGDSEdkrAwVrxJ/Rm9wI6e5ILA9wOFj/n8EuO5U22itQyHEFNBy9PbnXnHfk5Y7hBCfBD4JsGDBgjnY7fMAKwELb4D2FbDvxzC4hZuTW7jW30mJPLvUfJ50VjBkJBFmAyFdpKwD4AvN15/3MeSlfPPJQYypMldmpvi15QGXZyqARvdeT2PJrUxKyVB5L2iYl51Hm11nuByAbKDNMuvMpYwrizvUHn4l3Mp95kr67YggaONT923g3nW7Zzq+3914hHt+tI2R+gi9eY9rnJ1cyjgbjA5GZZoV4RSlqI2XxDwCYdKVK/DYp28G4nlVV1ow72rytUVYgy/y7Pr17IkWcRkjLJVHSIsqYzTxlZ/VuW5pkjCKM/nm2S0UpUlmeCfi0JPglNh8sM7z4XJelL0MWQYYHjq0IcqjtY1QNr/yloUnLJrvetdyPnXfZlBJvKCLzXg0GxVy2mUew3hKcu+P069KYKdnX8FlsXGIHC7r9SK8IM5j7XmVOQ5Tmti5Hsx0E6pyhGDyAHW/NmsC6zrjRCrATp+7/OBXQghBItWCIMJ14izY2XSOB8oOC+0jJGWD7cESUPFr1ry6HLa7mGGgUqQkW2iVVdpFjQ41QqPptY/1wbIDxhQ3yO3YOuAnrEB5HYBNyjJOSl6PxTSR1VpzcOogzlgvuu85mNhLsTFGefEtjJlJMlbmlFLwml+j5JSQk/2knQm8Qi+BN0mi4wqUncKSJmkzPfN8AJ+5fxMRsN6KaKHG28LDVIydrLMlkXSRYSt/+t0tPLF7lKFKlc6iwfVLmnhpbz9yapgWY4LICEgKD1MrhmUOX0iUFgzrJoZVEzWRoT2b4oe/cyNCCG6850cgIjQKVypcDRWSDDayDHauAK9CLvDIBDVyYYgUIo6LCJyYVAbj7HxuJ7comwHRylZ9CaM0o4F/e66fq3ubT/1eh37cTXVKUO6D8pGYsE6bSUgrztFuuQSS8QwuqaaYTBt2nO8szbj7WhmAqYFYSqz1f5wZtIs4bUxnHWesDGWvPOOqPQ2t9Uz26wXt7s0h0laaCXeCqHUZ4eEXSBx5ATpW8oOJbr76zG52BItwMSk2NvLTvSXaumw+sOzCkveRskJaSUpk6BCTtKiAiaCLkQloT7e/9gOca2gN5f44PserwvBWKPRA2xt3LvJs0F1MsbG8hKvYwzwxQZ/KkBN1UtlmnNAhY2Vi92ivTBhFZH0PP9OCZV9YT4RiyqLsBKATjOh2njUWcLs+zCfkE5TIs0bupU9keEHN56VnRvndt705yCswY7joK5+0maYu6zihc5HAni9orf8J+CeAq6+++tTtr9cj0s2xK/HlH8Vreoknvn8fy/UBrpO7eJt8ibLOMB4WKOk0Y2SIdJzVaLglBr+/lV8UZbLSxXQj1m9NwuqVLLnmRhodk2MFcwAAIABJREFUK6n5dUqNcbJWlp5cD3k7z2ffZR6d70uj/BQYU6y3DDzD4EPRbn41fIlHjYVsToSEUZqBeprPPTTKkwc6+eFLh/GUS7ucZM3UQXKiylNmN1MizZKwxuFoPntlO1qb6DDF0KQ+zogibaap+lWcbDP2/LfSqO5msTFOWSdJqCRFQkxZIapN8aX/vh9DGygHlqdcfmn+FIszLqRaiFbcwRc2jFIzFcJqgNIor/3oPKOk51Xsx+9c0zMjDUXbTEXdbJcTvEXsIiMbLFPDPF1r5rPfXc+XPnj1ST+yme6XVWElfXiY7I0WgsqcIEc9GRKJPOlMB1PmHkRtlEZjlJb07JyE3eowGk0yfX4D0lOZDiZqPt959AUevS9PdyF3WqZCsXxYsVjuI0LSFy1iWj78aoQfpmdSNzOouulijA5RY6k5xDU3tb4miS5kNDoaZK3q55DRxIFgMaj8KTuvp4IQgq5sF33K50f7hzi4ZYIm9yVGXxhl0U2f4PbL5pM0kvxg6+hxNvi//85FXLHIJ/TrtIztxrAyuEQksp0kWpfj69iV99gux/Q+fe6BzbiB5oeWJIvHbdEhTAQ/MFagDYdvbBwHbSMlBJUa+zZsplU28K2IIzJFmwpIaY0CPJ2kEuXYr+dRE2nQkqSR5I9vWxNHeQBdmV4Gyg6aCKQHwkcYPu15i3yiQGClqYYOZR1hKEU+UjQjSYReLOetDjHuwQJGWW0c4N28QIk8faqdI7qVBx4Z5s7F741jGkIPnKOEtToEjXHw6vEi0LTj2dX2FXGntzAvJq+nIqKB+3KHtj4O6JjkNvVeJLAXcVJ4kTcjnVNaneD8P52L+EbPQjwW03OwoQCv8zKSg1sxyof56yeGGQgWAnCJPEgXkxwKmnlgQ4VfuvHCLtQ7c3lG3EkO0sINYoCl4ggTuoAgvqZccAlnfRxCF5ovgcFN8XntkqtjRcibEKEKaYQN/MhHa40pTRJGgqSZRAo54x+xO5zPSnmQorLpSDb42Nt7Y++So070rlNFEJFRIZV0M8kLFX90FHe/fxV3fWsLgTKIwhxP2YtZQMBlso8IST8F1rGSmspRnXxzFLSmIUVsXudH8bhEwkhQ1VV8dWL80RsJc0FgB4BjByjmHb3tZNscEUKYQIHYzOl07vumwvuuu4zQbuKz92+gU4+wVu6lV4xQpEaPnMAkIhb5KRQSD4uKTnNEN3NEt7KHDr5ysIfvvm8FNb9KPaiTT+Rjl+OjF+JXZk1J1UQUGGyzBK5McafazZ3hHtqlx3Oil5IZ4inBw1vHKCqfFXqSVWKQUCqekgtQWCwNXIZ0F3tkB1qbEMWzda+cazSkQTFZxAkdqsDB3FrSlYMskAOkREBORyQjia8TGIEiJ2osFCNYXsBj+9MMvuU2Vtz4TgbcUVLNQ9QrPjoooMPsUTMgQU8xxdOfvfVV3+e737/qKImPIEpzQCymy6hQEGWKRokV6iD3r89jYPOFD15+wv27iykGKpM0GSMs0GUGRJGS6sQQ1mmRooSRIFnooZwqwNQgjXIfumXFrKRa9coRJIJk9vxWoZ8flByY8BH+BBCetqnQvet2I4RHtzFEQycZDOPu6em4+E0/7t/8KKLUOEIiMcn7F1j0dlRnqronwwMbD1P1xnivtR0LxbMsRfstWIbg3g9fMevFT8pMsWGf4p4XA5ZEGdaIBEVnnOceewjTWQu55dzz/QGcQAKKgXKVzz70BO9e3cSfrlSkvTpBrhtp2tg9V+Pp+IJxshil6X27Z90OhuqKb1pr0WzmHdFBulWdx41LqBs2SXyaaGCicYVkLwVcnWJ1NMG8qE7VsCjrIodUB8OiBTDQYZJiKsXd7z9+zv1Y8ypUGkiTlPD7tyyZMXsoJopIJGW/zFRQo4Igm20i07qYjLR4al2ORmWcDkosEYMsEkNcJffyFnaCA6x7Kn4yw4q7qmYSEvm4g1GYF3dY8z1xHIU8RWFCqXjmbJqwNiYAHT9W86L4/onXlpdfxH9MBCog0hFpKz1jWvLKY7ARNE6YiX2jY5rABiog6F6DN7SV1IGfMlIuAAZpGiwyBtDa4BCtDFf0Be8+33X7au566DB7RDtXMspauZeN0VJ87AuaGTqDyUOxAqQ2BlOHY5PO5teBFPYcwAkdKl6FSEcoHccfNsIGtmHTCBvk7NzM5/FvPyyh633MT2puXtvMquUFtNY4gRPHrTXGSEUKoQVhtvWCH2cvK5+2EEV5HD3F182raHWT5HEYNBJUpYeO0nQX3nzGXEkjSS2oxVE6RhJDGrihe1zu8hsNc0FgXwSWCiEWEZPPjwEff8U2DwO/Rjzb+mHgca21FkI8DHxDCPFlYhOnpcALc7BP5wXT4cAajdb6uJ9Kq5kTgNIqDqzQcdX3rUtNPvuB+fzND6s8EF2GzaUINFJHFHAIsYi0wNQGrrCpk0Afu86r1il7ZUIVUkgU6Mn2nPAFPDZr6sFNA3HlKVDstTVfI8X71E5uUP0sZYqKspgSSTSClHBJCZ8BkWOXaKdNBWSjkMN0sU+0olViRhb6ap3IlJlCCslv37KUv34kZCgosFwcQYsSzaJKhglSOiRCsk+3sUPP4xBFUjsj/n7NIWzD5rdvWMvf/rAfJ7CY7uSdTvdz+vXDyyY9YVSgT3axRAc4hkuHHKXDGOSb61MnJbB/ePsy/uR7P+FycZCk9tmue0mIZr74kdMjRZZhkczPw0y3Ek72EZQO4va6pKzTk9ForWlUhpBIUtnZO0efDf75hSo3KoOUdMiKBlWdfE1TIYi71kVjjIxRYzDsJFIxwXgt+fA07lzTw3sub2V0YhH1HQ9jTfZTG99LqWUZ6Xz6pOT/Tx96jvnWQS7Tg+w3iuwLlgJpTCnOeOHz3x4fwnEL7JaL6DAqLNQlUoHHC089xVNyFE8mwUwiRIiQEQiPzVtLHNJTXN5sUTckRucVBIaFKY0Z6fCpXvOda3pQWrH4z7/ON621jOvd3KwG+Hi4I46IEkWGRAujIour0yxSZdZwmAINDskcB1UHh3QXgbDRygaVAASb/+L2kz4fnDxIPVIR9bA+Y68/7Rhedss4gTOTxfiRW3v5/EMBh1Qbz+s4eiONQzuTrMw1uGPlwthsSUVxduB099zKxP+vDMaLQdN+eY7VtON52NCN/0XHVIbtTNz9yHdfJK0XcVpwQxeBQCJRWp2weJ7uEmWtN9f3SQhB2kxT8kok06143Vcij2zg/bk8O2tpsnKKDC6jqpkhI097Po0pLqwQ70NrF/CZB23KMsUBOllCiWUc4SUuuaCZoQC4lXhGX6m4iGYkoHXJm7L72ggaTHqTuIFLxs4cXwxRAVPeFBWvQme6M75urfoAbPXYs3ML923ay//1gkc608avv62XaxdIRNigRSsCQ6DSbRecwMKxyqdtuEEToTXBoGUwELUizEmENiHMvqFjc06FtJWeSQxoTbWSNJNMupMEKviPS2CPzrT+HrCOOEbnf2mttwsh/hJYr7V+GPgK8K9HTZpKxCSXo9vdT2z4FAK/+3p3IG4EDZzQIZrFbgZRQDWoUvEqMy37JfPhN27N8j9+dpDoGEH0GBrEdD6TQNMABCgrPrg0tOXjE0FHuoOW1GvPR04ftJ++bzPKE4yZNt8xV3NteIRLVIVQpUliglAcoZP9skAoBMujScIow/7EQrxUDlWOMHSKCP2qEt5pJIwEH796JYaw+P+e2Mn6SgJDX0IzFfI4NEhRJUndkEAEIqReDZmfnU97pp2rOmxaEl0nXWyfDo416fnUfZsYjOYx35jEUgamUWKR0c+oLlL36ydEpdyyMsvvlXMYz4wwHBVw04v5wiyjBuxUkWS6lZqwCKYO0wgbp01ggyjAd8awTRt7ltLjs0VfxeCabJKkcMiIKlWagZPH4ByL7mKKYqMfi4A+NQ+IOx6vJR8+FgkjQTLbSbl9OenKAMnJPiZL+ygkm8gn8sdt+60NBxF6mOv1HgIBL+pLUUH8XjmBmsUrPh5DZRdNBh/YKhfSJiqkhEtR11kSTrJFdmDYk6BBRRk6lcv72cbWXSmW3bKUsLgAuzAPjT5BOnwqSCHRQRuRNnjMFuxX7dwc9dMpJsnToFencLVNTvs04VAixQtiAftopUbcXdFhiulT+qu956cKUjekEWdTmmnc0MWLvJkuVqhCvMijHtS5fKHm9jWax14aQKk0OijSIMWIleVT710Nq05yjEQheJV4BlaFsZNw6B51FA6gUYs7tmYSkoX4p5WMu7T23GVlXsSbH1rrWD5s2IQ6nvF6pRlLPagjhXxTZhWnrTTj7jhaaxKL3o5XHeJXFg/y9e0VFDVclcAhScPK8Mc3LX9dLF47s0XGnDKD5FlCieXyMC+pS85NZqhScYGsMR7P0UsznrO3UkeLaXGBksiDwy9C3zNgZ6HYC00Loe3Sud+nC4wgCpj0JvFCj0KiQC6Rw5Y2QgjCKKTklZBCMulO4oQOK1pWIO0MP3JWsGvPz+nWFTpoY3+tyt8+/gLzZZ357iTX2SUuXbmUTjv5upHqzzQ3vreVqcBDWpNggVY22m/jE9ctu/Bd/3OEtJmm4ldminfjzjiNoPG6+WxmizkpvWmtHwEeecVtf37M7y7wS6e47xeAL8zFfpxrTHlTM3M1STOJ4OWFqRACgUCIuOorhCBQAWONMWpBnJ3Ynm4nZ+dIGAkkkms7TBZlB/jcd7cQzPDh6YV3BNIn7l8JEAqEJmmYfOrta1nWNDv79mMrT06QZErb/MywGZYTtFNDI6jrJEl8FusSRmhSUU3sTizgD99zGR+68pIzisgwpMHHr7mUD67p5dYvP8pwtcKESDFOBogQKISIAAOtknRkm+nMds5Ye59qsT3b1/6Z+7fg6wwjuoVF2ieNpJcpRs1BhhvDzJfzZ5wO/chnpDHCzclD5JalGZ53DZ+8/MN0ZGc3i5owEmTy86naKcL6GE6jBKdRcADwQoewPoFhZUikmmf9ms8GbYUi9SBDqxwnLSozt7/WYuIPbl/MU4/8LwIMBsKFwOl3zI9Fzs4x2baCxshOCpP9DI/vYqQwn4SZmKniKq3428ee4wq5h0WMsVm2c8BfDPrsFzzdxVQ8J6pSjKpONsoGPaJKgSpv0X0sCOv8NLiUvKiRo8L17CUizXqvifelm7HaV6HRp5QOnwrFlE3ZaSHSJgcsiz6jg8VBhV5doY0GeRFR0xnWs4S9sglfglZJtErOdF3hzN7zY2H+/+zdeZRkeXXY+e99a2y51169N02raRp1NwXCaEcNjZgx3UIIC41sPJYOY489cyyPWqCDjizZwkaj45HO+Fg+h5ElsNEumUXWgqAFko3E0kCjpoGm966urq4lKzMy1rfe+eNFROUSWZV7RmbeT508mRnvRebLqIh47/5+v3uv41ELatSokeYpmWZkeUamGdP5NFEW8Z43HOKO40/ynz/3dWabCxwuXcNPvf7U6q9V1ytqAVR29rl8UInINPC7wA3AM8DbVHVu2T53Av8RGKfow/5eVf3d3rYPAN8N9EuR/0NVfXgnjn2zoiwa5La2kha+4y/JoU/zdHABt1vVd7eT7xYzZ424wbXj19K69U3cVP0C91cv8GePPE+n6dEdu4b/47tv5gfuvGm3DxeAf/66O/i5PzvLQuoxqzWukQvM+BEP3Hvn1vwC1SIPf/65YhCttzqOoFoMoM1eoLjWWrT/3NNw5stQmSyKcZani5Ug29QGaTdd7FykGTeZLk0zVZoaDGpkecZCUlwDTIaTuOJyunGax+ce55apW/j5z7S5Ob2J73c/z8vyCzzNCdIopKotKuQkUYd//0jKvccu8bLXjk5RpP515R9+6Vl+6RNf5txCk2NjU7zrvjv3bfAKDK6r0zyl7JUJnIBm0mR6h68xt8qeKeK021pJiyiLBq0wriTNUy52LjIfzaOqxZtCOLWigTrAW195I54T8PN/9GivT9Ui2dKZh8mKf9XerVeyePngmbpDrAGPyBSlTLlWLlKViDk9AnnAJa3hT9X4qe+9lbe98qWbLide9so8cM8p3vORh+lkHURiEBdVGVyAl/2Ad73hjm3pS/X2b7uWD332GZ5wriHBZUxbHJNZ3n68xUL9WZ7KEm4Yv4FMM840z9CafZIT559krjxDcOzlTG6gWXngBIRjx8nL0zD3JNHs4zBzy5ru2+3OkcVNqtWjuN7OnjAfeMNt/PmfjOPIecpOA8gp+/5Vg6I33Fole7jDE+drzObH1jRLP0zJKzFZOcwLx17G/DNP8jdf/+/8VnoJp3wzP3XPd/DmO48z353H636Du/U0s06VL2S3kaeX34SnKht/zBbniWpW5ptyDWl+idBtc1hTbuMFbpFzlIjpEFKhy6OcYKoG6fQNeK6Pt6jq8Fr93JtvL6pnZxPkeQj+PN/0Qh7LT6JZCXIPkS5HppV4IeJIbYqf/L678Jxgw6sUrsZzPDy8Ym3NMv/ktSf50VN38XT9aZI84dqxYrnZeoJ2s23eDTyoqu8TkXf3vn/Xsn3awD9Q1cdF5ATwRRH5uKrO97Y/oKp/sIPHvGmqSitp4YpbFDPK0xXLhPtL5PfqrMPV9KstN+IGWZ5RnbiOelDljkMv8Jpvr1IeO875pEE9qo/Esk6AH7z7Rmajl/Pxv25wfr7Ky0tNfvWuOb7ttk0s8c7SomDc3DNw4etF4BqMQWWqKPrmleH4nUUxuTwrcu7bs8Wy4XavcNORl8Ht9xd5+/tUJ+0wH80zEUwwU55ZMtjTfw5NhpMEbsBUaYo4j5ltz/Jc4zleqNeZ1Vt5lX6DO5zTPJzdyqxOcMRJmXE6ROrzVDbGB//HC/zj1+7iH7mKH7z7+it2o9hvPMdDENI8RTyh6lepx/V1d5sYFRbArkGSJbSSFqVeK43VqCrtpM2FzgW6WZeaX+PwGtb+L17qOig8tMhk2V9RjGWjFs9ofuvP/wkLSZ2uA9/Mb4LcBUmZqHh84v96La64xajbFi0xesvd1+KIM7jYnij7iMB8O9nyC+/l+q12fvsLj/GMHAdy/snxgO8+mdE99xhnHZ8vRZdQVfw845qzX0XSDq1jd3J05lYCZ/0BvIgQVg/jjx3j9NMP88H/+hf86XzKicnaVf/WZuNFnKSDO3Z0Q797M95y93U88bc3Er/wTaacOZCMq71V/MxHHuHBL/4FP1g6y7PZTbz91K38m7dsfPR8pjzDh2cP8eUzIX8nepFXOad5sFPiJz/6R/z8n5X5jptdXps/yRgd/lJu5EJ6ba/IV+Ff/t3bN/y7lwz0zOdolvKkBJS1QcONWcgSXiVPk6rDN/RafGlzLqzwxtf8HXTqBgI3YDJcf2/F++86yUPPXuI3P/scqiXy+Ag4TcRr4/jFRNjhsRK//87vYaY0Q9kvD046uzFq3C/YdotzC88tPMdsdxbf8Zkpz+zLma095j7ge3pffxD4NMsCWFX95qKvXxCR88BhYJ49qp/eMxlODtro+ItmzHLN6WZdAifYkxdsazUWjDEfzQ+KPI6XpomDGqEbkuQJnU6HwAlGps+l53jc94qX8NprhcOXnuNklkPSgtOfh+PfCmstZBi3imXBcQOa52H2iSJw9UpFxfJgrFgN4oZFNeFnP1OkMcStXo5rUKQ4uF4xO3vta/Z18ArF7KsjDkcqR1b0SI7zmJpfW/I8uaZ2DXEWc6ZxhsMzdc5fqvJ5vY3/Wf6G75JH+DrXM06LgJjTOk1TSizM763GIftZP68ZihZjc9EcrbjFWDi8ReAoswB2DRpJA0ccxvzV/4PjLGYhXhjMuh6tHF33ReyVCqxsh59/87fywO9/mYQIcYrcXE8cHrj3W6h4FSp+ZctP8luxJHijfuH+O/hX991OPapTj+rkp7/Ak1/5G77+xc/x6e4Z/rZ6C07mcHf3Md5Qeozxm49z7PjLOVQ9vOEL8tAr8bXZgOfOd5DkHCrJVav6qiqtheeRPMcbO46zWqXWbfKRL5/hE08L3xm41GSBknToJD4P/P5Xhh7zz3zkET702Wd5Vfg0IjnPpNfy8c+fwXHcFT1618p1XD7wmQWa6Us47jT4zux5WnmVz3jXk8cRnUef49v1Rb7oHeOh7A40vTxDXg3cLVl2fnlQ6ct08yaP6g2MO008L+OR7DhV6eKIMOse4u/f8528/hU3oijjwfiGXze/cP8dnLp++nIbqHwcjWsoKeVA+BffczvXjF0zUhfftaDGdHma2c4sc9EcjjhMliZH6hgPoKOqerb39YvAFSvBicirgQB4ctHN7xWRnwUeBN6tqtEq9x2JHu1Zng0qDgduQD2q44gzWBGQ5ung/FzZ53nVNb+GKy71qM54OF4MpvYG0rtplyRLmAgnRuo1WvWrLFQO0Zh7hrg0TlCaKHJVz3wRKofg6O3D8+FbF4s+1b02X6gWQWjSKe530+vgyLfA8oH4+efh+S8Ubb7yFMQtUhyCanHfqevh2MbOX3tFlEY04gbTpWk8d2k40F9+v7hNIhQrF146+VKeqj/Fj35bm1/5xHN8Jr6NW3mOVzhPca2ep06ZXHK+zkkUh2PjS1tYmd3jOR6dtIOqUvbKuOLSSi2A3Ze6aZc0T1ctxqKqLMQLRFlEO2lTcStMliZXvOjXaicDvKUBc5PjkwEPvOHl/MDd1+zI798NjjhMhpPkmvOHc1N8+UnlpUmH75evclOrTomY652zPJuU+O9PV/mBm8e587qNLzUL3IDf+0rEK7KQaXcOx4nIsytX9U3zlLR+GhyH6vjOXxD+0scfo5nOkPgBVbdJjRZdxklyHXrMv/250yAp13mniQl4Ib9+cPtGA1iAF+cA/xB/7N3KRP417tev85rkRRL1OCEX+KY3zsd5BUk2BXp5lqUdb10duMutbh7lbDNjPi2D0+GSF4OUcKnwf37fTdx/5y2ISLF0cZM5UouD58uDWRPbOpi1WePBOFEaDfLHU02ZKk3ZcuJtJCKfBIYl5r9n8Te9iv+rToGIyHHgvwDvUO0nB/LTFIFvQNF//V3Avxp2/1Hp0d6vNdFfMpzkyWDmqH+eBpgqTW1LmsooERHGg3HqUX1Jm4x+gStHnKEpTbvJczyqfo1GeZpOHBGUpopc1YlrivY1z/wPOPzSoqBS81zRG9pxi6AVimJMtaPFcuDW+aIY3KFblra8yXOYfRzqzxfBcWW6CFJrh4v9+9IIRuzx2WqqyoXOBVxxmS4tzYHs55GPBcODGs/1OFY7xt99hc+vfOpRchX+a/JdvIGHOCkXcJ2Er+u1PC3ToMpPveHlO/EnmTXwHA9FSTUd9Pjdq+109ve7+BbopB1ccYdWK1RV5qP5YjpeizzPsWBsw8HrbtjNGdHdIiJMhBP8+t/UaWXXc1om+D4e527ncWI8HuUIf+VcyzPJcWY/fZF/9JqNL4d0xOHpRpWbwzLTMs+Uc57ZrDhRrlbVN8oikoUz4IVUx3f+/+aF+Q6ujNHWMhVpUXHqkB8fbFsuU6XqzDHpzFNPx2jkhwe3b8aJySpn6ikX3S7/ySvxpuRZXsFZ2nh8Rq7lQecG2slhSMeX3W9rK1f2XyML8QIfefgZfvXTT3C+eZ5D42P80++4m9fdVpz8BdnSthx76bVZ9spUgyo1aoPBvP5g0X4PFnaLqt6z2jYROScix1X1bC9APb/KfuPAHwPvUdXPLvrZ/dnbSER+A/jJLTz0LZdkyaBGheu4JFlCrvkg/aKTdgZt5w7K83E8HGcummMhXmCqVKxQibKIJEuG9sXdbZ7jEXoh9coM3e4zTPily/mo17yqWA58/uvFzuIUxZTSqCisNHFtEZC++EjRwmv6Jpi+uVgK3NddgLNfKbbXjsLYMRg7XuTDrjiY/R28QvGa6GZdJoKJFUvJ19IjueyWqfpVDlXHuNha4FJe5g+y7+KYnAeJuKRjqBuTp+P7elJkr+m/7pMswfeLGfZ6VF91yfgoOxjv5BuU5dkVe8U1kgZJnlByS3SzLlWvuqeC14PMczzOzTngTfOoU+Jr7nEmkhKpQMvrgiRoMs7Z+c3P5o2NHWI2muIEFzjmnGeWmwB31UCr250nbc/ihmOUNlA8arNOTJY5U09o5WNMuPPUnAX61bCHHbMrwrT7IhVp8c38RsiDwe2b8cC9t/LPf/dh8ugIrTDjD4KX8vvZ7YSkxG5GntbQZAYWVwPv3W87jAfj/Mipl/H2U7eRZAmdtAjmAzeg6ldHajneThMRyl6ZVtKi7JURpKhgGS8wFU5ZTuzO6/def1/v80eX7yAiAfBh4D8vL9a0KPgV4H7gq9t/yBvXT/PpF07rZkUf2P4FeCft4Dv+yBQt2glVv0rgBMxH80yGk0CxoizTjMANRjKAFRG8yiSt9ESRuyoedBtw9uEiiE1uKHYuTRQzrkmnWFY89wxceKy47ZpXQXVR67ksLYLf+WeL7SdPFTOuB1i/2BnKihaC/b6vVxuM9V2fml/jJ777O3jPf/sk4i2Q4XBGxlCqiJODepwY25sVbvcr13HxHI84i6n4FUpeiXpUp522geK9cq8EsAf3imsNullRrXDYSa+bdummXUpuiTiPccW9anViM1pOTEygWRnyMnhdFkpztMM5cGM0nUCz2pbM5v3E62/nIifxyDnkngMnRoDv/ZbhJ9FG4wx50sYNpwiW9T7dCQ/ceyu+4zGvU4gDE3IJyPEdGRocfttN49zkPgsIZ/Ib6L+tvP3brt3Ucdx/10kmyz5oibx7kiypgZMR4ZHFh9D4KMvL4/4vr7luW2ctPccb5AXNlGeYKc8wFowd6OC1rx+4QnGS9F1/kHfYLxphdsz7gNeLyOPAPb3vEZFTIvJrvX3eBnwX8A9F5OHeR7/y2m+KyCPAI8Ah4Bd29vDXrj+72m+Ls7gPbL+dXabZvq06fCXTpWm6aZcL7Qtc6FwgzmN8x0eQkZuJ9hwPRxwCJyAeP0oduWNPAAAgAElEQVR6+DbQDBynmGl97m+KXtLiFMuE87QIck9/oZiZrczADd+5NHiN28X95p4uZltv+M4DH7xCcW3biBtUvAold+nropN2EGRNr5eKX+GHX/lSat40ghYD/7kUX6NIXuKBN7xsm/4Ks1GBE5DkCaqKJx6BEwwqEcdZjG5y9dxOsauuK+imRbXC5evC0zylETfwxCPNU1R1UCjB7B0P3HsrZXcMTSbJoyNk6RhZOk4eHUXTScp+sCWzeT949/W84qW30c3LnJSLeE4DBf7wi2f4yJfPLNk3yRM69RfQvEs4foxgF5Yy3X/XSX7prXcRu0chh5pTx5OITJWHnr20ZN+PfPkMD58+z0n3eSINeT4rgtZvv3l6U/mvfT/35tsp+y4QQHKcvHMzeXQdpDMsXkAyVfH5lb9355b8TrMx/by6NE8HJ8Qxf4xMM+pRfc+cFPcDVZ1V1e9T1VtU9R5VvdS7/SFV/fHe1x9SVV9V71z08XBv2+tU9Q5Vfbmq/qiqNnfz71lNfybJc7zBBXecx4M+sFCcxxfPxh4k4+E4gRvQSTtUvAplt7yksNWo8aQYIMw1p1mZhJN397Y4RTB67mtw+nPw1KfgiU8WM7PdOhz+FrjmFPR6uZMlcP4b8Mx/L4Lfa14Fx19xefsBtxAtEOcxE6WJFVW6ozSi5JXWPCgrIvzM97+a0A0RJ0K8NkiCqMtbX3mjLR8eQYEboChJngzeO/spkP3b94LRGoIbIUlWjNouXxK8uBiEomSaMRFOjOwJwaxuaRErj8lwBlWoJ1vb1scRh798zuO1MsZxmWPKvcCFbJpOwoqiSHEW06k/h+BSGr92155X9991ki8/dhvpk5+m5jSoSoN6XuFDn30OuNyW6Jc+/hi+vsiEU+dcdow4K4o+PDM7PL93I8fR/z1n5ju4ImTqbLjHrNle/YIQruMSp3GRbx5MMBfN0U7btkrFbKlhxWb6RYoCJ6CbdumkHUI3PJCrJDzH41D5EFEakWlGnBXdBkZ1NtpzvEFhmWbSpFY9hnfylXDuUdC0CEyzHBAoT8L4ySKfVaTIcY2bRfuc1oVihnb8ZFHIyd/augh7Wa459bhedJpY1qs8zmIUXffz422vvJkk6/L//tWXuLjQ5fB4hf/9u+/g7a+8bSsP3WyR/iqM/jJiEcF3fAInQJCi1dgeWEZsAewq+jk0y5dXtJIWaZ7iiEOmGWPB2IEc2d0vdqpQzovzwjPlk9zAOa5zznJBbgT1VhRF6sZNdOEM4vqE0zfu6qz+7z3S4U2lCjVpUXPq1POiE8fi6sJn5lu8PHyaUBKeyq4Fwt7tWxPAwt4qZnTQ9U+AguCIQzftMlmaJHRD2kmbslc+kIGE2R6DirqLzsFxFg9m8RpxA9/xGQ92PhVjVPRzGaOsmFmretWRrTbqOR6uuJTcEqmmtJIWE9VDcNN3Q/sSNF6ELCpa5sRNuPhY8bGY6xdB7dQNUDq4/++rqUd10jxlqrqyNkGcxxueof+RV72MH7zrZtpZmyiNCL1w0xX5zfYQKVIIkjzBEQdHHFJNi3ZbXkiURuR+PvLnagtgh1ieQ9OXZMkg0TnXnKpfHVqd2Jjljk+Mcbpzgsh7lJt4ga+680R5yInJy4UScs2pzz9L3rmEG9QoT+xeT0WATl6lmU8w4S0w4cxyhgxwl1QXdp02t/jPkOYBz2Y3XL7dltMfSP2R3CiLqHgVmkmTNE+p+lWiLKKZNA90MGG2jqoSZ/GS2aI0T4vqw25AN+ui6Kot8A4K13GZCCdQ1ZF/HFzHHbQjgyLoTvOi3QeV6eIDil6vcbNYHpx0ihlYxyuqB5cmh1cWNgDMdecInGBoi5z+4M9GiAglv0TJL9FJO3hi4cUo8x2fdtoe5MGmeQpAxasMVq6M+oqp0Q6vd0n/JLh8ZrWRNIo8Li1mGkb9P9eMjp+69zZacpILjHFY6hx1zlIOsyU5tt20S7txBqIG4cQ1lINdfn6pw2x2CIecGfciIvGKXSr+Ga7hHJd0hrleqx3YfAsds3cFbkCmWVFVFCkuZhyPslemm3aJsmi3D9HscXEW00paKLpi9hXAF3+wdHjUihXtllEPXoFB0OM4TjFLrMWqtxVEIBwrCjZNXlv0ih07BuUpC16voBE36GZdZsozK7YleTIY/Nmssle22dcR1/9/7ufBZnnRcaO/hL/fZWGUWQA7RD+BefELuZt2SfO0WBwnQi3Yun6PZv+7/66T/Mz/9CoawUlKmnJ7+QI/9cZrePOdl4O+dtImmnsGH8GtHR+B2X2Hi3qEnICa1Bl35ija6RR++wvf4G73G5RI+VL2UsgvX0ie3OJerGbvGBTTyWJCr8iJ7a9Y8RyPelS3INZsmKoO2j4IsmTGKM5iRIV6XCfXfEWOnxlt/dnXfgqC53hEWTS4uDabc6l7Cd/xmQgnVmyL0uI9ud872exvg36weYLruCg6mIUN3ZBcc5JstIs52dDkEHEWD0q697WSFnEWE7gBFb9io7pm3d72ypfw8uk34z+ScE8Ykhy5xEK0wHg4zh9+6Vl+9ZN/wZ3R57jJW2Bsepo7drnQxsnJMrONw3TyCtPSYMKZpZ4f4uTEBB/+0vO890//kr/P0yzoGI9lt9BvaVP23W3rxWpG36CATtZlMpxcshxpKpxiLpqjETcISsGemBUyoyXKIhSl5teKYiS955BqUT0z0QRffSbDSZsF2oM8xxtcOLvikmlGK21Z6sEmRVlEJ+0wHU6vyG3MNR+sWBjV/GiztQZ5sFkymJDrz8b2J++iLBrp91CbgV2mfxJcPKobZVGRT6PFciVbOmw2wnVcJg7dSjR+jGr7Em79DAvRAr/5ha/ys3/0BaTzLDO0OJ+U+Xd/3V7RYmenPXDvraTuFPPZFBUiTrov4LoNWnGXf/nHn+UlfI0pafMlbkKTYkmSK8K/fcsdVnTpgCt5JXLNUVUCJxgsRxIRxvwxcs0H9QSMWY9u2sURh4pfWXJx1V8CqaqEXrgnqmialVxxycnxHZ9EE0peiSiNrA3XJtW7daBorbRcJ+2gqF3bHjC+4w+CVkecwerTfiGvOF+ZNjZKLIBdJs1TFF1y8usknaKCpl8emvhuzFpNhJPo0dtxHJ/y3DO068/yHz71BN2swTHq1LKMszJNIy7xSx9/7Oo/cBvdf9dJfuH+V3LBux7UZ0rqnHRPU0+ep5M/x6v1SZqU+UrycqB4veSqFryaoidgrxx/6PWWI/VOjr7rD6oS95csGbMWuebEebyiOwAUK6cGfQ2HbDd7Q391m+d45Jrj4Oyp3pSjRlWZ787TSlqUvfLQgZ1u2iVwAltZeMB4jjdYOuw7/pIlw6Fb9HQf5XO0BbDL9Ecc+jOwWZ4xH80PSvGPellpM9rGwjHKx15BY/wIUwvn8F58FLf1ONc55zhGA1WH0/lRyIMVLXZ2ww/efR2X/BvoaoUZ2tyg5xl363yrnuaavMFXuI44PTTY/4TlvhqKmdbADYiyaFBkp19gBy639mjGTZtZMWvWfw4Na13Xz5V0HddmX/ew/hJWRxwEIdMi/9UC2I1pp23iPMZ3fSaCiRXXsEmekGlmr5kDqD9g0Q9gM83INQeKVVT9IoyjyqKxZZIsWZL/2kpadNIOE8GEvcDNpjniMFWeJjp5N48vOPzhx7/GS/M5bk5bHEtjLjlVnstPgPojEww+Va/weH49pUy4mVnemj7GD6WPcc6t8dnsDsiLZUe+K5b7agYCNyDXvLg4cgK6aXewzXVcakGNOI9ZiBd28SjNXjLoU7ksLyvJkyLAEWz2dY/zHR9X3EErwzgvapIsHgAza6OqdNIODg6BGwy9hr3SoJDZ33zHR5BBAAssWUa8uAjjKLIAdpFh+a/9qm1joS0dNltjKpziry9O8FvPpTjxHBfTY8R5GUdSHucE3XyMsu+PTDDoapmv6M08w1EyDTgh88w7Ln/EK4iSw0BRRKUaeLZ82Awsnnntt9ZZXE207JUH/WFHvdqhGQ2r9amM0qioeu2GS/rCmr2p7JUH1VFzzUF76V22WmNd2ml7EHw44gztbBBlUTFoYMWbDiTP8QapF8CSJcNlr4yiSwafR4kteF9kef5rv3rmofIhyw0wW8Z3fT7013M0s1t5O1/kO/wv4ZHREpdH9FqOjU3yrjeMTiGkTB262SSf9V7CCeb5vDo87VZI8hJklwtC1DsWhJjL+oUgoiwqKogmxcVSxbnc2qTslWklrZGvdmh2X78/+/JZJFWlm3UHvdvtXL33lbxS0ec3VxxxyMkv5+rZ+8SatJM2raQ1KNRTcSsrqr7nmpPmqRVvOsA8x6ObdgctrBYHsL7jD1pZVfzRa0lm7/SLLM9/nevOISJMhpO7eVhmH3rxkocEE3yEV3OLzpKIy1f0GAkBD//kG0fqJH1yssyZ+Yym5HxTaojXAVXy6Cj91jlg+a9mpdANaSbNQV/H5Xlse6Xaodl9/d7By/tUpnk6aH1nyyD3h8XvC4Eb0EmKPLx+Lqcp0t3qcZ2xYGzwvE/zlFbSGlTkDpwAVUWQobOvg8J6Q1Y1mIPBd3w6dAazsMuLNpXcEs2kOagvMEo2tYRYRKZF5BMi8njv89SQfe4Ukb8RkUdF5G9F5O8t2vYBEXlaRB7ufdy5mePZrMX5r1mesRAvMOaP2Rum2XInJsfI8yoXnSqfyb6VzyevIHE8jtYmRu759sC9t1L2AzSrofkYeXyEvHsD6OUTovV+NcMs7icXuiFxFq9YBtivdrh4ebExy3XSDoETrLiIivN4cO62AHb/6KcduOIOZg4tD7Z4DBbiBepxnVxzWklr8HmuOzdIgxsPxgncgESLPp/Dgo9+6oYFsAfXIPc1S4oWVsvyXfvvqd1s9JYRbzYH9t3Ag6p6C/Bg7/vl2sA/UNXbgTcCvyIii6c0H1DVO3sfD2/yeDZsef7rbGeWXHOmSiticmM27YF7b6UsE4CD49dxgkuEnsNPvO7u3T60Fe6/6yT/9i13cHJiHMmqnBw7xI++5gZOTpYRihla6/1qhvEcb0lBlmHtMPpBbitt7cYhmj0gzmJyzYfmt/a3Be7K4NbsXYPBCAXp1VnozyweVKrKQrwwyEmseBXSPGW2MztYLjwVTjERThStytI2vuMPnX0FBte8y5cWm4PDdVxccQc55/2l+ou399vejVol8M0uIb4P+J7e1x8EPg28a/EOqvrNRV+/ICLngcPA/CZ/95ZanP+aZAmNpEHVr47kum+z9/WDvV/8uMeLzVmOjgf8xOvu4m2nbtrlIxvu/rtOWoBqNqSfz+biIsigqFOf53hU/Wqxj7iWj2VW6KSdoirmshlWVSVKIxCrorrfLL6w7ufSQxF0HdT/636u92Q4WQwIqhaVuXGoBbUl+d9RFpFrzlgwvACpahGorBbcmoPDd33iLKbiFfFOphneovBwLBjjUvcSzbg5UpN6mw1gj6rq2d7XLwJHr7SziLwaCIAnF938XhH5WXozuKoarXLfdwLvBLjuuus2edgrLc5/rXfrpHnK4fLhLf89xvRZUGgOgpJbBLBRHq2a71r1q2Sa0UpaBE4wcsvoze7JNSfO4qIv4bKZoiRPBlVUD2pQs5+Fbkgn7VDxKkRZVBTsSrsH7v9aVYmyiFbSwnO8wQCgiDBdml6xf5IlNJMmrrirPladtIOiB+6xNCv5jk837aIU6T1Zni0ub4IjDhWvMnK5sFddQiwinxSRrw75uG/xflokNq1a41xEjgP/BfhfVQdrQH4a+BbgVcA0y2Zvl/3896vqKVU9dfjw1geW/RyaNE9pJA1KXslGpowxZpNcxx30gQ3cYNV81zF/DFdc6wu7BdZSn6K3X7aoBsXHFt1+o4h8TkSeEJHfFZFda4IeZRGKDl0+3EmL4iMlt2TVh/ch3/VRikrEIoKigyXjB0WcxVzsXGQhXsAVl4lg4or7Z3nGfDSPIEyEw/fNNaedtgnd0AYLzSB1MtNsaLFFWFrPYlRcNYBV1XtU9eVDPj4KnOsFpv0A9fywnyEi48AfA+9R1c8u+tlntRABvwG8eiv+qPXq578GTjCo4Fb1qvbCNsaYLRB6IZleDlqHzcKKFJUyM81WVEI067aW+hQAnUU1KN686PZfBH5ZVV8CzAE/tr2Hu7pu2sUVd0WhmVxzumkXx3Gs9+s+1a84nWlG6IYoSq75SF1Eb6d+zqsjDpPhJFOlqSvOfuWa04gbAEyGk6sO6nTTYimypcgZKNJ4BCHNUzzxlpyrF+/Tb6kzKjZbxOljwDt6X78D+OjyHXojtx8G/rOq/sGybf3gV4D7ga9u8ng2JMkTtPevk3bwHM9e2MYYs0VKbglBBiO8q1UT7S9ns2qjm3YfRV0Kep/vX+sde+fj1wH98/W67r+Vcs2LGdYhAWo37dJNu5Tdsi2D3KdEZNDHtOyVccUl04xm3KSdtHf78LZdK2kNZpwdceimXdpJe8lHfza6GTe52LlInMdU/eoVA90kTwatiowBBitQ+5+XdwuA4vw8SoXUNhvAvg94vYg8DtzT+x4ROSUiv9bb523AdwH/cEi7nN8UkUeAR4BDwC9s8ng2pD9dnmQJWZ5Rckt2QjTGmC0iIgRuULTTccJVlwG6jjtyo7x71FrrU5RE5CER+ayI9IPUGWBeVfvT4M8Dqybri8g7ez/joQsXLmzJwff1BzKW936FIoDtBza2Wmr/Ctxg0KOyX9XcFZdm0hyZC+ntEGcxjbhRtB5DudS9xEK8QDNpLvm41L1EPaoPlgRPhpNXnYBJ8mRJIT1jFgewAKmuXAXVfx8elQHmTSWNqOos8H1Dbn8I+PHe1x8CPrTK/V+3md+/VeIsLqbPNS1GpVx/ZJKUjTFmPyh7ZaKoqIypFEVJhtUZCN1w0NvQkc2Ose5fIvJJ4NiQTe9Z/I2qqoisVp/ielU9IyI3AX/RG1Cur+c4VPX9wPsBTp06tWodjI2I83hwTl6unxNYC2pb+SvNiAncIrWrm3YZC8aY684NtqV5ui8DsTRPB+1yqn6VyXCy6IPsBpTc0pJiO/W4TpInVLzKml4L/Rm0YYNC5uDyHG/wvILiObh8hr6/1DjJE0rsftrGga960C8l3s+tGFaq3xhjzOYEbkDoFrOvqkUxlmEBbP+CdbUA1xRU9Z7VtonIORE5rqpnr1SfQlXP9D4/JSKfBu4C/hCYFBGvNwt7DXBmy/+Aq0jyhDiLhy5zzDWnm3WZCCaseNM+5zv+YFVGxa8M3kNgf84kZnnG6cZpAEp+iVpQI3CDJX9nvy+u4zocKh9a189PsmLFoS0fNostfh/t58Mu11/SPyozsAd+eLuf/5rmKejlipnGGGO2Vr8nYb81yrA8G9/xccUt+nuajVpLfYopEQl7Xx8Cvh34Wq+jwKeAt17p/tspyRLmunOo6qA34WL9IjQ2wHEwlNwSSZ4MZoUUHUw+7Dfn2ucGrYICJ9jS57iq0k7bxXusrTI0i/iOX9SnyOPBcuJhAjcg02wklu9bAJsnJFmR0N7/sHwaY4zZeo44g5kERYeW6wcoeSXiPB7absesyVrqU9wGPCQiX6EIWN+nql/rbXsX8C9E5AmKnNj/tJMH369SPVOeGXo+7qQdACu2eECEboggtNP2kh6oq71/7FX1qE49qjNVmuJI5QiT4eSK3seb0Uk75JpT9atb9jPN/hG4AXF25QC2P3M/CrOwB37tTZzFxFlMzS1yB/bbchRjjBkloRvSTbukeUqURUPfc/t5sFEWUXEsSFmvNdan+GvgjlXu/xS71NYOGCwdXi0HupN28MSz8/UB4TouJa9EJ+1Q8So44gwusKMs2hdpX1EWcalzicANOFw+vOUzpP3er4ET2OvGDNU/N2d5hqJkebbieThKebAHegZWVYtlanI5gXk/vBEaY8yoCt0QR5zi/XeVasOe4+E7Pt2su8NHZ3Zbvy/7lXL0OmmHsm/Lhw+SildBEOa6c6R5UXDTwaEe1emme/99ohE1SPKEmXBmW5b39lvuVAObfTXDBU6AIIPlwcP6wY5SHuyBDmCTPKGbdYuRXhwEsfxXY4zZRv2WOjk5WZ4NioosF7ohaZ7uu2WC5sr6y4dXmyWKsmhQddUcHK7jMlWawnO8wQV2xa/girvnA9goi7jQuUA7bdPKWtSj+pbmGOaa00k7hG5oxZvMqvrn5n7gOup5sAc+gI2yiKpXJdFixHcr8w2MMcasVPEqg1Hc1WZZS14JQfb8xalZnyRLEGTVC+1W3AKg6tlM0kHjOR4Vv1KsmFOlk3b2fL78QrTA6YXTzEfzTJemGQ/GBz1gt0o37aKo5Yybq1pSJG1IL9j+PrD7ebAHOoBtxS1EBMdxyDWn5O1+XyNjjNnvfNfHd3wyzYiyaGg14n7Bp9W2m/2p6leZLK1evKadtvHEo+Tb+fog6i9zdMVdMgu0WjrCKIuzmNON0zTiBkerRzlRO8FYMEbVrxJl0aBY2WZFWYQrrs2+mqvqp1Hmmq86KLQ4D3Y3HdgAVlVpJA1CN0RVrf+rMcbsoP5MSjftDpaNLlf2ykXLnVW2m/2nn2O1mnbStvzXA6y/zBGhaLeVRXji0U7bu76kcb3Ot85Tj+ocqhziWOXYoBdnxS9WqDTiBgvxwqZ+Rz8Nw1pOmbVwHXcwOLTaEuL+a3C3B40ObADbTbtFhUuvMmiGbcuHjTFmZ5S9MiW3RDftrrpMOHADHHFsGbEBoJW0SDWl5td2+1DMLqr4FVSVPM/JNcd1XHLNaSbN3T60NVuIFzjXPsdYMMaJ6okVy3snw0nKXnlwrboRuebMR/M44tgKQ7NmgRugKLnmV8yDvdL2nXBgA9hGUuQXBE7xH2WjU8YYs7OqQRURoRk3V10mXHJLRFm052ZXzNZbiBYQhPFgfLcPxewi3/GpBTVUilYf/aJe3bRLParv9uFdVTtpM9uZBeB49fjQqsMiwlgwhisuzXhjgXkjbqCqTIQTq7akMmY53/FxxSXV1Yso9gve7mYe7IF9Rk+H05ysniTRhMAJLDfAGGN2WNkrU/NrtNLWqrMM/ZkDm4U92FSVhXihuKjfhjYjZm8pe2VCNyTXnCiN8BxvkDu628VlrqQ/UzzfnWc8HGe6PH3F/WtBjUyzdQexWV7UFyh5Jbu+NeviO35R7TvPV30tuY6L53i7uoz4wAawnusReMUUuFVmM8aY3TERTpBrTr07fOak3xN2qwqamL2pETfINGMimNjtQzEjYiwYI/RCGkmDF1svkmQJjjgj+16Ra04jbnChfQHf8TlePX7VmdHQDSl7Zdppe13BQistqnVbuymzXq7jDp6XVyrUFLohSZ7sWgXwAxvAQtEM3RV31X5zxhhjtlfJK1HxKszH86ueCEteiUyzXa96aHbPXHcOz/GoBZb/agqOOMyUZjhcOgxc7iEcZ/HIVS5P85RL3UvMdeeIs5jp0vSan8s1v4bv+CxEC1fNOeyvVOimXSpexVYrmA3xHR+EK+a59gvf7tYs7IENYOMsJs1Tm301xphdNl2eJtOM+Wh+6PbQDa0n7AHWTbq00hZT4ZQVWzRLiAjVoErZK5PmKaqKoqv2l94NaZ4yH82jqsRZTDWocrR6dM33FynyvkWEhXhh1eA8yzNmu7N00y5Vv2qDPWbDAjfAE480T1ddRuw53q4uIz6wAWyap0VlNtcqsxljzG6q+TXKXpnZzuzQWVjrCXuwzUVzOOIwGU7u9qGYERS6IY44OOKgFO8PraQ1Eu8V/eAVivexVFMOlw+ve2bUdVzGgjHSPF11iXS/aNNUOEXVr2762M3BFbohruMO2jCtpuSWSPJkV/LOD2wAW/ErzJRmbDTXGGNGwNHKUVJNudi5OHR7vyfsbveeMzsr15xW0qLiVfBdK0ZjVur3pXTEwcEh15wsz3Y9FzbXfFAVOXAD2kmbklfacBuo0A0J3ZBm0qSdtAdVl+e788XS5Dym6lftdWI2zRFn0KXlSsFp2SvjijsYPNlJBzaABSx4NcaYEVHxK4wH48xHw3Nh+xeoFsAeLO2kTZzHjIfWOsesrl+sqF+AJtecdtretVnYJE+Y686Ra07ZLROlEYoy5o9tKsAcD8bxHZ9m0mQhXiDJExRFECpexdLizJYJvRAHhyRPSLLhs7AiMqiU3c9B3ynejv42Y4wxZhUzpRkW4gXmo3lmyjMrtpfcEu20TZZnVpzkgGjEjaJFimdLIs3qfNcndEPiLCbTrGgD0gtid3o5bZqng5nXMX+MZtokyiICNyD0wk39bBFhMpwkyRNExFrkmG0TuiGBG9BKWiR5surAS78nbJqng8JOO+FAz8AaY4wZHWW/TNktM9edG7q93xPWZmEPhn6+X9kt27JIc1U1v4bruHTTLt20i+/4tJLWji4lVtVB8DoVTpFoQpRGuI476Hu9Wf0l0xa8mu3kiEPZL5NpdsUCiiKCK+6qs7TbZVMBrIhMi8gnROTx3uepVfbLROTh3sfHFt1+o4h8TkSeEJHfFRHrZ2OMMQfYVGmKOI9pxI0V26wn7MESpRFxHm/JRb/Z/1zHZSqcouJVaKdtfMfHE49G3Lhq+5mt0kyaZJoNqgZ30y6ZZviOz3gwftW+r8aMkopXwRWXZtK84nJ83/VJdWdeY32bfSW9G3hQVW8BHux9P0xHVe/sfbx50e2/CPyyqr4EmAN+bJPHY4wxZg8bD8bxxONS59LQ7YOesDs82ruXrGVwWUS+d9HA8sMi0hWR+3vbPiAiTy/adufO/xVQj+u44lo7ELNmIsJEOIGizHXnyDQDhXba3vbf3U7axYoBr0zgBnTTLnEW4zkeFa9idVfMnuM5HtWgSjttX7GYk+/4V+wZux02G8DeB3yw9/UHgfvXekcpXsmvA/5gI/c3xhiz/ziOw1RpilbaopW0Vmwf9IQdoT6PI+iqg8uq+qn+wDLFubgN/PmiXR5YNPD88GfAZ4UAAA/hSURBVI4c9SJJltBMmlZ92Kxb6IaDLhML8QI5eTETOqQ43FZpxk2aSZPQDan5NVSVdtomyRMCN6DslbftdxuzncaDcXLNaSbNVffxnKKk0l4KYI+q6tne1y8Cq3VmLonIQyLy2f4ILzADzKsO5pyfB06u9otE5J29n/HQhQsXNnnYxhhjRtVUOIXneFxsX1xxQrSesGuy3sHltwJ/qqrbP021Rv0KrlOloZlJxqxKRDhUPsREOIEgJGlClmfbljuf5AnttGiRMxFOICJ00g5RGuG7PlW/arOvZs8qe2VKbomFaGHVfXzH3/EuAVcNYEXkkyLy1SEf9y3eT4sridWuJq5X1VPAjwC/IiI3r/dAVfX9qnpKVU8dPnx4vXc3xhizR3iux0xphjiPacYrR31LXolc8ys2WD/g1jq43PfDwG8vu+29IvK3IvLLIrJqacntGFyO05hL0SVqfs3agpgNERFqfo1aUCPKIzppZ1tWbagqjbiBI84gV7tf/TjLM0I3pOSWtvz3GrOTJsNJOlln6Pm4r18FPNd8R47pqgGsqt6jqi8f8vFR4JyIHAfofT6/ys840/v8FPBp4C5gFpgUkX4rn2uAM5v+i4wxxux5Fb9C4AS00taKfNfAKXrCHuRlxFs0uNw/d98BfHzRzT8NfAvwKmAaeNdq99/qwWVV5XynuJQ4VD606Z9nDq5+EOu7PvWoTj2qb/kSx3baJs1Tan5tUKCpk3aK3FfXcl/N/jARTuA7/mBlzDAlr4SiOzYLu9klxB8D3tH7+h3AR5fvICJT/dFbETkEfDvwtd5J9VMUS5dWvb8xxpiDJ3RDyl55kAu5+KTZbyMRpQd3GfFWDC73vA34sKoORglU9awWIuA3gFdv59+yWCspcp+nwqlB2yRjNqriVzhRO0E1qHKpc4mFaGHLVm6keUoraVHySoPnaq457aSNoviOb89hsy+4jstkOEk7bdNOhmea+I6PK+6OdQnYbAD7PuD1IvI4cE/ve0TklIj8Wm+f24CHROQrFAHr+1T1a71t7wL+hYg8QZET+582eTzGGGP2AUccQi/Ed33iLGY+ml8SxFa8CpPhpM1uDHfVweVF3s6y5cOLgl+hyJ/96jYc41Ce41H2ykyEEzv1K80+5zs+h0qH8ByPS9El5rvzWzLw1YybS5YOQ1GJOMkSHBxKXsna5ph9oxbU8ByPuWhu1YJoVb9KmqdX7Bu7Vbyr77I6VZ0Fvm/I7Q8BP977+q8plicNu/9T7ODIrjHGmL2j7JWJsoiSW6KbdVmIFgZFUvpVD81Q7wN+T0R+DHiWYpYVETkF/GNV/fHe9zcA1wJ/uez+vykihwEBHgb+8c4cdjGDVfErhO6qabfGrNt4OM5kMjkYDKsFtU1VBo6zeNCjuB+kZnlGO2kXtwc1619s9pWyV2YimOBi5yJz7hwz5ZkVA8glr0Q7bdNKWkXHgG0cYLYrAGOMMSMpcItc11xzxoIxGnGDTtqxwj5XsZbB5d73zzCk+r+qvm47j+9KKn6Fsle2mXWzpTzHYzKcZCFaoJ22WYgWKLmlDT/P2kkbR5wlQXAzaRLlEaEXMh6M23PY7DtTpSmiLKIe1yl5paE9umt+bUfa6djaBmOMMSOr7JWJ85jACfAdn3baPrB5rweFXfib7VDxi57CDg7ttL3hInBJlhDn8ZICTd20S5RFODgETkDgBlt56MaMBNdxB+2pFqKFoYFq4AZU/O0vXmYBrDHGmJHVb0HRzbpU/Sq55jtWJMIYs3/4jk/Fr+A4Do2owdnm2VVz+a6kna6cfW0lLVQV3/U3tTTZmFFX9avUghqNpMF8NL9rx2EBrDHGmJHlOi6BE9BJOwSuzcIaYzZuzB9jKpwi9ELqUZ3Z7uy67p/kCVEWLVnmHmcxmRaBsCAWwJp9TUSYLk1T8StFPmx3bld6slsAa4wxZqSVvBK55sRZUTQl15xW0trtwzLG7DEiwlRpiqOVoyjKhfaFdc3CtpP2iiC1nVweULP8bXMQeI7Hseoxyl6Zc+1zvNh8kUbc2NFjsADWGGPMSAvdEEccOmkH3/UHlQ7jLN7tQzPG7DEiwkQ4wZHKEepxnfPtK7VJvizJitnXil8ZVB6Osog4j1F0xbJiY/Yz3/E5UTvBTGmGRBPOts7yfON5mvHSvu3bxQJYY4wxI01EKLkl4iwuKhL7Y7jishAv7MiJ0hizv4gIR6tHqXk1nl14loVo4ar3aSQNHHGoeEUVdFWlGTeJsghBqPpVXMfd7kM3ZmT4js/hymFOVE9Q82t0sy7PN5/nTPPMtqf5WABrjDFm5JW8EorSSlqDGZSqXx3MhBhjzHr4js/NEzfjiMNT9aeuGMS2kzZpnlLza4Mlwp20M6g8XPJK1t7LHFglr8SJ2gmuG7uO6dI0wvYvo7czvzHGmJHnOR5lr0wn7ZDkyeB7Y4zZqGpY5bqx68jyjBdbL9JO2iv2yfKMdtrGd4r0BYBcc9ppEdQGbkDNX9kP05iDJnADjlSOcLx63NroGGOMMVA0SHfEoRk3d/tQjDH7xJHqEWbKM9TjOi80X1jSpivXnHpcR1WpBZeD1EbcoBW38ByPil+xpcPGLLITrwdv23+DMcYYswVEhIpXoZkUeWehG+72IRlj9jhHHE7WTpLmKRc6F7jQuVAshSxP00k7pHnKZDiJ7/hAsZx4vjsPUvTErPrVXf4LjDl4bAbWGGPMnlH2yrji2iysMWbL+K7PjRM38pLJl1DxKjzffJ7Z9ixZnjEZThK4AQDdtMuF9gXiPGYynGQ8GN/lIzfmYLIZWGOMMXuGiFALatSjOp20Y3mwxpgt4TouhyuHGQ/Gebr+NPWozjjjlNxSseojjWglLRTlcLnYz3q+GrM7LIA1xhizp4RuiO/4tJIWJbdkF5HGmC0TeiE3jN/ApegSC/HCoH2OqlLxKsyUZ5bkwxpjdp4FsMYYY/acml8j1dSCV2PMliv5JU74JziSHaGTdnAdl9ANrViTMSPCAlhjjDF7ju/6+Pi7fRjGmH3Mcz3G3LHdPgxjzDJWxMkYY4wxxhhjzJ5gAawxxhhjjDHGmD3BAlhjjDFmHxGRHxKRR0UkF5FTV9jvjSLymIg8ISLvXnT7jSLyud7tvysiwc4cuTHGGHN1FsAaY4wx+8tXgbcAf7XaDiLiAv8B+H7gZcDbReRlvc2/CPyyqr4EmAN+bHsP1xhjjFk7C2CNMcaYfURVv66qj11lt1cDT6jqU6oaA78D3CdFWefXAX/Q2++DwP3bd7TGGGPM+mwqgBWRaRH5hIg83vs8NWSf7xWRhxd9dEXk/t62D4jI04u23bmZ4zHGGGPMmpwETi/6/vnebTPAvKqmy24fSkTeKSIPichDFy5c2LaDNcYYY/o2OwP7buBBVb0FeLD3/RKq+ilVvVNV76QY1W0Df75olwf621X14U0ejzHGGLPvicgnReSrQz7u28njUNX3q+opVT11+PDhnfzVxhhjDqjN9oG9D/ie3tcfBD4NvOsK+78V+FNVbW/y9xpjjDEHlqres8kfcQa4dtH31/RumwUmRcTrzcL2bzfGGGNGwmYD2KOqerb39YvA0avs/8PA/7PstveKyM/Sm8FV1WjYHUXkncA7e982ReRq+T2j7hBwcbcPYo+xx2z97DFbP3vM1me/PF7X7/YB7LAvALeIyI0UAeoPAz+iqioin6IYcP4d4B3AR9fyA7/4xS9eFJFnt+uAd8h+eT7vJHvM1s8es/Wzx2x99svjNfTcLKp6xXuJyCeBY0M2vQf4oKpOLtp3TlVX5MH2th0H/hY4oarJotteBALg/cCTqvqvrv637H0i8pCqrtrewKxkj9n62WO2fvaYrY89XqNHRH4A+PfAYWAeeFhV7xWRE8Cvqeqbevu9CfgVwAV+XVXf27v9JorgdRr4MvCjqw0u7zf2fF4/e8zWzx6z9bPHbH32++N11RnYKy1TEpFzInJcVc/2gtHzV/hRbwM+3A9eez+7P3sbichvAD+5xuM2xhhjzBCq+mHgw0NufwF406Lv/wT4kyH7PUVRpdgYY4wZOZst4vQxiuVFcPVlRm8HfnvxDb2gl17Z/vspetcZY4wxxhhjjDErbDaAfR/wehF5HLin9z0ickpEfq2/k4jcQFEs4i+X3f83ReQR4BGKtdq/sMnj2Uvev9sHsAfZY7Z+9pitnz1m62OPl9lP7Pm8fvaYrZ89Zutnj9n67OvH66o5sMYYY4wxxhhjzCjY7AysMcYYY4wxxhizIyyANcYYY4wxxhizJ1gAu8NE5IdE5FERyUXk1LJtPy0iT4jIYyJy724d4ygTkZ8TkTMi8nDv401Xv9fBIyJv7D2PnhCRd+/28ewFIvKMiDzSe149tNvHM4pE5NdF5LyIfHXRbdMi8gkRebz3eWgrNWNGmZ2bN8fOzWtj5+b1s3Pz1R3Ec7MFsDvvq8BbgL9afKOIvIyikfztwBuBXxURd+cPb0/4ZVW9s/exogXEQdd73vwH4PuBlwFv7z2/zNV9b+95tW97p23SByjenxZ7N/Cgqt4CPNj73pi9xs7Nm2fn5iuwc/Om2Ln5yj7AATs3WwC7w1T166r62JBN9wG/o6qRqj4NPIH14TMb82rgCVV9SlVj4Hconl/GbIqq/hVwadnN9wEf7H39QYqWaMbsKXZuNjvAzs1mWxzEc7MFsKPjJHB60ffP924zK/0zEfnb3pKJfbUkYovYc2ljFPhzEfmiiLxztw9mDzmqqmd7X78IHN3NgzFmi9n76drZufnK7Lm0MXZu3ph9fW72dvsA9iMR+SRwbMim96jqR3f6ePaaKz1+wH8E/jXFG9q/Bv4d8I927ujMPvYdqnpGRI4AnxCRb/RGNc0aqaqKiPVmMyPJzs2bY+dms0vs3LxJ+/HcbAHsNlDVezZwtzPAtYu+v6Z324Gz1sdPRP4/4L9t8+HsRfZc2gBVPdP7fF5EPkyx3MtOkld3TkSOq+pZETkOnN/tAzJmGDs3b46dmzfNnksbYOfmDdvX52ZbQjw6Pgb8sIiEInIjcAvw+V0+ppHTexH2/QBF4Q2z1BeAW0TkRhEJKAqQfGyXj2mkiUhVRMb6XwNvwJ5ba/Ux4B29r98B2EyW2U/s3LwGdm5eEzs3r5OdmzdlX5+bbQZ2h4nIDwD/HjgM/LGIPKyq96rqoyLye8DXgBT4p6qa7eaxjqj/W0TupFim9Azwv+3u4YweVU1F5J8BHwdc4NdV9dFdPqxRdxT4sIhA8b74W6r6Z7t7SKNHRH4b+B7gkIg8D/xL4H3A74nIjwHPAm/bvSM0ZmPs3Lxpdm6+Cjs3b8j/364dnAAAwzAQo/sPna7Q76XSEubAtvnBj9t8ZlZdogEAAFjKhRgAAIAEAQsAAECCgAUAACBBwAIAAJAgYAEAAEgQsAAAACQIWAAAABIuyp29vCMDl8cAAAAASUVORK5CYII=\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(16,9))\n", "for _ in range(3):\n", - " samples = model.predict_f_full_cov(Xs_augmented, 1)\n", - " sigma = np.diag(samples[1][0,:,:,0])\n", + " samples = model.predict_f(Xs_augmented, 1)\n", + " sigma = np.diag(samples[1][0,0,:,:])\n", " plt.subplot(221)\n", - " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].reshape((Ns,)), color=cols[1], alpha=0.3)\n", - " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].reshape((Ns,))+2*np.sqrt(sigma)[:Ns], color=cols[2], alpha=0.1)\n", - " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].reshape((Ns,))-2*np.sqrt(sigma)[:Ns], color=cols[2], alpha=0.1)\n", + " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].numpy().reshape((Ns,)), color=cols[1], alpha=0.3)\n", + " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].numpy().reshape((Ns,))+2*np.sqrt(sigma)[:Ns], color=cols[2], alpha=0.1)\n", + " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].numpy().reshape((Ns,))-2*np.sqrt(sigma)[:Ns], color=cols[2], alpha=0.1)\n", " plt.subplot(222)\n", - " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].reshape((Ns,)), color=cols[1], alpha=0.3)\n", - " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].reshape((Ns,))+2*np.sqrt(sigma)[Ns:], color=cols[2], alpha=0.1)\n", - " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].reshape((Ns,))-2*np.sqrt(sigma)[Ns:], color=cols[2], alpha=0.1)\n", + " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].numpy().reshape((Ns,)), color=cols[1], alpha=0.3)\n", + " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].numpy().reshape((Ns,))+2*np.sqrt(sigma)[Ns:], color=cols[2], alpha=0.1)\n", + " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].numpy().reshape((Ns,))-2*np.sqrt(sigma)[Ns:], color=cols[2], alpha=0.1)\n", "\n", "#plt.title('2 layer DGP')\n", "plt.subplot(221)\n", @@ -423,32 +481,36 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/home/aboustati/miniconda3/envs/gpflow-v1/lib/python3.6/site-packages/matplotlib/cbook/deprecation.py:106: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", - " warnings.warn(message, mplDeprecation, stacklevel=1)\n" + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:6: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:8: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6oAAAIMCAYAAAD8TlFZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4xLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvAOZPmwAAIABJREFUeJzs3XuUVfV9///nmwExpQbUAS9gRCOC+NVEww9sRL8NuSi1EVMTgnap+f0IaoGliUkTqVURTFFrYvUL1ktxefnWjDSuBFaV0KjpUpJIgqGJQQelBCvemCNqjApy+fz+2AdnGAbmes4+c87zsdas89777LM/b8+asPOavfdnR0oJSZIkSZIqRZ+8G5AkSZIkqSWDqiRJkiSpohhUJUmSJEkVxaAqSZIkSaooBlVJkiRJUkUxqEqSJEmSKopBVZIkSZJUUQyqkiRJkqSKYlCVJEmSJFUUg6okSZIkqaL0zbuBlurr69Pw4cPzbkOSVCWeeuqpQkppcN599GYemyVJPamjx+aKCqrDhw9n5cqVebchSaoSEfFC3j30dh6bJUk9qaPHZi/9lSRJkiRVFIOqJEmSJKmiGFQlSZIkSRXFoCpJkiRJqigGVUmSJElSRTGoSpIkSZIqikFVklRZHpyZdweSJClnBlVJUmV4/GaYPQievg9uGJl3N5IkKUd9825AklTjGpfDor+CHVuKK+rgf38r15YkSVK+DKqSpHwUCrDwz+C9jc3rjjsPzp6fX0+SJKkiGFQlSeV32wR49anm5SHHw/Qn8utHkiRVFIOqJKl8Hr8ZHrsaSNnyvgfCV38J9fW5tiVJkiqLQVWSVHqFAtz5CdjyZrbcpx9M/hGMGp9vX5IkqSIZVCVJpfXgzGwm351GT4bJd+bXjyRJqngGVUlS6Vw/onmypP6DYNpTXuYrSZLaZVCVJPW8pkZYcBIf3Is67hKYODfXliRJUu9hUJUk9awVC2HpZVkd/WBGo2dRJUlSpxhUJUk9p+X9qH9yMHxrTb79SJKkXqlP3g1IkqrEomnNIfWwkw2pkiSpyzyjKknqvvvPg+eWZPXRZ8K59+19e0mSpL3wjKokqXuWXtkcUkdPNqRKkqRu65GgGhF3RcTGiPhdi3UHRMRPIuL54uv+PTGWJKmCrGqAFbdk9dFn+nxUSZLUI3rqjOrdwOmt1l0OPJpSGgE8WlyWJFWLpkZYfFFW1x/rmVRJktRjeiSoppQeBza1Wj0JuKdY3wOc1RNjSZIqQKFQfE4q8KEhMPPn+fYjSZKqSinvUT0opfQKQPF1SAnHkiSV04KRQIK6feHbz+fdTc2JiNMjYk1ErI2I3a5Yioj+EfFA8f0VETG81fsfiYg/RsQ3y9WzJEmdkftkShFxYUSsjIiVTU1NebcjSWrPdw6FtA2ogytfy7ubmhMRdcACYCIwGjgnIka32mwq8EZK6SjgJuD6Vu/fBCwtda+SJHVVKYPqaxFxCEDxdWNbG6WU7kgpjUkpjRk8eHAJ25Ekddt3j4Wt72T1zOfy7aV2jQXWppTWpZTeBxrIbrdpqeXtNz8APh0RARARZwHrgNVl6leSpE4rZVBdAlxQrC8AFpdwLElSqd0yFt7ekNVTHoL6+nz7qV1DgRdbLG8ormtzm5TSNuAt4MCIGAB8G7imDH1KktRlPfV4mu8DvwBGRsSGiJgKXAd8NiKeBz5bXJYk9Ua3ngKb1mT1pNth1Ph8+6lt0ca61MFtrgFuSin9ca8DeFuOJClnfXtiJymlc/bw1qd7Yv+SpBzdMrY5pE78HpwwJd9+tAE4rMXyMODlPWyzISL6AgPJZucfB3wxIm4ABgE7ImJzSml+yw+nlO4A7gAYM2ZM6xAsSVLJ9UhQlSRVoUIBbjsethXvSZ0wB8ZNzbcnAfwKGBERRwAvAVOAc1tts/P2m18AXwQeSykl4JSdG0TEbOCPrUOqJEmVwKAqSbXkkXnw+//M6mFjYcxfw+BRu25TKMD9f9F8FhXgyw1wzMSytak9Sylti4iZwDKgDrgrpbQ6IuYAK1NKS4CFwH0RsZbsTKqnwSVJvYpBVZKqXeNy+LezYfvmXde/9CSsuGXvn+2/P8xaX7LW1DUppYeBh1utu6pFvRn4Ujv7mF2S5iRJ6gEGVUmqZrdNgFefal7uOwD+9KCsfm8TbH0Xdmxl17l4Av7kIPh/F+9+tlWSJKkMDKqSVK2uOxI2v57VQ46H6U/k248kSVIHGVQlqRrNOxy2vJnVk253pl5JktSrGFQlqdrcMLI5pM5Y4eW7kiSp1+mTdwOSpB506ynw7qtZbUiVJEm9lEFVkqrF/efBxt9m9aTbDamSJKnXMqhKUjV4ZB48tySrT5zmPamSJKlXM6hKUlcVCrCqIe8uYMVCWH5dVg//FJx5Y779SJIkdZOTKUlSZ10/At7b2Ly8+CKgD4z+Iky+s7y9rGqApZdl9QEj4Ss/Ku/4kiRJJeAZVUnqqMdvhtkDm0Nq9IO6fYEAdsAzi+CaemhqLE8/KxYWQzIw6Ei45JflGVeSJKnEPKMqSR2xaFoWRAH6D4JpT0F9ffP7j98Mj10NaSssGAfjL4fPzCpdP3efBet/mtUDh8PXVpVuLEmSpDLzjKoktadlSD3yNJj1wq4hFeDUS2H2m/ChIdny8uvglrE938uKhXDNgc0hdehJ8PXf9Pw4kiRJOfKMqiTtzeM3N4fU0ZPbvwf12883B9tNa2BOPUxv3D3YdsaSb8Kzi+G9JiAVVwZMus3ZfSVJUlUyqErSnjQuh8euyurDTu74REmT74TGC6DhL2HHVpj/UTj6TDj3vvY/+/jN8Ks74I+vZZcR76YORp9d/kmbJEmSysigKkltKRSg4YysHjgcpj7cuc+PGp9dCjxvOGx5I3vG6eyB8CcHw6jPw2Fj4MWVsO5RePtl2L6F5rOlLfWBff4UDv0E/OW/dO/MrCRJUi9hUJWktsw/Onvtt1/37gGdtT67r/TH34K0Dd59FX59Z/azm4C6/jD4WPjzOVnYlSRJqkEGVUlqbe5BwHagDq7Y0P39jZua/RQK8MO/hkIjbN8Kdf1g/4/CCX+dvS9JkiTAoCpJu7p+BGzfDATMfK5n911fD9OW9ew+JUmSqpCPp5GknW4ZC+9tzOoZT3o/qCRJUk4MqpIEWUjdtCarJ90Og0fl248kSVIN89JfSbrpY/DW+qye+D2fTSpJkpQzg6qk2jbvcNjyZlZPut2QKkmSVAEMqpJqU6FQfATN9mzZkCpJklQxDKqSas+qBlh8UXGhLpvd14mTJEmSKoZBVVJtWTQNnlmU1f0HwawX8u1HkiRJuzGoSqodLWf2PfgTcPFj+fYjSZKkNhlUJdWG7wyDrW9n9bhLYOLcfPuRJEnSHhlUJVW3QgEWjIS0LVv+cgMcMzHfniRJkrRXBlVJ1atQgPlHAQknTZIkSeo9DKqSqtf8EUCCPvvAVU15dyNJkqQOKnlQjYj1wNtkDyvcllIaU+oxJYlrDgR2QPQzpEqSJPUyfco0zqdSSh83pEoqizlDivek1sHVhby7kXpcRJweEWsiYm1EXN7G+/0j4oHi+ysiYnhx/Wcj4qmIeLr4OqHcvUuS1BHlCqqSVB7fORR2bAEiuydVqjIRUQcsACYCo4FzImJ0q82mAm+klI4CbgKuL64vAJ9PKR0HXADcV56uJUnqnHIE1QT8R/EvtxeWYTxJtWrecNj6TlbPXOvESapWY4G1KaV1KaX3gQZgUqttJgH3FOsfAJ+OiEgprUopvVxcvxrYNyL6l6VrSZI6oRxB9eSU0olkf/mdERGntnwzIi6MiJURsbKpyfvIJHXRP46CLW9k9YwVhlRVs6HAiy2WNxTXtblNSmkb8BZwYKttzgZWpZS2lKhPSZK6rORBdedfblNKG4Efkv0luOX7d6SUxqSUxgwePLjU7UiqRreMhXdeyeopD8HgUfn2I5VWtLEudWabiDiW7HLgi9ocwD8iS5JyVtKgGhEDImK/nTXwOeB3pRxTUo25bQJsWpPVk26HUePz7UcqvQ3AYS2WhwEv72mbiOgLDAQ2FZeHkf3h+PyU0n+3NYB/RJYk5a3Uj6c5CPhhROwc6/6U0o9LPKakcpr/SSis3nXdASPhkl+Wfuy7z4JXn8rqCXPghCmlH1PK36+AERFxBPASMAU4t9U2S8gmS/oF8EXgsZRSiohBwEPArJTSz8rYsyRJnVLSoJpSWgd8rJRjSMpJ43Jo+EuarybceaVhys5wzh4IE78H46aWZvxF02D9T7N63CVw6qWlGUeqMCmlbRExE1gG1AF3pZRWR8QcYGVKaQmwELgvItaSnUnd+VecmcBRwJURcWVx3eeKt+dIklQxSn1GVVI1enYpPFD8/7199oG/eaL5vtCmRrjtf8P2zbD0MnjhSZh8Z8+Ov2gaPLMoq487DybO7dn9SxUupfQw8HCrdVe1qDcDX2rjc9cC15a8QUmSusnnqErqnKbG5pA64BC4qmnXyYsGj4IrX4OhJ2XLzyzKJjvqKS1D6tFnwtnze27fkiRJqggGVUmds6AYQD80BP62cc/bTVuWXZIL2aXA14/o/th3n7VrSD33vu7vU5IkSRXHoCqp4647EkgQfeHbz7e//cS52Uy8AO9thGsP7frY3z22+Z5UQ6okSVJVM6hK6pgl34TNr2f1jDUd/9wJU2DGiqze9g5cU9+5cZsaYc5geHtDtjxhjiFVkiSpyhlUJbWvUIBfFydEOnEa1HcybA4eBTP/G+gDaWs2I/CKhe1/7v7zYME42PE+EDDlIWf3lSRJqgEGVUntu/WY7PVDQ+DMG7u2j/p6mP0G9B2QLS+9DOYeBKsadt924V/A7EHw3JJsecAhMPtNGDW+a2NLkiSpV/HxNJL27s7Tms9oduS+1Pb8/cvZmdLnlmSPsFl8UfbTpjqY+I+lexarJEmSKpJBVdKePbsUXnoyqyfd1nP73XmP6d1nwQtPQNrW4s2A/gPh9Ouz+1slSZJUcwyqkvbsgXOy14M/UZrQ+JUf9fw+JUmS1Ot5j6qktu18FE2ffeDix/LuRpIkSTXEoCppd4umNT+KZvqz+fYiSZKkmmNQlbSrVQ3wzKKsHn955x9FI0mSJHWTQVVSs0KheQbeIcfDZ2bl248kSZJqkkFVUrP5R2ev+3wYpj+Rby+SJEmqWQZVSZk5g4HtQB383Yt5dyNJkqQaZlCVBHMPgh3vAwEzn8u7G0mSJNU4g6pU6649FLZvJgupa508SZIkSbkzqEq17B8Og23vZLUhVZIkSRXCoCrVqnnD4f0/ZPWMFYZUSZIkVQyDqlSLrh8BW97I6hkrYPCofPuRJEmSWjCoSrXmH0fBexuzespDhlRJkiRVHIOqVEtuGQvvvJLVX26AUePz7UeSJElqg0FVqhX3ToZNa7J60u1wzMR8+5EkSZL2wKAq1YJH5sG6ZVk97hI4YUq+/UiSJEl7YVCVqt2zS2H5dVl95GkwcW6+/UiSJEntMKhK1axQgAeKZ08HHQnnL8q3H0mSJKkDDKpSNZs/Invd58PwtVX59iJJkiR1kEFVqlZzDwJ2QPSFv3sx724kSZKkDjOoStXohpGwfTMQMGNN3t1IkiRJnWJQlarNbRPg3VezesaTUF+fbz+SJElSJxlUpWry4Ex49amsnvg9GDwq334kSZKkLjCoStVixUJ4+r6sPu48GDc1334kSZKkLip5UI2I0yNiTUSsjYjLSz2eVJMal8PSy7J66Elw9vx8+5FUUu0dWyOif0Q8UHx/RUQMb/HerOL6NRFxWjn7liSpo0oaVCOiDlgATARGA+dExOhSjinVnEIBGs7I6gGHwLRl+fYjqaQ6eGydCryRUjoKuAm4vvjZ0cAU4FjgdODW4v4kSaoopT6jOhZYm1Jal1J6H2gAJpV4TKm2zD86e+07AP62Md9eJJVDR46tk4B7ivUPgE9HRBTXN6SUtqSUfg+sLe5PkqSK0rfE+x8KtHyA4wZgXInHlGrHNfXA9uxZqX//ct7dSCqPjhxbP9gmpbQtIt4CDiyuf7LVZ4eWrtUWZh8AbC/LUJKkUqiD2ZvKNlqpz6hGG+vSLhtEXBgRKyNiZVNTU4nbkarI3IMgbQUCrn49724klU+7x9a9bNORz3psliTlrtRnVDcAh7VYHgbsctonpXQHcAfAmDFjdjtYSmrDvMNh+2YgYObavLuRVF7tHltbbLMhIvoCA4FNHfxsaY7NZfwrvCSp9yv1GdVfASMi4oiI2IdsAoclJR5Tqm43jIQtb2b1jCehvj7ffiSVW0eOrUuAC4r1F4HHUkqpuH5KcVbgI4ARwC/L1LckSR1W0jOqxftiZgLLgDrgrpTS6lKOKVW1fzoB3n01q6c8BINH5duPpLLb07E1IuYAK1NKS4CFwH0RsZbsTOqU4mdXR8Qi4BlgGzAjpeSNo5KkilPqS39JKT0MPFzqcaSqd9sEeHNdVk+6HUaNz7cfSblp69iaUrqqRb0Z+NIePvsd4DslbVCSpG4q9aW/knrC3WfBq09l9YQ5cMKUfPuRJEmSSsigKlW6RdNg/U+zetwlcOql+fYjSZIklZhBVapkS6+EZxZl9XHnwcS5+fYjSZIklYFBVapUKxbCiluy+sjT4Oz5+fYjSZIklYlBVapEjcth6WVZffAn4PxF+fYjSZIklZFBVao0hQI0nJHV+w2Dix/Ltx9JkiSpzAyqUqWZf3T22m8/+IaPHZYkSVLtMahKleT6EcB2oA6u2JB3N5IkSVIuDKpSpbj/PHhvY1bP+Hm+vUiSJEk5MqhKleDZpfDckqwefzkMHpVvP5IkSVKODKpSJXjgr7PXIcfDZ2bl24skSZKUM4OqlLdbxvLBfanTn8i7G0mSJCl3BlUpT88uhU1rsnrKknx7kSRJkipE37wbkCpGUyP86znw1ouQtu7+ft2+8Gdf69lLcx84J3sdehKMGt9z+5UkSZJ6MYOqdO9kWPcfQGr1RpBddLAje2/7Zlh+HfzsuzB9efcnPPqnE7L9Rl+Ytqx7+5IkSZKqiEFVtWvRNHjm32gOqAGDjoDT/0/bZzcfnAlP/9/sbOuCcXDiNDjzxq6NvaoB3lyX1dN/1rV9SJIkSVXKoKradO2hsO2drI5+cOZ8OGHK3j9z9vzs56aPwVvr4dd3wua3YPKdnR9/8cXZ6/BP+SgaSZIkqRUnU1JtWbEQZg9sDqkT5sDVhfZDaktf/w0ceVpWP7Mou3S4M64fASTo0x++8qPOfVaSJEmqAQZV1Y5H5sHSy7K6334w+y049dKu7ev8RXDceVm9bhncfVbHe3hvY1ZPf6ZrY0uSJElVzqCq2vDgzGwiJIAhx8MVG7q/z7PnZ/epAqz/afthtamxuYfjzoP6+u73IEmSJFUhg6qq35JvwtP3ZfXwT8H0J3pu32feuGtYvfO0trdraswmYALYb1gWciVJkiS1yaCq6vb4zdmkRwBHn1mae0JbhtWXnoTvDINCYdcedobUfgPgG6t7vgdJkiSpijjrr6rXqgZ47KqsHnoSnHtf6cY680Y46JjsHtitb8P8jwJ1fPAMVoB9Pgx/92LpepAkSZKqhGdUVZ0al8Pii7L6gJEwbVnpxxw3NZug6UNDiiu2k4XUyM7mGlIlSZKkDvGMqqpPUyM0nJHVf3IwXPLL8o7/7efLO54kSZJUZTyjqupSKMCCk7J6nw/Dt9bk248kSZKkTjOoqrrMHwEkqNvXS20lSZKkXsqgqupxzYHADoi+cOVreXcjSZIkqYsMqqoO19RD2gb0gatfz7sbSZIkSd3gZErq3QoFmH802Qy7fWCmExlJkiRJvZ1BVb1XU2Nx4qSUXe7rmVRJkiSpKnjpr3qnpkZYMA5I0Ke/IVVSTYiIAyLiJxHxfPF1/z1sd0Fxm+cj4oLiuj+JiIciojEiVkfEdeXtXpKkjjOoqvd5dmkxpAL99oOrNubbjySVz+XAoymlEcCjxeVdRMQBwNXAOGAscHWLQHtjSmkUcAJwckRMLE/bkiR1TsmCakTMjoiXIuK/ij9/UaqxVENWNcADU7J63wPhig359iNJ5TUJuKdY3wOc1cY2pwE/SSltSim9AfwEOD2l9G5K6acAKaX3gV8Dw8rQsyRJnVbqe1RvSindWOIxVCtWLISll2X1fsPgG6vz7UeSyu+glNIrACmlVyJiSBvbDAVaPkh6Q3HdByJiEPB54OZSNSpJUnc4mZJ6h5YhddCR8LVV+fYjSSUSEY8AB7fx1hUd3UUb61KL/fcFvg/cklJat4ceLgQuBPjIRz7SwWElSeo5pQ6qMyPifGAl8I3iJUhS5zx+Mzx2VVYfMBIu+WW+/UhSCaWUPrOn9yLitYg4pHg29RCgrZv0NwB/3mJ5GPCfLZbvAJ5PKf3TXnq4o7gdY8aMSXvaTpKkUunWPaoR8UhE/K6Nn0nAPwMfBT4OvAJ8dw/7uDAiVkbEyqampu60o2r0yLzmkFp/rCFVUq1bAlxQrC8AFrexzTLgcxGxf3ESpc8V1xER1wIDga+VoVdJkrqsW2dU9/ZX35Yi4k7g3/ewD/9qq7Y9Mg+WF5+eMOR4mP5Evv1IUv6uAxZFxFTgf4AvAUTEGODilNJXU0qbImIu8KviZ+YU1w0ju3y4Efh1RADMTyn9S9n/KyRJakfJLv3deWlScfELwO9KNZaq0NIrYcUtWX3wJ+Dix/LtR5IqQErpdeDTbaxfCXy1xfJdwF2tttlA2/evSpJUcUp5j+oNEfFxsgkc1gMXlXAsVZMl34Rf35nVQ0+Cacvy7UeSJElSWZUsqKaUzivVvlXFWobUw06GqQ/n248kSZKksvPxNKocD86Ep+/L6uGfgq/8KN9+JEmSJOXCoKrKcO9kWFe8xPfI0+D8Rfn2I0mSJCk3BlXlb+FfwIs/y+rRk2Hynfn2I0mSJClXBlXl69ZTYONvs/rEaXDmjfn2I0mSJCl3BlXl55axsGlNVo+/HD4zK99+JEmSJFUEg6ry8d1j4e0NWT3xezBuar79SJIkSaoYBlWV3w0j4d1Xs3rS7XDClHz7kSRJklRRDKoqr3nDYcsbWf3lBjhmYq7tSJIkSao8BlWVz7zDYcubWT3lIRg1Pt9+JEmSJFUkg6rK44aRzSF1xgoYPCrffiRJkiRVrD55N6AacMvY5ntSpzxkSJUkSZK0VwZVlda9k5sfQTPpdi/3lSRJktQug6pKZ8VCWLcsq8df7uy+kiRJkjrEoKrSKBRg6WVZPfQk+MysfPuRJEmS1GsYVFUaC0Zmr/0HwbRl+fYiSZIkqVcxqKrnXT8C0jagDma9kHc3kiRJknoZg6p61r2T4b2NWT3j5/n2IkmSJKlXMqjWiqbG7KeUWk6eNGGOj6GRJEmS1CV9826gpqxqgGcfgj+8BP32hcNPKd0kQ02NcNfnm89utla3L/zZ13pu/JaTJx12Mpx6ac/sV5IkSVLNMaiWSqEAP5gMr/0W0ta2t3nxZ7D8OiBgv6Fw/oPdPwu5YiH8+FvFe0R3CujTL3vdsQ3YDts3Z2Mv/0eYdGv3Hx0z/+jstf/+MPXh7u1LkiRJUk0zqPa0R+Zl4Y/trd6og777wj77wb4DYes7sPkt2PpHIMHbG2DBOIh+cPI3On+m89ml8G/nw473m9cdMBLOfRjq63ff/sGZ8PS/Zn0uvgge/iZc9F9tb9ueuQdl+4m+MGt95z8vSZIkSS1ESinvHj4wZsyYtHLlyrzb6JpH5sHyG4Adzes+NATOvAWOmbj3zzY1wr+eA2+ua7Ey4MjPwfmL9v7ZZ5fCD76SnSHd6egz4dz7Otb3vZOb7ysFOO48OHt+xz4L2Qy/723M+p25tmtBV5JKJCKeSimNybuP3qxXH5slSRWno8dmg2pP+CCsAfSBcTNh4tyu7evBmfD0/exyRna/YXDG7TBqfLZcKMC/fxVeeGLXS3wPO7nrl93OGw5b3sjqun3hb1a3HzpbfmbGCidPklRxDKrd12uPzZKkitTRY7OX/nZHoVC8N7MYKjt7NrItZ8/PflY1wL9fmp0pfXsDNJyxhw8EHPbJ7t8XOmt98azwddmY8z8KR57W9hndxuXQcCYf/Hd/ucGQKkmSJKnHeEa1q5oas3tKAaiDmc+V5rLXnZcFv/Vii7OnfaD/h2HClTBuas+PecNIePfV5uX++8OQ0bDlbSisgR1bim/UZc9KNaRKqlCeUe2+XnVsliRVPM+oltqCk7LXvgPg718u3TiDR8HXVpVu/2351pps9uBl34YdW7PLe1/82a7bDDkepj9R3r4kSZIk1QSDaldcUw8k6NO/tCE1T+OmZj+FAjw8HZpWQ78BMPoLpXv2qyRJkiRhUO28fzis+FzUPnDVxnY37/Xq69ufeViSJEmSelCfvBvoVe4/D97/Q1bPfD7fXiRJkiSpShlUO6qpEZ5bktUT5vi8UEmSJEkqEYNqR916cvY6cDicemmurUiSalNEHBARP4mI54uv++9huwuK2zwfERe08f6SiPhd6TuWJKlrDKodcespxUfD9IGv/ybvbiRJtety4NGU0gjg0eLyLiLiAOBqYBwwFri6ZaCNiL8C/liediVJ6hqDantWNcDG32b1l+/PtxdJUq2bBNxTrO8Bzmpjm9OAn6SUNqWU3gB+ApwOEBF/ClwGXFuGXiVJ6rJuBdWI+FJErI6IHRExptV7syJibUSsiYjTutdmjhZfnL0OPQmOmZhvL5KkWndQSukVgOLrkDa2GQq82GJ5Q3EdwFzgu8C7pWxSkqTu6u7jaX4H/BVwe8uVETEamAIcCxwKPBIRR6eUtndzvPK6fgTZ81L3gWnL8u5GklQDIuIR4OA23rqio7toY12KiI8DR6WUvh4Rw9vp4ULgQoCPfOQjHRxWkqSe062gmlJ6FiBit2PiJKAhpbQF+H1ErCW7T+YX3RmvrJZeCe8Vn5M6/dl8e5Ek1YyU0mf29F5EvBYRh6SUXomIQ4C2Hui9AfjzFsvDgP8E/gz4RESsJzv+D4mI/0wp/Xmrz5NSugO4A2DMmDGpa/8lkiR1XanuUd3bZUeVr1CAFbdk9XHn+SgaSVKlWALsnMX3AmBxG9ssAz4XEfsXJ1H6HLAspfTPKaVDU0rDgfHdch3rAAAgAElEQVTAc22FVEmSKkG7Z1T3dglSSqmtAyTs4bKjPey/8i4vuu347LX/IDh7fr69SJLU7DpgUURMBf4H+BJAcZ6Ii1NKX00pbYqIucCvip+Zk1LalE+7kiR1TbtBdW+XIO3FBuCwFsvDgJf3sP/Kurzo3smw7Z2snvVCvr1IktRCSul14NNtrF8JfLXF8l3AXXvZz3rgf5WgRUmSekSpLv1dAkyJiP4RcQQwAvhlicbqOc8uhXXFSZMmfi/fXiRJkiSpRnX38TRfiIgNZBM0PBQRywBSSquBRcAzwI+BGb1ixt8HzslehxwP46bm24skSZIk1ajuzvr7Q+CHe3jvO8B3urP/spo3nOxRNP1g+hN5dyNJkiRJNatUl/72LneeBlveyOrpjfn2IkmSJEk1zqC69Ep46cmsnnS7j6KRJEmSpJzVdlBd1dD8vNTRk+GEKfn2I0mSJEmq4aC6qgEWX5TVB4yEyXfm248kSZIkCajVoPrs0uaQOnA4XFL5T86RJEmSpFpRe0H1kXnwQPES3/2Gwdd/k28/kiRJkqRddOvxNL3OvZNh3bKsHnQkfG1Vvv1IkiRJknZTO0H1+hHw3sasPvI0OH9Rvv1IkiRJktpU/UG1cTk0/CWQsuXxl8NnZuXakiRJkiRpz6o7qN4yFjatyeroBzMafU6qJEmSJFW46gyqqxpg8cV8cBZ1yPEw/YlcW5IkSZIkdUz1BdVF0+CZ4v2n0Re+vBhGjc+3J0mSJElSh1Xf42kmzAMChn8Krn7dkCpJkiRJvUz1nVGtr4fZb+bdhSRJkiSpi6rvjKokSZIkqVczqEqSJEmSKopBVZIkSZJUUQyqkiRJkqSKYlCVJEmSJFUUg6okSZIkqaIYVCVJkiRJFcWgKkmSJEmqKJFSyruHD0REE/BC3n10Uz1QyLuJXsbvrPP8zjrP76zzquE7OzylNDjvJnozj801y++s8/zOOs/vrPOq4Tvr0LG5ooJqNYiIlSmlMXn30Zv4nXWe31nn+Z11nt+ZqoW/y53nd9Z5fmed53fWebX0nXnpryRJkiSpohhUJUmSJEkVxaDa8+7Iu4FeyO+s8/zOOs/vrPP8zlQt/F3uPL+zzvM76zy/s86rme/Me1QlSZIkSRXFM6qSJEmSpIpiUO0hEfGliFgdETsiYkyr92ZFxNqIWBMRp+XVYyWLiNkR8VJE/Ffx5y/y7qlSRcTpxd+ltRFxed799AYRsT4ini7+bq3Mu59KFBF3RcTGiPhdi3UHRMRPIuL54uv+efYodZbH5u7x2NxxHps7z2Nz+2r92GxQ7Tm/A/4KeLzlyogYDUwBjgVOB26NiLryt9cr3JRS+njx5+G8m6lExd+dBcBEYDRwTvF3TO37VPF3qyamdO+Cu8n+jWrpcuDRlNII4NHistSbeGzuPo/N7fDY3C0em/fubmr42GxQ7SEppWdTSmvaeGsS0JBS2pJS+j2wFhhb3u5URcYCa1NK61JK7wMNZL9jUreklB4HNrVaPQm4p1jfA5xV1qakbvLYrDLx2KySqPVjs0G19IYCL7ZY3lBcp93NjIjfFi9zqNrLGLrJ36euScB/RMRTEXFh3s30IgellF4BKL4Oybkfqaf4b2nHeWxun79PXeOxuWtq5tjcN+8GepOIeAQ4uI23rkgpLd7Tx9pYV5NTLe/t+wP+GZhL9t3MBb4L/H/l667X8Pepa05OKb0cEUOAn0REY/GvlJJ6OY/N3eOxuUf4+9Q1Hpu1VwbVTkgpfaYLH9sAHNZieRjwcs901Lt09PuLiDuBfy9xO72Vv09dkFJ6ufi6MSJ+SHaZlgfD9r0WEYeklF6JiEOAjXk3JLXmsbl7PDb3CH+fusBjc5fVzLHZS39LbwkwJSL6R8QRwAjglzn3VHGK/0Pb6QtkE2Bod78CRkTEERGxD9lkIEty7qmiRcSAiNhvZw18Dn+/OmoJcEGxvgDY09kpqbfx2NwBHps7zGNzJ3ls7paaOTZ7RrWHRMQXgP8DDAYeioj/SimdllJaHRGLgGeAbcCMlNL2PHutUDdExMfJLpVZD1yUbzuVKaW0LSJmAsuAOuCulNLqnNuqdAcBP4wIyP7Nuz+l9ON8W6o8EfF94M+B+ojYAFwNXAcsioipwP8AX8qvQ6nzPDZ3m8fmDvDY3CUemzug1o/NkZKX0EuSJEmSKoeX/kqSJEmSKopBVZIkSZJUUQyqkiRJkqSKYlCVJEmSJFUUg6okSZIkqaIYVCVJkiRJFcWgKkmSJEmqKAZVSZIkSVJFMahKkiRJkiqKQVWSJEmSVFEMqpIkSZKkimJQlSRJkiRVFIOqJEmSJKmiGFQlSZIkSRXFoCpJkiRJqigGVUmSJElSRTGoSpIkSZIqikFVkiRJklRRDKqSJEmSpIpiUJUkSZIkVRSDqiRJkiSpohhUJUmSJEkVxaAqSZIkSaooBlVJkiRJUkUxqEqSJEmSKopBVZIkSZJUUQyqkiRJkqSKYlCVJEmSJFWUvnk30FJ9fX0aPnx43m1IkqrEU089VUgpDc67j97MY7MkqSd19NhcUUF1+PDhrFy5Mu82JElVIiJeyLuH3s5jsySpJ3X02Oylv5IkSZKkimJQlSRJkiRVFIOqJEmSJKmiGFQlSZIkSRXFoCpJkiRJqigGVUmSJElSRTGoSpIkSZIqikFVklRZbhkLTY15dyFJknJkUJUkVYa7z4LZA2HTGviX0/PuRpIk5ahv3g1IkmrcI/Ng+fVAypb7DYCv/jjXliRJUr4MqpKkfDQuh0VfgB3vZ8vRF85cACdMybcvSZKUO4OqJKm8CgX4l7Gw+fXiioATvwpn3phrW5IkqXIYVCVJ5XPvZFi3rHn54E/AxY/l148kSapIBlVJUuk1LocHJkHali3veyB89ZdQX59vX5IkqSIZVCVJpXXbBHj1qeJCwMTvwripubYkSZIqm0FVklQahQLcekzzZElDjofpT+TbkyRJ6hUMqpKknrdiISy9rLgQ8OXvwzETc21JkiT1HgZVSVLPWjQNnlmU1f33h1nrc21HkiT1PgZVSVLPaXk/6tCTYNqyvW8vSZLUhj55NyBJqhK3ntIcUk+cZkiVJEld5hlVSVL3zf8kFFZn9fjL4TOz8u1HkiT1agZVSVL33H1Wc0idMAdOvTTffiRJUq/XI5f+RsRdEbExIn7XYt0BEfGTiHi++Lp/T4wlSaogS6+E9T/N6vGXG1IlSVKP6Kl7VO8GTm+17nLg0ZTSCODR4rIkqVqsaoAVt2T10Wd6ua8kSeoxPRJUU0qPA5tarZ4E3FOs7wHO6omxJEkVoKkRFl+U1UOOh3Pvy7cfSZJUVUo56+9BKaVXAIqvQ9raKCIujIiVEbGyqamphO1IknpEoQALTsrqDw2B6U/k208NiojTI2JNRKyNiN2uWIqI/hHxQPH9FRExvNX7H4mIP0bEN8vVsyRJnZH742lSSneklMaklMYMHjw473YkSe1ZMBJIULcvfPv5vLupORFRBywAJgKjgXMiYnSrzaYCb6SUjgJuAq5v9f5NwNJS9ypJUleVMqi+FhGHABRfN5ZwLElSOVx7KKRtQB1c+Vre3dSqscDalNK6lNL7QAPZ7TYttbz95gfApyMiACLiLGAdsLpM/UqS1GmlDKpLgAuK9QXA4hKOJUkqtXmHw7Z3snrmc/n2UtuGAi+2WN5QXNfmNimlbcBbwIERMQD4NnBNGfqUJKnLeurxNN8HfgGMjIgNETEVuA74bEQ8D3y2uCxJ6o2uOxK2vJnVM1ZAfX2+/dS2aGNd6uA21wA3pZT+uNcBnD9CkpSzvj2xk5TSOXt469M9sX9JUo7mHd4cUqc8BINH5duPNgCHtVgeBry8h202RERfYCDZ7PzjgC9GxA3AIGBHRGxOKc1v+eGU0h3AHQBjxoxpHYIlSSq5HgmqkqQq1LgcGs4EtmfLUx6CUeNzbUkA/AoYERFHAC8BU4BzW22z8/abXwBfBB5LKSXglJ0bRMRs4I+tQ6okSZXAoCpJtaJxOTw2C/7wUrb8pwfDkGPh+At2DaArFsIjV8PWt4sr6rJ7Ur3ctyKklLZFxExgGVAH3JVSWh0Rc4CVKaUlwELgvohYS3YmdUp+HUuS1HkGVUmqdo/Mg+U3ADt2Xb/5dSishmcW7fmzQ473OakVKKX0MPBwq3VXtag3A19qZx+zS9KcJEk9wKAqSdXs+hHw3s6ngwUMPBw+Urz687XfwNuvwpa3YMf7zZ/psw985JPwlR+VvV1JkiQwqEpS9ZpTDzu2ZvVx58HZ3oooSZJ6B4OqJFWjaw6EtA0ImPGkM/VKkqRexaAqSdVm7kHFkNoHZj7vJEiSJKnX6ZN3A5KkHnT9CNi+GQhDqiRJ6rUMqpJULW49pXnipBlPGlIlSVKvZVCVpGpw/3mw8bdZPel270mVJEm9mkFVkrqiUIAHZ8LdZ8Gqhnx7eXAmPLckq8ddAidMybcfSZKkbnIyJUnqjMblsOgLuz53dP1PYfFFcMBIuOSX5e1nyTfh6fuy+sjTYOLc8o4vSZJUAp5RlaSOuncyNJzRHFL7D4IBh0CfftnypjUwe1D5zrA+OBN+fWdWH3kanL+oPONKkiSVmGdUJakjbj2l+R7Q+mNh5s93fb+pEf75VNixJTu7+psG+MqPStfPP46Cd17J6uGfMqRKkqSq4hlVSWrPbROaQ+r4y3cPqZBNXnTVRjj4E9ny+p/CPxzW873cOxlmD2wOqSdOK20gliRJyoFnVCVpbxZNg1efyuoJc+DUS/e+/cWPwYqFsPQyeP8P2aXAX/4+HDOxa+OvWAgrboc3f7/rfbF9+sPfPO7svpIkqSoZVCVpTx6/GZ4pXlJ74rT2Q+pO46bCRyfBraOzS4EfmAIDh8PXf7P3zzUuh/+8CgqNsO1dIO2+Td8BcMb3nNlXkiRVNYOqJLWlcTk8dlVWH3YynHlj5z5fX59dCrzz3ta31meX7PbpD4OGw4B6eKcAb2+Are8BO9rYSUBdf9j/o3Cyj52RJEm1w6AqSa0VCtnsvgD7DYOpD3d9X9OfyCZa+pfTYMub2RnWTWuyn9aiH/zpQfD/XNjxs7eSJElVyKAqSa3NPzp77TcAvrG6+/sbPApmvZDVj98MzyyG916H/h+G//VFQ6kkSVIrBlVJamnOEGA7RF+44uWe3/+plxpMJUmS2uHjaSRpp3mHZ5fmEjCjjUtzJUmSVBYGVUmCLKRueTOrZzyZTYYkSZKkXHjpryR9ZxhsfTurZ6zw2aSSJEk5M6hKql2FAiwYCWlbtmxIlSRJqghe+iupNj27FOZ/tBhS+xhSJUmSKohnVCXVniXfhF/fmdX99oMrNuTbjyRJknZhUJVUW+Z/EgrFZ6PWHwszf55vP5IkSdqNQVVS7Wg5adJx58HZ8/PtR5IkSW0yqEqqfoUCzD8a2J4tT7odTpiSa0uSJEnaM4OqpOrWuBwazigu1MHM53xGqiRJUoUzqEqqXi1Dat8B8Pcv59uPJEmSOsTH00iqTk2NzSH1Q0MMqZIkSb1Iyc+oRsR64G2ym8O2pZTGlHpMSTWuUIAFJ2X1Ph+Gbz+fbz+SJEnqlHKdUf1USunjhlRJZTH/KCBB3b7wdy/m3Y3U4yLi9IhYExFrI+LyNt7vHxEPFN9fERHDi+s/GxFPRcTTxdcJ5e5dkqSO8NJfSdVl9gFAgj794MrX8u5G6nERUQcsACYCo4FzImJ0q82mAm+klI4CbgKuL64vAJ9PKR0HXADcV56uJUnqnHIE1QT8R/EvtxeWYTxJtWpOPdldBnVwVSHvbqRSGQusTSmtSym9DzQAk1ptMwm4p1j/APh0RERKaVVKaecN26uBfSOif1m6liSpE8oRVE9OKZ1I9pffGRFxass3I+LCiFgZESubmprK0I6kqnTtobBjKxDZI2ik6jUUaHlN+4biuja3SSltA94CDmy1zdnAqpTSlhL1KUlSl5U8qO78y21KaSPwQ7K/BLd8/46U0piU0pjBgweXuh1J1Wje4bDtnayeudbnpKraRRvrUme2iYhjyS4HvqjNAfwjsiQpZyUNqhExICL221kDnwN+V8oxJeWkcXn2SJhyu2EkbHkzq2esMKSqFmwADmuxPAxo/fylD7aJiL7AQGBTcXkY2R+Oz08p/XdbA/hHZElS3kr9eJqDgB9GxM6x7k8p/bjEY0oql6ZGuPOz8P4fdl3fbz+48BEYPKq049/0MXj31aye8lDpx5Mqw6+AERFxBPASMAU4t9U2S8gmS/oF8EXgsZRSiohBwEPArJTSz8rYsyRJnVLSoJpSWgd8rJRjSMrJ4zfDY1c1L/fpl73u2Apb34YF42D0ZJh8Z2nGv/UUeGt9Vk+6HUaNL804UoVJKW2LiJnAMqAOuCultDoi5gArU0pLgIXAfRGxluxM6pTix2cCRwFXRsSVxXWfK96eI0lSxSj1GVVJ1eiRebD8uqz+0BD49vO7vv/dY+HtDfDMIpi/Gmb+vGfHv/UU2PjbrJ74PThhyt63l6pMSulh4OFW665qUW8GvtTG564Fri15g5IkdZPPUZXUOasamkPq0JN2D6kA31gNJ07L6sLqbLKjntIypE6YA+Om9ty+JUmSVBEMqpI6rlCAxcVJQoccD9OW7XnbM2/MLsmFbLKjOUO6P/5NH9s1pJ56aff3KUmSpIpjUJXUcf98bPbabz+Y/kT7258wJZuJl4AdW2D2AVnY7YprD22+J9WQKkmSVNUMqpI65u6zYPvmrL5iQ8c/N3hU9mzT6Atsh/lHde4xNqsaYPag5uekTnnIkCpJklTlDKqS2te4HNb/NKt3Xs7bGfX1cPXrULcvkLIZge8/r/3P3fSx4qXGKZtVeOZ/O7uvJElSDTCoSmpfw+ez1/pjuzfD7pWvwcDhWf3cEpi9P9w7eddtVjXA9SNg9sDmS30POxmuKmSBV5IkSVXPx9NI2rvvHgvsyC7d7YnHzHz9N7BiISz9ZrbfdcuyUNqWfgPgwseyy4clSZJUMzyjKmnPHpmXPQ8VYPrPem6/46bC7DeyZ6D2HwRE8Y3ILvEdcnx2me8VLxtSJUmSapBnVCW1rVBofl7q6MmlCYzjpvocVEmSJO3GM6qS2rbzUTT9B8HkO/PtRZIkSTXFoCppd7dNKD6KJmDWC3l3I0mSpBpjUJW0q6VXwqtPZfWk2/LtRZIkSTXJoCqpWeNyWHFLVo+e3L1H0UiSJEldZFCVlCkUoOGMrB443PtSJUmSlBuDqqQspM4/Kqv7DsiedSpJkiTlxKAqqRhSE/TZB/7+5by7kSRJUo0zqEq1bvYBQILoB1c15d2NJEmSZFCVato1BwLbgTq4upB3N5IkSRJgUJVq15x6SNuAOpi9Ke9uJEmSpA8YVKVaNGcI7NgKBMx8Lu9uJEmSpF0YVKVac+2hsGMLWUhdC/X1eXckSZIk7cKgKtWSecNh2ztZbUiVJElShTKoSrVi/idhyxtZPWOFIVWSJEkVy6Aq1YL7z4PC6qyedDsMHpVvP5IkSdJeGFSlavfIPHhuSVaPuwROmJJvP5IkSVI7DKpSNXt2KSy/LquHfwomzs23H0mSJKkDDKpStSoU4IHi2dNBR8JXfpRvP5IkSVIHGVSlajX/6Ox1nw/D11bl24skSZLUCQZVqRrNPQjYDtEX/u7FvLuRJEmSOsWgKlWbG0bC9s1AwIw1eXcjSZIkdZpBVaomt02Ad1/N6hlP+qxUSZIk9UoGValaPDgTXn0qqyd+z2elSpIkqdcqeVCNiNMjYk1ErI2Iy0s9nlSTViyEp+/L6uPOg3FT8+1HUkm1d2yNiP4R8UDx/RURMbzFe7OK69dExGnl7FuSpI4qaVCNiDpgATARGA2cExGjSzmmVHMal8PSy7J66Elw9vx8+5FUUh08tk4F3kgpHQXcBFxf/OxoYApwLHA6cGtxf5IkVZRSn1EdC6xNKa1LKb0PNACTSjymVDuaGqHhjKwecAhMW5ZvP5LKoSPH1knAPcX6B8CnIyKK6xtSSltSSr8H1hb3J0lSRelb4v0PBVo+G2MDMK7EY0q1oVCABSdl9T4fhr9tzLcfSeXSkWPrB9uklLZFxFvAgcX1T7b67NDStdrC7AOA7WUZSpJUCnUwe1PZRiv1GdVoY13aZYOICyNiZUSsbGpqKnE7UhWZfzSQoE9/n5Uq1ZZ2j6172aYjn/XYLEnKXanPqG4ADmuxPAx4ueUGKaU7gDsAxowZs9vBUlIbrqkHtkP0has25t2NpPJq99jaYpsNEdEXGAhs6uBnS3NsLuNf4SVJvV+pz6j+ChgREUdExD5kEzgsKfGYUnWbexCkrUAfuPr1vLuRVH4dObYuAS4o1l8EHksppeL6KcVZgY/4/9u792CryvOO498HUEisEQygRjSGBD1oTCVhQBtiE+KImFY0ViSZQdLiLQOjSbQt1HopxEKs1kjwHh0vUyW0xEqjhIoxdUiqBjVRERBKMBIvcEQToxEE3v6xtp6jnnM4++zL2pfvZ4ZZ71p77bUe12x558d617uAYcAjVapbkqRuq+gd1cJzMdOBpUBv4OaU0spKnlNqaHM+CjveBAKmr827Gkk56KxvjYhZwIqU0mLgJuD2iFhHdid1UuG7KyNiIfA0sB2YllLywVFJUs2p9NBfUkr3AvdW+jxSw7vsENj6atae9hAMHJhvPZJy01HfmlK6qF37TeCUTr57KXBpRQuUJKlElR76K6kcvjsC3ngxa0+6Bwa15FuPJEmSVEEGVanWXTcWXl2ftSdcDy1j8q1HkiRJqjCDqlTLbjkRXnw0a4+dBSMm5VuPJEmSVAUGValWLZoOGx7I2qPPgaPPzbceSZIkqUoMqlItevAqePL2rH34ZBg/O996JEmSpCoyqEq1ZvVy+Elh8s79j4ST5+dbjyRJklRlBlWp1iz4UrbccwicsTTfWiRJkqQcGFSlWjJ7n2zZZw84b2W+tUiSJEk5MahKteKaz8GON4GAf3w+72okSZKk3BhUpVrw4FWw6Ymsfeqd+dYiSZIk5cygKtWCtydPOvgEGD4+31okSZKknBlUpbx9Z1i27N0Pvnp7vrVIkiRJNcCgKnVm82p4fEG2rJRlc+CPm7L21508SZIkSQLok3cBUs1YNgce+h5sfwNIHewQcMCfwdR7y3fO5XOz5eGTYeDA8h1XkiRJqmMGVemKw+C1je/f3mt36LUb7HwLdm4DEjz3M7ikP4y/AkZPLe28cw7Kln32gJPnl3YsSZIkqYEYVNW85o2CLWva1nvtDoed2nloXLUE/v20LLQu+RY8tajnd1eXXAhbX8naZz/Rs2NIkiRJDcpnVNV8Nq+GS/ZuC6l9B8D0/4OLNnd9Z3P4+GyfoeOy9ed+lr37tFitrfDwvKz96TMc8itJkiS9h0FVzWXRdLh6NLAD6A3THoaZG4oLi6cthDEzsvamJ+C7I4qr4bpPZcu+/eGEy4v7riRJktQEDKpqHrdNhCcLr3/pPxQu2QKDWnp2rGNmwvh/zdqvrocr/7T7NWx/PWvPfLZn55YkSZIanEFVzeG6sbB+adY+dCJ84/HSjzl6Kky4Pmv/bsOuw+rjC9pqGDur9PNLkiRJDcqgqsZ30/Hw4qNZe/Q5MPHG8h17xKR3h9XLDul4v8cXwN1nZe39j4Sjzy1fDZIkSVKDMaiqsS08I5v0CLLnSsfPLv852ofVN17MJmpataTt8zsmt4XUPYfAGUvLX4MkSZLUQHw9jRrXkgvh6YVZ+/DJ2XOllTJiEgw5Aq4+CtgBP5j0/n32PgTOeaRyNUiSJEkNwjuqakwP39T2Cpih47p+7Uy5DGqBS17JhvYSbdt77Z49k2pIlSRJkrrFO6pqPKuWwJJvZe19P5O9TqaaHNorSZIklcQ7qmosq5e3DbvtPxTO/km+9UiSJEkqmkFVjWPzaljwpaz9wX3L8woaSZIkSVVnUFVjaG2Fq4/M2rt/CP5uTb71SJIkSeoxg6rq3+bVMP8TQILe/eAfnsu7IkmSJEklMKiqvq1eDleP5p2QeuFLeVckSZIkqUQGVdWvVUvanknd/UOGVEmSJKlBGFRVnx6+qW123w8MdrivpKYQEXtHxH0RsbawHNDJflMK+6yNiCmFbR+MiHsiYnVErIyIudWtXpKk7jOoqv4sm9P2ntS9DoK/X5trOZJURTOA+1NKw4D7C+vvEhF7AxcDo4FRwMXtAu3lKaUWYATw2YgYX52yJUkqTsWCakRcEhG/jYhfFv4cX6lzqYksPh+WF24CDP4UfPNX+dYjSdU1Abi10L4VOLGDfcYB96WUtqSUXgHuA45LKb2RUnoAIKW0DXgMGFKFmiVJKlqfCh//ypTS5RU+h5rFounw5O1Z+4DPwtR7861Hkqpvn5TSCwAppRciYnAH++wPtH8eYmNh2zsioj/wl8BVlSpUkqRSVDqoSuXRPqQOHQenLcy3HkmqkIhYBuzbwUcXdPcQHWxL7Y7fB7gTmJdSWt9JDWcCZwIceOCB3TytJEnlU+mgOj0iTgNWAOcVhiBJxVl4BjxdCKaGVEkNLqV0TGefRcRLEbFf4W7qfsCmDnbbCHy+3foQ4Kft1m8A1qaUvttFDTcU9mPkyJGps/0kSaqUkp5RjYhlEfFUB38mANcCHweOAF4ArujkGGdGxIqIWLF58+ZSylEjumNyW0g9+ARDqqRmtxiYUmhPAe7uYJ+lwLERMaAwidKxhW1ExLeBvYBvVKFWSZJ6rKQ7ql39q297EXEj8KNOjuG/2qpjt02E9Uuz9qETYeKN+dYjSfmbCyyMiKnAb4BTACJiJHB2Sun0lNKWiJgN/KLwnVmFbUPIhg+vBh6LCID5KaXvV/2/QpKkXajY0N+3hyYVVk8CnqrUudSAbjkRNjyQtQ+fDCfPz7ceSaoBKaWXgS92sH0FcHq79ZuBm9+zz0Y6fn5VkqSaU8lnVC+LiKvkU8gAAA2BSURBVCPIJnDYAJxVwXOpkdx0PDz3s6z96TPgBCeOliRJkppJxYJqSmlypY6tBnbjOPjtQ1nbkCpJkiQ1JV9Po9px3Vh48dGsPfocGD8733okSZIk5cKgqtowbxRsWZO1x8yAY2bmW48kSZKk3BhUlb8rDoPXNmbtsbPg6HPzrUeSJElSrgyqytfcofDmy1l7wvUwYlK+9UiSJEnKnUFV+fnnA2Db77P2qQtg+Ph865EkSZJUEwyqyse3PwLbX8/ak+6BljH51iNJkiSpZhhUVX2zBsPOrVl72sMwqCXfeiRJkiTVFIOqqmvWQNj5FhAwfR0MHJh3RZIkSZJqjEFV1fNPAyEZUiVJkiR1rVfeBahJzN7HkCpJkiSpWwyqqrw5B8GONzGkSpIkSeoOg6oqa94o2PpK1p72kCFVkiRJ0i4ZVFU5i8+HLWuy9qkLnN1XkiRJUrcYVFUZq5fDYzdm7cMnw/Dx+dYjSZIkqW4YVFUZC/4iW/YfCifPz7cWSZIkSXXFoKrym70PkKB3P/jG43lXI0mSJKnOGFRVXvNGtc3we+FLeVcjSZIkqQ71ybsAVcHq5fDErbD9TRgyEo4+tzLnWTS93eRJd1bmHJIkSZIankG1Wh68CtYuhVefhW2vQ6/dYM994ahpMGJS+c+3bA78/ErYufXd259ZDD+5CAjYfzScsbQ851u1BJ68PWs7eZIkSZKkEhhUK+XxBfDjGbD1VSB1vM8fN8HdZ2V/eveDo74Bx8ws7bx3TM7CaHu9doO+AyB6wbbXYPsbWU2/fQgu2QsOnQgTb+z5OVtb4QeFsL33IU6eJEmSJKkkBtVyu24svPjoezYG9PkgfGAAfHgY7DkEtv4OWtfAqxuyu5473oTlc2H5d3p2p3Px+fDY93knFEcf+ORXOg+Nq5bAf3wtO+/TC+GSRTBpMbSMKe68APOHZcvd9oRzHin++5IkSZLUjkG1XG45ETY80LYefWDIaJh6b/e+v2g6PHUnpO1tdzr32A/+ejkMHNj19578N2Bn23mPuwxGT+36fMPHZ5MdPXwTLDkf2AELvgQDD4PpP+9ezQCzBmfnjj5wwcbuf0+SJEmSOhEpdTIsNQcjR45MK1asyLuM4rS2wjXDYee2bL13PzhlUc/uTEJ2p/OHU+Gt19u29e4Hh5wAXzgPBrVkz58+dgu88WK7L/aGMX/b86HD13wONj1RWOkFE67t+tnZ1la4ugXSW0DA9HVdB2pJykFEPJpSGpl3HfWsLvtmSVLN6m7fbFAtxaolbc9mEjDhuvJNjNTaCrf+Oby2i7uUsRt84cLyzOS7ejn8YEJ2VxeyIcpT/uf9AXTZnGyYclaAIVVSzTKolq7u+mZJUk3rbt/s0N+eenxBNgkSZM9mlnvY68CBcN7KrL1oOjzzI3jrD9kjqH12hw+3wF8tLG9AbBkDF78MNx0Pz/0sC8nzP56F4X4DsrvGW3/HO8/B7rYHXPB8+c4vSZIkSRhUe2bz6raQuueQtkBZKSfPB6o4k+7Ue7P/xpuOhzdfzob3/nFTux0CPn06nHB59WqSJEmS1DQMqsVqbYWrj8za/T5c+ZCal0EtMGN91l61BJ78IfTbC446PftMkiRJkirEoFqsq1uABL36tgW5Rjd8fPZHkiRJkqqgV94F1JVrPtc2y+1Fm3a5uyRJkiSpeAbV7np8QdvrW069M99aJEmSJKmBGVS76+6zs+X+RzoMVpKUi4jYOyLui4i1heWATvabUthnbURM6eDzxRHxVOUrliSpZwyq3XHZIWTPpe4GZyzNuxpJUvOaAdyfUhoG3F9Yf5eI2Bu4GBgNjAIubh9oI+LLwB+qU64kST1jUN2VZXPgjRez9teX51uLJKnZTQBuLbRvBU7sYJ9xwH0ppS0ppVeA+4DjACLiT4BvAd+uQq2SJPVYSUE1Ik6JiJURsTMiRr7ns5kRsS4i1kTEuNLKzElrKyyfm7UPn+xrWSRJedsnpfQCQGE5uIN99geea7e+sbANYDZwBfBGVyeJiDMjYkVErNi8eXPpVUuSVKRSX0/zFPBl4Pr2GyPiUGAScBjwEWBZRBycUtpR4vmq67pPZcu+/eHk+fnWIklqChGxDNi3g48u6O4hOtiWIuII4BMppW9GxEFdHSCldANwA8DIkSNTN88rSVLZlBRUU0qrACLe1ydOABaklLYCv46IdWTPyfxvKeerqtsmwvbXs/bMZ/OtRZLUNFJKx3T2WUS8FBH7pZReiIj9gI7elbYR+Hy79SHAT4GjgM9ExAay/n9wRPw0pfR5JEmqMZV6RrWrYUe1b/NqWF+YNGnsrHxrkSSpzWLg7Vl8pwB3d7DPUuDYiBhQmETpWGBpSunalNJHUkoHAWOAZwypkqRatcs7ql0NQUopddRBQifDjjo5/pnAmQAHHnjgrsqpjms+my33OgiOPjfXUiRJamcusDAipgK/AU4BKMwTcXZK6fSU0paImA38ovCdWSmlLfmUK0lSz+wyqHY1BKkLG4ED2q0PAZ7v5Pi19RzMvFGQtgO94Ju/yrsaSZLekVJ6GfhiB9tXAKe3W78ZuLmL42wAPlmBEiVJKotKDf1dDEyKiL4R8TFgGPBIhc5VPg9eBVvWZO1J/5VvLZIkSZLUpEp9Pc1JEbGRbIKGeyJiKUBKaSWwEHga+DEwreZn/G1thZ9clLUPPgFaxuRbjyRJkiQ1qVJn/b0LuKuTzy4FLi3l+FV1zaHZsm9/+Ort+dYiSZIkSU2sUkN/68u/tMDOrUD4KhpJkiRJyplB9ZYT4fUXsva0h/KtRZIkSZLU5EF18fmw4YGsPXYWDGrJtx5JkiRJUhMH1SUXwmM3Zu2h43xfqiRJkiTViOYMqsvmwMPzsvZBX4DTFuZbjyRJkiTpHSXN+luXbpsI65dm7f2PhK/9Z771SJIkSZLepbmC6rxRsGVN1h46zjupkiRJklSDmiOotrbCNcNh57ZsfcwMOGZmvjVJkiRJkjrU+EF12RxYPrewEnDqnTB8fK4lSZIkSZI617hBtbUVbhgB236frfcdADM35FqSJEmSJGnXGnPW30XTYf7H20Lq4ZMNqZIkSZJUJxrvjuodk+GZxVm7b3+Y+Wy+9UiSJEmSitJ4d1S/ejv02j2bMMmQKkmSJEl1p/HuqAJctDnvCiRJkiRJPdR4d1QlSZIkSXXNoCpJkiRJqikGVUmSJElSTTGoSpIkSZJqikFVkiRJklRTDKqSJEmSpJpiUJUkSZIk1RSDqiRJkiSppkRKKe8a3hERm4Fn866jRAOB1ryLqDNes+J5zYrnNSteI1yzj6aUBuVdRD2zb25aXrPiec2K5zUrXiNcs271zTUVVBtBRKxIKY3Mu4564jUrnteseF6z4nnN1Cj8LRfPa1Y8r1nxvGbFa6Zr5tBfSZIkSVJNMahKkiRJkmqKQbX8bsi7gDrkNSue16x4XrPiec3UKPwtF89rVjyvWfG8ZsVrmmvmM6qSJEmSpJriHVVJkiRJUk0xqJZJRJwSESsjYmdEjHzPZzMjYl1ErImIcXnVWMsi4pKI+G1E/LLw5/i8a6pVEXFc4be0LiJm5F1PPYiIDRHxZOG3tSLvempRRNwcEZsi4ql22/aOiPsiYm1hOSDPGqVi2TeXxr65++ybi2ffvGvN3jcbVMvnKeDLwIPtN0bEocAk4DDgOOCaiOhd/fLqwpUppSMKf+7Nu5haVPjtXA2MBw4FvlL4jWnXvlD4bTXFlO49cAvZ31HtzQDuTykNA+4vrEv1xL65dPbNu2DfXBL75q7dQhP3zQbVMkkprUoprengownAgpTS1pTSr4F1wKjqVqcGMgpYl1Jan1LaBiwg+41JJUkpPQhsec/mCcCthfatwIlVLUoqkX2zqsS+WRXR7H2zQbXy9geea7e+sbBN7zc9Ip4oDHNo2GEMJfL31DMJ+O+IeDQizsy7mDqyT0rpBYDCcnDO9Ujl4t+l3WffvGv+nnrGvrlnmqZv7pN3AfUkIpYB+3bw0QUppbs7+1oH25pyquWurh9wLTCb7NrMBq4A/qZ61dUNf08989mU0vMRMRi4LyJWF/6VUlKds28ujX1zWfh76hn7ZnXJoFqElNIxPfjaRuCAdutDgOfLU1F96e71i4gbgR9VuJx65e+pB1JKzxeWmyLiLrJhWnaGu/ZSROyXUnohIvYDNuVdkPRe9s2lsW8uC39PPWDf3GNN0zc79LfyFgOTIqJvRHwMGAY8knNNNafwP9rbTiKbAEPv9wtgWER8LCJ2J5sMZHHONdW0iNgjIvZ8uw0ci7+v7loMTCm0pwCd3Z2S6o19czfYN3ebfXOR7JtL0jR9s3dUyyQiTgK+BwwC7omIX6aUxqWUVkbEQuBpYDswLaW0I89aa9RlEXEE2VCZDcBZ+ZZTm1JK2yNiOrAU6A3cnFJamXNZtW4f4K6IgOzvvDtSSj/Ot6TaExF3Ap8HBkbERuBiYC6wMCKmAr8BTsmvQql49s0ls2/uBvvmHrFv7oZm75sjJYfQS5IkSZJqh0N/JUmSJEk1xaAqSZIkSaopBlVJkiRJUk0xqEqSJEmSaopBVZIkSZJUUwyqkiRJkqSaYlCVJEmSJNUUg6okSZIkqab8P7Qoa0c4o8ObAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ - "" + "
" ] }, - "metadata": {}, + "metadata": { + "needs_background": "light" + }, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(16,9))\n", "for _ in range(20):\n", - " samples = model.predict_all_layers_full_cov(Xs_augmented, 1)\n", + " samples = model.predict_all_layers(Xs_augmented, full_cov=True, num_samples=1)\n", " for i in range(2):\n", " s = samples[1][0][0,:,i]\n", " plt.subplot(2, 2, i+1)\n", @@ -457,39 +519,6 @@ " plt.plot(Xs_augmented[Ns:,0], s[Ns:], color=cols[1], alpha=0.3)" ] }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[1. 0.]\n", - " [0. 0.]]\n" - ] - }, - { - "ename": "AttributeError", - "evalue": "'Zero' object has no attribute 'A'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ml\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mlayers\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ml\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmean_function\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m~/Documents/PhD/Software/gpflow1.0/GPflow/gpflow/params/parameterized.py\u001b[0m in \u001b[0;36m__getattribute__\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 336\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 337\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m__getattribute__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 338\u001b[0;31m \u001b[0mattr\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mmisc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_attribute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 339\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattr\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mParameter\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mTensorConverter\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtensor_mode\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 340\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mParameterized\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_tensor_mode_parameter\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mattr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/PhD/Software/gpflow1.0/GPflow/gpflow/misc.py\u001b[0m in \u001b[0;36mget_attribute\u001b[0;34m(obj, name, allow_fail, default)\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mallow_fail\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 135\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mdefault\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 136\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 137\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/Documents/PhD/Software/gpflow1.0/GPflow/gpflow/misc.py\u001b[0m in \u001b[0;36mget_attribute\u001b[0;34m(obj, name, allow_fail, default)\u001b[0m\n\u001b[1;32m 130\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_attribute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mallow_fail\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdefault\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 131\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 132\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mobject\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 133\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mAttributeError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0merror\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 134\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mallow_fail\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mAttributeError\u001b[0m: 'Zero' object has no attribute 'A'" - ] - } - ], - "source": [ - "for l in model.layers.layers:\n", - " print(l.mean_function.A.value)" - ] - }, { "cell_type": "code", "execution_count": null, @@ -514,7 +543,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.7.3" } }, "nbformat": 4, From 87e2a9fb4190e0b959d6bf27f1c3083aa2532ac7 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Fri, 9 Aug 2019 11:21:30 +0100 Subject: [PATCH 11/17] unfixed tf version in requirements --- requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 244cd89..513941e 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,4 +1,3 @@ pytest tabulate -tensorflow==2.0.0-beta1 git+git://github.com/GPflow/GPflow@awav/gpflow-2.0#egg=gpflow From c7ff01149e0c8d7ea78f80106ad675c6cdd8afe1 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Thu, 15 Aug 2019 11:42:49 +0100 Subject: [PATCH 12/17] restructured multiprocess layers and create weighted layers --- dgplib/multiprocess_layers.py | 14 +- dgplib/weighted_layers.py | 61 ++ doc/notebooks/simple_example_multitask.ipynb | 241 ++++--- ...imple_example_multitask_with_weights.ipynb | 589 ++++++++++++++++++ 4 files changed, 800 insertions(+), 105 deletions(-) create mode 100644 dgplib/weighted_layers.py create mode 100644 doc/notebooks/simple_example_multitask_with_weights.ipynb diff --git a/dgplib/multiprocess_layers.py b/dgplib/multiprocess_layers.py index 83592e8..ded10cd 100644 --- a/dgplib/multiprocess_layers.py +++ b/dgplib/multiprocess_layers.py @@ -11,7 +11,7 @@ class MultiprocessLayer(Module): """ - Inherits from Layer class. Can handle outputs from different priors. + Abstract class defining multiprocess layer construction. """ def __init__(self, input_dim, sublayer_output_dim, kernels, feature=None, @@ -83,7 +83,7 @@ def initialize_linear_mean_function_weights(self, W): sublayer.initialize_linear_mean_function_weights(W) -class ConcatinativeMultiprocessLayer(MultiprocessLayer): +class ConcatinativeMultiprocessLayerMixin: @property def output_dim(self): return self.sublayer_output_dim * self.num_sublayers @@ -141,7 +141,7 @@ def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False): return samples, mu, var -class AdditiveMultiprocessLayer(MultiprocessLayer): +class AdditiveMultiprocessLayerMixin: @property def output_dim(self): return self.sublayer_output_dim @@ -189,3 +189,11 @@ def predict_f_samples(self, Xnew: tf.Tensor, num_samples=1, full_cov=False): var = tf.reduce_sum(tf.stack(var), axis=0) return samples, mu, var + + +class ConcatinativeMultiprocessLayer(ConcatinativeMultiprocessLayerMixin, MultiprocessLayer): + pass + +class AdditiveMultiprocessLayer(AdditiveMultiprocessLayerMixin, MultiprocessLayer): + pass + diff --git a/dgplib/weighted_layers.py b/dgplib/weighted_layers.py new file mode 100644 index 0000000..5f73ca0 --- /dev/null +++ b/dgplib/weighted_layers.py @@ -0,0 +1,61 @@ +from .layers import Layer +from .multiprocess_layers import MultiprocessLayer, ConcatinativeMultiprocessLayerMixin, AdditiveMultiprocessLayerMixin + + +class WeightedLayer(Layer): + """ + The basic SVGP layer class with weights on the KL divergence. + """ + + def __init__(self, input_dim, output_dim, kernel, feature=None, weight=1.0, + num_inducing=None, share_Z=False, fixed_linear_mean_function=False, + mean_function=None, whiten=True, q_diag=False, q_mu=None, q_sqrt=None, name=None): + + super().__init__(input_dim=input_dim, output_dim=output_dim, kernel=kernel, feature=feature, + num_inducing=num_inducing, share_Z=share_Z, + fixed_linear_mean_function=fixed_linear_mean_function, mean_function=mean_function, + whiten=whiten, q_diag=q_diag, q_mu=q_mu, q_sqrt=q_sqrt, name=name) + + self.weight = weight + + def prior_kl(self): + return self.weight * super().prior_kl() + + +class WeightedMultiprocessLayer(MultiprocessLayer): + """ + Inherits from Layer class. Can handle outputs from different priors. + """ + + def __init__(self, input_dim, sublayer_output_dim, kernels, weights, feature=None, + num_inducing=None, share_Z=False, fixed_linear_mean_function=False, + mean_functions=None, whiten=True, q_diag=False, q_mu=None, q_sqrt=None, name=None): + super(MultiprocessLayer, self).__init__(name=name) + + self.input_dim = input_dim + self.sublayer_output_dim = sublayer_output_dim + self.num_sublayers = len(kernels) + + if mean_functions is None: + mean_functions = [None] * self.num_sublayers + + self.fixed_linear_mean_function = fixed_linear_mean_function + + sublayers = [] + for i in range(self.num_sublayers): + sublayer = WeightedLayer(input_dim=self.input_dim, output_dim=self.sublayer_output_dim, kernel=kernels[i], + feature=feature, weight=weights[i], num_inducing=num_inducing, share_Z=share_Z, + fixed_linear_mean_function=self.fixed_linear_mean_function, + mean_function=mean_functions[i], whiten=whiten, q_diag=q_diag, q_mu=q_mu, q_sqrt=q_sqrt) + sublayers.append(sublayer) + + self.sublayers = sublayers + + +class WeightedConcatinativeMultiprocessLayer(ConcatinativeMultiprocessLayerMixin, WeightedMultiprocessLayer): + pass + + +class WeightedAdditiveMultiprocessLayer(AdditiveMultiprocessLayerMixin, WeightedMultiprocessLayer): + pass + diff --git a/doc/notebooks/simple_example_multitask.ipynb b/doc/notebooks/simple_example_multitask.ipynb index 85369ef..6a03733 100644 --- a/doc/notebooks/simple_example_multitask.ipynb +++ b/doc/notebooks/simple_example_multitask.ipynb @@ -81,7 +81,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 5, @@ -90,7 +90,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6oAAAD9CAYAAAC1H4rMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeZxbZ3n//c+tbTT77iXekzjO5hCCEycEaEyhcaAkbekC/OjylDZNgD5046mdAqUscbrQhV/BISmUthRSoIUEcJwFHLI0seOQxYnjJI4db/EyizSLNBpt9/PH0dGM7Rl7ZnSkkXW+79eLF8wZWToWss657uu6r8tYaxERERERERGpFoHZPgERERERERGR8RSoioiIiIiISFVRoCoiIiIiIiJVRYGqiIiIiIiIVBUFqiIiIiIiIlJVQrN9ApPp6uqyS5cune3TEBGRGvHUU0/1Wmu7Z/s8zmS6NouIiJdOdW2u2kB16dKlbN++fbZPQ0REaoQxZt9sn8OZTtdmERHx0qmuzSr9FRERERERkaqiQFVERERERESqigJVERERERERqSoKVEVERERERKSqKFAVERERERGRqqJAVURERERERKqKAlUREZEaZIz5mjHmmDHm+Ul+b4wxXzTG7DbGPGeMuazS5ygiIjIZBaoiZyprT/2ziPjd14G1p/j9dcDywn9uBDZW4JxERBy6j5HTUKAqcibasgE2rx/7UrfW+XnLhtk9LxGpGtbah4H+UzzkBuDfreMJoM0YM78yZydnir7hUW67dxcf+c+fEU+mZ/t0zgiPvtLLt7cfYG9vYrZPpXqNu495bHcvH/7GU/zH175I/ie6j5Exodk+ARGZJmshNQBbC8mPtYUv+60bYfXNzu+Nmd1zFJEzwQLgwLifDxaOHR7/IGPMjTgZVxYvXlyxk5Pq8Nkf7uQHzx0ml7dceFYLH1lz7myfUlV7rTfBB7+6FYDz5zVz78feitE1+Xjj7mOshQ27382uw3E22XPpDu9kre5jpEAZVZEzjTFOcLr6Zic4/au2sSB17QZ9uYuIp6y1d1hrV1lrV3V3d8/26UgFJdNZ7t95lF9ftYirz+3kP5/YRzaXn+3Tqmp3PXmAYMDw4WvOYdeRIZ49ODDbp1R9xt3HPP3EAzz/+iCfCP47XeE09wTervsYKVKgKnImcr/kx1OQKiLTcwhYNO7nhYVjIgA8+OIxkukcN1x6Fr955VJeH0ix5aWe2T6tqpXO5vnuUwf4+fPncPM151AfDvKtrftn+7SqU+E+5hvZd9BEkl8NPswvXn4eD+46xlAqM9tnJ1XCk0BVnQVFKszdkzre+D2rIiKndw/wW4Vr9JXAgLX28On+kPjHD599nXktUa5Y2sE7LphDfTjI/77aO9unVbWe2NNH73Ca37h8Ec3RMO++ZD4/2uGUTcsJCvcxj+cvYk3gGZpMiutHvk86m+eBnUdn++ykSniVUf066iwoUhlukOqW+/5lfKwMWMGqiBQYY74FPA6sMMYcNMZ8yBhzkzHmpsJDNgF7gN3AncCHZ+lUpUo9fSDOm8/tJBAwhIIBLl7Qwg6Vsk7q2QNxAK5Y1gHAlWd3MjyaZW/v8GyeVvUp3Mcce+KbHKaTN1z3IVh9M2/c+Tc0B7M8vT8222coVcKTZkrW2oeNMUtP8ZBiZ0HgCWNMmzFmvlZuRWbAGIi2ju1JhbH/jrbO3nmJSFWx1r7/NL+3wEcqdDpyhjk2lKJnaJSLzhq7rly8oJW7th0gl7cEA9pqcqIdhwY4u6uR5mgYgEsWthaPnzuneTZPrboU7mOeX/4ReB5WLmiFZRswwAXPpXjh9cHZPkOpEpXaozpZZ0ERmYlr1mGvvZUNX/k6N3/h37n76UNOsHrNOo2pERGRku0sBAsXndVSPHbJwlZGMjle7VGGcCI7Dg2wcuFYYH9OdxP14SDPKQt9sjXr2THvlzEGLlrQWtyzeuEFF7PryJDKpQWosvE0aoEvMgVbNkBqgKcv+DhfeW0O9aTY9t3/5V39uwlnBjWmRkRESrbzsBOoXjB/LFBdWciuPndwgPPmNus6M07P0CiHB1JOdrAgGDBcdJbKpSez49AA53Q30VRXCEeM4cL5LSTTOfb1JTi7u2l2T1BmXaUyqlPqLKgW+CKnMW722H/f/T2i4QC3dd1HX76Rh376wFiQeu2tunkQEZEZ2/n6IAvb62mtd8pY2bKBs5/6PI2RIDsOxsf6JaiCB4DnDznB6PhAFWDlwlZeeH1QGcIJ7Dg0cNL7dWEhg+8ulIi/VSpQVWdBES8USmNSl3+YHxxuYW3uYd419F26GOC7ubc5j7n2VrjvFt08iIjIjO08PDhW9ltYJA1s28h5dTFeOTY81tQvNaAmfowFqhedGKgucMql1VDpeAMjGY4OjnL+vOP37i6f20QoYIql5+JvXo2nUWdBkUoxhm3n/jGDNHJD8DHCJscvBh9nS/5S0jYId7xNNw8iIjJjqUyOvb0JVswrBKru7O7VN7Mk8Rz7Xt01VsGjGd4A7O1LML81OlbGWuCWr+7tTc7GaVWt/X3O+7Gks+G443WhIOd0N/HSkaHZOC2pMl51/VVnQZFKsZbnH/o2sIzLArsBeGP0CF9PRHjVnsUFR3bAvJUq/xURkRk5FB/BWlg6PogoBKuLH/0Q9/Bm0jZIREFq0f6+JIs7Gk467r6H+/oSlT6lqra/3wlUF3c0nvS7JZ0N7O3V+yWVK/0VES/k87B5PTv3HWFhNEXrz30U5q3koszzALxglzqPO+9dENA/bxERmb6xIGJc4FXYk7okcIw8AQ7abs3uHue1vuRJ2UGAtoYILdEQ+/qUUR1vX78TiC6e4D1b1NHAgVgSq8+W7+lOVuRMsWWDs/e0roWddW/gwrOXwOggLF/Lsvld1JNiZ36J89jRQd08iIjIjBw4MVB1Gydt3cjii64CYN95v+uU/25e5/vrTWI0S+/wKEs6T84OAizpbGRfvwLV8fb3JelqipxUKg3O5y6VydMzPDoLZybVRIGqyJlgXLffRHKYvakGLkpsc24SXtlM8OhznN+c5oXFH3T2DG3dqJVuERGZkQP9SepCAbqb65wDxkC0FRasYkldynnM2b8Oq2+Cg9vhodtm8Wxn375J9lu6lnQ2qPT3BPsmKZWGsQWSAwrufa+q5qiKyCTcRhbArsfvx9qrufD178Cbb4ZoCyx5CxemLuaeZ1/H/v6tGHBuKrR3SEREpml/f5JFHQ2Y8deQa9bBSJzurV8kGrjcCc6CwKHtsPByX89U3V8oY106aUa1gc3PHyGbyxMKKkcEzmfs8qXtE/5uUSFQ3d+f5E1LOip5WlJlFKiKnCkKwerOx14B4KLAa7D2J85xa7lo2wH+c+t+DsZTLFKDCxERmaH9/SMnZ7uMgetuwxjD4odfZ9/jT0PkdnX+ZSyjOtF+S4AlHY1k85bX46lJH+Mn6UyOwwMjLO5c6Bw4YZFjYXs9AAf6R2bj9KSKaFlH5ExR2CO0x86ngRTz6R8r7zWGc+c4LfD39CZ8fcMgIiIzZ63lQP8kZZlu519zlP12rnPM50EqOI2UOhojtETDE/7eLQl+TeW/sGUDB+/5HHkLSzoaxvY/j5v9Hg0HmdcSLTb1Ev9SoCpyJhjXyOJA2xUsnteNufL4vaja0yEiIqWKJTMMj2aL5ZfHKVyLFpkeDtku55j6IXCgUCo9GbfJku8Dr0K/jUPP3A8UMqeFe5sTZ78v7mjQ+yUKVEXOCG4ji9U3cyC0hIXtDcXh6+5e1DnNdURCAQWqIiIyY+41ZFGh/LJo3ILpvCUrSFDP0Js+quZ9wOGBERa0RSf9fXdzHcGA4chAqoJnVYUKGfkjZ78XgPlfv9L5/ExQPr6wo173M6I9qiJnjDXrsfk8Bx6/n6vP7R5rsFT4Yg8EDAvb6zkQ0xe7iIjMzOEBZ1/gWW0nBKrjFkznzftl2PMsR69YR3Mo5/vmfUcGUrztvO5Jfx8MGOY213HY74EqgDEcXfIeeOll5piYc2yC8vGzWus5NjRKLm8JBvz72fI7BaoiZ5D+ZIZkOseijsINxAlf7IvaG9R8QEREZuzooDO7cm7LBBnCNU7mdM6efgCODI5yrs/3qA6lMiTSOea3Tp5RBZjbGuXIoK7PWMuR5x+ijWaiJuMc27z+pGB1bmuUXN7SOzw68WdRfEGlvyJnkP3FkqyJ98Is6qjXng4REZmxI4MpwkFDZ2Nk4gcYw7xCUHZkMOXrIBUolvPOa60/5ePmt0ZV+lsoHz9y5HXmNQbgL+OTzn6fVwhOjw76/D3zOQWqImeQAzFnNXay9vaLOxoYGMkwMJKp5GmJiEiNODqQYk5zlMApyi0VRIxxy3nnnSbrN6+lnsMDKayP9/K65eNHG1Ywd8HSsS1M4/ptuOa21AEouPc5BaoiZxC3scDCE5tcFLiZVjUgEBGRmTgymCoGCZOpjwRpiYYUqFLIKsNpS3/ntdaRTOcYGs1W4rSq15r1HDVdY4G9G6yuWX/cw7QYIqBAVeSMcqA/SVdTHQ2RibeXu+3xD6qhkoiIzMCRwVSxtPdU5qmUFRjL+M05TXDvlgYf9fl7ls3lnX2n4z9jE5SPdzYVOiUrUPU1BaoiZwprORgbGcumTlA+5GZUD8bUsEFERKbPLf09nbktUWW7cAL7zsYIdaHgKR/nZlz93vm3Z3iUvOW0WftgwBm7d2RgtEJnJtVIXX9FzgRbNkBqgKOD13FOd9PYPLto63HlMi31IaLhgG4eRERk2oZHsyTSuallVFuivHx0qAJnVd2ODEwxA10oZfV7FvrIFPf0ghZDRBlVkepnLaQGYOtGjvbHnFXIwtB1UgPHZVaNMYUvdq1AividMWatMeYlY8xuY8y6CX6/2BizxRjztDHmOWPMu2bjPKV6TCeImNcapWdolGwuX+7TqmqHB1JTer/c0mC/Z1TdwHMqI2fmtURV+utzClRFql2h0cDIqo8wmA0z98nbnCB19c0TDsnWCqSIGGOCwJeA64ALgfcbYy484WGfAL5trX0j8D7gy5U9S6k20wki5rZEyVvoHU6X+7Sq2tEp7umtCwXpaor4fpaqu5A+lfdsbkud7/f0+p0CVZEzgTEcXX0LAHNN3Dk2yZB1BaoiAlwB7LbW7rHWpoG7gBtOeIwFWgr/uxV4vYLnJ1VobCboFDKEzU6GsHfYvxU86Wye/kR6Snt6AbqbnSy0n/UMjRIMGDoaJpnTO87c1ihDo1kSfu+U7GMKVEXOBNZy9MEvAjCXmHPshOHYrrnNdRwdHPX3rDYRWQAcGPfzwcKx8T4NfNAYcxDYBPzhRE9kjLnRGLPdGLO9p6enHOcqVeLokJtRPXWjG3C6soLTHMev+hLO3727+fTvF0BXU8T3gWrv8CgdjZFTzul1aUSNKFAVqXbWwuZ1HN35MABzP3IvrL7JKf+dIFid2xJlJKNZbSJyWu8Hvm6tXQi8C/gPY8xJ9wXW2justaustau6u7srfpJSOb1DaRojwUlHoI3XXQhU+3xc+ts75Pzdu5pOnx0EJ6D1e6l073CarqapBvZu1t7f75mfKVAVqXYP3QYHt3N0kdPnZE5L1CnYW7DK6fp7Qvmv27DhmFYgRfzsELBo3M8LC8fG+xDwbQBr7eNAFOiqyNlJVeodHqVritnBzkJw5ufSX/fvPtX3rLupjp5hf1c89Q6PTjmwHwtU/fsZ8zsFqiLVzO34e2g7R0friIYDtDz0Kdh2uxOoXnNSI89iEwx1/hXxtSeB5caYZcaYCE6zpHtOeMx+4OcBjDEX4ASqqu31MSeImFrQ1VgXoj4cpNfHpaxuGW/3NDKE6WyewZR/K56m8xnratZiiN95EqiqBb5ImRQ6/rL6Zo4e3s+87OuYbYWOv9fdNmEzJc1qExFrbRb4KHAf8CJOd98XjDGfMcZcX3jYnwK/b4x5FvgW8DvWz6kemVa2C2vpbIrQl0gXf/Ybd3/uVPeodqsBFX3DaTobp/YZ62iIYAy+Xgzxu9NvQjiNcS3w34nTrOFJY8w91tqd4x7mtsDfWGiPvwlYWupri/hCIVg9+vAXmOM2Upqk4y+Mlf66TTFExJ+stZtwrrfjj31q3P/eCVxd6fOS6tU7nObypR2nf+CWDZAaoKvpPU7QZa3TMyHaCmvWl/9Eq0Tv8ChNdSGi4eCUHl8sZR0a5ZzupnKeWlVKjGYZyeSmXCodCgboaIjQoz2qvuVFRlUt8EXKqXADcJR25ppTd/wFaIiEaI6GOKbSXxERmaJsLk8sOYVGN+6WlK0b6Uq+6gSqm9c7Df5SA77KrPYMjU45mwpjpax+7ZTsNt6aakYVnODezxlovys5o8rELfBXn/CYTwP3G2P+EGgE3jHRExljbgRuBFi8eLEHpyZyhisEqfaJjRw1/8Gcq66EUM65IYBJM6tzmuvUzl1ERKasP5HG2ik0BnK3pABdjz7Ls7kAxApbUk5R7VOLplUqzfEZVT/qmWbzKeexEQWqPlapZkpqgS8yE8ZAtJXk5R8hlQ/S1Rwt7lmdqOOvq6upztcjA0REZHqK+y2nEngVgtVOBumnhbw1vgtSYXqjVgDaGyIEA8af41aspW94XPOpKWbelVH1Ny8CVbXAFymnNevpu+ovgMKsNnc1+xT7gLqa6+hN6ItdRESmxg2ephR4Fap9Os0gOYLEaTrllpRa1Ts8vdLfYMDQ0ejDDOGWDbB5ffHv3dkYdj4vWzac9o92NdUV59WK/3gRqKoFvkiZ9SZOuIE4zap1V2PEt6VFIiIyfe41Y0p7VAt7UruWXwFA38obnS0pPgpW09k88WRmWhlVcN7fHj9dn8ftae57+ocAdD722Snvae5qqmMkkyMx6t+RPn5W8h5Va23WGOO2wA8CX3Nb4APbrbX34LTAv9MY88c4jZXUAl9kGtwbiM4p7oXpbKpjMJUlnc0TCWlcsoiInFrvVPcPFraksPpmupb/Fry4jZ5LP8zyxuQpt6TUmr7EFAP7E3Q1+SyjOm5Pc++jL9FCN5EnvzzlPc3uHuDe4VEa67xorSNnEk/+H1cLfJHy6jsxo3oa7uP6E2nmtUbLdl4iIlIbeodHiYYDNEamMGpljZM57To27PzZRNp3e1TdctTpNFMCZ3/mnp5EOU6pehWC1d5HPkmXGXCOTfHz0jVu9uySzsZynqVUIaVaRKrduAYEHY2RKZVVdY5bgRQRETkdtzGQmWqwaZz9lgCxRNpXQSqMZVQ7p5lR7WiM0J/w2Z7LQrl4Py10MOQcm2KZeHfh/e3RPlVfUg5dpJpt2QCpOL2Z36K5LkQ0FIDN6yDadupmSgpURURkGnqHR6cddLXVhwGIJf0XRLjBZsc0ZoICtDdGGMnkGEnnqJ9K9vpMN25Pc6z+ThYvORu6bz7tmD1XcaSP7md8SRlVkWplLex+ELbeTu8r25ws6eZ1sPV25/gpViI7G50vdo2oERGRqYgnM3ROM+gKBQM0R0PEk5kynVX1mmmgWsxC+yW4H7enuT/Q4fz9pzBmz9XW4CyGxP3yfslxlFEVqWYLVsGh7fT19dBlY06Q6h4/hfF7OkRERE6nP5Fm+dymaf+59oaIf4KucfoTaUIBQ0t0erfS7Q2R4p8/q62+HKdWfdasx+bzxB7dTHvjuDF7UygXj4aDNEaC9Cf8txgiClRFqpcxcN1tAPQ90sIyc9g5fsVNzvFTfME3RoLUhQLFJkwiIiKnEkum6WiYXnYQnFJW3+25xAk02xsjU9/TW+C7jGrBcDpHJmfHPmPTeN86mvy5GCIq/RWpfgb6bAudZrD482n/iDHOkGxlVEVE5DRSmRzJdM7Jdk1Te0PYl6W/fYn0tEulAToanVJWvwX3sUJGdCafsY4Gfy6GiAJVkeplLWxeR/aJO+inmS4KLd233u7sVT3tkOwIvdqjKiIip+EGmu0zyaj6uPR3uvtTYew9jvks8OpPunt6w9P+s37N2osCVZHqdnA7MZqwBOh69yedst/C8dPpbKorjrURERGZzFhjoOkHEW0+zajGCqW/09VaH8YY6PfZe+YG5jNZDFFG1b+0R1WkWhkD576Dvra3wVPQ0VQHVzl7VqlvO+3+js7GCC+8PlCBExURkTOZmxGdaRAxPJolnc0TCfkn/zHT0t9QMEBrfdh/GdUZdkkGJ6Pqx6y9KFAVqW5r1hN7tRee2uo0IHAbLE2hCUFHY4RYMoO1dtrNHkRExD+KgeoMgoi2wp+JJ9PMaYl6el7VKpPLMzCSmVHQBYUMoc8Cr1I+Yx2NEZLpHKlMjmjYB7Nnpcg/S18iZyJriyVVbQ0RZ1/qFIPOtoYI6WyekUyunGcoIiJnuFLKMtsLcy5jPipldYOumWRUoZAh9GFGNRQwNNdNP0fm107JokBVpHpt2QCb148ryQrB5vXO8Snw482DiIhMnzujsq1hBo1uGvwXRJTSwRac98xvey5jyZmN84HjZ8+KvyhQFalG1kJqALZuJPbMDwBof/RzsHWjc/w0HX9h7ALqt1VbERGZnlgyTXM0RDg4/dtCP3ax7Us4jQpnXPrbGPZVYA+FLskzyNjD2PusQNV/tEdVpBoZA2udzGn80ReIchbR7V+C1Tc7x6ewIunHVW4REZm+WHJmo1YA2hv9V73jBkydjXUz+vNO6a+/ekjEEpniZ2W6/Dp7VpRRFalehWA1ThNtDDvHphikgkp/RURkavoT6RntTwV/LooW9/TONPBqiJDO5Umk/dNDor+UxRAfZu3FoUBVpFpZ6+xRtU20mUKgunn9lMp+QaW/In5njFlrjHnJGLPbGLNuksf8ujFmpzHmBWPMNyt9jlId4slMcXFzuqLhINFwgLiPAlV3T++Mg3sfXp9jibTTFHIG2hoivpw9KwpURapTIUhl60biTctpX3aZU/a7deOUg9W2ejej6p8LoYg4jDFB4EvAdcCFwPuNMRee8JjlwHrgamvtRcAfVfxEpSr0J9IzbgwEhXErCf8EEfGRNE11M9vTCxT3avqllNVaS3wkM+M9qsGAoc2Hs2dFe1RFqpMxEG2F1TcT23kWKxrDxT2rRFunVP4bCgZojoaK421ExFeuAHZba/cAGGPuAm4Ado57zO8DX7LWxgCstccqfpZSFWLJmTe6ASfj5aeMajyZmVGHZJe7KOCXWarDo1lyeVvye+aX90vGKFAVqVZr1kM+T3z7j51yGWPg2lshMPUV3I5G/7XAFxEAFgAHxv18EFh9wmPOAzDGPAYEgU9bazef+ETGmBuBGwEWL15clpOV2ZPK5EimcyVlVNt91sU2lpz5nl4YNxfUJ9dnd8G8tX7mgWpHg/9mz4oCVZHqtWUDdmSA+MjbnDJea+G+W5yM6pr1U3qKtoaIr24eRGRaQsBy4BpgIfCwMWaltTY+/kHW2juAOwBWrVo1tU3ycsZwg4hSAq+2hgiH44NenVLVi5WYUfVb6e/AiDunt5TFkAgH+pNenZKcIbRHVaQaFeaoDm39Orm8dZpcFPasTnWOKjidf1X6K+JLh4BF435eWDg23kHgHmttxlq7F3gZJ3AVH3GDpY4ZdrCFQrbLR4uiA8mZNwYCaI6GCAaMb94z9z6k1ODeL4G9jFGgKlKN3NE0l/wBAG33/5ETpF5x09RH1Fh7/Bf7FINbEakJTwLLjTHLjDER4H3APSc85vs42VSMMV04pcB7KnmSMvvcvaUlZbsawsRHMuTy/rjOxErokgwQCBjaG8K+GR8XHyl8xkoo/W1vdBZDrO5lfEWBqki1eug2YlmnOr/dHU9jnOOntWUDbF5PW0PYuQlxuwhv2VC+8xWRqmGtzQIfBe4DXgS+ba19wRjzGWPM9YWH3Qf0GWN2AluAj1tr+2bnjGW2uA1qZjrjEpwg11oYHKn9wCuXtwymMiUF9uCUWvtlz2Vxj2oJwX1nY4RMzjI8mvXqtOQM4EmgqlltIh6zFlJxYs/fD0C7GXKOb70dUvFTZ0cLZcNs3Uj7oYdIpHOMbrpl2mXDInJms9ZustaeZ609x1r7+cKxT1lr7yn8b2ut/RNr7YXW2pXW2rtm94xlNrjBUil7VNsb/TMObWAkg7WUlFGFQhdb3wSqzt+zlGZKY7Nna38xRMaUHKhqVptImViI0wxAG8PHHT+lQtkwq2+m/eCPAYhv+6Yzh3WqZcMiIuILMQ/2D7rZRT+Uso6VSpcWqPppX288maEhEqQuFJzxc7h7qDWixl+8yKgWZ7VZa9OAO6ttPM1qE5kOY6C+jfjiawFoc0t/r7gJ6ttOH2wWglW3ZDhmmxWkiojISfoTaZqjIcLBmd8Sul1s/VDKOhbYl1j62xih3yfZwfhIpqT9qTCW8e9PjHpxSnKG8CJQnWhW24ITHnMecJ4x5jFjzBPGmLUTPZEx5kZjzHZjzPaenh4PTk3kDHbNOmJZ54u9lYRzzDjHT6uwJ7Udp2Q4ZpucPaoq+xURkXFiyXRJ+1NhLIjwQ4bQzaiWUioNTobQL82B4skMrSW/X26g6o/gXhyVaqY0flbb+4E7jTFtJz7IWnuHtXaVtXZVd3d3hU5NpAoVAs34wV20hDKEPt3vlO5uvf30AafbOGnrRtovuQ6A2PJfdfaoKlgVEZFxnJmgpQURbYWyTD+MQ4sV586WniF0GjPVfnOggZG0J3t6wR9ZexkT8uA5pjqrbau1NgPsNca4s9qe9OD1RWqPMRBtJda5gvZs69i+U4Bo66lLeAt/ltU3037Vx+GpnxA779egu/f0f1ZERHwllkjT1VRaoNpcFyLkk7mgxT2q9d5kCGOJdElNhs4E8WSG5XObSnqO5roQ4aDRHlWf8SJQLc5qwwlQ3wd84ITHfB8nk/qvmtUmMkVr1hPbs5U2d7XVDVanEmiucTKnbdk84OwP0R5VERE5UX8iXXIQYYyhzSfNgeLJDAEDzdHSbqHdDGF/Ms1SGr04taoVH8nQWmJgb4zx1UgfcZRc+qtZbSLlE0+e0IBgOoGmMUTDQRoiQacFvoJUERE5QSyZLnm/JTilsH4YHRJLpmlriBAIlHZN9UsDKmstA8lMyV2SwclC+2Wkjzi8yKhird0EbDrh2KfG/W8L/EnhPyIyRfGRNOd0l7bS2u6TVUwqxBcAACAASURBVG4REZmeVCZHMp0ruZkS+OdaE/co6BrrYlvb79lIJkc6ly+56y9M8BmzVovwNa5SzZREZAbiCQ+aXDSEfdHgQkREpidebAxUeqDql2tNfCTtSdDllwZUcQ/m9AKwZQMdQ7vocwN7t3Hklg0lnqFUMwWqIlUqk8szNJr1oAW+SmVERORk7rWh1I6sznNEiI/U/rUmlsh4Etg314UIBkzNv2duoFrSHlVrITVAe/8zxOPx46YbkBrQNIMapkBVpEoVV7obS7uBaGuIFLsUioiIuIozQT0o/fVNRrWwR7VUxhja6sPFcTe1yg3ES8qoFppJti9YQTwTJP/pdidIXX2zGkXWOAWqIlWq2AK/xAtie0PtXwhFRGT63FEfXuxRbW0IM5rNk8rkSn6uahZLZjzJQIMb3Nf2QvKAV6W/xtB+ybXkCTBIg3NMQWrNU6AqUqXiI4Uv9xL3wrQ3RBhMZcjm8l6cloiI1Ai346wXzYHcuaK1nFVNZXKMZHKevF/gVjzV7vsF4+9lSlwMsZb23d8DoN82O8c2r1fZb41ToCpSpWLFvUOlZ1SthYGR2r4YiojI9MQ8bqYE1PSeS/c66kXpL/ij4smTZkqFPantr34fgNjvPu6U/W7dqGC1xnkynkZEvOdVpzx371EsmaGzqa7k8xIRkdrQn0jTHA0RDpaet3Crf2o5Q+iORvEisAcn4N35+qAnz1Wt4sk0daEA0XBw5k9iDERbab/4Wni6sMCyttDtN9qq8t8apkBVpErFPGpy4V5Qa30fjIiITE8smfYs6Gpt8EGgmnAz0B6V/vqhmZJHc2dZs56OvgQ8/ZBzf1RosKQgtbap9FekSsWSGcJBQ2OkhFVI/DNUXEREpieWzHjS8RfGymEHarr015smh672xggjmVxNN6By5s569BkrVogVPmMKUmueAlWRKjUwkqa1PoIp8Yu4zQer3CIiMn2xRJoOD7ODUNvXmphXHWwL3Oep5R4S8WSmmG0vVVNdiHDQ1HwWWsYoUBWpUs5QcQ+GsBdWIGu5wYWIiExff8K70t+GSJBw0BS7vNYiz/eo1p+QIaxBAyOZkqcXuIwxtDVEis0mpfYpUBWpUl7tHWqMBAkFtAIpIiLHiyfTnpX+GmNora/tcSvxZIa6UID6ErfkuNzFaHfvay3ybI9qQUdDpKYDezmeAlWRKuXVl7u7AqlmSiIi4kplciTSOTo8ClTBKWWt5T2qcQ+bT4E/9vXGR9Ke7ekF5zNWy4G9HE+BqkiV8rIbY3tDuKZXuUVEZHq8GoE2Xlt9bV9rYh5nB93nqtWKp1QmRyqTp9Wj0l+AjsYI/Vp49w0FqiJVyFrrZFQbvWvYoFIZEX8xxqw1xrxkjNltjFl3ise91xhjjTGrKnl+Mrvca0KHx9muWg5U48m0p4Hq2Pi42nzP3CZR3gb3qhDzEwWqIlVoJJMjnct719K9obb3DYnI8YwxQeBLwHXAhcD7jTEXTvC4ZuBjwNbKnqHMNrchjVd7VAFa6yM13cE2lsx4WvobDQeIhAI1G3gVs/Ye3csAdDQ6s2ettZ49p1QvBaoiVcgtA/JyqLgCVRFfuQLYba3dY61NA3cBN0zwuM8Cfw2kKnlyMvv6Pe5gC25GtTaDLnB7R3j3fhljaK/hiqd48TPmbRY6l7cMprKePadULwWqIlXIXen2cqh4rV4IRWRCC4AD434+WDhWZIy5DFhkrf3RqZ7IGHOjMWa7MWZ7T0+P92cqs2Iso+rtHtVEOkc6m/fsOauFsyXH29JfcAKvWl1IdkcVeTVHFcYWVjSixh8UqIpUm8L+VCisQnpQ3tLWEGY0myeVyZX8XCJy5jPGBIC/B/70dI+11t5hrV1lrV3V3d1d/pOTihir3PE2owrUZPnv8GiWbN56mh0EaK3hiqeBYsMu7z5j7sKKFt/9QYGqSDXZsgHuXUcsOQoUAtV71znHS+CHoeIicpxDwKJxPy8sHHM1AxcDDxljXgOuBO5RQyX/6E+kaa4LEQ56dyvYWsPjVuJlCLrAWSio1WtzvPA5aPOw628xo1qj75kcT4GqSLWwFnY/CNtuJ/7kdwBoe/xvYdvtzvESMqt+GCouIsd5ElhujFlmjIkA7wPucX9prR2w1nZZa5daa5cCTwDXW2u3z87pSqXFkmlPGynBWEBSixnCeBky0OBkCOM1mIEG5z0LBw0NkaBnzzlW+lub75kcT4GqSDVZ6CQz4q89DUDbM1867vhMuSvA8Rpc5RaRk1lrs8BHgfuAF4FvW2tfMMZ8xhhz/eyenVSDWDLjfaDaULuBqpvB83qPamu9M26lFrvYxkcytNZHMMZ49pzuZ1YZVX8IefEkxpi1wD8BQeBfrLW3TfK49wLfBS7Xqq3ICYyBtc4/ndijwzQyQsTkYPVNzvESvuhr+eZBRCZmrd0EbDrh2Kcmeew1lTgnqR6xRJrOJq8zqu6iaO1da2Jl6GDrPl8mZ0mmczTWeXJbXjXK0XyqJRoiGDAKVH2i5IyqZrWJeMxC3DbTxnDx51JpT4eIiIzXn0jT4XEZa2txUbT2rjXl2qPqBnK1eH2OJzOe7k+FsZE+/Sr99QUvSn81q03EC9Y6jZO23U6MJtpNIVDddrtzvISyIGVURURkvHgZ9qg214UImNrs+lsMVD0OvIpbc2rw+uzMnfX2/QJ3pE/tBfZyMi8CVc1qE/HKIaciPtZ4Du3nXO6U/Y47PlPRcJBoOKAvdhERIZXJkUjnPC9jDQRMzY5biSWdLskhD7skw1jFUy2+ZwOFPapea2+I0K85qr5Q9mZKmtUmMkXGQKgO5q1kIDLPKaG6dgPMW+kcL7EZQS0PFRcRkakrdrD1OKMKToawFveoxpNp2hq9zw7Wdumv93tUodApWfczvuBFoKpZbSJesBbmXQJHdhAbGHBWuu+7BY7scI6X2BGwtT5cHPAuIiL+5QZFXu9RBSfwqsXqnVgy4/loGhi/Nae23rN0Nk8infO8VBoKGdUae79kYl60FyvOasMJUN8HfMD9pbV2AOhyfzbGPAT8mbr+ipzAGFi7gZyFgYeDtD/5jxD+Lqy+GdZu8Cijqi92ERG/iyXcUStlCLzqw/TVYFlmfCRTpverNkt/3X3K5cmojo308XL0jVSfkjOqmtUm4iFjGHzbX2EJ0OY2U/IgSIXaHiouIiJT52ajOspV+ltjQRcUyljLkB2MhAI0RoI1V/E0UJjb3lqG4N4d6TM8mvX8uaW6eLJH1Vq7yVp7nrX2HGvt5wvHPmWtvWeCx16jbKrIJKwldp8zS7XdDDnHNq8vuewXxoaKi4iIv8WKe1S9D7ycZkq1d62JJdKeN59yOft6a+s9K1eXZKjtBlRyvLI3UxKRKbIWNq8n/qyzvtP2gX91yn63bvQkWG1vcJoPWA+CXhEROXMVS3/L0JG1rSHMYCpLLl8715psLs9gKluW0l9w9/XWVtA1Nne2fIGqOv/WPi/2qIqIF4yBaCvx834dnoe2xohT9gsQbS25/LetIUw275TKNEfLsyosIiLVrz/hjFqJhLzPV7gZtMGRTFm6Cs+GwZRTYlqujGp7Q6Tmuv66W43KsRjifq5q7T2TkylQFakma9YTe+oAPP+cs2JYaLDkxR7V8UPFFaiKiPhXrEyjVmDctaaGAlU3ICpnRvX1+EhZnnu2uOXfrWXJqNbuSB85nkp/RapMce+Qe0H0qKOd9nSIiAg4GdWOxrqyPHdrDY5bcUulyxV4tzWEay7oGhjJEDDQXOd9TsxtAtaf0P1MrVOgKlJl4snCl3vU2y/3Wh4qLiIiU9c3nKazXEFXofS3lrrMuwvI5Zg7C85C8sBIhnwN7euNJzO01ocJBLwfH9MSDRMwtbUYIhNToCpSZWLJNG0NEc+/3FUqIyIi4GZUy5UddJ53oIaqd8bmzpavXDpvYShVO+NW3HuZcggEDG0NETVT8gEFqiJVJj6SKUs799ZCQ4OBGlrlFhGR6bHW0p+oQEa1hhZFY2WcOwtj71ktLSTHk5myBfZQm52S5WQKVEWqTDyZLsuXe7H0V3s6RER8a3g0SzqXL1vQ1VKDpb/9yTSRYICGSLAsz+/Os62l9yyWTI/12iiDDmVUfUGBqkiViSUyZflyDwcDNNeFam6ouIiITJ17c1+uQDUYMLREQzWV7YonMrQ3hjEeNTc8kVvxpIzq1LXV4EgfOZkCVZEqEy/jvo5WlcqIiPhaXyFQ7WwqX7arrdAcqFb0lzk72F6LnZLLnVFtrL1OyXIyBaoiVSaWzGiouIiIlEWsmFEtz3gacPcP1s61Jl72QLW2xseNZnMk07my3cuAez+Twdra6ZQsJ1OgKlJFUpkcI5lcGTsLKqMqIuJnxYxqmUp/AVrrwzW137I/kS7uIy2HlvowxoyNwTnTufcZ5aoOA2embTqbJ5nOle01ZPYpUBWpIm6pVLm+3NsaIjW1yi0iItNT7j2qUCj9rZGgC5zAq5wZVWdfb+1kod3KrUqUS6tKrLYpUBWpIuW+gWhvCNfMiq2IiExffyJNXah8HWzBGbdSKxnVfN6Wfb8lONfnWql4cqcLlLv0d/xrSW1SoCpSRdy9Q+W6ILbVhxlMZcjltadDpNYZY9YaY14yxuw2xqyb4Pd/YozZaYx5zhjzY2PMktk4T6msvmFnhmq5OtjC2B7VfBmvNdZadh8bIpPLl+01AIZSWfLWKTUtp9YK9ZAYSGZ4PT5S1tdwM8NlLf09MaOqvao1SYGqSBXpL/dQ8YYI1sJgjax0i8jEjDFB4EvAdcCFwPuNMRee8LCngVXW2kuA7wJ/U9mzlNnQnxilo4wdf8HZo5q3MJzOlu01vvroXt7x9w9z2WcfYMtLx8r2Ov3FMtbyZQfd5y93RvUzP9jJZZ97gLd/4SFePjpUttdxK7fKtq93ywbaf/bPhddKO0Hq5vWwZUN5Xk9mjQJVkSpSzKiW6cu9FoeKi8iErgB2W2v3WGvTwF3ADeMfYK3dYq1NFn58AlhY4XOUWdCfSJe14y+MZdLKtU/1mQNxbrt3F29d3kV3cx2fvueFsmVWi/sty5xRdcqly5dRffZAnK89tpe1F8+jqS7Mh//zZ6Qy5WlEVNY9qtZCaoD25+50XiuRdoLUrRshNaDMao1RoCpSRfqL+zrKVfpbe0PFRWRCC4AD434+WDg2mQ8B9070C2PMjcaY7caY7T09PR6eosyGvkS6rB1/wQm6oHzjVr7y01dprQ/zzx+4jL941wXs60vyX08eOP0fnIFyb8lxtTVEiJdxv+Xf3f8S7Q1hbvuVlfz1e1ey+9gw971wpCyvFU+miYYDRMNl2AdtDKzdQOvqD2LI07/ps06QuvpmWLvB+b3UDAWqIlUklkzTHA0RDpbnn2ZbDQ4VF5HSGGM+CKwC/nai31tr77DWrrLWruru7q7syYnnnIxquYMut3rH+2vNUCrDT3Yd4z1vOIvW+jBvP38Olyxs5a4n93v+WjBWxtpR9mZKEYZGs2XJDB/oT/LIK7383lvPpjkaZs2KOcxrifKDZw97/lrgzoMv4/tlDKHrNtBKgn5anGMKUmuSAlWRKhJLlvcGotaGiovIpA4Bi8b9vLBw7DjGmHcAfwFcb60drdC5ySxJZXIk07nKBapluNY8+OJRRrN53vOG+QAYY1h78TyePzTI0cGU56/nZlTbyjhHFcZtzSnDe+bu4b3u4nkABAKGX7xkPj99+VhZyrPjyXRZGym5e1I7zSD9thCobl6vst8apEBVpIr0J8rbAr+t2CVPgapIjXsSWG6MWWaMiQDvA+4Z/wBjzBuBr+AEqeXrRiNVo68QdJW79Le1sM2kHP0QfvTcERa01XPZ4vbisbefPweALbu8/xjHkmlCAUNzXcjz5x6vOG6lDBVPP37xGMu6Gjm7u6l47PpLzyKTszzw4lHPX8/JqJYpsHcbJ23dSGdLE71LrnPKfrduVLBagxSoilQLa4/PqJbhy7YlGsYYlf6K1DprbRb4KHAf8CLwbWvtC8aYzxhjri887G+BJuA7xphnjDH3TPJ0UiP6h8vbWd7VWtijOuDxtSaft2zb28fbzus+brzOirnNLGir5ydlClTbGso7zgfG/j9x56l7JZnO8viePtasmHPc8ZULWulojPDEnj5PXw8o79xZYyDaCqtvpmvRCvqGR52y39U3O8dV/ltTyrs8JCJTs2UDpAaIJd7JirktYyuG0VZYs96zlwkEDK31tTNUXEQmZ63dBGw64dinxv3vd1T8pGRW9SWc6u7OMo+niYQCNEaCnlfvvHJsmMFUllVL2o87bozhmhXdfP/pQ+TylmDAu2AllsjQUeayXxgLVGMeB6pPvhYjnc1zzYrj95cbY7hscTtP7Yt5+nrglC+3lXOczxonc9p59wv07ekrNlhSkFp7PMmoaqi4SAkKrdbZupH+wYRzQSxjq/X2Cg0VFxGR6uJm68o9ngacLrZeX2u27+sHYNXS9pN+96Yl7STSOV7tGfb0NfvLvd+yoJhR9fg9e2Z/HGPgjYvbTvrdqqXt7O1N0Dvs3fb0fN4SL2dG1WUMnU0R4smM04BKQWpNKjlQ1VBxkRIVVgJHVn2EkXyQ9sdvLWur9baGMAOaoyoi4jtjgWplAi+vq3e2vxajq6mOxR0NJ/3uDYucQOyZA3FPXzOeTJe94y+M6yHhcUb12YNxzu1uojl6cobz8kLAv/0177KqQ6kseUt5M6oF7l5rLb7XLi8yqhoqLlIqY4hd/QkAOhhyjpWpjKWtPqwvdRGRanJi5UyZGsL0JdKEg4aWaPl3frU1hD3fb7l9Xz+rlrRPuF90WWcjzdGQ54FqfyJT7MhbTnWhIE11oeI8dS9Ya3nmQJxLF52cTQW4eEErkVCApwqZai+49xdlz6gCnU1OZUDfcBnuaSr0b1JOzYtAVUPFRUplLf0PfAGAdlMoWypT97r2hgixMg4VFxGRadiy4fjve7dHwZYNnr9U/7BTklnuxkDgZFS9XBSNJ9Mc6B/h0glKWMHpwXDpojae9TBQtbZCZawF7Y3eLiQfjI3Qn0gXs80nqgsFuXB+CzsODXj2msVAtQLBvZtR9TxQreC/STm1inb91VBxkQkUvgBjOzYD0PG73y5rq/VWlf6KiFSHcT0Kit/3ZexR0Jco76zu8ZxFUe8CiBcPO9VGF8xvmfQxb1jYxq4jQ6QyOU9ec2g0SzZvKxaodjREiiOEvOBmlyfLqILzfr54eAjr0WfNLfeuxL7eYkY14eEI6Ar/m5RT86L2Y7pDxX9OQ8VFxim0Wu8/91fgRWhvrHPKfqEsrdbbGyIMj2ZJZ/NEQppQJSIyq9zv+60bnf/A8T0KrPXsOtCfGC17x19Xe0OEwVSWTC5POFj6tWbXkUEALpjfPOljVi5sJZe3vHh4kDcuPrnh0nTFC9VH7ZUK7hsjnmYHnz80QCQYYMW8yd+zC+c3861t+zkymGJ+a33Jr1nJ0t+uwme518uMqttBGCb/NykV48VdqoaKi5RqzXpi5/4KUGhy4X5RejiaxuUO4dYsVRGRWTS+vHDtCSWF1946FqR6WHIYS2Yq0vEXxko/vWqo9OLhQTobI3Q3TX7+5xcCspePDnnymv3FoKv8ZazgZFS93Nf70tEhzpnTdMqFgvMLGepdh715z9yRRJV4z1qiYYIB48xS9dqJ/yYVpM6KkjOq1tqsMcYdKh4EvuYOFQe2W2vv4fih4gD7rbXXT/qkIj7Un8xgzNig9HJ9Ibo3Kf3JNHNaomV5DREROYXx5YX7HoVFb2ZbfgWP5C6h3QzxW393AaE/exHuu2WsC7wHmdW+4dHivr5yczNq8WSa7ubSg+NdR4a4YH7LKffXLmpvoD4c5KUj3oyoGdtvWbmMqpd7VF8+MsQVyzpO+Rg327rz8CBrzp9T8mvGk2mMcYLIcgsEDB2N3gb3zlz7OFg4atv49+wv0GBS/OrtNzD3prsVrFaYJ23fNFRcpHSxRJq2+rCng8onUpzVVo4ueSIicnrGQF0LNHTCkR38z6FWPp75BBZDngBb4pdy51/NIWoynpUcZnJ5BlPZiu1RLV5rPAgisrk8Lx0Z4jevXHLKxwUChvPmNvHS0cGSXxPGRsVUbI9qY4RkOkcqkyMaDpb0XAMjGV4fSLFi3uR7esEJKBe01bPriFcZ1TSt9WECZb6XcXU2Rrwr/bXWCVK33s6L+UX8Nv9ATy6CxfDNfT18438+zbJf+bSC1QrSBjWRKtGfTFdk1dbdn+RlwwYREZmGfN7JqCb72JlfzMczf8AVgV08V/d7bOjYxCP5S/hK7hedx3pUchir4AxVGDcX1IPS39f6koxm86dspOQ6b26zZxnV4tzZCgaq4M1c0FcK5c8r5jWd9rFOQyWPgvtkpmKBPUBXUx29XpX+GgNrbyN31uX8WeYmSCfZHPlzfnjZU6TCrfzBi5eQyauZUiUpUBWZinLP07KWWGJcC/wydpVzX8Pr+XYiImekSs9L3LIBvvpOwGLnXMxfZn6HVhJsDP8jTSbF+y9u5LrAVm7PvofDtsOz7u/HhpybeS/KcKfCy6Dr1R4n8Dx3zumDrhXzmukdHvVk32I8mSFgoLkCc2fB2+vzS4VA9by5kzdSci2f28S+vgTZXL7k140n08VFikrobq6jZ8jDParG8N1Lv8YLdhl/Ef4GKwIHufjXPsmG913Fy8NR/u1/X/PuteS0FKiKnE6552kVnr/fDVTLPK/LbXBQ9kBVw7JFpNpVel6itTASh0PbYdtXuP9wlCft+fx56C7aTMJ5zLavcMsqQyZQz9e613k2qqynwoGql0HXa73Oe7O0q/G0j11RbKhUela1P5mmrSFSsTJWL8ulXz4yRFNdiAVtp+/ku6yrkUzOcig+UvLrxhKVzah2N9fRMzzq2XidfC7Plzdt4w1mN9cHHncObl7POy+YwzUruvmnH7/C8GjWk9eaMh/fTylQFTmVcs/TGvf8sf5eOhrDZZ/XFQoGaGsIly9Qtfb4mz/3PxqWLSLVZDbmJRoD190GV9wEwFez17GAHt4bfNj5fchpcLcomuLt58/he/GzyVz+YU9GlR0bSgEwp0KBajQcpD4c9KTD/Gt9CToaI2PNBk/BzSC+cqz0PZf9w+mKNZ8CjwPVo8OcO6fplM2nXGcXFgD2FBYESlHpjOqcpgjpbJ7BkULwWMq/W2vZ9u2/Zl+qnt9ekcN8Ol6ca2/uu4U/+vnlDKWyfPvJA96c/FRUejGtylSmlkHkTFUYE/P8UCP3P7qXtzy+misCL3k3T6vw/NZC7OEA7U9/GcJ3lX1el+dd8txulFs2kB+J893Dc4nv3c8NqU8xN5qGg9udDIJHnStFREp2unmJ5bR2A889cR/b7AV8IvQfhEzeCV633Q5zL4ZoK7+2ahH37zzKQ0s/xjsvmlfyS7oZ1a5TjHfxWntDmP5E6XtU9/YmWNrZMKXHzmmuozESZE9P6UFXXwXnzoK3c0H39ia4+tyuKT12WSFQ3duTYM2K0l63ontUt2yge18EOJ+e4RSt9SEniIu2zmy8nzF8p2chTcEs173//z3+OyLayqWL23nTknb+9X/38ttvXlr25pfHLaaBcy7uYppP7qcUqIqcirX8988O8ac/uwy4jC/m3su60De5ycsg0hgSb/8s6Yfvp8MUSpXKPK+royFCX8KjPR1bNjhfpNfeSnZkgP/n0TYeya8AVvB/tyb4QeQTLA0cdW7CNIdMRKqJeyPq3gjC2I1pKTe8k3FHX+Qt38q9nQZS/EbwocK54HxP1rfCmlu4Jpenq6mO7z/zuieB6rGhUVrrwyV3k50Or8at7OtLctU5nVN6rDGGZd2N7PUgO9g3nObCs07fwMkrrfVhQh7MBU2MZjkymOLs7tOXSoOzeN0SDZX8nqUyOUYyucrMnS0Ecd2v/hT4BMcGU5z71OdLCuJSmRyberq54bKzqK8rhEjud0ThuX736mV85Js/45FXerhmRenjfE7pdItpPrifUumvyGS2bGD3f3+GT3z/ea5sjbO17sNcG9jGF7K/zt7/+SvvysKsJbbpcwC0UyhV8qh5xmQ6GiPEPFjlPm61775buKv9Jh7JX8InQ//O/ZGPEyTPhzMfY9SGnHI3H3ypisgZxFrYvA6AnDXcn3sT/3D7Rv7tX77IwBP/5m0J8LjRF+lt/8Km3Gp+oXE3zaawL3Dr7U6weo0TGIeDAd5xwRwefrmHjAdNbnqGRiu2P9XlRfXOSDrH4YEUyzqnFnQBLOtq8iRQ7R0erWgG2hhDZ1Ok5C62r/U5f/dlU9jT677usu7S37N4ocNzWyUyqoUgbs6lawHo+bffGgtSpxvEFf6NP76nj5FMjrUnLgyNe653XDiHlmiIu595veS/wkTn4P73K0cG+dKW3Xzxx6+w69ITFsvWbhjbVlXjlFEVmUghALvtZ/VEGOaLqVuYM38Rnzv8Ndak38CtTxnubFg/ttI10wCssNeg/5n7gCvo+MAdsO8fjy/zKENw19kU4Wf746U/0bjVvsEnvs7fj76B1eYgvxvcjDHwN+E7uDHzp3wn93N8cPN636wAisgZoLgn9XYOvuFj/N7zF7Er0QT7nF9/IbSRf1p6FWs8rJ6hrhUa5/DTwYUM0MQN6R/BgpVgwhAIQLTtuO/INefP4a4nD/Dka/28+ZyplXFOyFqODY2O7U+tUMlgR2OEfX3Jkp5jX//UGym5lnU18qPnXmc0m6MuNLMMcjrrzJ2t5B5VgM7GOvpKLP11A86pBqrg7FPdtre/pNd1K7W6KlUubQzd162HJx/gmG1zjk33PmPLBqfB2XW3sWXXMaLhAFe+8g9wuGXCaoq6UJB3XzKfu595nWQ6S0PEg1DqJ7fC6CBEW8iPDLIh/5v8y6N7sTh/j79/8BXeH/wQnwl9nbDJwaY/h/2PQbIPLvttb6s+qowyqiITMYbdl/0F5QT52AAAIABJREFUD+ZX8dtmE3NMHI7soHvhefze4sM8kF/FAVu4adi8HrbcOuPXIdpK/3nvA6C9sc75kl19syfNMybTUSjHyns1D2ztBu7JvZl+WlgX/lbxtN8ZeIo3NA9yZ+gD5J64veyZYhGRKSt8/+6/5I/5pRfeyqFcG/8U/r+8Uveb/DByC4vndHLjN55iy65j3ryetc7NaOIYd+eupoNB3hJ4Ho7sgMVXwIceOOmG8y3ndhEOGh56qWfmr1toxlLMqFawGYsTdJWYHZxh0JW3cKB/5kGymwnurGBG1Xm9CL0lZqH3FvbnLp1WFrqRQ/ERUpncjF/XDbAr9p5ZS8tDn6KOND1uoDqd+wxrYfeDsO127KZ1/GTXMa5u7iH61Jed45M8zy9duoBkOscDO4+W/nf4yefh5U1OguKlTXzqsRR3Pvoa7wv+hKcW/iNP193IjcEf8q3cz3NT5o/JzlkJT34Fjj4PQ4edKo0avq9SoCoyiTsf2Us0HOB3QvePHVy4ivce/nsA7oneMLap/aVNzorYTKxZT+yC/wMUOv65WcoyrpC1N0TI5S2DqRLLf7dscFb2Nq/j7tzVLDcHudS8CuEGuPwPMFfexE2pr7IvVc/9Z/9FWYNvP7dvF6kVxwZT/Otje/n/vvssf3n38/z4xaOezHaczPCbP87v7VtDJmf5n4u3ckPwccImx8WB1/jPZZs5b24zf/Rfz3B4oPSxHRgD197K8Jw38WD+Mt4dfMLJjsxbCdducDKqJ2isC7F6WefMg+VCdZB9YiPH4kN0N9WVv7PxOJ1NERLpXEnBz95eJ9icbkYVKKmhklt+W8lmSuA0uyo1uN/bm+Cs1ij1kalnk933zC0bnolicF+JLHRhwcVs20h3NM+xlTcWO/ROK1hduAqAV7few8HYCGsGv3/c8YlcvrSDBW31fO/pQ6X9HbbcCi/f6yxWzVvJ9w618I3cO7kx+ENuDX2Vzt5ttC88n1uuauIzHffx4/xl3HroDWN/fvVNsNbbbVWxRJpvPLGPdf/9HJ/4/g5+9NxhRrMz//dbKpX+ikwgmc7yw+de54bO1+mIj2txby2L5s/n8v27+N4DB/lwZCNm/krnS2bJW2ZcTtVfaDbR4e7rKHNJlnvh7U+kZ76XxFp45X54/WccyHfxpP0iH29/BDMCZJIQMHDtBn7B3sJZ29J8117DdWsu9+4vMZ7b0Mkt+XEzBl43QhGRssjnLXc+sod/fPAVRjI5uprqGEln+bfH93Hxgha+8GuXFudjeukzP3iB3ceG+Y+VO1j+/BfG9rdtXk/r1n/mn1eGeXfvlfzZd57lGx9aPaVRH5OyFu67hfsP15Oijl8KPuYcP7ID7rtl0pLFtyzv4rZ7d81sj2lh4XM4GyT1WJA5T3wOQj+qWDMWtwS0L5Ge0jzPibzWm6CrqY6muqnfsrpBbSl7LvsKQVfFylgLOhsjJZf+7ulNsGyKjZRc4zv/nj9vZg2kxoL7CmRUCxURrL6ZOXvn0TM8Cr8x1qF3Sp9tY5xAD3j8sd0AvDWw47QBYCBguOHSs/jKw3tmvvfbWkgNFoPUw4cP8cnMx7jCvMifh8Yq0/i9BwH4rXdZ9nzyY3wt9y7eEnietwef8TxI/d7TB/nLu18olryns3m+8cR+lnU1suFXVnLl2VNraOYlZVTlzFOBzNkDLxwlkc7xS313Ohf0vyzM0tr2FVjyZm4IPsZuu5CX7CLnS6bEi34smSYYMDRHK7N21NHofKmW1ORiywbIORnZTfkrAbg+8R3nd/NWOheKQIDgdRt4z+rz+enLPeWZ3TobsxBFxDOpTI6PfutnbLh3F29Z3sWDf/JzbP/EO3j6U7/AP73vUo4MpHjvxv9l654+T1/3J7uO8u3tB7np587h6vn2+O/xwhaMZR11rLvufB7b3cd9Lxwp7QWNgWgLd4euZaE5xmXmFef4vJUQbZn0+rF6WQfAzPcPGsOx1U7DqG5T6E1QoX4BnYVrTSkZwr19CZZ1TW00jau1PkxXU6S0QNUNuhorXfpbx0gmRzKdndGft9ayp2d4WmW/MC4LXWJwHw4aWip0L8Map/dFd3MdxwZHZ16RZmFr/gLm0cdicwymcNvwy29cQC5v+cGzJ2RVp3rPMe57hiM7+OvM+0gT4u/CXyFoxj3H5vWQz8NX3sr60Dc53+znzzO/T9w2Oo3gPLjHsdby9w+8zB//17OcN7eZH/7hWwrfwe/kq7+9CmstH/yXrdy1bX/JrzVdClTlzFKhwcd3P/s686NpVl91zfE3LlfcBIee4ueDTwPwaH6l8weuvbWki35/Ik17Q5hAuWdyFbhlOTOe1ebutTq6A+au5JH8SlaY/SwK9MLclfD7P4U1tziPNYZffuMCsnnLj57zuEte4fmLX/ZbN8Jftc2885+IVFQ6m+fD//kzNu04wi3vOp87fvNNnDunCYBIKMANly7gB3/4Fua21PE7//okOw4OePK6I+kcn/z+C5w3t4mPvWN58Ya3+H0x7ob3A1csZsXcZj6/6UXS2RLKkK2ldyDJoyNLuX5hCvPpuHNNObLDyaxMcsN58YJWGiJBtu6dYaBuLT0//mcA5lAIVCvUL6DDzaiWkCF8rTfBkmkGXeAEXqUEXbNV+ttZ4nsWS2YYTGWntacXnDLzuS11JQf3HY2R0ioPpssY5jRHnYxq4ecpsxbuXYfdejtb8+dzRWCX88e33Q73njoIXD63mQubR7jnp1tLuyf9hc/zTP4cvp9/C78f3MTiwDFoKGQu56107mf+7lw4+jx1JssXLuuhn1b+Ovt+p1O4B8Hqlx96lS/++BV+Y9Ui/usPruLiBa0YYwgFA/z8BXP5wR++havP7WLd/+zgf352sKTXmi4FqmeaatmHV+HzyOctm58/zD+/1MLm/32S3L3ly5wNpjI8/HIP77nifALXnRDoGODQdubPX8A55hCP5C92jt/xNmfFa4Z6htIVbYHvvtaMW+CPC9xTR3axLb/CaQoCsOTNJ+21On9eCyvmNvOD5w6XctqnPZ8hW89/ZN/BHdl388xFfz5WBjyel59V97nc/+9P/FlkFhlj1hpjXjLG7DbGrJvg93XGmP8q/H6rMWZpJc/PWsu6/36On+w6xud+6WJufNs5E97gzm+t564br6KjMcLv/tuTHBlIlfzaX35oN4fiI3z2hovHusKe+NqFn0PBAOvedT4H+kf43tMl3KQ9dBs/2j1CjiC/9N7/U3gNYMGqU5YqhoMB3rSkna17xmVUp9MsZvN6ju38KQDdH9k8s318M9TVWNq1JjGa5djQ6LSDLnAC1dKCrjSRUGBaJcdecEuNZ/qe7e115rFPdYbqeKW+Z/2JdMUz0ABzmuuIJzMz2wt9aDuv2Xn00M7q6//AKfstHD8la7m+6wjPDLWw/3t/Nf17UrfHx50/xz9lf4UOBvlw6G4I1TvdfOethOXXOf9eI43QOAdW38RFv/pJPvTWc/hW7u08Fb3qpE7h07Xp/2fvvOOjqtI3/j1T0ivphYTeQidUEQiglLVhrygWDJZdy6qADRug+7OjIFjXvoqu6AqoVBHpPdTQEpKQRnqbzMz5/XHvZCYhZVoI6jyfDx8yd+7MuXNnzr3nfd/nfZ69Ofxr5SGu6B/L/Kv6oG2kYBLoo2fx1EGM6BzGI1/vYfVBN4hI2QlPoPpHwjmqJp6FhpNtzdxzehz5ZTVcv2QTqZ/s4P9OdCC19iGu+DWOojnxZ1fO3HDTXX84H6NZcnGvqAZBqtoPEa30pI6MEWzRDqImqr+1x8jJ8QvKz62/XZiLN0IrJNvM3THgZQ1Ut7zTaCbyol6RbD9ZRInqs+bugHH7l3MZWfM6TxpvZ67xJq54eyPPvv0h5uWt9Fu1zMf3JymJCpNJebx6rvL4g8muj+GBB05CCKEF3gImAb2AG4QQvRrsdgdQJKXsArwKvHguj3HB6nS+2ZnFQxd14+Zhic3uGxHozQfTBlNRY+S+z3a45Ct6vKCCd9YdY8qAOIba2XM1plsEfeKCeXvtUefEndQWhe8K4+nhX063qMA6axzik2HMWXkEK9bMY1jtNg7llintE45cx9T7Vk77vwEQE+J7TpTlLQiz6VF1BhZhH0dprKB4qeaX1VDmpGhgQbmB8HNdHcRKNXaW8WQRkOoYHuDwa131ny0oN5zzCjRAdLAPALmlDiaxhIAu49nSQQlOh3YKU/o+h6ZCl/HNzw8huPTa2wH4fscxx9hcUiqWOFvfYV92GWvMA7gjsQB/UQPGKmWd2W0SjHtcea8H98HDh+p6Uv8xvhuxwT487jOb2lGPOfaZbZBRWMmjX+9hQEIIL17dt9nfurdOy+KpyfSKCWLGJzvYkVHk9LiOwBOo/lHQaB/ezPqZm9ao4jQMjs1mReH2HPUDVhlM3PGRQvd66aq+7H92Aq9e249DMp6phplUS72Vdms2uyUIWX0gjxA/PQMSQs9+MmU2dJsMQ2cwctylVNWa2HHR1y7f9PPLzq2puF6rIdRP71qgKiWkfcuv5t7oMTJEc0Ch/cLZmcg18xhbvBSTWbL2cJ57Akab4PPg189x265utPPVsOzeEewc8TtTtT/xfkYE838rsfZ42P5WXZkvtvOx4JCSqHi5q/J427vK45pST2XVg7bEECBdSnlMSmkAvgAub7DP5cBH6t9fA+PEOVqVf7cri5d/PsyVA+K4f2wXu17TLSqQ+Vf1ZdvJIuYvP+jUuFJK5ixLw0unYdakHna/TgjBfWO7cLKwkh+cYYYIQcaQJ9khu3F5zfcNFrXNCKKo15rk7H8DsCujyPF7bsoscqLHEuCtI9BHf06U5S3w89Lio9c4rU9wok7x17EeVbBRsS1wzqKmsKKG8HOYQLbAMqazfb3HCyrQaQTxoY6LV3UK9+dMhYHiSue+r8KKmnPuOwsK6wIgxxm2RcostgeNJdRPT+cIf6vAkh3zIy7Uj+TEUJaZhls32tNyZJmDccksMF5BEBVMPf2C0gowNBW6T4axj1v3BYWppv7t761jzmVJHDxdxge/HXf8M6O0Xdz3+Q40At68YYBdfsMB3jo+nDaY6GAfpv97G6eKXPNItgeeQPWPgkb78BbBkLuV7VK6v4ojpeLPZBuUrpxFZc5hDFH9WrcfUL35PvXdPvZmlfDmDf25dnB7/PRapuQu4G39G+yVnXjNeJW1mrV4lMsBs8ksWXMoj5TukY3SHwAYq6gzDu0chhCw+USRSzd9KSUF5TXnXFkwPMCb/DInA1VVvZKKPDZrB9EvMQL/YbfX9azSZZz1t6AutPrt/xdhegOrD+S5ntywSaAYzZJ/Hu6Jt8bMZ0NO0Ld9KKGXPsczF/hya8geFpsu4YeNO+DZUGXM6D7gFagcv7OBsu18rFT7xioLqZTeGCqKlTHuWld/PkjpnkSO7XvYJqgs72/7r7HXePBXQRyQafP4lLqt0X2klEagBDirxCiEmC6E2CaE2Jaf74Kfp4rqWhNzfzzAkI7tmHdVH4cqVpf1i+W2ER14b8NxftzreMD4w54c1h3O58GLuhEZ5OPQay/qGUX3qAAWrEm3elA7MLeW7VZ69C/TbrRubOm+qV5r+gwZhxYTOz553Kl7bk5JFTHBNp/3HFUJhRCE+Xs7nRR1paJqob4eU6mwjqKw3NAmQZdVQ8L5QDWhnR96reNL/I4uqiUXlhvOue8sQEyI8tt21kZqV2Yx/duHWK9F9s4PKblMv5VDMoFD5nhlmz2U+jXzYOVsDl/yDSvMQ7hNu4JAUQW+wWqQPLvFoS9OimZ8zyhe/fkIWcWOf+6XVhxkz6kSXrq6L/Gh9ieCwgK8ee/WZGpqzSxYne7wuI7CE6j+kWBZHNti71fKQnXxKKWKk38QVr3gnvHWzleUz4amUrtpMe8+eSPD1yXRq+YDBuTM5iHDDPKlKmHuziB1zTxYPpMNR/L5avspZozuzPgTryqUSjXAGR9Xy3XaNSwx/Y392SXwXLs6iW+nhI3Ui8rOjCKKKmsZ1yOy+f2FIMhHT7fIQHZmFLv02ctrjNQYzee0ogpKoOq0mJIQ4B1EzeB72G+KZ1BiqHLeh85QMoG2F1n1d6sdlkqK+XfW7j6McdM7zic3GrALPvjtOPvK/HhOu4QYCussgsTEuTzZt4S+4ihzam9TFPJA+Z0cWe46C8BmPu4wd+G6mifoXfMe3Wo+5oqiv7PmzbutIgeqYAPvjnetimzLcFgzD5aMg3dGwfuTlfdfMRNe6QnvjlMer5l37loEPPjTQkq5WEqZLKVMjoiIcPn9fPRavpg+nHduHmRXFr8hZk/uyYCEEB75ajdH8+0PQkoqa3nm+zT6xAVz6/DmqcaNQbNuPve220Z6Xjkr0k47NLeklPx3VzZDgkuIEzaiSPYsaoXA728v0FNksFN2VbY5eO3MKalWaL9tgPAA5+1WjhdUEBnojb8TfaIJ7fwQwvmK6rlmOlngo9cS6K1z+v58vKDCqZ5eoM7SxplAtcpgotJgahPqryUJk13seEW1rLqWI3nl9G/fCIuuOajzf1Lm/6FBsmzEUpv+72YEjmzWMG+9+w7+VDFNt1J57tCPDq1J5lymdHPMWZbm0KH/sj+Xdzcc55ZhiUzsHePQawG6RAby+fRhzLksyeHXOgpPoPpHgjopimQA281d2W3uRE1lqTVI8wtTqjuGMtcrKJaJtGURxQYdt9Y+xvPGm+moyeGxDse4LOwUP5iHMrHmRfaaO7pPlMFshvRfMG5ezFOfraVDmB9/r/1IUWA7ukqR8B86A6avZ/YQb/yp5lXj1dbX37WuUdP0ZmGz+F91MA+dRnBhxlt2LT4GJoawM6PIml13Apaq5rnsUbWM5zT1d808qCllX9I/MZgkAxJClAqlT5BScW4INagbp9lBCQFsl92cT24IURcUl2/6gLd+3MpozS4mjUiu/54aDbqJc5kfs5YiAnjFeI31PdxgKWSZjx8bx3ON4WkyZBSp2u/5u3YpRWWVTDs9hZc2FCGXz1SCxi2LFEp0dbFzc6VegD4Tqoogezvk7qUk7yRbNq1h7+8rqSnNh6ztynhVxWe3CHjwV0EW0N7mcby6rdF9hBA6IBhwrwdME+gY7k+ok9UqL52Gt24ciLdey4xPtttt4zFv+QGKKmuZf1UfdI5Wm9T597djz9HJt5IFq9ORy+1nhhzIKSU9r5zLKr6ub3lmj6iReq0ZoDnCbnMnTFI4fM/NKakmxsEKsrsQFuBNYYWTFdWCijpPVEfho9cSF+JbJy7kCMxmSX55DZFB5z5QBYgI8iavzPGgy2yWnCh0PlCND/VFI+BEoePBveU7Dm8DMSU/Lx3BvnqnhNb2nCpBSuifEOLYC9X+74j4blwQUsz3e3KQE+Yq1N1T25RiT1OvmzCX42Gj+L6iJzdrfyFUlNfpnziidxIf6scD47vy8/5cfrLTPiuruIqHv9pNUmwQj/+tp72f9iz0jgvGR+94otFRnFspsz8RzGZJYYWBWpOZ6CCfs21F1KpOk48dhZRkfjuHudu8+FkuwiiVm6wf1dymXck9uu8IqCxUbnwuWqUAdYFFpVFw28YI9ssOvKxfyFXaX4E+ULSXackPMy19JFPL5/DV77PoAq4t/NfMUxbxcYP4LsOXYzV+LDI+j892td8xPhnGqPTatfMJzvudO3VZvGK8hn3mDvTWnIBXekDyNLtoE0D9xT+w6uAkBgcVEbx9gXIuW/jeBrQP5fMtmRwrqKizVHAUlqxpm1RUnaH+2pyznadigc4MTH8bdi1s+pypC62Rmn3oMbLKNJChK2ZZGQKO/GbWzFPGnzCXj37LophAHtJ9Dd7XnD3nVs6m15lVXKdN5HPTWKbrfiBeFCjPuzJP1M+zdOM+njTOYJxmB68GfU5QdRb4hXFfxX95WqbytuFyTL8tY5b+C+V1LZiINwtbRoX6ez1ujuYl43WsqB6MVPOOwZRzo3YV9+v+i9+WReq4rWfVU2M0kVdaQ5CvnmBfvdvf3wOnsRXoKoToiBKQXg/c2GCfZcCtwO/A1cBqKf8Y2YzYEF9ev74/U9/fwuPf7uOVa/s1SyHeeLSAL7ZmcvfoTiTFBjs+oIUZAsz47d88kpPKmoLfGTvCvnvu19uz0Aszk4f0gonP1Z/Pzekb2OhADOj6NB8f9ONI74fosfll5Xk75rXBaKagvKaOHnmu0c7fiwM5pU699kRhZcsMp2bgrEVNYYUBk1kS1UbBfVSgD7mljt+fT5dWU11rrquMOgpvnZbYEF9OFjpxztS1TFtUVEGpqjpD/d2VqVg29Y93MFAFRQStqpjLM77gn7Uz2HqiiCESJSkdP7jpNaRGw0KuQY+RO3Q/Ktumr1cT/o7pndw+siPf7MhizrI0hncOU/rQm0Ctycz9n+3AZJa8dePAcxJougpPRdVB5JVV89wP+xk2bxWDX/iFEfNX02fOSh7+z27S88qUnVpBnff7PTlctC2Z9WIQt4/szAe3DmJh+FLGanbytulyrjA8yzFzNIx/zrXeOxtIKXn4UHf2yM68qX9TCVKHptZRbLtd+QSf3TUUrY8/M3TPUKlzQSK7LvhZhBHBG9rb6CVOMEGjBqlD7q6/wK8qgqzt3KZdQRAVLDReqmyvyIODP9ovYqNSWInuQ+bvX3M4t5xx5d8rmS3vpg3YLRiYqFzYXFE/s1Q1z3mgGuhFhcEJU/G6/sxUdh7PJ458Ine9oQZhjSyabBZagfFJDAstY5XXWCXYstBV7f292gTJhnfG8L5xEimanfTTHIPDDb53IZQKb3Qf7tf9F4GZN41TrM+7oNKMEGSaw3nCNJ3hvqd4u/0vBD2iVmmT78QrphdzO+ziFu1PvGO6jM+NKcrrJjRQp3Z0fMvvFVhhSuYSwwusN/flbu0PfKB/kbf0rzNSs4+FpsuZZJhHujlWHdcNyasGWH0wlxuXbKLXUyu58KU19HvmJya+tp6PNp6gxuiERYAHboXac3ofsBI4APxHSpkmhHhWCHGZutt7QJgQIh14CGhGevb8w4VdI3hwfDe+3ZnFp5ubNqLPLa3mH1/somO4Pw+M6+b8gOo15Qrtb8SRz5vGKciLX2jxnltda+Kbnae4uE8c7S59rlGv1ubHDIahMxj4t+kA7Ey41SEBv9zSaqSkfo/qOUSYSv11NAdSVl1LQXmN0xVVUMSBjhdUODy2pZoZ2QZiSgCRTlZULZTdjk709FrQIczfpYpquzbo6wVLoOr4OduZUUynCH+C/ZxItAoBk+YzeWhfAqnki3f/pbCZWkgOZxVV8k12KNdr1xApVG/olbOVe7WDeid6rYa5V/Yht6yGR77a0+RvXUrJ08vS2JFRzLwr+7g0r84lPIGqnZBS8uXWDFL+tZYPN55gYEIocy7txQtTenNJ31iW78th0uu/8sYvhzFXNVTndU045r0Nx7n/8530SQjj539exOxJPUhZdzWTypeywPttPtM/zxkZxLWGp0h/vr9rND8bEZb/bDvF8oIIHtV9wQStGjCqPat0mwwaDYlh/rx+/QDSq/x5ruxvjo9ngY04zTcbD3Cy2pcHdV/bzPGGk115HCSquFq7jpXmweTJYIX+3G2S/fRfKRV11tN7WW0eAMBYzU6ramsL57BTeABBPjqlT9VJtBn11+KlWuZEH4zav7zT3IUBGrWZXtI41cWy0BqSCvHJjC1bxtEqP070eUDJOm5e5NjvdcJciO7DymxfCgnmNu3KxikzUkK18t3GxMRxk3YVX5tGc9wcbTXRdpKyLqXkidxRaHRevPyPqXjfvQa0WuU3PHY23LUOEd2HObqPuFCzh2eMUzlijjvbxsbRBJbJBId/5FdTb+6t/QddRBa/eD/CTP0XpGh38zftZt7yeoPP9c9RIX250vAMu82dlHFXz3X4czaG4koD0/+9jds/3MbJwkqmj+rES1f15ZEJ3fHRa3l6WRoTX/u1LkvtQdtBSvmjlLKblLKzlPIFddtTUspl6t/VUsprpJRdpJRDpJTH2vaIHcd9KV0Y0z2CZ7/fz2/pBWc9f6bCwO0fbqWixsiimwfh6+VCBUFVvdcLE6m679kpu/L7G1NbVBJfmXaa4spabhyS0KRXa7NIUdgnieH+hPrp2ZlZ7JCAn2XxblFGPdeICPDGYDJTWu1YUvSkGix1dELx14IO4f6UVRsdtsfJK7Xcl9uoohrkQ15pjcMBtqV67GxFFSAxzM+piqplLdEWfb2gWC85GqhKKdmVWcQAR/tTbaH2kF+h3cAP5qGKHkbDILWBuOE7H3+CkGamJ4fWbwNwMoE+KDGUWZN6sCLtNM//78BZvxuzWfLiikN8tjmDGWM6c2m/WGc/7TmHWwLV891U3FUYTWZmf7uXx5bupV/7EH55aDSLbhnEbRd05Kahibx4dV/WP5rCpN4xvPLLEabnX0V18r2Nq+I6iH//foLnftjPpN7RfHLnUGJD/ZQgzCsIdD4gTYwIzOU/Xs8CcHPNY+T5dISLX7BattiLNfMUsZflMzmWV8ac/+5ihGYf04O2wujHlM+wZZESkNjcIC/oEs5dF3bi8y0ZbDvhhCG5ZV8hqB3/PG+aptBHHGO8Zof1+S2LrN6cQoBviBL4ADdpV2FEx39MY2DQ7UqPrr2LciGUcxXdh1XmAXQS2XTSnLZblEmjEfSJD2ZfVon9n7UBCspr0Ihzn4W0SODnO9qnqvp/FW7+lGzC6ac5qmy39EQ29r2nzIJJ82HifMYNVJr/V+88qASq9tJSLUwFIaD7ZD41jaO9yONCzV6FMtOwwmBTiaD7ZGYMCcVLr+f1kJl1FkPOWgp9ryqHPnxxd2JDfK2JEUu1dOVs2LIIrZC8HLsWf6q5v/Z+qnMOWm1sDv9oX1LJbFbFk+bCktGkZxdyj/EhuoosPvWaS4w4o1wLbDBce4BvvZ4k2EfDrcbHOZx95uyKsz1ocFzH8sqhz0N+AAAgAElEQVS4bMFvrD2Uz8xJPVj7yBgem9iDawe3596ULnx7zwg+nDaYmloTVy/cyNLtpxwbzwMPHIRGI3jtuv50CPfj1ve38NaadCoNRqSUbD5WyNWLNnIkr5y3bhpI9+hA5weyzGuVUXSNdh2RFPFGfj/lftFEZVVKyfu/nSAxzI/hdnq2NgohEEIwICGUHQ4K+FnokLFtRP21qCvnOehxaakOulL5cVbF1lLNjGqjHtXIQG9qjGZKqxwL7o/nV+Cr1xLlQoDdIcyf4spahy1qLB6mbdXXGxvsw5kKA9W19jN6ThVVUVBucLw/1RZqQeoG7WoMePG5aWx9L/k18+qJK+WVVvNFThRXBh4g7oo59V0EXLA5vGNkxzpF9Ps+21k37zMKK0n9ZDuL1h3lxqEJPDqhu/OftQ3gcqD6RzAVdwVVBhOpn2zn8y2Z3DOmM5/cMbTRJvXwAG9ev74/cy7txaqDeUzLvoxKaTNZLRYythWUFgK5/+3J4ellaVzUK4o3Gnoc3f4jDLtfuUFWFtJFk81HXi9Sgj93m2dRI7GqAdtjWWOxosnahmHzEh5Y/D+8MPCKfiGaylyoKrGquvqeTfH9h34Zsd7VPPHffYoRuyN0Z0sAYjaz9OM3yZSR1mrq0FSF9gv1vTnHzESJmKGzJocRmn18bhyL6dBKaxCwxo5gdbWy+C/POcImcy/GWYJjBxrak2KDOXS6zGkD+oLyGtr5ezVth9NKsFRUnbKoEZBm7gBAkjhRb3vTrxEgBAlTnqarOMUq80Bluz1Bqm0v8fKZHD1jYJM5ieu1q9EIxTapUcqMWokgZTaRlz3L1BGJfJcfSXrv+522FCqprOXZ79PoGx/MrSM6NP45fUMgLhmGphJ5z3L+r3cGB2UCLxhvstrZ2CPo9MFkeLk7/O9RqC7hTM4J7qh9BG9qedfr/wgQ6sIvZoDVfy0gBvwjaa8p4FPzLLzM1dxseoqM9lc4JjTWoIXhaF4Z1y/4mYryUr64exipozufZX8ghGBM90iW/2MUQzq24+GvdvPGqiMOVwU88MARhPh58fWMEYzrGcm/Vh6i75yf6PfMT1y3eBPVBhMfTRtCSnfn+xyB+omvu9bhI2q5W/c9m8xJrAm9Fn56/OzEk5T8ll7I7sxipo/qhDsu8QMTQkjPK6ekqtbu11iqTNFtVFG10GfzHLzXnFCDy8R2rlB/Fe0IhwPV0rZhOlkQUXfOHAvuTxQq4lNn6aY4gMQwpYJ90kH6b15ZDSF+eqeUvN2BaDUhUieoZMd9Z6fK/BnQ3slA1YY12Wv437iwazjvycuo3vyeEqyazZD+s8Ice3ccSMkrH3yKWcKM0C3W93GDt7EQgqcv7cUjE7rz8/5chs9bzYBnf2LUv9aw7nA+syf34IUrejtkB3Y+wB0V1fPaVHxl2mnS85zz0DpTYeCGJZtYdTCP5y5P4tGJPZqd/EIIbrugI69c04/Nxwq41fAY5VLNar07Dt65sD5FyNKb13AyqZngB7/cxaCEUN68YUDjfljjn1BUblUkaU7yin4hO0sDePybvch3RlkprC1VUmysaF4zXs2e8kBe1C4iWhQpC+BJ85VFbmMTSUr8jUXMMb+lmA9vOG4/3blBz+Gbh0PppztJimaXSs9cpEzgIXdDl/HWitXymbDlHeU9/MK4WfsLWUSwJken0H9P71Vony2NrdJ+N+iHY0Cv0H7V97SnRxWgV0wQBpPZ6d9ZW0ngW26EDiv/CgE+IaTFXwdAL81JZfvQVPBpoU9ZvaiP1exgs7kHZdLXbnsGJs5TfotbFvH5jjx0GLkmOVEZd/OiphMLNhXW6Rd2wken5c3V6U5nLeevUJRD507p03RyIWUW3PmL0let0ZBy02Pcof2Rj00Xs8bUz7pfU0GqxR+14IjSd71tMYZaSarpn+TIUBbr/2UVhQKI7a+818T58PABePgQAAmaPD72mofBqx237B9k/3fdwAIoPbeM6xf8gtlQzed9dzOwhZt6sJ+eD6cN4coBcbzy82FmfbMXo5OJnB/35jhFQ/Pgr4UgHz3v3JLM16nDuXt0J/7WN5b5V/bhl4dHM7yzC5VMW6SoCbGfHgfgFu3PdBCneX6XD7WbFtdPPK2Zh1w+izdWHyEy0JurB8a5xSZqQIJCUdztALU+u7iKQB8dAU5YvLgDkU4GXccLK4gJ9nGJrh0b4oNeKxwOVHPLqts06LKIODka3CvWNM5TpcFawT7h4HU3r6y6zXp6WTOP2MOfAIqqrV3FEinZlVGMj16jsC2cSajaJrAmzuO+lC4UmPz51DTOWlwpUvvns7aT9nQ/vjwdxa3an+igKz77vVyEEIJ7U7rw80OjeHRidyYkRTNzUg/WPZLC9FGd/3BBKrgnUD1vTcVrjCae/X4/U97+jXWHHXu/4wUVXL1wI/tzSll40yBuGd7BvhdKyZTcBbyuf5MdsjtTvV9VFuNZ2yF3H0T1Vm50K2cpi+sdH9WnCEjJga+f4673NxDfzpclU5ObVuUym2HJ6HqbJnnv5R/apXy9I4v3s+KU8aavt04Amx7Ueu+jWtFsKgpmoelSrteuZqJ2q/K87WK6sR+5GkRcPGII4zXbeW35LrI3fWkfpdOG8vBVVhhZRPCg+BwxLNWGzhkCk160BsgNKlY8fISLNNuJpIhPTOOVipW9Y6v9jquruhBIBcmaw3VVant6VAGSYhVxm7Rs51QN88sNbZK1tVCNnaqojn6MtPIA4sgnRKg3M4la6W4CNpnHcb0TMaLj187/tL9XVBUtqJZ6vjaN4mLNdiIvf04JzuykzIQFeDN1eCLf785W/BcbSRI1hy3Hz/D5lkzuGNmR3nEtKIeqFWTL535E9yXdRQaP1k7njFQpiJbPbZtIUn2EAUiaUndYj2+WbDF25V/6dxho6Qt+qqh+b4sFNn9315zi/R5byS2truvVaxE2ImNHfl/G9a8uQxoq+SL2S7q109l1Q/XSaXj52n7cm9KZL7Zmcs+nOxyiZEkpeXPVEe75dIeSWPDAAzuQ3KEdj0zowbwr+3D9kAT8vNwYnFnov2o7j9fTBTyp+5ijMk6xSbO0i6iJnq83prHl+Bn+Pq4L3r884RabqL7xwQjhmIDfycLKuipZW8BC/XVUxfZEQQUdXBAFAtBpNSS08+N4vuMVVVfos67CmeC+1mQm80yl09Y0FiS0c66imltaQ2RbnDN1viUceheAjMKKloslKmNoV2YRfeKC0WuE84kkC3NLCIZ0bMeFXcJ5Vd5Izqlj8GwoVCrxR7XU83BtKu0o4++6b6H9YFc+dbNIDPPnnjFdmH9VX1JHdya6jYTU3IHzSkzJ3abi3jotX949jPhQP6Z9sIX3Nxy3i4K26VghU97+jaJKA5/eOZSJvaPtH1TNrlw6YgALbhrInvIQbjU8pgSroASrz4YqQSqAyaj09qkL1vSlz3Lz9i74aUx8NG1w0z5zDfpl6hasxmr+ofuGizVbmWu8iY3Blyj7W8Rb3h2v/LMVnFk5G7yDKBlwHw/uiaeDyOVJ3cfWsRyoeD2t+wgTGl6ovbl+T25zKqdCUDP+ed4yXsFAcZjRmj11lai6Cm7DhbGlYjVhHvz0OHph4nrtGtaZ+5JpDrcuGFqqJGs0mLtOZrVpAKM1e9ALU+P9js2gU0QAPnoNadnO9anmlVa3ycVdrxGEB3hZM7b2Lp5Wz4XFo9hfYCQpTCi/veg+9X7HjcJWvfKaxwj21bPKZ7z951oN+FaYh1BMIDdqVynjgUOUmbtGdcJbp2XBZ/9tWp27kQC2xmhi9rd7iQvx5YHxXe0ayzY494npwav6tykmkNm1dyAjeys30iXjFIr+mrl1/b9sWQTvXaTMg6jeLDZdwlemMfxdu5TLtb9b3/+9i6yUfB81cLbcoG28GgceeIm3uu8lLbuUGZ/uwGBsYV6obIN92WVcb3gCDZIvvJ6ny5m1didwQMnuPjKhB3Mu7cVP+3OZ+v4WCu2o6pZU1XL3x9t5+efDTBkQxwtTets1ngcetCpsqycT5sLK2YzT7uR67WoWmi5l+Scv1+koHBkwm+e5g8HiIDcu719fq8KFqkagj57uUYEOCfidLKxwiT7rKgK8dfh7aevotPbiRGGlW5RJO4YHOFwdzC1rOw9VcC64P1VUhdEs6RjunFWeBT56LTHBPg6fs/y2Omfq+jNmqGL3cmLZ3ObnmxrY1mxawr7MM/RvH+Ky6KllDCEEL8RswCgFD9XOoFoqSsIm33Aer72dgzKR/9O/Q3BMJ6sLgAfNwh2B6nltKh4f6sfXqcMZ3zOKZ3/YT+on25vMUJnMkvc2HOeW9zYT5u/Ff++9gMEd2jk+qJpdmdQ7hgU90tgjO3GzYRaFshEhh15TVOriQo4/3YMbt3VG6H357L6LaN/cjcX2hjl9vRLUXfwC+IWhEZJX9AvpJHK4d09HMt+6RJmAh35UqAhZ2+DHx+otos1VJTxyuBv5BPOa/i38RY1yXFBfyKgpqO/VXlPAfbr/8j/zMH59/XaF3mw2N69yKiX/+egtsgm39qZaAoiWJrElux3dh2t1awH4yjRGWfgbjS336ErJ3gIzBYQwTrvD+p4OSIRrNYIe0UFOVVRNZkleWQ3Rwef44q5mE6OCfDhdYidNBuoCmIqcwxyXMST1H1Y/YeLTAl1anRs6nZYx3SNYeygf08V2nGsLVX7zQj7zu5nEdn6MGD7SWo11AOEB3tw8LIHvckI49vu3Z6tzp/9iFT6w/Fsxi3c+/JD0vHKen9Lb/ipNA0GnXsMm83DHDFaYh/Bp5WAYfDeUZCrn79CP6m9efW3WNng2lJXZPsw3Xs8lmt95ULdU/RA9rfvY9uc2oCHZMhbGxZmYO6U36w/nk/rJ9uarm0LwW+eHuK72aXww8IXXc3TRZNstMtYQt13QkTduGMDuzGIufXMDG4+erc5qwc6MIi59cwOrD+bx5CW9eOXafm1Gv/PAg7Ngof/aVFaffnI+/QLLuWd/D+YsWMLCtelcu3gTXr4B/Ev/jtJHD27zMh6QEMKuzGLM5pYX1EaTmVNFVW1aUQUl8HKkOlhSVcuZCoPLNFZQVIOPF1TYdb4syC+tbrP+VHAuuD9eoLQfueOcKcq/9ldUpZQq9beNKndCoJ00j/YijwwZpWxrar6p98W0Xg9hkBoGbfq72xJJSEmCyOMF7WI2mXtyveEJPjRezNSS6Sw1j+Yf2qWkaHepOijOuQ781eCOQLXOVFwI4YViKr6swT4WU3FoA1Nxf28di24exOOTe7L6YB5j/28d85cfZF9WCZUGI7ml1SzdfopL3tzAcz/sZ1TXCL655wISXaScsGIWE489z9tJhzio7cYVtS+w09zZ5sAiQSPg4rlsNPXiKsMcjGj5bPAxOkXaoU5ooRtoNFYacGUhRPchYMitLNa/ghENd2Zfqshl5+5Vgs/Bd8PWd+opEi/wvoOfCsOZpftM8aQEqxVNXHKjAkp1sF3kD0nlruExdBCneTp3BIZNS5RgsSmVUykp/+EJ3kgPY3BQCSOf+dVKZWypkmtDT+T0XuL9JaM0e/iPeQzGnDR4pVvzPbrqca/acxwNktGPfeu0RHhSbBAHsksduhGC0h9qMstzK3Jh038YU3Oc06XV9mcT1Qv8gZ4PIBEkrU+1XuCnr4eU2U2/1vY9gLE9IimsMLDrVAuV6DXz4L3xkLmVI70fYktJMDcE70Nzaqvy23RCJW/6qM5463W8HDyrvjq3aqGjCB+MVwLW5TM5+vt/WXA0kksj8kjJfs+hsWwFnZg0n7u6lDHa9yjPFKSwbfMapQfV0ldtYVuoSaId5i48UHsPfcUx/k+/yPoxCw5ARC9rX7CtSJINDQmoJ9Jw3eAEXpjSm9UH87hu8Sayi882R5dS8ummk0z7YDPx5LLUe46ihA0OiYw1xGX9Ylk6YwReOg03LtlM6sfbWX84n5LKWkoqa/n1SD73fbaDKW9vpNZk5su7h3PHyI5/yJ4aD/7k0GjqJYR8ffR8/s9rmBKVz6fZMby44hCJYf581XMDHTS51tc5aYfVEAPah1JSVVtnRdIcsouVKltdoNpGC+OIQG+H+i0tQkquUn9BqajWGM3k2Kk6bDZL8str6vpE2wqOBvfHCyx2Pq5VVEE5744EqkWVtdSaZNv1qKrruUSRywlLoNoCw2tH7A0ADNQcUba5KZGEgKu0v/K6/i2yZThzjLex35zI87r3eFC/1Lpf5lbXx/oLwOXmDSmlUQhhMRXXAu9bTMWBbapf23vAx6qp+BmUYPacQqMR3DWqE+N7RfHSioMs+fUYi9YdrbdPpwh/Xr++P5f1i3V9cWRT2bh4wj/58qu53LOzPVcZnuFK7a9cqfmV9mX5ZPy+gf9seo7vap+gizjFYv0rdMqOAPOD9il0Wo5To7EGbWpPaset77BI/xrTah/lVsNMPvB6iXYT5ilZHBt8HHw3ryzbzxTNr9w+vANMKrJmi4ekwh0/N38sDao4PsDTRS8ybV8flpgu4d7T3yn7NaZyKgQLczqTTyhLbh6BsNB9wb4AZOxspQKVOBIufoEbXruL1Pz+rDP3Y1zlTuv5aOz41eP+xXcAA8Pa0S7A27GxbZAUG8ynmzPILKp0KMFhUaeLPpc3REvgAkRt2Ml2kxcUOZBNFIK09jfArv0kaU4o25y4wI/pFolWI1h1IJdBiU14mEmpKOZlbQfgs+rr0AszV2e/BKJUSbo01xfbBCICvUkd3ZlXfzFxq1d3hmgU8SEmzVeSGic21LEPzFIw2/ctfMwmnip9Cqpvsq/abwubfbWGUt4wL+By8Ry3Gx7hM6/n6V15ssHnhp3mztxmeIwoUcySoPfweeQ0PG/T2t/zEiX4bSpj3MTjm4YmEubvzUP/2cX4V9Zxx8iOTEiKJtBHx76sUj7ceJytJ4oYGVbBW35LCc636YWzp2reDHrHBbP8H6NYuDadDzeeYEXa6XrPB/rouGdMZ+5J6dJmwi8eeGAXUuqzfny9dbzywDSeNZioqK4lauMz9as0lmQguLwgHqBaaezMKKJLZDNByZp5nMwWQB/lvmRJKvsEu6Qu6gyignzYe8p+urKFduoe6q8qDlRQQVxIy0nhM5WGtg26VEQGetdZvtiD4wXlBPvqCfXTuzx2Ypg/BeU1lNcY7boWW+182qhHVZ1fiTH/Ykt+AnLIDERz801KdmxeT7yQRAr1d7liluvBqio2ydBULtu8iEs0m8iUEcSLfLTxA+HOYpUdtshD+7UTblkJSCl/BH5ssO0pm7+rgWvcMZar6Bjuz8KbB5FXWs2m42c4VVSJv5eOfu1D6BsX7JKk91lIsWZz+peuZoX3fl41Xs3nprF8bbKKIPlSzb3a/3KP7jv8Y7pZqxaOTphpqk+iEHV0yAu0abzF69xb+3euMDzLi0+PYLj2AADl0oeXjdfwwbL9jI8o4cUeAjF5Xr1ABp9g+wLmBjftlJseY/LjT/Oa8SpSNDvppVFVzxp8psO5ZSzJiOGK/tH0V9UM68a397OnzK4be9zfFxP+5Jd8bhrLOO3OpoNUFcf7/J39K9fy+Kho58ZWYSuo5EigajViP8cXd0tPx2+3UkQg1VKPj72fW0rStq6mHX5Eo/rmOnGBD/bTM6xTO/63N4dHJnRvOjkUNxiytlMt9SzNDmWCZjPholQRCps03+mL/fQLO/LFr3t50jCN77yexEfUKurcxhqll1zF+6aJbC4J4SXdO0QMu8m1G5kQcPELBO/9D58wl+tqnuQ6w1M86/0pU1iDRkiMUsNnG4/yvOkZon1r+aTd10QWnoR3x9R/r5oy544BmNg7ml4xo3j+f/tZsCa9nlhRTLAPz1+RxI1nFqHZsvXshXbiSMcDdRv4eml56OLupI7pzObjZ0jPLUci6RoZyLBOYS4pfHrgwTlFIwmhAG9VXbcxCj645JNoQeeIAAJ9dOzIKOaa5PaN76T2u584kA70IbGdr6qWv0g5LhfmsDOIdLCierygAiGswj6uwBKoHiuo4IIu4S3ub2GaxNoR1LYm4kJ82Xz8TMs7qjheoFjTuIOF0qHOoqaCpNgWhAOx9tK2WY+qOt8SAy+i4of9FIycQ4Sg8flmNsPK2ewo6MWQSBM8YFOcAdeD1TEz6wQRNUKSKPKU9codv6jXgvnKfi25JHgAuClQ/SMiMsiHy/rFtv5AFgVABEGiiqdH+PGAeRs7tmwgX4YQLkoYpjmAn1Av4NPXKxPG2ZuZJUhV+zY5vZeLYmv5Muc57jP8nRtqn6Sr8RQRXrXsFV0pMxm5TbuC2T0C8Jr0wtl0QWeqRmp263n9J2yr6cb9tffzjdccgkVFvYCmxmjiwS93EeSj44lLejX+Xo6MbTajf28MV2uTWGy6hNMylOjFo5oNVpftykYIuKRfjPNjA92jA9FqBGnZJUzuE9PyC1RYsqXnPAupfkdRKNWyXBlKoj3Bpvq6tNx4kkK9EY8Wu1QpuKxfLI8t3cueUyX0a8zyRFX6Bfjf72mU4q+IKAHc/atjvqANPofv6ieYa97INPkYL0c8z+MFj9VVbvELg8pCdpi78JLxei7WbOUa7TqY+J3L/Sv89DhUFhIv4GvvZ7jfcD8P19zJq+JyOoocDspE8mUwI0OKeOO+a2jne7lC67cwEmz748Dpm2pCmB+LpyaTW1rN1hNnqKwx0TnSn77xIYod1prWW2gD+HnpSOke6bq/pQcenI9okLx1NgnaGDQaQf/2IexsTvl37XwQkBF9Ed6nDES9GgtCKu0S7qI4OoDIQG8qDSa7K3QnCiqIDfZt2vXAAUQFeeOr19qt/JtVpASq9lRfWxNxob6c3l2N0WRG15hFYQOcKKhkSEcndFUaQYKNl6o9gWqeupZpsyq0Ot86HFIUdjOKKolo7He+Zh5Ul5AtwzhNGAOH9FTX3EEOiWg2CUt115IQsk3y2hagJjqfZP+r4bxS/f3TQgjFA3RIKkx+keBLXiBFu5trdesYq91lDVLBYSGfRseyEW9RegfXMSDGj1Xe/+Qp3b+JEYVUeYUxISmKb2eMYM5If7z8gs5e9DsziWwoGO1iOvCG15tkyijuMjxEaWRyXe+p0Wji75/vJC27lHlX9nXdR9RsVnphT+/l+uhszGj4wvd6ZXG/eFSjPapSSpbtzmJIh3bEuNgj6qPX0iUiwGFBpZySavRaQVhT6s6tAZvvKKbXBQCc7jnN7r5gg1cIh0mkV59B9cR6nLnAT0yKwUurYdnu7OZ3FPCJcTydRDbDNfuVba70e6nzJGXECG4emsCSU+352Dje+nxlIQfM7bnD8AixopD5+ndVka8WRMXsGlel6AMx4gxfeD3HAv3r9BAnKfHvyPA+PViclMbHQzIVOrpWC90mW296Fnq8O26qKEmSS/rGcu3g9gxKbGf1bG6m19UDDzywA81Q8F3FgIRQDueWUd6Y3VSdDsEiTlb5kiDyrIJO8cluOwZHUOcLaieV9XhhJR3cIAoEihJrh3B/u1Vss9SKanxo21dUTWap6Ei0gOpaE1nFVW7p6QXqmGF2nTMp66rlkYE+bScQJES9ALsxuq9Fn2N7vvLcwOzPVH2OUtfW3jbH0JSgYb37tSdItRt/2YrqOYcNDfgslVJLH6W7qAe2mVyzWelJzd2Lj4DbdSu4nRVQCwSkQsJ8SHBjdtV2kvoEMSyxlJdjknnwSw2X5nciNSEDvzPevLfod/acKmHOpb24qFeU6+Pa9Oh2mP4dKR9t4+NT40iN/B0fb/9GK2+7Mos5ml/B7SM7uj4+Cv331/Sm1UwbQ65qTeNWynlLsPmOogfeC3vWc7rHVAgptSvwOdJzBrU/byDJ4iPqQqUg2E/PmO4RfLcri0cndrequ1p+v1LC8sfYvmk1O+UzPKP70DrMFtXiyVn6rzpPnjaZOZ2+kycLb2enuSsTtFs5IBNYZLyUICr5UP8i7aI7gNZLtZVyoTIipXJDtKgkn96LTpi5RLuZS7SbYeYZJTCVA+q//9jZrVadaRatuND2wAMPnMfAhBDMEvZkFjOiIZ21jgEhOba+mo7Cphe8jWIICyX0dGk1nSJaFvs5WVjB3xxgJ7WETuH+7M+xL5GcVVyFv5eWYF/Xez1dgYV6nF1cTXxo80G7RfioY4R7AtUAbx3hAd6cLGhBUEmtUObW3Eygjw5fvabN+qAB2of6odUIxSe9IYSoWyfuOHwCHzrRM+0ViOmjbHeWodUQrcim+CvCE6iea9h6HHoHKUq4lp7UCXOVfdxBrbOdIKe2KX8PSVUW9ZY+Fct2d08e20kqJZcKQUywD48u3cusw8rNKiKwmjdvGMCl7qRfW3p0NRruGtWJG5ds5puLPuLGYR0a3f3DjScI8NZxef84twzfKzaIb3ZmOSTRfrqk+tz3p0LddxRdXascR2mNciFtKRNqNtdVjZNig+rOtyu/oZt8f+en8k78uDubKYPaWyu+3kGAhLRvecd4EyGaSq6Z9W/490WKgrV/pFvmiv7nx3mrfAmvt3+eJdmj+Kb2QgBSNDt5Ub+YyOgEmL5O+ZyWG7ArPao+VqXquv8tWDK6efGv5h574IEHfxn0V1sldjYWqKqoNmo4JmOZrNmibBiSqtz722DhHBtsDbpaQnGlgeLK2rreUnegY7g/K9JOU2syW1kjTSCrqIrYEF+39Hq6gji1optVXAk0T+m1WNN0cuM56xDmx/HmKqo2Fcps/17EhXSov8Y9x33QAF46DZ0j/DmY04iGg2qvx+m97DBfQ19xDL0wKfdgF7UXzoLnfu02eALVc4nGKAFjZlp7Ui2UPnf+oC2047hka+VJ7flr1nLGHePa/J/cMYxVD4/msCqc0jHcv3W8EdUF/vBOYfSND+attce4cmA8Pra+lypN5X97crhleKLb1EV72wgqRXb3seuid7q0ml7q6845PvwbATWlBHg/ocL0wjYAAB6gSURBVIg6SanQpL2DlKC/IT6YDDWl7I9ZhJ+Xlo6hvs3vbw+k5EL/LDoJHz74Locr+k9DrJytLKZ0yk16nyGKn83J3De6M35vJSkWTFF9oPskpdLoCtQ56T3sLh6dcDd3/+9Jjm9dTowoJMqiBJi7V+krnTjPPfMzZTZYbIwsfacXv2DtQ3VGSM0DDzz4SyHEz4tOEf7N9qkeOnESMyPppTmpbBAowaqb+swdQUyIj5I3L2rZ8sRiu+POQLVDuD8msyTzTGWLFd3skqq6ILEtYQnuLT2zzcFyztyhkmxBx3B/1h3Ob3oHG+2CU+sriBdrodhNfqQuoGdMEFsbE6ESAibMpfr4JtIyOnCnVl23OOkP7sG5gadH9VyjYd+XJTi1UCRaY6KkzKpPj7QEq+eYliGEoHt0ID2ig1onSG0w1syJPcgqruL9DxbV821lxUxe+/d/kMCtwzu4p59izTx67X8VgLSsEmtVcM28Jl8ipVQqqm0h524212UWo8255JZU1fX4Nuo7a7P/vh0b6BUThObd0c371NoDIdBMnMvtoXvYY4jh5zkXKUFqVG8wViFrq3jWOJV2lHLXphQlSPULg7vWwtjHXT4NQD0/4mB/f/rH+lmDVFBuYt6qJYu75ue4x6095BPnKXTf6evd1nfqgQce/PkxMCGUHRnFnGVLr95/DuQqwUvPf/xX9QhfpASrTlh6uQpvnZbIQG+7gq6jeUp1sLMdFGF7YQl6j9vhPZtVVNXmQkqgKKSH+XvV9cw2h+P5FYQHeLvV1qtzZAB5ZTWUqsyrRqEGq1kynDihtj61caK1V3Qg2SXVFFcalA2W9YmUsHI2e09XYkTHIM1hZbsL/uAetD48gWpboC0oAX9BGsKIzmGMDytkwfEYDn79nHIRenc8u3//ic9PtePW4YmKBHsLAWWLUOkvQdsXkOhTpVBjLfSX6pImL34lVbVU1ZqIbgvqr0ajBEbRfYgxZZO9f6OVitoY9VTd3xzVhwM14SSd+qL5/R08lusGRNNNZPJM7VQqpbdiDxPVm0/kRLaYe/CAbilBQr1ZP3wEdG4mg1j6YdVgnKEz4Oli5X9LMO7um1jK7OaTVh544IEHzWBQYihnKgyk5zXox1OZIvsjLyHAW0f7dv42gi5tZ4kRF+JrV9CVnl+Ol1bjVjEji9/skYbnqgEqDUaKKmvb3JrGgrhQX7LsoEsfySuna3Oeuk6gs8XWx6KW3Ng9UEpKfniCMvysgaorQoeu4oPJ9Nz5DIDSk2wR2vxgcl3rzWa/MQAM1BxRXuOiP7gHrQtPoOrBnxdC8Pxd1xDgJbhzR3t2PJ3M9swS7jQ8TKSXgQfHd7UroLRnHMsiIMmwh7S03fWN3pu4+GWcUShQ7vCJcwpq8Nle5JEpI5RtzQWdGg0nrlpOBb4kiRMt728vzGb0R5fznP4Dsgnjjtp/kiXD+CqrHc8YbiRFs9NqSQMKDbc1boL2qvW5e8zmHnvggQceNIGRam/q+iONiPilzOKAVxI9ogMVsb7zQLU7LtSPU3ZVVCvoEO5nlyWLvQj21RMV5M3h3Ob9p7PPE8VfC2KDfclqgS4tpeRIbhndowPdN/CaeXQ++A6gVrgbY4mp27K2LgMg/tr/Uyv3djgItAbMZig4Qs/itQDszyqxMsUKjoDJBNWlrC+JpHdAGWFzMq3J6OpWSEZ74BZ4AlUP/tSIDvFlyZ0pVEtvrjQ8y1WGZ9B6+fEpjxP4YoRdAaVdUBcBSZrjZMgoSqRfi+9ZF6iGtVGgqmYaE0QeZwiiTPo2aeVj2X/fvx8CIElzQtnW3P72QKXicHovQwPyeVW/kC3mHlxQ8yaPGFPpK47xhn4BWou1gl9Y694EPZYsHnjgwR8E7dv50Sncn/WN9BGazZIDOWX1NRDaMhEmJXEhvuSUVGE2y2av38fyy91K+7WgW1Rgi4HqqfPEQ9UCpaJadTa92wZZxVVUGEx0jXLTOVNZYu33vI5emBUF3caS+mpy91TXW9Rj9Wv95G5zEAJ6TSFClBJBEftXLLaKFfaaAhoNZbpQdtCdCwf1OzfJaA9chkdMyYM/N6SkX9qLrPX+gG9NI/ETNYwe1J/wnTa+ne7op1Azi5ZK435zIsNXzGr2vS1y8u1bkJ1vFdj4ziaEdod8yGg3gqTTq5TtDSul6v5pRUl4YaTrEzvg/TFWn1pnK6s2cvGc3ssV2t/oJU6wydyLSFHMxZptaHReMKsQ3lXH8wuz9oy2BjxVTg888OAPglHdIvhiawbVtSZ89Fbth/05pZTXGOvUgdsUqoVJfGgqtSZJXmk10b8/06iFicFo5uSZSia70ZrGgm5RgXy6+SQms0TbhCXc8VYQJXIFHcL9qa41c7q0ukm/9yO5Cp25e5SbKqpqAKcHEtdnc3T9NvBqIqmfMousDcchbb8iQNWWVixCwOQXAej/21G2yB6KpuXg6cp2IdgYeytGuZ1R3SLrfVbPff78haei6sGfFxaqyuaFBAybxi3Pfc1VI5II3/lm/f1crc7ZjJOUPAaAtPY3WSt/TVQcM89UEh7ghb8bxQ/sho3vbMK1/6ccT8oCq3BQw6Bz3YtQUUCavg/dYtvhpddC+xGKRYyr/mNjZ0O3yYqSL9BNk8VU3c9M9ElDo/cBUw38/ATctU45vvDurqv9euCBBx78CTCqWzjVtWY2HSust92i1nph14i2OCwrbCxM4tK/BODUilebbLnJOFOBySzpHOn+QLF7VCDVtWYyzzRNpT2aX06wr54wfy+3j+8MOqu+qEfzmhaBOqRWibu6K1CFugCus8jmqFRtBJsI6LKKq/DRa6znrI0r92RuZLRmN6dkJMdkDOxfqqzDpGTtwTz8NCYGnVhifY0nSD2v4amoevDnRcOeQ7Cancclw52/WOks4HxWzWacCG9forxqSAsaCe1nKA36FvuhBpnjjDOVtG+r/lSo851tX21Ujqe4SqmMWoSFLOdCXWjI0hzSTPFcHBuknLet78Dgu+symE7DImKUu1f5XuKTle9pyyIYPF0Jgn2Crcq47jLl9sADDzz4g2NE53CCfHR8syOLMd0j667d6w7l0zsuiIiANg64bCxM4n//CPgXWWm/kjyi8ZabdDUgaw3qr4Uaezi3rMmK6dG8CjpH+Le5h6oFXdTzcDS/nJFdG/fLPZxbRnSQD8G+evcNrCbgO4szrDYPpFZq0TfBEssqVlSS2/yc2TDFRmuUBM06cz86V66Al7tS3eMaftg+hAlsxctAm/i8euA4PCs+D/7csO05FELxjh2SqgSp7uxPSJml+HDVlNLbmMa+w0eUx9WlTWaOTxZWktiWgSrAuhcJ/nQSIbpahYosBCyfCe+Ot4omqN5j2f0foMiop/euZ629vSqdxiXYJhTu/AUmzlfsk4bOAL92ymNLkO8JUj3wwAMP6uCj13J5/zhWpp2m5KcXYcUsSqsMbM8oYnTXCNdV7d0B9V5rUYXNlBFNJoYPnS5DiNYKVAPrxmgKR1upP9ZZRAR6E+itU/pEm8Dh3DK6uVNIyYYl1rVrd2rRcbzPA03qQ2QWVSr9qW0NIaBC+Y21j46kk8hmHcnKc5WFrNy6mzKzD9eEZ7Ru+5AHboVn1efBnx8N+inO8pR1l1iOai+SFB/O0Upfqp6JalKsyWA0k1NS1XaKv6DcbKqKIWsbCaYMMg7vUoLULYsgaxtUFyv7rJkHK2eT1jUVwGoe704594YJBdvvxXMz8cADhyCEaCeE+FkIcUT9P7SRffoLIX4XQqQJIfYIIa5ri2P1wHVckxxPjdHM0pO+sHkhSz9ZhMksGVu81HVVe3dADXz8RA0xFHLUHGsNeBoc14GcUjqE+bdKS0yAt46Edn6KhVwjKK2uJa+shk7nUaAqhKBTZECTgarBaObw6XJ6ujNQtUke95xwJwAHOt/eaFLfbJYcy6+ooyi3KYSAgbcqTK/UDYyNM7PR2I0McyRSwmfGccSLPIaV/Ng6lnMetAo81F8P/npoTbEcIUgadQXmT3ZwQCYwUKQ3mjnOLq7CLGlb6q8QStAOtN+QR1qxvxKkAgxNVSqZUNdftG+XQMMIeooMZfuhH2H0TPdVOT0iRh544C7MBFZJKecLIWaqjx9rsE8lMFVKeUQIEQtsF0KslFIWn+uD9cA19IkLZlindrycqSWp52O8tjuKkZq9DDzwEgxzg6q9K7CpzhGXTJczgiO1/WHz3YBU2jx8Q+qSxQdOl5Jkq1TsZvRrH8L2E2cafc7iF3peBF026Bzhz8b0wkafO3i6FIPJTD93i2alKImEzmaJl1bD/pwyLp/UyFqmpIpKg4mukW4MlF2BetwIwV23TOXTeT/yvPEmhmkOsFn2Yo7uQzQxvRXGm2eN8YeAp6LqgQfuhJQkHVGCvTRzB2VbI1SZE4XKDbFNK6pQF6wmijxOyXBqpaoaOcGmujlhLkT3YX+ZL51ENn6ipk6ll5WzPVlJDzw4/3A58JH690fAFQ13kFIellIeUf/OBvKANlbe8cAZCCF4+dr+aDWC63b3oww/ntB9oqzD21rRtK46lwpxyXQt3UR6pR/mIalwapuSHFUrvmXVSgtKr5hWDFTjg8kuqSavrPqs547mKVXLzpHnT0UVFBr06dJqymuMZz23O1PJK/WND3b/wEKg12roGhXA/pzSRn9HR9Rz5jZrHHdA1dmI2jiHe3TL+Mk8mGeNU7lQs4ep2p89a5c/GDyBqgceuAtq5jhu12uE6mrZ0++pJs2vLT0ybjXodgZSwpJxdNOcwohOUcgDRZBg9Vzlb40G2XUye8yd6K3a7zB9vcd7zAMPzl9ESSlz1L9PA1HN7SyEGAJ4AUebeH66EGKbEGJbfv7Znp0etD3iQnxZmjqcF7oe4TuvJ+mhyVSeaC3PaUeQMqtOe6Br565Um7VkbVqqtJjYtMZY7os9WzNQVSuPezJLznruSF45Oo1o+wRyA1h6ZtPzzqb/7sosITzAq1V9X3vGBHEgp3G6dLpqjdPlPKJLW6v4i7gn4RSLI75ivm4xC/RvoBESonq7t3XJg1aFJ1D1wAN3Qc0ci2EzGNglju0ZRU2KNR3IKSUm2IcQvzZUZJQSfnwMsrfTUyh9pwc6TlOeO70XDv9YJ+l+qqSGPEIZpDmsPL9ytlJpdUdvrwceeOAwhBC/CCH2NfLvctv9pJQSq955Y+8TA3wMTJNSNuqlJaVcLKVMllImR0R4iq7nJaSk68653JT5NH2GT4Sni5tMlLYJVIZO15RbAEiXccp2m4qvJRjq1YrU36TYILQawe5TZzPcd2QUkRQbhF57fi2N+7VXqqU7M4rOem7PqWL6xoe0quJur5ggCsoN9avQ6u/pSF4Z4QHehJ4ndj5AvSq+Nj6Zi8u+5foRPQgeNlVxFsjdpwhdtvWc8MAueHpUPfDAnVD7I5LXHWPVwTwKKwyENUK9OpBTRo+2rqYKAX6hEDuITiYjXidrOZCezhV6FH/U7pOVfVbMZOvOfcAQku95H3bPdd3SxwMPPHAJUsrxTT0nhMgVQsRIKXPUQDSvif2CgP8Bj0spN7XSoXpwLtDQjs3GFua8Yb5ISde9rwLDOSLjSGGXEkSrx7svq5QQPz3RQT6tdgh+Xjq6RQWyK7N+oFprMrM7s5ibhia22tjOIibYl7gQX7adLGLaBR3rtpdV15KeX84lfWNbdfyeud8DnUk7VUJkTx+1YjkTfEI4kjeKrpEB55/Vi6VXde38+haFoPzmzpc54UGL8ASqHnjgbghBcgdFZHP7ySIuToq2PiclNSYzR/PLGdczsu0v7imzYMxM9FLS5fGFHJAJyvaHDykiSWvmwaltbAu/nsAzyg0eiZKV9FzoPfDgfMUy4FZgvvr/dw13EEJ4Ad8C/5ZSfn1uD8+DVoGNkAxgDVbPh+u0SscM3rGQSK+BHO7zKAQk1Et6bj1xhkEJoa3uxzm0Yzu+2JpBda0JH72iy5CWXUqN0cygxLMEss8LDEwMZevxM0gp687Pb+mFSAmDO7biMUtJP+/T6Ehky+pvSelxt2Jfl7UNOSSV9NxypgyIswZ/5xPLSoiz5wScP3PCA7twfvEbPPDgT4I+ccF4aTVsO2lD1VkzD1bMIj23HKNZ0jMm8PzwuANYOZue4iQHzAl1jzGbFZGLrG1sKwlmYGIo2p9mK+IXcckwZmbbHrMHHnjQFOYDFwkhjgDj1ccIIZKFEO+q+1wLjAJuE0LsUv/1b5vD9cBtOF/V020tTzrEszuzpF5rTF5ZDccKKhjWKazVD2Vsj0iqa81sPFpQt22bqgRsSTKfb0hODOV0aTXZJVb67aoDuQT66P6/vbsPrqq+8zj+/t4EwoOBgJAQkmWDNSIPdmGbJoJrJ6wIoa4jOLNqd6bSp7Fx2unMbnd3YJndtkO3pk9b246ri61b1HatY5eWUWsFLQ+uBIxtFBAhEFGCkBDAtshTk/vtH+dAshhMbi733nMvn9dMJuecezLny28O53u+9/zO78eHK8am7sBmjLjp3/ngqBNsaTsJXykK3i0G9p4Yzh9OdzH16LpoTIN0IVH9PyEDoieqIikwbEge15SPZusb4TD47uemedl5qBiYwtQ9P4Bt4TyrmXqy2mvqgKkVK/hZ6xg6Z32BcVu+F3xWdw/H/pjP7hdHcnPrffDWz/ucF1ZEosPdjwA39LG9CfhMuPwo8GiaQ5NLWfh0a/bGVhp++TqHj59hfJhLGl95G4CaK1JYdIVqrhjLyKF5rNvZwV9fHYwz1rTvGOVjhlOSwm7HyTj7pPelN45SNquMeNz59a4OaqcUp/6dWjNqZs3kwQ27OeEFwcj/1fVsfnEb8GHm7LsPZuu+QFJDT1RFUuT6ynG80vYOncdP93TBqrmb5j1vMYJTVLx6b+aLvrPfcpdVMb0wGL2vufJzUF0ffGu64eusL68P/j2xbcHfKBmJiMhgmDE7fGq6ufXIuVzS2HqEwoL8lE5Nc1ZBfh7XV47n+Z0ddMedzuOneX5XB7VTojtQ2NUTCikZVcDPftMGQHPbO3QeP8MNVxen/uDuXLv7m3SRz8vxymCbweb4dCbSySTr0H2BpExShaqZjTWztWbWEv5+T58JM5tpZpvNbIeZvWpmtydzTJFsceO0Etzh+Z3hOCZm+IKvsT7+F8yJbSff4tG4uNcuhfIq/vL1bzMi1s36XYfBCArVk8dY+/w6ijnGB6012D8KI0iKiEhWmj5xFIXD8tkcdr2Nx51NLYepqhhDfppG3F00ayKHfn+Kn2x9ix83vsWZrjifmDO5/z/MkPy8GHfOrmBTSye7Dv2B/3h2N4XD8pk7JcWFajhwUtXRJ8mniw3FH4eaeuKN/8Xm+DRmx3YEtzC6L5AUSfaKsBR4zt0rgefC9fOdAO509+lAHXCvmRUleVyRyJtWOoqyouE8+1p7sMGdvf+7gjYvZm6sOdgWhYu7GdQ1UFA+kzn8ll9veRlvfABKZnB6XyMbOi/jhtJTxGo+G7ybGpXpDkREJOvk58WomXw5m1o66Y47G1oOs//oSRbNKktbDAumT2D2FZfT8PROVm7cS+2U8VxZHKG5QPvwd9WTGDYkxsd/uIUX9nTyTwumMHrEkNQe1AyGFTHy2k9y48hWnjhQxKnGH7LDKzhGIXMqS3RfICmVbKF6C7AqXF4FLDp/B3ff7e4t4fLbBMPkR7d/hchFYmbMm1rMC3sO87sTZ+CZZaxvfh2A2i/+OFpz3AGUVTE31swBxrPXJ0L7djYczOddhjP/8s6eQZRq6jXir4iIDNqiWRNpO3aSx5v2s+rFfYwvLGDhjNK0Hd/M+OriGVSMG8ncq4v58s3T03bswRozcij33j6TypLLmD+tJH1T6cxdBgvuYcmVJ3mHQn7efR3f7LqNwrwu5u77DpRXBa8L6b5AUiDZwZRK3P1guHwIKHm/nc2sGhgK7L3A53cBdwFMmjQpydBEMu921rLqj1excmMr/1AwmtXDbuGq+LuUNX83enPcGdTmvQJd8ET3R/hn+ynf7bqVcuvgupZvwLW95iKLQrwiIpKVbrqmlIcnv8ny1duIO/z9vKsYmp/eYVM+MP4ynvrC9Wk9ZrLqZpRSl8aC/pz1DdQce4ppNprlXZ+mmzz+Nf9hxpZfBXUNwT66L5AU6LdQNbN1wIQ+Plree8Xd3cwu+FgonHT8EWCJu8f72sfdVwIrAaqqqiLwiEkkCe5MG9rO38SO8N8buznyoZvYcXw/3xvyfTgVzgIRhXdUz438+wBl19Zz66aNPNh9E+8yjB0+mW8NuZ+h1h2NWEVEJOuZGV9bPIMVT+5k3tRi7qjWw4nIisdh99NYx3YemriGhw5dQYcXcWfeWuiaGtxDxDQ2q6RGv4Wqu8+70Gdm1m5mpe5+MCxEOy6w3yjgKWC5uzcOOlqRbBKO9PuPJ79C09Z3eOyl/cyPvcTNs2dGq+g7N79dPTj825BH2HT6Gh7pns91se0sjr0Q7PfMsmjFLSIiWevK4kJWfao602FIf2IxmPJRcGdCeyP/MqTXbXx+ge4JJKWS7fq7BlhCMJn4EuAX5+9gZkOB1cDD7v5EkscTyS5mVCz+Ev/3yhhe8wo+YG9jC9ujd2GvXQq/XApbH6Copp41Z3Zx+jc/pSLWHrx7YgTv04KKVRERkUtJ7bJgLvj27T3bauphywP6EltSKtln9Q3AjWbWAswL1zGzKjP7QbjPbcBHgE+YWXP4MzPJ44pkh7BbbZ4518TeCCbKjsrgSb2ZwfCiYICnhQ2Ujh5BxezFQZE6vCh4B6Xm7ui8TysiIiLp09b0/9cdDa4oKZfUE1V3PwLc0Mf2JuAz4fKjwKPJHEckK5179/P+oMiru6dnHaL3DeTcsIA261mGnhijFq+IiIik1tl7mQNNwZfXCxt67mWq64MeWSIpkmzXXxG5kHPvft7dU+RFbaTf8/WO6fz4ohiviIiIpE423stIzlChKpJKvZ9SQs8FXhd2ERERyQa6l5EM0XjSIqmmJ5MiIiKSzXQvIxmgQlVEREREREQiRYWqiIiIiIiIRIoKVREREREREYkUFaoiIiIiIiISKSpURUREREREJFJUqIqIiIiIiEikqFAVERERERGRSDF3z3QMfTKzw8CbmY7jIhgHdGY6iCyi9kqc2ixxarPE5UKb/bm7j890ENlMufmSpfZKnNoscWqzxOVCm10wN0e2UM0VZtbk7lWZjiNbqL0SpzZLnNoscWozySU6nxOj9kqc2ixxarPE5XqbqeuviIiIiIiIRIoKVREREREREYkUFaqptzLTAWQZtVfi1GaJU5slTm0muUTnc2LUXolTmyVObZa4nG4zvaMqIiIiIiIikaInqiIiIiIiIhIpKlRFREREREQkUlSopoCZ/a2Z7TCzuJlVnffZMjPbY2a7zGxBpmKMMjP7spkdMLPm8OejmY4pqsysLjyX9pjZ0kzHkw3MbJ+ZbQvPraZMxxNFZvaQmXWY2fZe28aa2Vozawl/j8lkjCKJUm5OjnLzwCk3J065uX+XYm5WoZoa24FbgY29N5rZNOAOYDpQB/ynmeWlP7ys8B13nxn+PJ3pYKIoPHfuAxYC04CPheeY9G9ueG7l7NxjSfoRwTWqt6XAc+5eCTwXrotkE+Xm5Ck390O5OSnKze/vR1xiuVmFagq4+05339XHR7cAj7n7aXd/A9gDVKc3Oskh1cAed2919zPAYwTnmEhS3H0jcPS8zbcAq8LlVcCitAYlkiTlZkkT5WZJiUsxN6tQTa8yYH+v9bZwm7zX583s1bCbQ051Y7iIdD4NjgPPmtnLZnZXpoPJIiXufjBcPgSUZDIYkYtI19KBU27un86nwVFuHpyczs35mQ4gW5nZOmBCHx8td/dfpDuebPN+7QfcD6wguGitAL4NfCp90UmO+yt3P2BmxcBaM3s9/JZSBsjd3cw0t5lEjnJzcpSbJYOUm5OUi7lZheogufu8QfzZAeDPeq2Xh9suOQNtPzN7EHgyxeFkK51Pg+DuB8LfHWa2mqCblpJh/9rNrNTdD5pZKdCR6YBEzqfcnBzl5otC59MgKDcPWk7nZnX9Ta81wB1mVmBmk4FKYGuGY4qc8D/aWYsJBsCQ93oJqDSzyWY2lGAwkDUZjinSzGykmRWeXQbmo/NroNYAS8LlJYCeTkmuUG4eAOXmAVNuTpByc1JyOjfriWoKmNli4PvAeOApM2t29wXuvsPMHgdeA7qAz7l7dyZjjahvmNlMgu5F+4DPZjacaHL3LjP7PPArIA94yN13ZDisqCsBVpsZBNe/n7j7M5kNKXrM7H+AWmCcmbUBXwIagMfN7NPAm8BtmYtQJHHKzUlTbh4A5eZBUW4egEsxN5t7TnVlFhERERERkSynrr8iIiIiIiISKSpURUREREREJFJUqIqIiIiIiEikqFAVERERERGRSFGhKiIiIiIiIpGiQlVEREREREQiRYWqiIiIiIiIRMqfAKdr8TzPqxm4AAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -131,11 +131,15 @@ "source": [ "# Layers\n", "def make_input_layer_kernels():\n", - " kernels = [\n", - " SharedIndependentMok(RBF(lengthscale=0.8, variance=1.) + White(variance=1e-5), output_dimensionality=1),\n", - " SharedIndependentMok(RBF(lengthscale=0.2, variance=2.1) + White(variance=1e-5), output_dimensionality=1)\n", + " shared_kernel = SharedIndependentMok(\n", + " RBF(lengthscale=0.8, variance=1.) + White(variance=1e-5), output_dimensionality=1\n", + " )\n", + " task_kernels = [\n", + " RBF(lengthscale=0.2, variance=2.1) + White(variance=1e-5),\n", + " RBF(lengthscale=0.3, variance=2.2) + White(variance=1e-5)\n", " ]\n", - " return kernels\n", + " task_kernels = SharedIndependentMok(SwitchedKernel(task_kernels, 2), output_dimensionality=1)\n", + " return [shared_kernel, task_kernels]\n", "\n", "def make_output_layer_kernel():\n", " sub_kernels = [\n", @@ -203,33 +207,36 @@ "text/html": [ "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "
name class transform trainable shape dtype value
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float642.200000047683716
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float640.30000001192092896
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
" ], @@ -272,38 +279,41 @@ "text/html": [ "\n", "\n", - "\n", + "\n", "\n", "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", "\n", "
name class transform trainable shape dtype value
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].feature.features[0].Z Parameter True (100, 2) float64[[-2.67277756, 0....
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter False (2, 1) float64[[1.]\n", + "
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].feature.features[0].Z Parameter True (100, 2) float64[[-9.88181722, 0....
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter False (2, 1) float64[[1.]\n", " [0.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].feature.features[0].Z Parameter True (100, 2) float64[[-2.67277756, 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter False (2, 1) float64[[1.]\n", + "
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].feature.features[0].Z Parameter True (100, 2) float64[[-9.88181722, 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float642.200000047683716
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float640.30000001192092896
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter False (2, 1) float64[[1.]\n", " [0.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (100, 3) float64[[-2.67277756, -2.67277756, 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (100, 3) float64[[-9.88181722, -9.88181722, 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
" ], @@ -327,7 +337,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 14, @@ -359,10 +369,10 @@ "output_type": "stream", "text": [ "WARNING: Logging before flag parsing goes to stderr.\n", - "W0808 18:37:51.556109 139652235097920 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/ops/array_grad.py:502: _EagerTensorBase.cpu (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "W0809 16:36:14.580498 140536594392896 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/ops/array_grad.py:502: _EagerTensorBase.cpu (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Use tf.identity instead.\n", - "W0808 18:37:51.648337 139652235097920 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/optimizer_v2.py:468: BaseResourceVariable.constraint (from tensorflow.python.ops.resource_variable_ops) is deprecated and will be removed in a future version.\n", + "W0809 16:36:14.697237 140536594392896 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/optimizer_v2.py:468: BaseResourceVariable.constraint (from tensorflow.python.ops.resource_variable_ops) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "Apply a constraint manually following the optimizer update step.\n" ] @@ -375,16 +385,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -395,40 +405,7 @@ }, { "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "samples[1]" - ] - }, - { - "cell_type": "code", - "execution_count": 40, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -446,7 +423,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -481,7 +458,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -496,7 +473,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -519,6 +496,66 @@ " plt.plot(Xs_augmented[Ns:,0], s[Ns:], color=cols[1], alpha=0.3)" ] }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float640.00032125385359672225
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float640.0008219559882079048
DSDGP.layers.constituents[0].sublayers[0].feature.features[0].Z Parameter True (100, 2) float64[[-1.06162195e+01, -5.92635572e-01...
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float640.00247732980217349
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float646.109535224367189
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float640.0003167635256223428
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[-5.08258073e-02...
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[6.61847700e-01, 0.00000000e+00, 0.00000000e+00...
DSDGP.layers.constituents[0].sublayers[1].feature.features[0].Z Parameter True (100, 2) float64[[-9.9758125, 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.1266403712848294
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float640.7689388163128974
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float640.0002643975046019253
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float640.1304554709561652
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float642.7259712765975057
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float640.00030418115883955684
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[3.85160891e-01...
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[4.06244118e-01, 0.00000000e+00, 0.00000000e+00...
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (100, 3) float64[[-9.51627751, -10.60144693, 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float640.1416200367414555
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float643.6654446997786163
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float645.359247612521348e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float640.19052483942437387
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.2965477195975943
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float643.1924859280557164e-05
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[-0.03565266...
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[0.06420091, 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/doc/notebooks/simple_example_multitask_with_weights.ipynb b/doc/notebooks/simple_example_multitask_with_weights.ipynb new file mode 100644 index 0000000..d9c4deb --- /dev/null +++ b/doc/notebooks/simple_example_multitask_with_weights.ipynb @@ -0,0 +1,589 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# useful imports\n", + "import numpy as np\n", + "import tensorflow as tf\n", + "\n", + "import matplotlib\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "\n", + "cols = [c['color'] for c in matplotlib.rcParams['axes.prop_cycle']]" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# GPflow imports\n", + "import gpflow\n", + "\n", + "from gpflow.likelihoods import Gaussian, SwitchedLikelihood\n", + "from gpflow.kernels import Matern52, RBF, White\n", + "from gpflow.kernels.mo_kernels import SharedIndependentMok\n", + "from gpflow.mean_functions import Linear\n", + "from gpflow.utilities import set_trainable\n", + "\n", + "gpflow.config.set_summary_fmt(\"notebook\")\n", + "gpflow.config.set_default_float(np.float64)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# dgplib imports\n", + "from dgplib.layers import Layer\n", + "from dgplib.weighted_layers import WeightedConcatinativeMultiprocessLayer\n", + "from dgplib.cascade import Sequential\n", + "from dgplib.specialized_kernels import SwitchedKernel\n", + "from dgplib.utilities import print_summary\n", + "\n", + "from dgplib.dsdgp import DSDGP" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "Ns = 300\n", + "Xs = np.linspace(-12, 12, Ns)[:, None]\n", + "Ys1 = np.sinc(Xs)\n", + "Ys2 = np.sinc(Xs) + np.sinc(5-Xs) + np.sinc(5+Xs)\n", + "Xs_augmented = np.vstack((np.hstack((Xs, np.zeros_like(Xs))), np.hstack((Xs, np.ones_like(Xs)))))\n", + "\n", + "N1, N2, M = 150, 100, 50\n", + "X1 = np.random.uniform(-10, 10, N1)[:, None]\n", + "X2 = np.random.uniform(-10, 10, N2)[:,None]\n", + "X2 = X2[np.logical_or((X2<-3), (X2>3))][:,None]\n", + "Z = np.random.uniform(-10, 10, M)[:, None]\n", + "Y1 = np.sinc(X1) + np.random.randn(*X1.shape)*1e-2\n", + "Y2 = np.sinc(X2) + np.sinc(5-X2) + np.sinc(5+X2) + np.random.randn(*X2.shape)*1e-2" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16,9))\n", + "plt.subplot(221)\n", + "plt.plot(Xs, Ys1)\n", + "plt.scatter(X1, Y1, c=cols[1], marker='x')\n", + "\n", + "plt.subplot(222)\n", + "plt.plot(Xs, Ys2)\n", + "plt.scatter(X2, Y2, c=cols[1], marker='x')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "Z_augmented = np.vstack((np.hstack((Z, np.zeros_like(Z))), np.hstack((Z, np.ones_like(Z)))))\n", + "X_augmented = np.vstack((np.hstack((X1, np.zeros_like(X1))), np.hstack((X2, np.ones_like(X2)))))\n", + "Y_augmented = np.vstack((np.hstack((Y1, np.zeros_like(X1))), np.hstack((Y2, np.ones_like(X2)))))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Layers\n", + "def make_input_layer_kernels():\n", + " shared_kernel = SharedIndependentMok(\n", + " RBF(lengthscale=0.8, variance=1.) + White(variance=1e-5), output_dimensionality=1\n", + " )\n", + " task_kernels = [\n", + " RBF(lengthscale=0.2, variance=2.1) + White(variance=1e-5),\n", + " RBF(lengthscale=0.3, variance=2.2) + White(variance=1e-5)\n", + " ]\n", + " task_kernels = SharedIndependentMok(SwitchedKernel(task_kernels, 2), output_dimensionality=1)\n", + " return [shared_kernel, task_kernels]\n", + "\n", + "def make_output_layer_kernel():\n", + " sub_kernels = [\n", + " RBF(lengthscale=1.3, variance=1.) + White(variance=1e-5),\n", + " RBF(lengthscale=1.4, variance=1.1) + White(variance=1e-5)\n", + " ]\n", + " kernel = SharedIndependentMok(\n", + " SwitchedKernel(sub_kernels, 2),\n", + " output_dimensionality=1\n", + " )\n", + " return kernel\n", + "\n", + "input_layer = WeightedConcatinativeMultiprocessLayer(\n", + " input_dim=1,\n", + " sublayer_output_dim=1,\n", + " num_inducing=2 * M,\n", + " weights = [0.8, 1.2],\n", + " kernels=make_input_layer_kernels(),\n", + " fixed_linear_mean_function=True\n", + ")\n", + "\n", + "output_layer = Layer(\n", + " input_dim=2,\n", + " output_dim=1,\n", + " num_inducing=2 * M,\n", + " kernel=make_output_layer_kernel()\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "seq = Sequential([input_layer, output_layer])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "lik = SwitchedLikelihood([Gaussian(), Gaussian()])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "model = DSDGP(Z=Z_augmented, layers=seq, likelihood=lik, multitask=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float642.200000047683716
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float640.30000001192092896
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter True (1, 1) float64[[1.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter True (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model Parameters Initialized\n" + ] + } + ], + "source": [ + "model.initialize_layers_from_data(X_augmented)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float641.0
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].feature.features[0].Z Parameter True (100, 2) float64[[-9.50854502, 0....
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float640.800000011920929
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[0].sublayers[1].feature.features[0].Z Parameter True (100, 2) float64[[-9.50854502, 0....
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float642.0999999046325684
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float640.20000000298023218
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float642.200000047683716
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float640.30000001192092896
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (100, 3) float64[[-9.50854502, -9.50854502, 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float641.2999999523162842
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float641.100000023841858
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.399999976158142
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float649.999999747440792e-06
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[0....
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1., 0., 0....
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.log_likelihood(X_augmented, Y_augmented, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def log_likelihood_callback():\n", + " return model.neg_log_marginal_likelihood(X_augmented, Y_augmented, num_samples=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING: Logging before flag parsing goes to stderr.\n", + "W0809 16:48:34.042294 139775988909888 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/ops/array_grad.py:502: _EagerTensorBase.cpu (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use tf.identity instead.\n", + "W0809 16:48:34.156194 139775988909888 deprecation.py:323] From /home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/tensorflow_core/python/keras/optimizer_v2/optimizer_v2.py:468: BaseResourceVariable.constraint (from tensorflow.python.ops.resource_variable_ops) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Apply a constraint manually following the optimizer update step.\n" + ] + } + ], + "source": [ + "opt = tf.optimizers.Adam(learning_rate=1e-2)\n", + "gpflow.utilities.training_loop(log_likelihood_callback, opt, model.trainable_variables, maxiter=1e3)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model.log_likelihood(X_augmented, Y_augmented, 1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:5: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \"\"\"\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:9: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " if __name__ == '__main__':\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:15: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " from ipykernel import kernelapp as app\n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:17: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16,9))\n", + "for _ in range(3):\n", + " samples = model.predict_f(Xs_augmented, 1)\n", + " sigma = np.diag(samples[1][0,0,:,:])\n", + " plt.subplot(221)\n", + " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].numpy().reshape((Ns,)), color=cols[1], alpha=0.3)\n", + " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].numpy().reshape((Ns,))+2*np.sqrt(sigma)[:Ns], color=cols[2], alpha=0.1)\n", + " plt.plot(Xs_augmented[:Ns,0], samples[0][:,:Ns,0].numpy().reshape((Ns,))-2*np.sqrt(sigma)[:Ns], color=cols[2], alpha=0.1)\n", + " plt.subplot(222)\n", + " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].numpy().reshape((Ns,)), color=cols[1], alpha=0.3)\n", + " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].numpy().reshape((Ns,))+2*np.sqrt(sigma)[Ns:], color=cols[2], alpha=0.1)\n", + " plt.plot(Xs_augmented[Ns:,0], samples[0][:,Ns:,0].numpy().reshape((Ns,))-2*np.sqrt(sigma)[Ns:], color=cols[2], alpha=0.1)\n", + "\n", + "#plt.title('2 layer DGP')\n", + "plt.subplot(221)\n", + "plt.scatter(X1, Y1)\n", + "plt.subplot(222)\n", + "plt.scatter(X2, Y2)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:6: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \n", + "/home/ayman/anaconda3/envs/multitask-gpflow-2.0a0/lib/python3.7/site-packages/ipykernel_launcher.py:8: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", + " \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(16,9))\n", + "for _ in range(20):\n", + " samples = model.predict_all_layers(Xs_augmented, full_cov=True, num_samples=1)\n", + " for i in range(2):\n", + " s = samples[1][0][0,:,i]\n", + " plt.subplot(2, 2, i+1)\n", + " plt.plot(Xs_augmented[:Ns,0], s[:Ns], color=cols[1], alpha=0.3)\n", + " plt.subplot(2, 2, i+3)\n", + " plt.plot(Xs_augmented[Ns:,0], s[Ns:], color=cols[1], alpha=0.3)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
name class transform trainable shape dtype value
DSDGP.likelihood.likelihoods[0].variance ParameterSoftplus True () float640.00041024642926659955
DSDGP.likelihood.likelihoods[1].variance ParameterSoftplus True () float640.0005896648659102992
DSDGP.layers.constituents[0].sublayers[0].feature.features[0].Z Parameter True (100, 2) float64[[-1.11090547e+01, 8.45366068e-02...
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].variance ParameterSoftplus True () float640.00569071053087592
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[0].lengthscale ParameterSoftplus True () float643.926312684223526
DSDGP.layers.constituents[0].sublayers[0].kernel.kernel.kernels[1].variance ParameterSoftplus True () float640.00018509265661799667
DSDGP.layers.constituents[0].sublayers[0].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[0].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[0].q_mu Parameter True (100, 1) float64[[-1.13632912e-01...
DSDGP.layers.constituents[0].sublayers[0].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[5.95739400e-01, 0.00000000e+00, 0.00000000e+00...
DSDGP.layers.constituents[0].sublayers[1].feature.features[0].Z Parameter True (100, 2) float64[[-9.49222460e+00, 0.00000000e+00...
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float641.0915126217936635
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[0].lengthscaleParameterSoftplus True () float640.8013848846751531
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float640.00023070809067161598
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float640.001447424238160931
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[0].lengthscaleParameterSoftplus True () float644.349944370867345
DSDGP.layers.constituents[0].sublayers[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float640.00023643524724954832
DSDGP.layers.constituents[0].sublayers[1].mean_function.A Parameter False (2, 1) float64[[1.]\n", + " [0.]]
DSDGP.layers.constituents[0].sublayers[1].mean_function.b Parameter False (1,) float64[0.]
DSDGP.layers.constituents[0].sublayers[1].q_mu Parameter True (100, 1) float64[[-1.71143367e-01...
DSDGP.layers.constituents[0].sublayers[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[1.48777063e-01, 0.00000000e+00, 0.00000000e+00...
DSDGP.layers.constituents[1].feature.features[0].Z Parameter True (100, 3) float64[[-9.56020826, -10.3331547, 0....
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].variance ParameterSoftplus True () float640.1356169222976048
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[0].lengthscale ParameterSoftplus True () float643.0268476848588617
DSDGP.layers.constituents[1].kernel.kernel.kernels[0].kernels[1].variance ParameterSoftplus True () float646.696008458792229e-06
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].variance ParameterSoftplus True () float640.17437337093914762
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[0].lengthscale ParameterSoftplus True () float641.2259209722244166
DSDGP.layers.constituents[1].kernel.kernel.kernels[1].kernels[1].variance ParameterSoftplus True () float642.5067905475946642e-05
DSDGP.layers.constituents[1].q_mu Parameter True (100, 1) float64[[-0.18415413...
DSDGP.layers.constituents[1].q_sqrt ParameterFillTriangularTrue (1, 100, 100)float64[[[8.02467074e-02, 0.00000000e+00, 0.00000000e+00...
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print_summary(model)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From c72332e1e3aa25569ccb5e7113b3680dabff8ecf Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Thu, 15 Aug 2019 11:43:16 +0100 Subject: [PATCH 13/17] point to fork for GPflow dependency --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 513941e..4d99328 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,3 @@ pytest tabulate -git+git://github.com/GPflow/GPflow@awav/gpflow-2.0#egg=gpflow +git+git://github.com/aboustati/GPflow@awav/gpflow-2.0-snapshot#egg=gpflow From d792469afb41a281c276a92d41d28bc4677345ac Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Wed, 21 Aug 2019 11:43:41 +0100 Subject: [PATCH 14/17] adapted some gpflow utilities --- dgplib/utilities.py | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/dgplib/utilities.py b/dgplib/utilities.py index c14f043..50c4fe1 100644 --- a/dgplib/utilities.py +++ b/dgplib/utilities.py @@ -105,3 +105,12 @@ def _get_leaf_components(input: tf.Module, prefix: Optional[str] = None): return var_dict + +def set_trainable(model: tf.Module, flag: bool = False): + """ + Bug fix from GPflow + Set trainable flag for all `tf.Variable`s and `gpflow.Parameter`s in a module. + """ + for variable in model.variables: + variable._trainable = flag + From e0136dede9d3afa8706cfd18ad7f96a07fcd3cf1 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Tue, 27 Aug 2019 10:57:05 +0100 Subject: [PATCH 15/17] fixed bugs and added training utilitites --- dgplib/__init__.py | 3 +++ dgplib/specialized_kernels.py | 11 ++++++---- dgplib/training_utilities.py | 41 +++++++++++++++++++++++++++++++++++ requirements.txt | 2 +- 4 files changed, 52 insertions(+), 5 deletions(-) create mode 100644 dgplib/training_utilities.py diff --git a/dgplib/__init__.py b/dgplib/__init__.py index bff8eae..cb0ce8a 100644 --- a/dgplib/__init__.py +++ b/dgplib/__init__.py @@ -1,6 +1,9 @@ from . import utilities from . import layers +from . import multiprocess_layers +from . import weighted_layers from . import cascade from . import specialized_kernels +from . import training_utilities from .dsdgp import DSDGP diff --git a/dgplib/specialized_kernels.py b/dgplib/specialized_kernels.py index b4a206a..3213762 100644 --- a/dgplib/specialized_kernels.py +++ b/dgplib/specialized_kernels.py @@ -30,12 +30,15 @@ def K(self, X, Y=None, presliced=False): if not presliced: X, Y = self.slice(X, Y) - idx_X_parts = tf.dynamic_partition(tf.range(0, tf.size(idx_X)), idx_X, self.output_dim) - idx_Y_parts = tf.dynamic_partition(tf.range(0, tf.size(idx_Y)), idx_Y, self.output_dim) + idx_X_parts = tf.dynamic_partition(tf.range(0, tf.shape(idx_X)[0]), idx_X, self.output_dim) + idx_Y_parts = tf.dynamic_partition(tf.range(0, tf.shape(idx_Y)[0]), idx_Y, self.output_dim) Ks = [] for k, p, p2 in zip(self.kernels, idx_X_parts, idx_Y_parts): - gram = k.K(tf.gather(X, p), tf.gather(Y, p2)) + X_gathered = tf.gather(X, p, axis=0, batch_dims=None) + Y_gathered = tf.gather(Y, p2, axis=0, batch_dims=None) + + gram = k.K(X_gathered, Y_gathered) Ks.append(gram) N = tf.shape(X)[0] @@ -56,6 +59,6 @@ def K_diag(self, X, presliced=False): ind_X_parts = tf.dynamic_partition(tf.range(0, tf.size(idx_X)), idx_X, self.output_dim) - Ks = [k.K_diag(tf.gather(X, p)) for k, p in zip(self.kernels, ind_X_parts)] + Ks = [k.K_diag(tf.gather(X, p, axis=0)) for k, p in zip(self.kernels, ind_X_parts)] return tf.dynamic_stitch(ind_X_parts, Ks) diff --git a/dgplib/training_utilities.py b/dgplib/training_utilities.py new file mode 100644 index 0000000..f6a2565 --- /dev/null +++ b/dgplib/training_utilities.py @@ -0,0 +1,41 @@ +from typing import Callable, List, Optional + +import tensorflow as tf + + +def training_loop(closure: Callable[..., tf.Tensor], + optimizer: Optional[tf.optimizers.Optimizer] = None, + var_list: List[tf.Variable] = None, + maxiter=1e3, + monitoring_frequency=None, + jit=False): + """ + Simple generic training loop. At each iteration uses a GradientTape to compute + the gradients of a loss function with respect to a set of variables. + :param closure: Callable that constructs a loss function based on data and model being trained + :param optimizer: tf.optimizers or tf.keras.optimizers that updates variables by applying the + corresponding loss gradients. Adam is a default optimizer with default settings. + :param var_list: List of model variables to be learnt during training + :param maxiter: Maximum number of + :param monitoring_frequency: if not None, prints value of objective every int steps + :param jit: just in time compilation using tf.function + """ + + optimizer = tf.optimizers.Adam() if optimizer is None else optimizer + + def optimization_step(): + with tf.GradientTape() as tape: + tape.watch(var_list) + loss = closure() + grads = tape.gradient(loss, var_list) + optimizer.apply_gradients(zip(grads, var_list)) + + if jit: + optimization_step = tf.function(optimization_step) + + for iter in range(int(maxiter)): + optimization_step() + + if (monitoring_frequency is not None) and (iter % monitoring_frequency) == 0: + tf.print(f"iteration {iter + 1}: Objective = {closure()}") + diff --git a/requirements.txt b/requirements.txt index 4d99328..883a195 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,3 +1,3 @@ pytest tabulate -git+git://github.com/aboustati/GPflow@awav/gpflow-2.0-snapshot#egg=gpflow +git+git://github.com/aboustati/GPflow@ayman/gpflow-2.0-dgplib-compatible#egg=gpflow From 35e5bc030cd03e550e97ab77b72e3d68c8548040 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Wed, 28 Aug 2019 12:56:08 +0100 Subject: [PATCH 16/17] fixed bug with multiprocess layer --- dgplib/multiprocess_layers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dgplib/multiprocess_layers.py b/dgplib/multiprocess_layers.py index ded10cd..f79a0c9 100644 --- a/dgplib/multiprocess_layers.py +++ b/dgplib/multiprocess_layers.py @@ -118,7 +118,7 @@ def predict_f(self, Xnew: tf.Tensor, full_cov=False): var.append(v) mu = tf.concat(mu, axis=-1) if full_cov: - var = tf.concat(var, axis=1) + var = tf.concat(var, axis=0) else: var = tf.concat(var, axis=-1) From 1a127e85dababc8a1633d74ab840ec8888450917 Mon Sep 17 00:00:00 2001 From: Ayman Boustati Date: Tue, 17 Sep 2019 16:03:32 +0100 Subject: [PATCH 17/17] tweaks for compatibility with graph execution --- dgplib/dsdgp.py | 2 +- dgplib/training_utilities.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/dgplib/dsdgp.py b/dgplib/dsdgp.py index 21f1ea8..9272d65 100644 --- a/dgplib/dsdgp.py +++ b/dgplib/dsdgp.py @@ -146,7 +146,7 @@ def log_likelihood(self, X: tf.Tensor, Y:tf. Tensor, num_samples: int = 1) -> tf self.likelihood.variational_expectations(f_mean[s, :, :], f_var[s, :, :], Y) for s in range(num_samples) ] var_exp = tf.reduce_mean(tf.stack(var_exp), axis=0) - assert var_exp.shape == (X.shape[0], self.num_latent) + if self.num_data is not None: num_data = tf.cast(self.num_data, var_exp.dtype) minibatch_size = tf.cast(tf.shape(X)[0], var_exp.dtype) diff --git a/dgplib/training_utilities.py b/dgplib/training_utilities.py index f6a2565..6a5ea64 100644 --- a/dgplib/training_utilities.py +++ b/dgplib/training_utilities.py @@ -31,7 +31,7 @@ def optimization_step(): optimizer.apply_gradients(zip(grads, var_list)) if jit: - optimization_step = tf.function(optimization_step) + optimization_step = tf.function(optimization_step, autograph=False) for iter in range(int(maxiter)): optimization_step()