From 62febc7857804365d832512eb4f28e7eb786dbba Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:28:35 +0100 Subject: [PATCH 01/54] Approximate marginalisation during prediction time using Laplace approximation --- GPflowOpt/__init__.py | 1 + GPflowOpt/models.py | 92 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 93 insertions(+) create mode 100644 GPflowOpt/models.py diff --git a/GPflowOpt/__init__.py b/GPflowOpt/__init__.py index 7030392..e8a294c 100644 --- a/GPflowOpt/__init__.py +++ b/GPflowOpt/__init__.py @@ -19,3 +19,4 @@ from . import design from . import transforms from . import scaling +from . import models \ No newline at end of file diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py new file mode 100644 index 0000000..12599b1 --- /dev/null +++ b/GPflowOpt/models.py @@ -0,0 +1,92 @@ +from GPflow.param import Parameterized, AutoFlow, Param +from GPflow.model import GPModel +from GPflow.likelihoods import Gaussian +import GPflow +import tensorflow as tf + +float_type = GPflow.settings.dtypes.float_type + + +class MGP(Parameterized): + def __init__(self, obj): + assert isinstance(obj, GPModel), "Class has to be a GP model" + assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" + assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" + self.wrapped = obj + self.cov_chol = None + super(MGP, self).__init__() + + def __getattr__(self, item): + """ + If an attribute is not found in this class, it is searched in the wrapped model + """ + return self.wrapped.__getattribute__(item) + + def __setattr__(self, key, value): + """ + If setting :attr:`wrapped` attribute, point parent to this object (the datascaler) + """ + if key is 'wrapped': + object.__setattr__(self, key, value) + value.__setattr__('_parent', self) + return + + super(MGP, self).__setattr__(key, value) + + @AutoFlow((float_type, [None, None])) + def predict_f(self, Xnew): + """ + Compute the mean and variance of the latent function(s) at the points + Xnew. + """ + return self.build_predict(Xnew) + + def _unwrap(self, p, c): + """ + Unwrap all the parameters captured in the model + """ + if isinstance(p, Param): + c.append(p._tf_array) + elif isinstance(p, Parameterized): + for p2 in p.sorted_params: + self._unwrap(p2, c) + + def _compute_hessian(self, x, y): + mat = [] + for v1 in y: + temp = [] + for v2 in y: + # computing derivative twice, first w.r.t v2 and then w.r.t v1 + temp.append(tf.gradients(tf.gradients(x, v2)[0], v1)[0]) + temp = [tf.constant(0, dtype=float_type) if t is None else t for t in + temp] + temp = tf.stack(temp) + mat.append(temp) + mat = tf.squeeze(tf.stack(mat)) + return mat + + def build_predict(self, Xnew, full_cov=False): + fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) + c = [] + self._unwrap(self.wrapped, c) + L = self.cov_chol + Dfmean = tf.stack(tf.gradients(fmean, c)) + Dfvar = tf.stack(tf.gradients(fvar, c)) + + tmp1 = tf.matrix_triangular_solve(L, Dfmean) + tmp2 = tf.matrix_triangular_solve(L, Dfvar) + return fmean, 4 / 3 * fvar + tf.reduce_sum(tf.square(tmp1)) + 1 / 3 / (fvar+1E-3) * tf.reduce_sum(tf.square(tmp2)) + + @AutoFlow() + def _variance_cholesky(self): + c = [] + self._unwrap(self.wrapped, c) + h = -self._compute_hessian(self.build_likelihood(), c) + diag = tf.expand_dims(tf.matrix_diag_part(h), -1) + h = 1/diag*h/tf.transpose(diag) +tf.eye(len(c), dtype=float_type)*1E-3 + L = diag*tf.cholesky(h) + return L + + def optimize(self, **kwargs): + self.wrapped.optimize(**kwargs) + self.cov_chol = Param(self._variance_cholesky()) From 2f554cc316a21ad4461d2ebc1043f932823768f8 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:42:29 +0100 Subject: [PATCH 02/54] Adding docstring --- GPflowOpt/models.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 12599b1..a2e990b 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -8,6 +8,19 @@ class MGP(Parameterized): + """ + Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation + Key reference: + + :: + + @article{garnett2013active, + title={Active learning of linear embeddings for Gaussian processes}, + author={Garnett, Roman and Osborne, Michael A and Hennig, Philipp}, + journal={arXiv preprint arXiv:1310.6740}, + year={2013} + } + """ def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" From 267fdadaee2805ce7ff4dba415a4b95a3ad4c09a Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:45:20 +0100 Subject: [PATCH 03/54] Small example Interfacing still needs cleaning up --- doc/source/notebooks/testmgp.py | 40 +++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 doc/source/notebooks/testmgp.py diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py new file mode 100644 index 0000000..699195a --- /dev/null +++ b/doc/source/notebooks/testmgp.py @@ -0,0 +1,40 @@ +from GPflow.gpr import GPR +import numpy as np +from GPflow.kernels import RBF, White +from GPflowOpt.models import MGP +import matplotlib.pyplot as plt + +x = np.random.randn(4, 1)*2 + +y = np.sin(x) + +m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1) + White(1))) +m.optimize() +print(m) +print('Trained') + +X = np.array(np.linspace(-3, 3, 100)[:, None]) +fm = [] +fv = [] +for xn in X: + fms, fvs = m.predict_f(xn.reshape(-1, 1)) + fm.append(fms) + fv.append(fvs) +fm = np.stack(fm, axis=0) +fv = np.stack(fv, axis=0) +print('Evaluated') + +plt.subplot(1, 2, 1) +plt.scatter(x, y) +plt.plot(X.flatten(), fm.flatten()) +plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), + alpha=0.2) +plt.title('MGP - GPR') +plt.subplot(1, 2, 2) +plt.scatter(x, y) +fm, fv = m.wrapped.predict_f(X) +plt.plot(X.flatten(), fm.flatten()) +plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), + alpha=0.2) +plt.title('GPR') +plt.show() From be294eeac4cb8d0946b22d3a9be1256ea9214592 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:46:41 +0100 Subject: [PATCH 04/54] Adding predictions for multiple points --- GPflowOpt/models.py | 70 ++++++++++++++++++++++++++------------------- 1 file changed, 41 insertions(+), 29 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a2e990b..8f551e2 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -7,7 +7,30 @@ float_type = GPflow.settings.dtypes.float_type -class MGP(Parameterized): +def rowwise_gradients(Y, X): + """ + For a 2D Tensor Y, compute the derivatiave of each columns w.r.t a 2D tensor X. + + This is done with while_loop, because of a known incompatibility between map_fn and gradients. + """ + num_rows = tf.shape(Y)[0] + + def body(old_grads, row): + g = tf.stack(tf.gradients(Y[row], X), axis=1) + new_grads = tf.concat([old_grads, g], axis=0) + return new_grads, row + 1 + + def cond(_, row): + return tf.less(row, num_rows) + + shape_invariants = [tf.TensorShape([None, len(X)]), tf.TensorShape([])] + grads, _ = tf.while_loop(cond, body, [tf.zeros([0, len(X)], float_type), tf.constant(0)], + shape_invariants=shape_invariants) + + return grads + + +class MGP(GPModel): """ Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation Key reference: @@ -21,13 +44,19 @@ class MGP(Parameterized): year={2013} } """ + def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj self.cov_chol = None - super(MGP, self).__init__() + super(MGP, self).__init__(None, None, None, None, 1, name=obj.name + "_MGP") + del self.kern + del self.mean_function + del self.likelihood + del self.X + del self.Y def __getattr__(self, item): """ @@ -46,14 +75,6 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - @AutoFlow((float_type, [None, None])) - def predict_f(self, Xnew): - """ - Compute the mean and variance of the latent function(s) at the points - Xnew. - """ - return self.build_predict(Xnew) - def _unwrap(self, p, c): """ Unwrap all the parameters captured in the model @@ -82,24 +103,15 @@ def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) c = [] self._unwrap(self.wrapped, c) - L = self.cov_chol - Dfmean = tf.stack(tf.gradients(fmean, c)) - Dfvar = tf.stack(tf.gradients(fvar, c)) + C = tf.expand_dims(tf.stack(c, axis=0), 1) - tmp1 = tf.matrix_triangular_solve(L, Dfmean) - tmp2 = tf.matrix_triangular_solve(L, Dfvar) - return fmean, 4 / 3 * fvar + tf.reduce_sum(tf.square(tmp1)) + 1 / 3 / (fvar+1E-3) * tf.reduce_sum(tf.square(tmp2)) + Dfmean = rowwise_gradients(fmean, c) + Dfvar = rowwise_gradients(fvar, c) - @AutoFlow() - def _variance_cholesky(self): - c = [] - self._unwrap(self.wrapped, c) - h = -self._compute_hessian(self.build_likelihood(), c) - diag = tf.expand_dims(tf.matrix_diag_part(h), -1) - h = 1/diag*h/tf.transpose(diag) +tf.eye(len(c), dtype=float_type)*1E-3 - L = diag*tf.cholesky(h) - return L - - def optimize(self, **kwargs): - self.wrapped.optimize(**kwargs) - self.cov_chol = Param(self._variance_cholesky()) + h = -self._compute_hessian(self.build_likelihood() + self.build_prior(), c) + L = tf.cholesky(h) + + tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) + tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) + return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ + + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) From 56e081149880235d5b53b0e06b61b2831ff6ebda Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:47:06 +0100 Subject: [PATCH 05/54] Add notebook for MGP --- doc/source/notebooks/mgp.ipynb | 172 +++++++++++++++++++++++++++++++++ 1 file changed, 172 insertions(+) create mode 100644 doc/source/notebooks/mgp.ipynb diff --git a/doc/source/notebooks/mgp.ipynb b/doc/source/notebooks/mgp.ipynb new file mode 100644 index 0000000..bc03569 --- /dev/null +++ b/doc/source/notebooks/mgp.ipynb @@ -0,0 +1,172 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Marginal GP\n", + "*Nicolas Knudde*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook demonstrates the approximate marginalisation of the hyperparameters during testing time. A Laplace approximation is used here and is described in Garnett et. al. (2013)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from matplotlib import rc\n", + "rc('text', usetex=True)\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "import GPflow\n", + "import GPflowOpt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we set up a test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(3)\n", + "x = np.random.rand(8, 1) * 8-4\n", + "y = np.cos(x) +np.random.randn(8,1)*0.1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We proceed by constructing a Marginal GP wrapper around a GPR object and defining some suitable priors on the hyperparameters. Eventually we optimise the model." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " fun: 11.219668379985972\n hess_inv: <3x3 LbfgsInvHessProduct with dtype=float64>\n jac: array([ -8.31933750e-06, 6.32051531e-06, -1.65760996e-06])\n message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n nfev: 9\n nit: 6\n status: 0\n success: True\n x: array([ 0.77306105, 0.02511576, -1.60659824])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = GPflowOpt.models.MGP(GPflow.gpr.GPR(x, y, GPflow.kernels.RBF(1, lengthscales=1, variance=1)))\n", + "m.kern.lengthscales.prior = GPflow.priors.Gamma(3, 1/3)\n", + "m.kern.variance.prior = GPflow.priors.Gamma(3, 1/3)\n", + "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 1)\n", + "m.optimize()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we compare the prediction of the MGP and the regular GPR model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluated\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEFCAYAAADzHRw3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X = np.array(np.linspace(-4, 4, 100)[:, None])\n", + "fms, fvs = m.predict_f(X)\n", + "print('Evaluated')\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(x, y)\n", + "plt.plot(X.flatten(), fms.flatten())\n", + "plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()),\n", + " alpha=0.2)\n", + "plt.title('MGP - GPR')\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(x, y)\n", + "fm, fv = m.wrapped.predict_f(X)\n", + "plt.plot(X.flatten(), fm.flatten())\n", + "plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()),\n", + " alpha=0.2)\n", + "plt.title('GPR')\n", + "plt.show()" + ] + }, + { + "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.0 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From 8cb9e83c3ac06e8093905546a12172f4c95361ff Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:56:59 +0100 Subject: [PATCH 06/54] Update notebook MGP --- doc/source/notebooks/mgp.ipynb | 46 ++++++++++++++++------------------ 1 file changed, 21 insertions(+), 25 deletions(-) diff --git a/doc/source/notebooks/mgp.ipynb b/doc/source/notebooks/mgp.ipynb index bc03569..e9d0b09 100644 --- a/doc/source/notebooks/mgp.ipynb +++ b/doc/source/notebooks/mgp.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -61,28 +61,26 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "collapsed": true }, "outputs": [ { - "data": { - "text/plain": [ - " fun: 11.219668379985972\n hess_inv: <3x3 LbfgsInvHessProduct with dtype=float64>\n jac: array([ -8.31933750e-06, 6.32051531e-06, -1.65760996e-06])\n message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n nfev: 9\n nit: 6\n status: 0\n success: True\n x: array([ 0.77306105, 0.02511576, -1.60659824])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "name_MGP.name.kern.\u001b[1mlengthscales\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 1.47220582]\nname_MGP.name.kern.\u001b[1mvariance\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 0.75133993]\nname_MGP.name.likelihood.\u001b[1mvariance\u001b[0m transform:+ve prior:logN([ 0.],[ 30.])\n[ 0.01172159]\n\n" + ] } ], "source": [ "m = GPflowOpt.models.MGP(GPflow.gpr.GPR(x, y, GPflow.kernels.RBF(1, lengthscales=1, variance=1)))\n", "m.kern.lengthscales.prior = GPflow.priors.Gamma(3, 1/3)\n", "m.kern.variance.prior = GPflow.priors.Gamma(3, 1/3)\n", - "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 1)\n", - "m.optimize()" + "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 30)\n", + "m.optimize()\n", + "print(m)" ] }, { @@ -94,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "scrolled": false }, @@ -108,9 +106,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEFCAYAAADzHRw3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJztvXm4XFWV9//ZNQ+36s43Exm4SQhDBEkuIINKILQM2goG\nUGxaxDa0rbb92t3Q2N2+/rTfV8GfbbfQ2sR2pFGBSCsKqAQQEcOQhMkgCUkgCSHDnW/N437/OFXh\nktyh6tQ+dU7V3Z/n4UlVnapzNrd2rbP22mt9l5BSotFoNJrGx2X3ADQajUajBm3QNRqNpknQBl2j\n0WiaBG3QNRqNpknQBl2j0WiaBG3QNRqNpknQBr0ChBA7hRB3T/D6TUIIecRrK4QQD5Y+s1MIcdO4\nY8NCiM2l45vHHzM5LlPXmuDYbbWMQ6Mpo+ekvWiDXjm9E7y2GhgpPxFCrADuBm6QUi6WUi4Gnj7i\nM+dLKS+QUq4sfcaUUVdwrfHHduofkKZW9Jy0H23QK2eDEGJN+YkQohfYdMR7voUxmbeUX5BSrp/i\nnHcCK0yOR+W11gN9Jseh0ZTRc9JmtEGvnDuBK8c9vw7DGwFACNEGrJhmAh/JjcCD1Q7EgmvdgPH/\np9GYQs9JZ+CxewANxC7eHHZZLaW8QQhRft5Res90PDTuM3dKKW82MRYV1yofW4HhVZkZh0ZTRs9J\nB6ANenWUwy5bOHryDjHO4JfedyPQK6VsH/e+86WUI9SGimudL6UcEUI8iPH/o9HUgp6TDkCHXKrj\nNoywy5rS48OUJukWIcTq0vP15Y2fahFC3F3a6d9citW/CZXXwlja1pRto9HoOekMtEGvAillOexy\ngZRywwRv+Rhw20RGuMrrXC6lXFn6b7JlrKprbQF2jd/w1WhMouekzeiQS/VsYOIURqSUW4QQl/Pm\nSX2XFYNQfK0bMDanqtnQ0mjehJ6T9iO0HrpGo9E0BzrkotFoNE2CNugajUbTJGiDrtFoNE2CNuga\njUbTJNQ1y6Wrq0suWrSonpfUzCA2b948IKXstuPaem5rrKTSuV1Xg75o0SI2bTpSz0qjUYMQYrdd\n19ZzW2Mllc5tHXLRaDSaJkEbdI1Go2kSag65CCHWlh4ullLeUOv5NBqNRmOOmjz0khDPBinlOqC3\nLMyj0TQKpS47kx27qfTv2sneo9E4iVpDLr0YbdjgaL1wjcbRlByQo3rFjmOtEGInlel8azS2U1PI\npeSZl1mB7jCiaSCklBuEEFMZ649V2YFHo7EVJZuipWXrlvG9BMcdWyuE2CSE2NTf36/ichpNvegV\nQqwWQlxv90A0mkpQleWyerINUSnlOilln5Syr7vblpoPZ1HIQfwQjL4GiUEoFu0ekWYSpJQ3l3Tv\nO/X+UBXkUhA7UJrjA1DI2z2iGYOSLJdy7z8hxOpJGj9oADJxGH4FiuMmeGw/tC8Cf4ttw9IcTWkj\ndKgUchlkgv2h0nvWAixYsKC+A3QiUsLoXkgOvvn1sX0Q7obIHHijn6jGAlRkudwkhNgphBhWNKbm\nJJeCoZ1vNuYAxRwM7oDkkD3j0ryJUvd6gE0YzUwAFpeevwm9+hyHlDC062hjDiCLED8I/dsgn6n/\n2GYQNRl0KeUGKWW7lHJx6V/tnU9EsQjDrxoTe0IkjOyBlL4n1pNSi7O+I1qdPQSH26BdUTq2c6L9\nIc04Rl+DzNjU78mnDKOeidVnTDMQ3YKuHsQPQD49zZskDO8Glwf8kboMa6ZTCqesP+K1leMerzvq\nQ5qjSQ1DcqCy98oCDO6EtgUQ6rB2XDMQXfpvNfksJCrN7pEw9IoRntFoGoFiEcZer/JDEkZ2Gxun\nGqVog2418QNThFomQBaMWGQhZ92YNBpVxA9AIWvus7H9RihSZ3opQxt0KynkzW12FrLGsrRYUD8m\njUYVhXwVq89JSA3DwHbITReS1FSCNuhWkhwApLnP5lOGp669F41TSRyqbvU5GfkUDGwz6jI0NaEN\nulVIaRRV1EI2Xkp11EZd4zCKhdrn93hkEUb3GCvTvMkQjkYbdMtIjxo55rWSjcPgy7raTuMskkPG\nfo9qMmPQ/5JO4TWJNuhWkVJYKJRLGkvSbFLdOTWaWqg0TdEMsmBslo7uM1a6morRBt0KCnlIT1Nk\nUfU5s4anHtcCZxqbycQqqKtQQOJQqSBPG/VK0QbdCtIjmN4MnQpZhLHXYGCHzgrQ2Ec9ZSrSI0bO\nuqYitEG3gtSItefPxow448hena+uqS/FYslhqSOpYV2EVCHaoKumkDcMruVII4556EUY26+XpZr6\nkB5Rk6pYLbH9WgOmArRBV029vRdZNKr1+l/SkgEa67Ez+2Rkjy62mwZt0FWTHrXnuvm0UXFn1/U1\nzU8hb6+XXMganrpmUrRBV0mxYO+ElyWZXr001VhBehRLNvurITGgEwKmQBt0lWTGsH3Cy6Kh2Kir\n7TSqqXc4cUKk0QFJMyHaoKvEKeEOWTBSvfRGqUYVdq8+x5MZg2zC7lE4Em3QVSGlcyY8GJIBKrU2\nNDMbJ4RbxqPTGCdEG3RVZBNH9wu1m9h+rQGjUYNTVp9lMmM6q2sCtEFXxXT9FO1AFnRWgKZ2nLb6\nLBM/ZPcIHIc26Kpw4oQHowu73iDV1EImZo2yYq2khnWl9BFog66CQs5QRHQk0ig80mjM4sTVJ2BU\nS+umGOPRBl0FTvXOyySHtJc+CUKIFVMcWyOEWC2EuL6eY3IcqpVDVaIN+pvQBl0FTtswOgpZe+/H\nJkQIsRq4e5JjKwCklBuAkakMf1OTz0AhY/coJqeQbYDfX/3QBl0F2bjdI5ie5KDWwTiCkrHeNcnh\nK4FyJc0uYHVdBuU0nOydl9Fe+mG0Qa8VJ6YrToQs6IlfHW3AeOHvTrsGYiuOjZ+PIz2mN0dLeOwe\nAGCkRQlh9yjM4fT4+XgSA9DSY/comgYhxFpgLcCCBQtsHo0FFIuWrD4f2dbP7Rt30x9L0x0JcPWZ\nC1m1rLuGM0oj40XPbYd46PlM4wruNJJBL2R0vLFyRoCO0uM24KjljZRynZSyT0rZ191di0FyKNm4\ncu3zR7b1c+vDOzgUSyOBQ7E0tz68g0e21bjHU88uSg7GGQYdGrPLd7HQeJoSWg5gSoQQbaWHdwK9\npce9wAZ7RmQjFjgrt2/cTSb/5r2cTL7A7RtrbDOXT+nKUZwScgFDyS06x+5RVEcmhqP0LSohM2as\niDx+u0diO0KINUCfEGKNlHJ96eWHgJVSyi1CiL5SJsyIlHKLfSO1CQsMen9s4pV4fyxdeygmNQze\noKKRNibOMej5NGST4AvZPZLKaaRwy3iSgxCda/cobKdkxNcf8drKcY/X1X1QTqGQM7xexXRHAhya\nwKhHAh5ufXjHYe+9HIoBKjfqqeEZP6+dE3KBxgu7NLJB19K6mqmwaG5ffeZC/B73m17ze9yGXEyt\noZhCFjINkEJsIc4y6I4Q0K8QpxdcTEUx33g3T019sShdcdWybj553hJ6IgEE0BMJ8MnzlhDPTJz6\nO1mIZlJm+Lx2TsgFjDtsNgG+sN0jmZ5G9c7LJAch1DH9+zQzEws93VXLuo8Ko9y+cfeEoZjuSKC6\nk6dHQB7TuGnQNeIsDx0g1SBeeiMUXExFNt64qaIaa8mloFjfQp3JQjFXn7mwuhMV841RuW0RzjPo\njRB2kbI5YnVJncKomQCLV59FKdkzmmfbYI541shznywUY6rgaAaHXZSEXIQQK5SldTVC2CUbd6Y+\ndLUkhyAyF1zOu69rbMQig34oUeAbm+L8YnuKgZRhyF0CVs7xcd2KFs4/rqvGitES6dHGrj6vgZoN\neilP9zZgce3DKZEacbZBb/T4eRlZMLyZ8MyUKdFMgJSWhCx++lKSf3xklExBcuHiAGfP99Pic/Hy\nUI57XkrxF78Y4pKlAb50XhtRf40ORjFv/EYDUTWDbyBqNuhSyg1CiMkU68yRHoHWeUpPqZRmMehg\nhF20QbeOQg7cXrtHUTmKy/2llHxlY4xvbIpz+lwfN61u49i28WYnyKdOi/CtZ+J8dWOMnUMD/PCy\nTjqC7knPWRHpkRlp0J251i6HXZyIo7sTmSCXbI79AKfSCPKz41E8F27+vWHMP7g8xB2Xdh5hzA28\nbsFf9UX43ns7eGUkz1X/M0gsU+NNpRx2mWE406CDc0Wk6vgDfWRbP9d+bxPvueV3XPu9TbULGE2G\n3hy1jkKDCc8pXH3+8A8Jvrk5zlXLQ/zfVa143VPHtN++IMC6d3fw8mCev31whGItBrkcdplhWG7Q\nhRBrhRCbhBCb+vurMEhOTV+sU7qiZap0E5Ea0XrSVtIoKa7FgrLV5+b9WT73m1HOXejni+e2Iirc\noHznwgCfPSfKr3el+fYzNa7SGyFjTjGWFxaV9DDWAfT19VV+yy1knKftImXd7vqTqdJ967c7FWtJ\ng9GibqDxxNEahfRYY2h1KxKbi2WKfPpXw8xpcfPvF7bjdlWXbXLtW8M8uS/LVzaOsWqRnyUdJvcg\nZmC2S80e+njFOgXjeTNOC7vUMV1xspLnsXTeGq89OWA0NNCoJxtvjPZ/ipyVLz42xuuxAv/2rnZa\nTWSsCCH4l1WthLyCGx4aQZoNvRTzjbM6UkTNBl1KuV5K2T5OflQdTlsy1fEGU2nJsxItaSjpuzRA\nk4CG3OiSjWFYFKQr/n5vhrteTHLdihZWzvGZPk9P2M1nz2ll8/4cP9tWg+qjU0O3FuHcTVEwJHWd\nJFpfxw3RiUqhJ6NqAaPJiB9ytsEsFo050Yg4Pdsln635b5vJS/7pkREWRN18+oxIzUNac0KQk3u8\nfOnxMZI5k6vHGZbt4myDDs65w+bSdVVXnKgUOuKfeMujagGjyShknLcqGk823rg/TqdnXCgY3/ee\nS7BrpMAXzm0l4Kk9bu0Sgs+9I8rBRJHvPmtyg1QWGmN1pAhnqS1OhFM6GdkQzz9Sla6c+TJ+s9SU\ngNFUxA9BsF3d+VSSjUOgbfr3OZFiznmb/OPJ1mbQB5MFbn06xqpFfs5dpMjBAPrm+jlvkZ91W+Jc\nfXLYXBVpagQCrcrG5GSc76E7JexSJ4NeKEo27ErzN78a5tzvH+TUdQc4+7sH+ci9g/Tnw/zFOxar\nETCajFzSeZvRZRq9AMrJnmKNHvotT8dJ5iSfPVt9deZn3hZhNCPNe+kzKOzifA8djDusnb0C81nI\nWV+5+vjeDJ/7zSg7h/N0Bl30zfUxK+xiLCN59kCW6x8aoTvk4oazT+T9xwcrzu2tmtgB53k0CnOk\nbSM9BpHZdo/iaLJJY1PcJK+N5bnjhQRXnBhiaad6mYPlPT5WHxvgu8/F+diKMCFvlX6oLBhGPdig\nq7sqaAyDbnfYxWKPNV+U3PT4GN96JsGCqJtbLmznwsWBN1XWSSl5+vUsX3p8jL97cITH9mT40nmt\n1U/uSsgljZuok34A2TgN15D7SHIJKOTB7bCfXY3e+defiiOAT51e+0boZHy8r4X3353mrheTXHNK\nS/UnSDtsPluE80MuYH/YxcKNwmSuyLX3DvGtZxL8+ckhfv1nPbznuOBRZdJCCE6f5+cnl3fx92dG\nuHdbij//6VDtmheTETtgzXnN4lRtn2pxYtilBoO+ZzTPT/6Y5EMnh5kbqVFQawpWzvHRN8fHt7Yk\nyBdN3NjTozOizqIxDDrYJ1pfyFnWASWVK3LNz4YOe9tfOLdt2uwAlxB84rQIt17UzrMHs1xz7yDp\nvAWeaz5l6KU7hUaPn5dxmkEvFmua39/cHMftgr9cYcJrrpKPrQizL1bgwV0m0itl0dkZXIpoIINu\n05dh0Y0kV5B84oFhNu3P8u8XtvPB5dXpv1+yNMjX39XOlv05/vbXw7UJGU1GbL8zvJpi0ZL4uRBi\njRBitRDi+kmO31T6d62yi2Ziztqgy4xhNpS1P1Zg/YtJrjgxxKwW67zzMquPDTAv4ub7z5ndHNUG\n3TkUMvYsuy0y6F/47SgPv5rhi+e28qfHmdvwvXhpkBvPiXLfjjT/udkCD7aQhcQh9eetFgvi50KI\nFWDo+QMj5edHsFYIsRNQp/dfzDsrfFRDuOW/nolTlHDdSuu9cwC3S3D1ySGe2JflpQETYnLpMWMP\no4lpHIMO9Q+75NKWeIZ3bk1w+wtJ1q4I86G31NaZ6WOnhrlkaYCvbozx9OsWFD7FD9qvxGhNyOtK\noOyy7QJWT/Cej0kpF5eMvjqcFHYxOZbRTJEfb03y7uOCzI/Wb5P3yhPD+N3w3y+YuSnKpvfSG8+g\n13O5aoG2yUsDOf75N6OcM9/H9WfVnrMrhODL57UxL+LmM78eIZFVHCKRRRjbp/ac1WJN/LwNGP8F\nT9S2qXeakIw5aWinVI3m0sYqzAR3vJAgkZOsrUPsfDztQRcXLwnys20pc3IATd5AurEMejFfv6IX\nKZVvCqbzkr/+5TBRv4uvvasdT5WyopMR8bv4ygVt7B0r8JWNFhiL1LB9Rsii+HklSClvLnnnnaXe\nuUceXyel7JNS9nV3V1HclUvav+oB0955tiD5/nMJzpnv46Tu+rfX+8DyELGs5L6XTWyOZuNGXUmT\n0lgGHeqnCJgeNcq1FfLVjWNsH8rz1Qva6A6p3UQ6Y56fD58c5vvPJXj2gAUTdvQ1ezbzrMs/HwE6\nSo/bgMHxB0ved1kSehDoVXp1J4h1mXSOHtiR4mCiyEdPra93Xub0uT562z386A8m9yIaQVXUJI1n\n0NNj9fFukoPTv6cKNr2e4b+eSfCht4R450J1Whfj+bszI3SFXPzvR0fVZ73k00Y8vd5YlDIK3Mkb\nRroX2AAghChXn2wqvwYsLj1XR8ZmeYWCuc1ZKSXffiZBb7uHdy70WzCw6RFCcOWJIbYcyLFz2MQm\npxPDLopWDY1n0FEfCjmKfEbpxlUmL7nhoVHmRtzcaIHWRZmI38Vnz4ny3MEc61+0oBArftD429QT\nizJCpJRbAEqhlJHyc+ChccevKHnpO8cdV4Pd6Ysm0xW3HMjx/KEcHzkljMvGTkCXHh/EJeCeP5oI\nx+XTzso0AmXSIg1o0FHuPR9FQm3T5HVb4uwczvMvq1pp8Vn7J3/fsiCnzvby1Sdq0JCeDFk0Qi/1\noli09IdXioFvKLVJLL+28ojj66WUN6u/eNHezVGT4ZYfPJ8g4hNcdryN2koYDTDeudDPPS8lKZip\nHHVS0Rwom+eNadALGes2R4tFpTeMPaN5bnk6xiVLAqxSKCs6GUII/vEcQ0O65ia7E5EZq9+StRn0\nW6bCLlVLk71xDyUK3P9yijUnhghb7JhUwvuPD7E/XuT3r5lYNdY7Y24qpDQE0hRg/7diFsVe9GGS\nA0r7hn7xsTE8LsE/v6N+6oV9c/38SW+A2zbHGUlbUOk59np9Kkiti587A7vy0TNjpub4j7cmyRXh\n6hprJ1SxujdAxCf4qZkWdbLgnJz0XNJYsSmgcQ16Zky9YFexqHTj79HdaR7cleZTp7Uwuw6l0eP5\n2zMjJHKSdVssqiCN10G8q1n0WyajkFXmmVWFiZVBvij54QsJ3r7AT2+7M9QiAx7BhUsC/GpH2pye\nkVPCLgrDio1r0MHorqOS5EBNutDjyRcl//LYGIta3Vz71vqndy3r9PLu44J877kEg0kLOs7HD1m7\nQdoM+ueVYIeXbsKgP/xKmgOJIn/2Fmd1XLp0WYh4zmgKUzWZmDPqARSuRBvboKeG1RmVYkGpd/6j\nPyR5eSjPjedE8Svor2iGT5/eQion+bbZTi9TIo3Qi1U0e/y8TL3j6JmYKaflv19IMjvs4vxjrd8H\nqoYz5hlNYEyFXeqRMVcJCldpjW3QkYYioApi+5V557FMkX97MsYZ83z8Sa99P4AlHV4uXhrgB88l\nGLUilp4esS4LxSnl8VaTS9a3ctGEaume0Ty/3ZPhA8vDyqqbVeF2Cd69NMhvd6cZNdMbwOqMuenI\nZ5QWMDa4Qcfw0muNpedSSjdZ122JM5gq8o/nRK1rE1chnzwtQjwn+Z5ZydHpGFN0Qz2SmWLQob5y\nFiY2An+8NYlLwJUnOivcUuY9xwXJFuHXO02EXQoZe/dqFDtEjW/QobbcaClhZA+qlveHEgX+65kE\n714a4ORZPiXnrIUTurycv8jP959LkFKdlw5Gt3jVZez5rFH8MVOol0HPjFW9Cs0VJHe9mOS8RQHm\nWNiRqBZOmeVlftTNz7ebdOzs9NK1QZ+AbBwSJr+U2H6lm29ffypGrij5+zOtqwitlutWtjCULrL+\njxa18VPdrm4meedgzN966HSbCLdseCXNQLLIVcst9M5FbWZICCPs8vjeDEMpEwkA6RFjD80OtEGf\nhLF9hhxoNaSGlW6E7h7J8+OtST5wUoiFbc5I7QI4ba6PU2d7Wbclbq6qbjpyCbVeupP0wuuCtN5L\nL5rLu/7hH5LMbXFbo9sSbIeek2DOKdC5FNzmV7SXLA1SkPArM2EXWbRH36VYMFo9KqR5DLoswPCr\nld9pM/FSqEUd//ZkDI9L8NcWdj83gxCC61a0sHeswK/NpHdVgqobo5TNX1A0EVYblNRI1cUre8fy\n/G5PhstPDOJWvRka6oT2ReApGXF/C3QtA7e5G8dJ3R4Wtbq534ykLtgTdrEgoaB5DDoYd7uhXdMb\n9fQYDO1UVp0FsH0wx0+3pfjwKWF6ws6LNV7QG2B+1G2NHAAYRljF5lI2rizbqKHIWpwTbUIy9q6t\nRijyipMUh1u8IWidf/Trbo9h5Kn+5iGE4OKlQX7/msmwSy5Z/yIvbdArIBuHgZcn/nKKRSN3WrEx\nB/jXJ2KEvaIu3c/N4HYJrjklzKb9WWv00kGNl+4EnXC7sKoRei5d9aonX5Tc/WKSdy70My+iMnwo\noG0hTJb95QtBZLapM1+8pIawC9TfS9cGvULyKRjYBoM7jYrGxIARXjm01RJN7z8cyvLLnWmuPTVM\ne9C5f9IrTgzR4hXWpTBmxmr3cuwSrHICVoVdktWn5P52d4YDiSIfUL0ZGu4C7zS1GeEecFXfCemk\nbg8LW908sMOkQU8N10ejCIzQoiLJ3PE41/qoIDNmbJaO7jXuvhYt5b/2RIyoX/AXNnVwqZSI38Xl\nJ4W47+UUhxIW7erXcsPMpY284JlKLlH9xv50FIumqiF/vDVJV9DF+SoVQoUbWirwvl0uiMyp/vRC\ncNESI+xiSpSunoJduZTyKAE0u0GvA88eyPLQqxnWrmgh6nf+n/PDJ4fJF812Ta+A9Ih5o+TETjL1\nRnV7tNRQ1cqKhxIFHnolzftPDOF1K9wMDXcbcfJKCHWYynq5eEmAfBEeNLv5Xy8pAIsqrJ1vgRzO\n156M0R5wcc0pzpAUnY5FbR7OW+Tnhy8kyZhRqKsEs166NujqDUqiv+qPrP9jkoI0QnTKEC7DoFf8\nflHd+0u8pcfLvIibB3aYTAfMxurTlStrTa2FNug1sHl/lkd3Z1i7Imx5JyKVfPiUMAOpIr/caVGh\nUWq4en2SbGJmh1vKFHPqNkdTI1VX3EopuWtrktPn+lisUiY32F65d14m1GmEaarACLsE+N2eDDEz\n2i5Qn81R7aE7j397IkZn0MWfn9wY3nmZcxb46W1z832rNkeR1eulO0H1zimoMigm5KWf3Jfl1dEC\nH1Cdqhjuqf4zLrdxI6iSCxcHyBbh4VdrCLtY2c0ol7ZsP08bdJNsej3DY3szXLeyxRHtuKrBJQRX\nnxxmy4EcLxyyKIUxOVT50rWQVx87bmQyY7VvjqZHTWVR3Lk1ScRneLnK8EWmz2yZjHBX1R9ZMcdH\nd8hlPn2xmLM228rCPrmNZYkcxNeejNEVdDlO8L9S3n9CiKBHcPvzVhVTVKGXnhywZMd/OoQQa4QQ\nq4UQ15s5bimJGpu3mFDBHE0XuX9HivctCxL0KjQN4U7zn/UGwVvdCtglBO9aHOCRVzPmBemsDLtY\nWAmtDboJntqX4fG9Wf5yZQshlRO/jkT9Lt53fJCfbUtao5UORsbLdNWjxaJ1/WGnQAixAkBKuQEY\nKT+v9LjlJIfM66Qnh0xphPxsW4pMAa48SWEI0eWFQFtt5whVf0O4cHGQVF7y6B6T+zJWdjNyskG3\n1Yuxia89GaMr5OJDDeqdl7n6LWEyBbj7RQtLnkf3Tl2sEXtdqcB/FVwJlHcfdwGrqzxuMdJctlCx\nYNReVHs1Kfnx1gTLu70s76m+qGdSgu2TV4VWfI62qhUZz5jno9UvzGmkA0Y3Iwu89HzG6CVrETUZ\ndNu9GBt44rUMG1/L8vGVLWqXpTZwYreXvjk+/vuFBEWrNoHyacOoT0Q2YSqtThFtwPjA/ZFu4HTH\nrSc5WH0sfex1UxtuLxzK8eJAnitVb4aa8K6PwuWGQGtVH/G6BRf0BtjwSppsweTctmKj3sL4OdTu\nodvsxdQXKSVfezJGT9jFh97SWJktk3H1ySFeHS3wO7NL00pIDRlNSMbfNDJxQ5qhgRFCrBVCbBJC\nbOrvt+LGJKtr3pIeNVXmD/CjrUkCHsF7lwVNfX5CvGHzm6FHEuyo+iMXLg4ylpE88ZrJuV3IqNfm\nt1jrv1aDPq0XY/2krx+/fy3Lk/uyfKIvQsCmxs+quXBxkM6gi9tfsFhpLtEP/dtgdJ+hiDm4o+oK\nRsWMAGUr0QYcub6e7jhSynVSyj4pZV93d/VFMBWRjVW2x5DPmpaDTmSL3LstxSVLA2qrnVV452X8\nkar1Xc5Z4CfsFTxgOuyC+v0di6WhLY8Z1GXS1wEpJf/6xBhzWlzql6U24vcIrjwpxEOvpNkXs1i2\nNp8ysjfSo6hq+VcDdwK9pce9wAYAIUTbVMdtYfS1qTeXC3njBmkyt/kXL6dI5CQfVDmvhcuIfSs7\nn6j6fAGP4NxFfh7clTbf2CU9qq6blMXxc6jdoE/rxTQ6j2zr59rvbWLVLVvYvD/HBQtoGu+8zFXL\nQ0gJP/pDnfWgbURKuQVACLEaGCk/Bx6a5rgNSGNVM1EFaTYJA9tNVdmW5/bnHzpI2JVjbExh7nWg\n1Yh9q8RUkVGQgWSRLaYlo6W6Gok6tFastbb3TqCv9NheL8YCHtnWz60P7yCdK3CAeXjJ8cL213lk\nvptVyxrUs0tPAAAgAElEQVR3tXEkx0Q9nH+snx//Iclfnx7Bp1KQycFIKddN8NrKqY7bhizA8CuQ\njBppgEIY3qPJ1U55bo/k3KQIMLs4wH888jpCCDVz20TMe1p8YaOjURU3r1WL/Pjc8MCONKfNNdlG\nLzkILSYqXY+kDq0Va/LQneXFqOf2jbvJ5AvECJHGTw/D5AoFbt+4u74DCXXCrOUw91ToXFJ1oUUl\nnNyRZyBV5Pz/eJZrv7eJR7Y19n5H05IZg9E9MLK7JPVqLpRQntvDRBAUaSNOJq9obru8ELCoSXqV\nYZcWn4t3LPDzq51ppNlMrny69m5cUqrp6DUNNcfQSzHyDY7yZhTRH0sjJRykAx9Z2ogffr1uROdB\n2wJwlzaE/BHDqPvV/WAe2dbPb57bhY8cg7RyKJbm1od3aKPexPTH0hSkYIQIURJ4RPHw6zUTssA7\nL1NlkdIj2/rZt/8A+2IFLv/O8+bntMnsocNkE3VJAmjsRGqL6Y4EGKGFDD5mMXy4PqI7olDnYipC\nXRMv9VwuaD/WdEPdI7l9426yhQIdjJEkQEr61HlrGkfSHQkwSgtFXHQy9qbXa8aKcEsZX6jieV8O\nK8lSWOrVhMe8o1Lr5mgd4uegDfqUfOCMBfTTToAMUYyCAL/HzdVnLrT+4m6f4Z1PhssF7Qsx01D3\nSMpeWTsxBEWGiL7pdU3zcfWZCxkRUfxkCGLEpJXMbW9IXe75ZFS4OVoOK3lEkTApxgiTzpl0VGSx\nts3ROsTPQRv0KdmXCZHFy7JQHJeAnkiAT563pD4botF5htGeCl/YlBrdkZS9MrcwYqkjtJCXrvqt\nRDR1p6OtlaT0szCQUju3rfTOD1+jsrDLeIeklQRZfGTwmndUzOak57OQq08Gmcp23k1FLFPk1qfj\nnHWMjzsuXY6oVY+iGrzhyjd/WmaX9JvNx+euPnMhtz68g0zeCLsMEyXmauXqMxXs7GscyQ+eTxD2\nCn7y4eOJKCsmEqZSC6vGGwRPYNrmHd2RAIdKxjtKkteRjNLCgojJxi6FjBF6qVKGoJ6Nz7WHPgm3\nbYkzmCpyw9nR+hpzgMisyt/r9kBLFe+fgFXLuvnkeUvoiQQIiSyt7gxZfzvvWFq7969xHkOpAj/f\nnuLS44MKjTlGZku1XYlMX2t6o3r1mQvxe4xceI8oECJNjHBtYSUzXnodDbr20Cdgf6zAt7bEee+y\nIKfMqr5RbU14Q9V7AOFuowKzhi4oq5Z1H15u3/dyik88MMzDr2a4oFeHXZqNu15Mki3A1ao7bdUj\n3FIm0DatGmV5Pt++cTf9sTTHBDJsT7dxTFcNFayZMciljFVCJRRylpf7j0cb9An4ysYxpIS/OzNS\n/4ubaIyLq9SAN1Z9U4OJeNfiAHNb3Hz32bg26E1Gvii5/fkkZ8zzsaxToUyuy1u9I1IL5WyXaYqM\nxjsqB+MF3vadgzywM83SWv7f4wehfVFl700OUU+ZCx1yOYJnDmS556UUHz21hfnROt/vXB7zzQDC\n3VU31J0Mj0tw9ckhfv9alj8O2KJVrrGIDa+k2Rcr8JFTFHvnoY7adc+rpcobyKwWN31zfdz/co3N\n0VMjlbdXrHNrRW3Qx1GUkv/v0VG6Qy4+cVpL/QcQ6pw+s2UyXG6lBR0fXB4m4BF891lr9Zs19eX7\nzyWYF3GzWvXKq57hlsPXrN75uWRpgJcG8+wYqsVRkZWthrOJaTduVaMN+jjWv5ji2YM5bjg7Sosd\njZ9rlRsN96AiLx2gLeBizQlBfvpSkkMJW2VuNYrY2p9j42tZrj45hMel0Jv2tVifez7hdcNGvUYV\nXLQ4iADue7lGQ5saNmLpU2Gm41SNaINeYiRd5MuPj9E3x8dlxysU+a8UXwQ8NVZ+enxK45gfPbWF\nXBFuf1576c3At5+JE/IKPqiyZyio1T2vFhNhl9Pm+riv1rALTN18JJuoa3ZLGW3QS9z0+BijmSJf\nOLcVV71jgaAuXKJCFa7EsW0eVvcGuP2FBEmz3dM1juBg3EhVvOLEEK0BhT97l6c+ueeTYWLP6d1L\ng2wfyrNtsMb9oWwc4pPICIypSVCoFm3QMfqE/mhrko+eGubEboU7/5Ui3LV3Ri/jCytVY7xuRZiR\ntOQuKxtJayznu88lKEjUb4YGbdgMHY+/pepORhctDeAS8PPtCrz0sX1H69SP7jM6TdnAjDfoqVyR\nGx8e4Ziom785w4Y0RTA2d8xuhk5Eizppgr65fk6b6+NbWxLkzDbb1djKWKbIHS8kuGhJgIVtijO3\nFEhP1EyVYZfukJuzjvFx77aUeUndw0gYftUIv6RGjMeJQzWe0zwz3qB/ZWOMV0YK3Hx+GyGvTX8O\n1RkCgbaqN4um4i9XtrAvVlDj0Wjqzh0vJIhlJR9fqThzK9Ba+76PCkxku/zpcSH2jBV47qCKtFxp\n9MwdfsXYLLWRGWnQD7eV+/omvvNsnPPmuzhrvk0T0+03lo0qEcJcgdIknLfIz/FdHm7dFDffm1Fj\nC6lckW8/m+Dt8/0s71Fc9axwjtWEr8WI5VfBu5YE8Lng3iZzUhxh0H/23IEa80Irp6yR/PpYlr30\n4CPH0P5X7WvmYFUzgFCn0ahXAUIIPnVahF3Dee7foSV1G4kfbU0ykCzyqdMVOw3ekNFsxQkIUXXD\nl1a/i1XHBrh3e4p8Ezkpthv0RCbP//nVy3zgnkFernXXuQJu37ibdK7Aa/RQwM18DpEv5O1r5mBV\nQYbLrTSd7KIlAZa0e7jlqZj20huEdF7yn5vjnDHPx+nzFK9AneKdlzERdrl0mdFA+vG91TfYdiq2\nG/Sw38MPr1mBAD5wzyBb+6016v2xNIdoJ06IOQwQFNnDr9cdX8TIHbcKhT86lxB8+owI24fyOpbe\nINzxQoJDiSKfPl2xJ+3225uqOBH+aNXSF6sWBWj1C/7npeaZz7YbdIAlPWHufH8Xfrfgg/cMsHl/\n1rJrFfzt9NNOO2O080ZqkS3NHKzsvQjGhpWqdEiMsunjuzx87cmYznhxOIlskW9sinP2fJ/6/aGW\nHntTFSdCiKobU/s9gkuWBvnVzjTxbHPUWTjCoAP0tnu4a00nnUEXV90zwK93qr9rPrYnzbZMOxGR\nZg4Dh+dk3drKjUdl7vlUKCw0cgnB370tyu7RAnc2QV66EGKNEGK1EOL6SY7fVPp3bX1HVjvffjbB\nYKrI352prpk4YGRP2VkZOhUmqqTff0KIVF5yf61SAA7BMQYd4Jioh/Vruji+y8t19w1z2+a4gjxR\ng9/vzfAXPx9iaaeHL69qYXY0gKDObeXGozr3fDJ8YSMLQBHnH+vn9Lk+/u2JGLFM43o1QogVAFLK\nDcBI+fkRrBVC7AR2mb2OqvlbCeXsrQu/vpF/f2KUlT2CU2crDum1zHaed17GH6VaLaMVs730tnu4\n+4+N76CAwww6QGfIzY8v6+TiJQG+9PgYn3xguGbDcf/LKa65d5CFrR7ueF8nlyzv4TvX9PHzT53D\nd67pq78xh/p6OQq9dCEE//j2KAOpIt/cXD/hfgu4EiiX+O0CVk/wno9JKReXjH7VbH19lMt+sL0u\n4mbl7K1DsTQHaaeIID30mtrsLU/A+jBhLbjcVWfeCCG4/IQgT7+e5ZUR8w1inILjDDpA0Ovilova\nueGsCL/cmeaiH/Wz8bXqd6LzRcn/v3GMTzwwzFt6vNz5/i46Q2o0w2vCEzQ853oRaDWuqYhTZvm4\ndFmQ/9oSb+QfQRswXqx6ojts7zQhmbVCiE1CiE39/UcbTo/LxUuH0vzV/cNkLd5zKHe4T0o/w0To\nYBRRyKjN3oo42DsvYyKMednxIdwC7tza+F66Iw06GPHaj/dFuGtNFx4BH7xnkL/+5TCvVmhAnjuY\n5bK7Brj16TiXnxjijku7aA865H/XjpQvhV46wI3nRPG5BZ9/dLRuYYWBZIEnXqlfJZ6U8uaSd94p\nhDjKg5dSrpNS9kkp+7q7j/5Ol82OcPMlC9i0P8sXf2ut8l5/LI2U8DpdeCjQw/Dh15Xga3FeZstE\nBFqpNuwyq8XNeccGWP9i0vIbr9U4vgXdyjk+7r+qm//cHOe2zXF+8XKKC3oDvPe4IG87xkdH8A2P\neyRd5LE9Ge5+Mclv92ToDrm45cJ23nOcDXK4kyHc9vwwgu2GKH9BTQZRT9jN/3pbhC8+Nsa921O8\nd1lIyXknI52XrP3FEC8PD/C7G3poDU0vyDTJZuauctwcKMcP2oDBCT47JKVcXzrWa2bc7zmxnRf2\n9LNuS4ITur1ctdyalVl3JMCLY37S+DmGg7iFPPy6EqLz1JzHatweY/VbZR/Pq5aHeHBXmg270ly8\n1EH2okocb9ABQl4Xn3lblD97S5jvPJtg/R+T/Gqn4Xl0BFxE/YJ4TjKQNGLtPWEX158V4eq3hNV2\nNVdBLV2JakEIowHG2BQazlVyzSlhfr49xecfHePs+X66LApnSSm54aERthzI8c0rT6rImJc+t26K\nw3cCfaXHvcAGACFEm5RyBNjEG5uhi4HbTA0euOGsKNsG83zuN6MsbPVwtgUyE6tPXsAjv8sSIUEr\nhn69suytUJfRw7NRCLRVbdDfscDPvIibO/6QaGiD7jBrNzU9YTf/cHaUJ66dxd1rOrnhrAgXLglw\n8iwfq48NcOPZUe5e08nGj8zir/oizjPmqNVYqZpQZ9WaF1Phdgm+srqNRLbI9RtGLAu93Pz7GD/b\nluLvz4xw0UlqQkdSyi0ApVDKSPk58NC441cIIdYAO8cdrxq3S3DLhe30tnn4y/uGatfhPoJMXvLj\n7YKQx8XJLTFcQmH2lssL0blqBlovTKQvul2Cq5aHeHxvti4V61bREB76kXhcgtPm+jltrgOU3qoh\n2G5tZeh0uFyGtxU/oOyUSzu9fPbtUT7/6BjffS7BtW9Vqxny7WfifHNznKuWh/irPrXnnsiDl1Ku\nnOq4WaJ+F9/50w4uu3uAP//pIOsv71LWhPxLj4/x/KEc/3lJOxcuVmx8W+cZ2SONhMdnaM3kqtvk\n/MBJIf79qRjffz7Bv6yqQ42IBTjNhW1uWmbZPQJjhaBItKvMh08Oc0FvgP/7uzFT2UiT8aM/JPji\nY2NcuDjAF85tRTg9w2Iajol6+MF7O0nlJR+6Z5B9sdozhO7amuR7zyW49q1hLlysOFQQaGuMjdCJ\nMOGld4bc/OlxQe55KcVog9ZYaINeL4Id9jTSPRK3+pZhQgj+9YI2FrV6+Pj9Q0qUM3/wXIIbHx7l\n3IV+/v1d7WqbGtvI8V1efvDeTobTRa78yWBNaZ+PvJrmxodHeMcCPzeerbgi1OWF1vlqz1lPTPbW\n/chbW0jmJD98oTH76GqDXg+ECyJz7B7FG4TVpjACRPwuvv2eDjwuwYf+Z5DdJg2VlJKvbhzjc4+O\nsvrYALdd0oHf0xzGvMxbZ/u449JOklnJZXcN8NS+6lc1D+5Kc90vhjihy8s3Lm7H61b8N2qbb9z8\nGxVv0BARq5KTur28fb6f7zybIJ1vvBRGbdDrQcsse2PnR+INVK0fXQkL2zz89/s6yRQk718/wPMH\nq0uRHM0U+fj9w9zydJwrTwzxzYvbm86Ylzl5lo97ruiiLSD44D2D/MfTsYp0uaWU/OfmGNfdN8QJ\n3V7uuLSTFp/in3G427SH6yiqFOsqc93KFvqTRf7npfoVGj29L0UyW3sIrikMelnD4j23/I5rv7fJ\nvmYVE+EJOiN2fiSKC43KHN/lZf2aLgIeweXrB/jOs3GK47JfJvuuHnolzcU/7GfDK2n+6ZwoXz6/\nVb3X6TAWtXn42ZXdXLg4wFc2xnj3j/t56JX0m/5e43n+YJYrfjLIlx+PcdHiAD+8tJPWgOKfsDfU\nODnn02HypnT2fB9v6fHyjU3xuqiK7ovlueae/fzzT7fWfK4GXlMZlDUsMnlDL+NQLM2tD+8AsEej\nZTzCBW0LnFku7Y8YN5u8elXLJR1efnpFF9dvGOELvx3jrheTfHxlC/5CnG89uvPwd3VgLMMXN+zj\nS0/l2T4sOa7Dw91rutQLSjmYqN/FrRe1856dab742Bgf/fkQx0TdnLvQz5IOD24h2Bcr8Pu9GZ4/\nlKM94OLL57Vy5Ukh9ZvEwgVtC505X81Qbk1XrM7zFULwv86IcO3Ph/jJH5N8wKJiMDBWXJ99eBQJ\n/M3qpTWfr+ENelnDYjyZfIHbN+6236C3znd2QUa4G0b3WHLqrpCbb7+ng3u3p/jaEzE+/asRXEh8\nzMZNkQIuMniRBRf+kTyff2c7Vy0P42tyr3wihBBcuCTI+ccGuO/lFD/fnuKel1Ikc4Z36HUZsd3P\nvSPKmhNCRK2qr2id74yNe1WUW9OlhqZ/7xGsWuTnlFlebnk6zvuODxGwKPR39x9TPLo7w+dXdTG/\no3Zb0fAGfTKtCls6EI0neoyzlemgJAfwetUeTKUIIXjvshDvXhrkqdezfOqenaTxUUTgoUALKVpI\n0iLTXHNKA2dUKMLrFrzv+BDvOz6ElJLBVJGiNPpfWr6XEOxw/nw1Q8CcQRdCcP1ZUT70P4N8/7kE\n161U3JMV2DuW5wuPjnL6XB9//lY1e1pKbvWTaEnXhcm0KmzpQARvLFtbHNZzcSJcLut6mo7D7RKc\neYyfk6NJFokD9Ir9LBIHmC2GaBFpeqJN5BUqQghBV8hNT9htvTH3BBo7RXEq/NWLdZU5e76f8xf5\nufXpGANJtRLI+aLkb39tqDd/9U/acCkKc9Vs0Eul03crGIsprj5zIX7PmyvZbOlABMbyrmtZY3k6\n4a66XcpR35WmhDAcEDv0heqBy1W1Rvp4bjwnSiov+dLjYwoHBbc8FeOp17N84dxWZRXDoMCgl5Tr\nTHd0qZVVy7r55HlL6InY1IHI5THK6buWQefixotBevyWpDBOhO3fleZoonOdvc+jghpSMJd0eLlu\nRQs/+WOKx/aoCeP+dneaW56O8/4Tglx2gtq/veUx9JIM6VqABQsWWHKNVcu662sUhNtoIRdoM+7+\njZ4VEOqEjFoPZDLq/l1pJscXsSx91VEEWmF0r+mPf+r0CA/sSPEPD41y3wd9tNWQKrp7JM+nfjnM\ncR0evniu+lx/y9dZ0zUBaCjcPiPWOGu5kY4YiDa+MQdjwrsqk6TVNAnCbczhmYDba+TXmyTgEfzr\nn7RzMFGoSVV0MFngmnsHEQLWvbuDkFe9+Z3WQ5+mScDMIdxjlO83Y6xRCCPuHz9o90g09aL1GGdV\nL1tNoLVq9cXxvHW2j384K8q//G6Mrz0Z4zNvqy5MOZou8pF7h3g9VuCHl3WxoNWa4Mi0Z1UpIdqQ\nuDzGppHJMuKGIdRpuUF/ZFs/t2/cTX8sTXckwNVnLtThFzvwRxtr414F/qjRsasGPnpqmO1Deb7+\nVJyOoItrTqkslfFQosA1Pxtkx1Ceb17Swco51t1Ia75NlBoA9Akh1pTadTUPbh90NOBGpxk8fiOm\nmo1ZcnpHV/Q6GOU3QeFq3hTFqfCFjN9zDS0YhRD8n1WtDKeLfP7RMQ4linzmbRE8LjHp97R5f5a/\nun+I0YzkW+/p4J0LrbUlNRv0khFvLkMOxpffuXRmLUtDHZYZdEdX9DoUS26Ckbkza06Pxx+F5EBN\np/C6Bd+8uJ1/emSUb2yK8/u9GS5aWORXW3aRLbzxPX31oVf5/tYCj75WZF7UzT2Xd3Jit/X7VA1f\nKWoJLo/hmc+0iR9oA/EaSLVFFODgil4Ho/wm6A01RsGbVQRaazboYHRM+9J5rZw138/nfzPKl54q\n4mMuATIIJBl8pPM+xGsFrnlrC585o37tMJtwh69WBLQvmhlhliNxuYx0TAtwXEVvA6D2JihmZqhl\nPP6Ikd2jACEEf3pckMc/0sM8+vGTJY2fJAHcFOlhmGXs4X+/o7WuvY21QT+S6LyaKssaHoukAHSV\naPUovQmGu5q/gGg6hFD+2w56XSyL5lgoDnKc2MsysZdjxX56xAhzo/VPBdYGfTyBtpm9JAXwt5jq\n9DIdTq0SnUqHSAixRgixWghxfT3HVEbZTdDldVbHLDuxoHGHk5wVHUMv4/bPnEKL6Qh11JziNRFO\nqxIt6RDdBiye4NgKMKQthBC9QogVUsot9Rxf+W9Vc5ZLdC641IQaGp5AWaxLXeMKZd+TArRBBwyB\nogV60pcJWmPQnUbJWE+mQ3Ql8GDp8S5gNVBXgw4KboK+lpmXcz4VLrfxN1GczeUUZ0WHXMDQs/Cr\n1ztuWDw+Iyd9ZtMGjBfS7rRrIOYRRkWo5s00Q7/USdAG3RPU8cWJCLbbPQLHI4RYK4TYJITY1N/v\noD62ZcLd4A3aPQrn0cQGfYaHXIRze37aTbANxl4DWbR7JKapUYdoBCjHKtqAwSPfUJLFWAfQ19dn\nfTfhanB5ITLb7lE4E4/PyMmvQdvFqcxsg97So1O5JsPlNjyZ1LDdIzGNGR0iIUSblHIEuBPoK73c\nCzSWGJ3eCJ2aGsW6nMrMDbl4AjrUMh1NHnYZr0M07uWHAMoZLaVMmJF6Z7jUxEwU36qWgDUFdHYz\ncz10HWqZHn/UWLoXc3aPxBIm0iGSUq4c97jxlEaFS2+EVoI3YDh1eTXSE05REp2ZHnq4B3xhu0fh\nfIRoei+96WiZZShnaqZH0eZoWUTtUCyN5A0RtUe21X+jfOYZdLdfh1qqQS/dGwdPwDDomspQFHaZ\nSkSt3sw8g942vzm7DlmFN2ikdmqcT+t8HUasBl9IicyFk5REZ5ZlC3XObOEts4QasKZmphHq0sVx\nZlAQUnSSkujMMegur6GkqKmeYDuG/oXGkbi8RpqipnoUyEVrcS47aD1G5+Waxe0xeqqmR+0eiWYi\n2ubruW2WckgxnzJ9Ci3OVW8CbZY1bpgxhDq1QXciwfamLmWvC8F2iJk36KDFueqHy6M7tagg0Gr0\nWdU4B5cHojrnvGaaKJOr+Q16dJ4RMtDUjt4cdRatx+i5rQK31yiiawKa26D7Ik1197WdUCd6c9Qh\nBFp10ZdKmuRv2bwGXbiMzSKNOtxevRfhBIRbhxFVE2w3QlgNTvMadF0CbQ3hHrtHoInOM26uGnUI\nYVmD9HrSnAZdl0Bbhy+kuxnZia8FwnovwxLCXXaPoGaa06DrEmhradFeuj0IHWqxEo+/4VNAm8+g\nBzt0CbTVBKLaS7eDlh5D9lVjHQ2+sm8ugy7cury/Xuj2ZvXF7YMW/Te3HF+4oZ2V5jLokTk6L7de\n+Ft0Xno9ic7TKqH1Itq48trNM0O8oabY1GgoovMMYSiNtfijOl20nvjCDZuX3jwGPTpPb4TWG5cb\nOnqNnH+NRQgdRrSD6DwjhNtgNMcvMdiuN0LtwheC9mOnKMoQhocZmQOtC4wfSqAVXXFaIeFuvRFq\nB25vQxYmNn7AWbi0B2M3gSh0Hw/xQ5CJGa95A4YhD7ROIO3aA/ksjO6FzFjdh9swuDx689lOgu2Q\nS0H8oN0jqZjG99BbZuuqOSfg9kLrPOg53vivfZGhozOZTrfHB52Lba88FUKsmOLYTaV/19ZvROOI\nzNE653YTndtQqYyNbdDdfl3k0ui0zjPap9mAEGI1cPcUb1krhNgJ7KrTkN7AE9RZRE4hOhc6l5QU\nGUuhQuEyEjFCnUaEoHW+YfgV9CithcYOuUTn6o3QZqD1GMinIRuv62WllBuEEFMZ649JKdfXbUDj\n0XPbWfgjxn9SgixOvnKKzoXYAeM/ZF2HCI3sofsiOpWrWRAC2hY4MVumVwixWghx/UQHhRBrhRCb\nhBCb+vv71V3VHzX2JTTOQ4jpw2CR2dBe/36i0MgGvVVvhDYVHr/jKiGllDdLKTcAnaXwzJHH10kp\n+6SUfd3dqtqP6TTFpiDYbks3qZpDLuM2jBZLKW+o9XwVEeo0mrtqmouWHkgOQiGj5HSTbGbuKhnp\nSj47VAq5DAK9SgY1HaFOnabYLLR0QzZW1168NRn0kteyQUq5SwhxtxBidSU/lpoQbojMtfQSGpsQ\nwii7Hn5VyemklOuqH4Jok1KOAJt4YzN0MXCbkkFNeXG3kdmiaR5aF0D2JSjm6nK5WkMuvUB5KbqL\nCbwY5XHGyGyt19LMBNvBG67LpYQQa4C+0r9lHgKQUm4Brigd21l6bi1ai6j5cHuMjdI6UdPsOcID\nWgHcOcl71gH09fXVtu3r9huVc5rmJjoHBndYfplSOGX9Ea+tHPe4ag/fNJ6g1iJqVkIdkBquSxGd\nkk3RUnHGFsu9mFat1zIj8EcaWsLUFHpuNzfRedRD7mJaD73CjaXVlm+IlsvINTODyGwYjNk9ivoQ\nbDduYprmxRswoguJQ5ZeZlqDPt2yUwixVkp5c+mxNZuiwmUUn2hmDv4Ww0vPNrlR101ZZg6R2Ubo\nxcIN0ppCLqUsl5uEEDuFEMOKxnQ0LbOMPGXNzGImCFNF52otopmCy/osplo3RTcA1irBewINJY6j\nUYi/xQi1Nasioy+iN0JnGuFOSA5ALmnJ6Z1fKdo6X28WzWSaNS9buA25A83Mw8IQm7MNerhbN66Y\n6fhCEGhCzZ7WYwwJYc3Mw99iWYs75xp0T1BXhGoMonNpqg5HwQ4jN1kzc7GoxZ0zDbpwGWplusu5\nBowN8WYpKPOGjDCiZmbj9lpSQepMi9m2QItvad5MZDa4GjwbxOUt9V915s9OU2fCXeBTG1J23syK\nzLEsvqRpYFzuxpZMdnmMlns6bq4Zj+I+AM4y6OHumZF7rDFHsN1IY200XF6jhZledWqOxONXqpvu\nHGm3yBxtzDXT02jhCk8Auo7TnrlmcsKdRls7BTjDoHsD4NXGXNOE6GwWTSW0qNn0bzB3R6PRaDST\noQ26RqPRNAnaoGs0Gk2ToA26RqPRNAnaoGs0Gk2ToA26RqPRNAnaoGs0Gk2ToA26RqPRNAnaoGs0\nGk2TIKSU9buYEP3A7kkOdwEDdRvM5DhlHKDHMhFTjWOhlNIWnd0p5rZT/m6gxzIRThkHKJjbdTXo\nU6RvyP4AAAJQSURBVCGE2CSl7NPjeAM9FueOo1KcNF49FueOA9SMRYdcNBqNpknQBl2j0WiaBCcZ\n9HV2D6CEU8YBeiwT4ZRxVIqTxqvHcjROGQcoGItjYugajUajqQ0neegaTUUIIa63ewwajWpUzGvH\nGvSZ/qMVQqwRQqy2++8ghFhb+u8mO8dRRgixGrjA7nHUgt3fqZ04ZV6XxuKYua1qXjvSoDvlR2vX\nFy6EWAEgpdwAjJSf15vS97BBSrkO6C0919TATJ7bTpnXpbE05dx2pEF3AjZ/4VcCI6XHuwC7Jlvv\nuGvvKj23DSHEipIx0NSAjXPbKfMaHDS3Vc5rxxl0B/1o7fzC24Chcc8763jtw0gp15V+9AArgE12\njGMcDd2gU89tZ8xrcNzcVjavndEk+s044kc77ssG4wu/066x2E1pabxFSrnFzjE4xBjWgp7bDsPu\nua16XtfdoAsh1k7w8i4p5QYn/mht+sJHeOPH3wYM1vHaE7FaSnmDzWPoFUL0YvxdOkpzxbYbzETo\nuT0tTpvXYP/cVjqv627Qj/AOjqSuP9qpfoDjntvxhd8JlDUdegHbDIEQYq2U8ubS49V2GSUp5fry\neDCMgePQc3taHDOvwRlzW/W8dmRhUel/7gbgcpuX+WvLP9J6f+Glv8EuoHcaQ2HlGFYDd2PEPTsw\nvg9HeZmNxkyf206Y16VxNOXcdqRBdwLN+oVrNHpuNy/aoGs0Gk2T4Li0RY1Go9GYQxt0jUajaRK0\nQddoNJomQRt0jUajaRK0QddoNJomQRt0jUajaRL+H7wsCZuovLFEAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlsAAAGeCAYAAACjCMTrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -122,19 +120,17 @@ "fms, fvs = m.predict_f(X)\n", "print('Evaluated')\n", "\n", - "plt.subplot(1, 2, 1)\n", + "plt.figure(figsize=(10,7))\n", "plt.scatter(x, y)\n", - "plt.plot(X.flatten(), fms.flatten())\n", + "plt.plot(X.flatten(), fms.flatten(), color='b', label='GPR-MGP')\n", "plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()),\n", - " alpha=0.2)\n", - "plt.title('MGP - GPR')\n", - "plt.subplot(1, 2, 2)\n", - "plt.scatter(x, y)\n", + " alpha=0.2, color='b')\n", + "\n", "fm, fv = m.wrapped.predict_f(X)\n", - "plt.plot(X.flatten(), fm.flatten())\n", + "plt.plot(X.flatten(), fm.flatten(), color='r', label='GPR')\n", "plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()),\n", - " alpha=0.2)\n", - "plt.title('GPR')\n", + " alpha=0.2, color='r')\n", + "plt.legend()\n", "plt.show()" ] }, From 5eff800cdecd62ebc759b994c0314ee396fa22ba Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:42:15 +0100 Subject: [PATCH 07/54] Make use of the free_vars instead of collecting the variables manually --- GPflowOpt/models.py | 34 +++++++++++++-------------------- doc/source/notebooks/testmgp.py | 32 +++++++++++++++---------------- 2 files changed, 29 insertions(+), 37 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 8f551e2..a1a4afd 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -14,17 +14,18 @@ def rowwise_gradients(Y, X): This is done with while_loop, because of a known incompatibility between map_fn and gradients. """ num_rows = tf.shape(Y)[0] + num_feat = tf.shape(X)[0] def body(old_grads, row): - g = tf.stack(tf.gradients(Y[row], X), axis=1) + g = tf.expand_dims(tf.gradients(Y[row], X)[0], axis=0) new_grads = tf.concat([old_grads, g], axis=0) return new_grads, row + 1 def cond(_, row): return tf.less(row, num_rows) - shape_invariants = [tf.TensorShape([None, len(X)]), tf.TensorShape([])] - grads, _ = tf.while_loop(cond, body, [tf.zeros([0, len(X)], float_type), tf.constant(0)], + shape_invariants = [tf.TensorShape([None, None]), tf.TensorShape([])] + grads, _ = tf.while_loop(cond, body, [tf.zeros([0, num_feat], float_type), tf.constant(0)], shape_invariants=shape_invariants) return grads @@ -86,31 +87,22 @@ def _unwrap(self, p, c): self._unwrap(p2, c) def _compute_hessian(self, x, y): - mat = [] - for v1 in y: - temp = [] - for v2 in y: - # computing derivative twice, first w.r.t v2 and then w.r.t v1 - temp.append(tf.gradients(tf.gradients(x, v2)[0], v1)[0]) - temp = [tf.constant(0, dtype=float_type) if t is None else t for t in - temp] - temp = tf.stack(temp) - mat.append(temp) - mat = tf.squeeze(tf.stack(mat)) - return mat + l = tf.unstack(tf.gradients(x, y)[0]) + lll=[] + for ll in l: + lll.append(tf.gradients(ll, y)) + return tf.stack(lll, axis=1) def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) - c = [] - self._unwrap(self.wrapped, c) - C = tf.expand_dims(tf.stack(c, axis=0), 1) + + c = self._predict_f_AF_storage['free_vars'] + h = tf.hessians(self.build_likelihood() + self.build_prior(), c)[0] + L = tf.cholesky(-h) Dfmean = rowwise_gradients(fmean, c) Dfvar = rowwise_gradients(fvar, c) - h = -self._compute_hessian(self.build_likelihood() + self.build_prior(), c) - L = tf.cholesky(h) - tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py index 699195a..e4bdf9a 100644 --- a/doc/source/notebooks/testmgp.py +++ b/doc/source/notebooks/testmgp.py @@ -1,33 +1,33 @@ from GPflow.gpr import GPR import numpy as np from GPflow.kernels import RBF, White +from GPflow.priors import Gamma, LogNormal from GPflowOpt.models import MGP +from GPflow.transforms import Log1pe import matplotlib.pyplot as plt -x = np.random.randn(4, 1)*2 -y = np.sin(x) +np.random.seed(3) +x = np.random.rand(8, 1) * 8-4 +y = np.cos(x) +np.random.randn(8,1)*0.1 -m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1) + White(1))) -m.optimize() +m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1))) +m.kern.lengthscales.prior = Gamma(3, 1/3) +m.kern.variance.prior = Gamma(3, 1/3) +m.likelihood.variance.prior = LogNormal(0, 1) +m.optimize(display=True) print(m) print('Trained') -X = np.array(np.linspace(-3, 3, 100)[:, None]) -fm = [] -fv = [] -for xn in X: - fms, fvs = m.predict_f(xn.reshape(-1, 1)) - fm.append(fms) - fv.append(fvs) -fm = np.stack(fm, axis=0) -fv = np.stack(fv, axis=0) +X = np.array(np.linspace(-4, 4, 100)[:, None]) +fms, fvs = m.predict_f(X) +print(fms, fvs) print('Evaluated') plt.subplot(1, 2, 1) plt.scatter(x, y) -plt.plot(X.flatten(), fm.flatten()) -plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), +plt.plot(X.flatten(), fms.flatten()) +plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()), alpha=0.2) plt.title('MGP - GPR') plt.subplot(1, 2, 2) @@ -37,4 +37,4 @@ plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), alpha=0.2) plt.title('GPR') -plt.show() +plt.show() \ No newline at end of file From 4a54addc747ba0ebaedecbbbd28a26e3f61bffd7 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:43:39 +0100 Subject: [PATCH 08/54] Remove unnecessary functions --- GPflowOpt/models.py | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a1a4afd..74883cc 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -76,23 +76,6 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - def _unwrap(self, p, c): - """ - Unwrap all the parameters captured in the model - """ - if isinstance(p, Param): - c.append(p._tf_array) - elif isinstance(p, Parameterized): - for p2 in p.sorted_params: - self._unwrap(p2, c) - - def _compute_hessian(self, x, y): - l = tf.unstack(tf.gradients(x, y)[0]) - lll=[] - for ll in l: - lll.append(tf.gradients(ll, y)) - return tf.stack(lll, axis=1) - def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) From 1e6d81d75f40a2dacef3e71716882b36071c933c Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:57:40 +0100 Subject: [PATCH 09/54] Can hanle predict_f and predict_y --- GPflowOpt/models.py | 43 +++++++++++++++++++++------------ doc/source/notebooks/testmgp.py | 2 +- 2 files changed, 28 insertions(+), 17 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 74883cc..a49a5e8 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -1,5 +1,5 @@ from GPflow.param import Parameterized, AutoFlow, Param -from GPflow.model import GPModel +from GPflow.model import Model, GPModel from GPflow.likelihoods import Gaussian import GPflow import tensorflow as tf @@ -31,7 +31,7 @@ def cond(_, row): return grads -class MGP(GPModel): +class MGP(Model): """ Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation Key reference: @@ -51,13 +51,7 @@ def __init__(self, obj): assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj - self.cov_chol = None - super(MGP, self).__init__(None, None, None, None, 1, name=obj.name + "_MGP") - del self.kern - del self.mean_function - del self.likelihood - del self.X - del self.Y + super(MGP, self).__init__(name=obj.name + "_MGP") def __getattr__(self, item): """ @@ -76,17 +70,34 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - def build_predict(self, Xnew, full_cov=False): - fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) - - c = self._predict_f_AF_storage['free_vars'] - h = tf.hessians(self.build_likelihood() + self.build_prior(), c)[0] + def build_predict(self, fmean, fvar, theta): + h = tf.hessians(self.build_likelihood() + self.build_prior(), theta)[0] L = tf.cholesky(-h) - Dfmean = rowwise_gradients(fmean, c) - Dfvar = rowwise_gradients(fvar, c) + Dfmean = rowwise_gradients(fmean, theta) + Dfvar = rowwise_gradients(fvar, theta) tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) + + @AutoFlow((float_type, [None, None])) + def predict_f(self, Xnew): + """ + Compute the mean and variance of the latent function(s) at the points + Xnew. + """ + theta = self._predict_f_AF_storage['free_vars'] + fmean, fvar = self.wrapped.build_predict(Xnew) + return self.build_predict(fmean, fvar, theta) + + @AutoFlow((float_type, [None, None])) + def predict_y(self, Xnew): + """ + Compute the mean and variance of held-out data at the points Xnew + """ + theta = self._predict_y_AF_storage['free_vars'] + pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) + fmean, fvar= self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) + return self.build_predict(fmean, fvar, theta) \ No newline at end of file diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py index e4bdf9a..09f682c 100644 --- a/doc/source/notebooks/testmgp.py +++ b/doc/source/notebooks/testmgp.py @@ -20,7 +20,7 @@ print('Trained') X = np.array(np.linspace(-4, 4, 100)[:, None]) -fms, fvs = m.predict_f(X) +fms, fvs = m.predict_y(X) print(fms, fvs) print('Evaluated') From 850df949df04295515aadefc3c0e74efcca55456 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:31:30 +0100 Subject: [PATCH 10/54] Can handle multi-output GP --- GPflowOpt/models.py | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a49a5e8..d71e0e2 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -49,7 +49,6 @@ class MGP(Model): def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" - assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj super(MGP, self).__init__(name=obj.name + "_MGP") @@ -74,13 +73,19 @@ def build_predict(self, fmean, fvar, theta): h = tf.hessians(self.build_likelihood() + self.build_prior(), theta)[0] L = tf.cholesky(-h) - Dfmean = rowwise_gradients(fmean, theta) - Dfvar = rowwise_gradients(fvar, theta) + N = tf.shape(fmean)[0] + D = tf.shape(fmean)[1] - tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) - tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) - return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ - + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) + fmeanf = tf.reshape(fmean, [N * D, 1]) # N*D x 1 + fvarf = tf.reshape(fvar, [N * D, 1]) # N*D x 1 + + Dfmean = rowwise_gradients(fmeanf, theta) # N*D x k + Dfvar = rowwise_gradients(fvarf, theta) # N*D x k + + tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) # N*D x k + tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) # N*D x k + return fmean, 4 / 3 * fvar + tf.reshape(tf.reduce_sum(tf.square(tmp1), axis=1), [N, D]) \ + + 1 / 3 / (fvar + 1E-3) * tf.reshape(tf.reduce_sum(tf.square(tmp2), axis=1), [N, D]) @AutoFlow((float_type, [None, None])) def predict_f(self, Xnew): @@ -89,7 +94,7 @@ def predict_f(self, Xnew): Xnew. """ theta = self._predict_f_AF_storage['free_vars'] - fmean, fvar = self.wrapped.build_predict(Xnew) + fmean, fvar = self.wrapped.build_predict(Xnew) return self.build_predict(fmean, fvar, theta) @AutoFlow((float_type, [None, None])) @@ -99,5 +104,5 @@ def predict_y(self, Xnew): """ theta = self._predict_y_AF_storage['free_vars'] pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) - fmean, fvar= self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) - return self.build_predict(fmean, fvar, theta) \ No newline at end of file + fmean, fvar = self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) + return self.build_predict(fmean, fvar, theta) From 8c4c239789e56f432e400b11c5c72c2af0f1b441 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:44:59 +0100 Subject: [PATCH 11/54] Add predict_density --- GPflowOpt/models.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index d71e0e2..186f664 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -106,3 +106,17 @@ def predict_y(self, Xnew): pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) fmean, fvar = self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) return self.build_predict(fmean, fvar, theta) + + @AutoFlow((float_type, [None, None]), (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. + """ + theta = self._predict_f_AF_storage['free_vars'] + pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) + pred_f_mean, pred_f_var = self.build_predict(pred_f_mean, pred_f_var, theta) + return self.likelihood.predict_density(pred_f_mean, pred_f_var, Ynew) From 7869161feab86ff84a9b2c437e7bae716b57ecb9 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:45:26 +0100 Subject: [PATCH 12/54] Models tests --- testing/test_models.py | 57 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 testing/test_models.py diff --git a/testing/test_models.py b/testing/test_models.py new file mode 100644 index 0000000..7b041e3 --- /dev/null +++ b/testing/test_models.py @@ -0,0 +1,57 @@ +import GPflowOpt +import GPflow +import numpy as np +import unittest +from GPflowOpt.models import MGP + + +def parabola2d(X): + return np.atleast_2d(np.sum(X ** 2, axis=1)).T + + +class TestMGP(unittest.TestCase): + @property + def domain(self): + return np.sum([GPflowOpt.domain.ContinuousParameter("x{0}".format(i), -1, 1) for i in range(1, 3)]) + + def create_parabola_model(self, design=None): + if design is None: + design = GPflowOpt.design.LatinHyperCube(16, self.domain) + X, Y = design.generate(), parabola2d(design.generate()) + m = GPflow.gpr.GPR(X, Y, GPflow.kernels.RBF(2, ARD=True)) + return m + + def test_object_integrity(self): + m = self.create_parabola_model() + Xs, Ys = m.X.value, m.Y.value + n = MGP(m) + + self.assertEqual(n.wrapped, m) + self.assertEqual(m._parent, n) + self.assertTrue(np.allclose(Xs, n.X.value)) + self.assertTrue(np.allclose(Ys, n.Y.value)) + + def test_predict_scaling(self): + m = self.create_parabola_model() + n = MGP(self.create_parabola_model()) + m.optimize() + n.optimize() + + Xt = GPflowOpt.design.RandomDesign(20, self.domain).generate() + fr, vr = m.predict_f(Xt) + fs, vs = n.predict_f(Xt) + self.assertTrue(np.shape(fr) == np.shape(fs)) + self.assertTrue(np.shape(vr) == np.shape(vs)) + self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + + fr, vr = m.predict_y(Xt) + fs, vs = n.predict_y(Xt) + self.assertTrue(np.shape(fr) == np.shape(fs)) + self.assertTrue(np.shape(vr) == np.shape(vs)) + self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + + fr, vr = m.predict_f_full_cov(Xt) + fs, vs = n.predict_f_full_cov(Xt) + self.assertTrue(np.shape(fr) == np.shape(fs)) + self.assertTrue(np.shape(vr) == np.shape(vs)) + self.assertTrue(np.allclose(fr, fs, atol=1e-3)) From 22421787569c9bf4a41bea6a9c085814ed588c5a Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:47:25 +0100 Subject: [PATCH 13/54] Models tests --- testing/test_models.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/testing/test_models.py b/testing/test_models.py index 7b041e3..9635cd7 100644 --- a/testing/test_models.py +++ b/testing/test_models.py @@ -49,9 +49,3 @@ def test_predict_scaling(self): self.assertTrue(np.shape(fr) == np.shape(fs)) self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) - - fr, vr = m.predict_f_full_cov(Xt) - fs, vs = n.predict_f_full_cov(Xt) - self.assertTrue(np.shape(fr) == np.shape(fs)) - self.assertTrue(np.shape(vr) == np.shape(vs)) - self.assertTrue(np.allclose(fr, fs, atol=1e-3)) From cf672a54d804e486029b7c16e430d932ea6e55c1 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:28:35 +0100 Subject: [PATCH 14/54] Approximate marginalisation during prediction time using Laplace approximation --- GPflowOpt/__init__.py | 2 +- GPflowOpt/models.py | 92 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 93 insertions(+), 1 deletion(-) create mode 100644 GPflowOpt/models.py diff --git a/GPflowOpt/__init__.py b/GPflowOpt/__init__.py index 5e35f8f..e8a294c 100644 --- a/GPflowOpt/__init__.py +++ b/GPflowOpt/__init__.py @@ -19,4 +19,4 @@ from . import design from . import transforms from . import scaling -from . import objective +from . import models \ No newline at end of file diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py new file mode 100644 index 0000000..12599b1 --- /dev/null +++ b/GPflowOpt/models.py @@ -0,0 +1,92 @@ +from GPflow.param import Parameterized, AutoFlow, Param +from GPflow.model import GPModel +from GPflow.likelihoods import Gaussian +import GPflow +import tensorflow as tf + +float_type = GPflow.settings.dtypes.float_type + + +class MGP(Parameterized): + def __init__(self, obj): + assert isinstance(obj, GPModel), "Class has to be a GP model" + assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" + assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" + self.wrapped = obj + self.cov_chol = None + super(MGP, self).__init__() + + def __getattr__(self, item): + """ + If an attribute is not found in this class, it is searched in the wrapped model + """ + return self.wrapped.__getattribute__(item) + + def __setattr__(self, key, value): + """ + If setting :attr:`wrapped` attribute, point parent to this object (the datascaler) + """ + if key is 'wrapped': + object.__setattr__(self, key, value) + value.__setattr__('_parent', self) + return + + super(MGP, self).__setattr__(key, value) + + @AutoFlow((float_type, [None, None])) + def predict_f(self, Xnew): + """ + Compute the mean and variance of the latent function(s) at the points + Xnew. + """ + return self.build_predict(Xnew) + + def _unwrap(self, p, c): + """ + Unwrap all the parameters captured in the model + """ + if isinstance(p, Param): + c.append(p._tf_array) + elif isinstance(p, Parameterized): + for p2 in p.sorted_params: + self._unwrap(p2, c) + + def _compute_hessian(self, x, y): + mat = [] + for v1 in y: + temp = [] + for v2 in y: + # computing derivative twice, first w.r.t v2 and then w.r.t v1 + temp.append(tf.gradients(tf.gradients(x, v2)[0], v1)[0]) + temp = [tf.constant(0, dtype=float_type) if t is None else t for t in + temp] + temp = tf.stack(temp) + mat.append(temp) + mat = tf.squeeze(tf.stack(mat)) + return mat + + def build_predict(self, Xnew, full_cov=False): + fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) + c = [] + self._unwrap(self.wrapped, c) + L = self.cov_chol + Dfmean = tf.stack(tf.gradients(fmean, c)) + Dfvar = tf.stack(tf.gradients(fvar, c)) + + tmp1 = tf.matrix_triangular_solve(L, Dfmean) + tmp2 = tf.matrix_triangular_solve(L, Dfvar) + return fmean, 4 / 3 * fvar + tf.reduce_sum(tf.square(tmp1)) + 1 / 3 / (fvar+1E-3) * tf.reduce_sum(tf.square(tmp2)) + + @AutoFlow() + def _variance_cholesky(self): + c = [] + self._unwrap(self.wrapped, c) + h = -self._compute_hessian(self.build_likelihood(), c) + diag = tf.expand_dims(tf.matrix_diag_part(h), -1) + h = 1/diag*h/tf.transpose(diag) +tf.eye(len(c), dtype=float_type)*1E-3 + L = diag*tf.cholesky(h) + return L + + def optimize(self, **kwargs): + self.wrapped.optimize(**kwargs) + self.cov_chol = Param(self._variance_cholesky()) From 8acfad6d71371d65b7969ad9ea45b4e7460f3399 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:42:29 +0100 Subject: [PATCH 15/54] Adding docstring --- GPflowOpt/models.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 12599b1..a2e990b 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -8,6 +8,19 @@ class MGP(Parameterized): + """ + Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation + Key reference: + + :: + + @article{garnett2013active, + title={Active learning of linear embeddings for Gaussian processes}, + author={Garnett, Roman and Osborne, Michael A and Hennig, Philipp}, + journal={arXiv preprint arXiv:1310.6740}, + year={2013} + } + """ def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" From 66ff92cf75fbbd9de51908764b87835b84b39e86 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:45:20 +0100 Subject: [PATCH 16/54] Small example Interfacing still needs cleaning up --- doc/source/notebooks/testmgp.py | 40 +++++++++++++++++++++++++++++++++ 1 file changed, 40 insertions(+) create mode 100644 doc/source/notebooks/testmgp.py diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py new file mode 100644 index 0000000..699195a --- /dev/null +++ b/doc/source/notebooks/testmgp.py @@ -0,0 +1,40 @@ +from GPflow.gpr import GPR +import numpy as np +from GPflow.kernels import RBF, White +from GPflowOpt.models import MGP +import matplotlib.pyplot as plt + +x = np.random.randn(4, 1)*2 + +y = np.sin(x) + +m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1) + White(1))) +m.optimize() +print(m) +print('Trained') + +X = np.array(np.linspace(-3, 3, 100)[:, None]) +fm = [] +fv = [] +for xn in X: + fms, fvs = m.predict_f(xn.reshape(-1, 1)) + fm.append(fms) + fv.append(fvs) +fm = np.stack(fm, axis=0) +fv = np.stack(fv, axis=0) +print('Evaluated') + +plt.subplot(1, 2, 1) +plt.scatter(x, y) +plt.plot(X.flatten(), fm.flatten()) +plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), + alpha=0.2) +plt.title('MGP - GPR') +plt.subplot(1, 2, 2) +plt.scatter(x, y) +fm, fv = m.wrapped.predict_f(X) +plt.plot(X.flatten(), fm.flatten()) +plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), + alpha=0.2) +plt.title('GPR') +plt.show() From 2316ac93a1142d6c50862dd7c360eeaae891e983 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:46:41 +0100 Subject: [PATCH 17/54] Adding predictions for multiple points --- GPflowOpt/models.py | 70 ++++++++++++++++++++++++++------------------- 1 file changed, 41 insertions(+), 29 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a2e990b..8f551e2 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -7,7 +7,30 @@ float_type = GPflow.settings.dtypes.float_type -class MGP(Parameterized): +def rowwise_gradients(Y, X): + """ + For a 2D Tensor Y, compute the derivatiave of each columns w.r.t a 2D tensor X. + + This is done with while_loop, because of a known incompatibility between map_fn and gradients. + """ + num_rows = tf.shape(Y)[0] + + def body(old_grads, row): + g = tf.stack(tf.gradients(Y[row], X), axis=1) + new_grads = tf.concat([old_grads, g], axis=0) + return new_grads, row + 1 + + def cond(_, row): + return tf.less(row, num_rows) + + shape_invariants = [tf.TensorShape([None, len(X)]), tf.TensorShape([])] + grads, _ = tf.while_loop(cond, body, [tf.zeros([0, len(X)], float_type), tf.constant(0)], + shape_invariants=shape_invariants) + + return grads + + +class MGP(GPModel): """ Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation Key reference: @@ -21,13 +44,19 @@ class MGP(Parameterized): year={2013} } """ + def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj self.cov_chol = None - super(MGP, self).__init__() + super(MGP, self).__init__(None, None, None, None, 1, name=obj.name + "_MGP") + del self.kern + del self.mean_function + del self.likelihood + del self.X + del self.Y def __getattr__(self, item): """ @@ -46,14 +75,6 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - @AutoFlow((float_type, [None, None])) - def predict_f(self, Xnew): - """ - Compute the mean and variance of the latent function(s) at the points - Xnew. - """ - return self.build_predict(Xnew) - def _unwrap(self, p, c): """ Unwrap all the parameters captured in the model @@ -82,24 +103,15 @@ def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) c = [] self._unwrap(self.wrapped, c) - L = self.cov_chol - Dfmean = tf.stack(tf.gradients(fmean, c)) - Dfvar = tf.stack(tf.gradients(fvar, c)) + C = tf.expand_dims(tf.stack(c, axis=0), 1) - tmp1 = tf.matrix_triangular_solve(L, Dfmean) - tmp2 = tf.matrix_triangular_solve(L, Dfvar) - return fmean, 4 / 3 * fvar + tf.reduce_sum(tf.square(tmp1)) + 1 / 3 / (fvar+1E-3) * tf.reduce_sum(tf.square(tmp2)) + Dfmean = rowwise_gradients(fmean, c) + Dfvar = rowwise_gradients(fvar, c) - @AutoFlow() - def _variance_cholesky(self): - c = [] - self._unwrap(self.wrapped, c) - h = -self._compute_hessian(self.build_likelihood(), c) - diag = tf.expand_dims(tf.matrix_diag_part(h), -1) - h = 1/diag*h/tf.transpose(diag) +tf.eye(len(c), dtype=float_type)*1E-3 - L = diag*tf.cholesky(h) - return L - - def optimize(self, **kwargs): - self.wrapped.optimize(**kwargs) - self.cov_chol = Param(self._variance_cholesky()) + h = -self._compute_hessian(self.build_likelihood() + self.build_prior(), c) + L = tf.cholesky(h) + + tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) + tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) + return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ + + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) From 8f609cd7b335f9da601e6a1ae52d8757a48bba09 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:47:06 +0100 Subject: [PATCH 18/54] Add notebook for MGP --- doc/source/notebooks/mgp.ipynb | 172 +++++++++++++++++++++++++++++++++ 1 file changed, 172 insertions(+) create mode 100644 doc/source/notebooks/mgp.ipynb diff --git a/doc/source/notebooks/mgp.ipynb b/doc/source/notebooks/mgp.ipynb new file mode 100644 index 0000000..bc03569 --- /dev/null +++ b/doc/source/notebooks/mgp.ipynb @@ -0,0 +1,172 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Marginal GP\n", + "*Nicolas Knudde*" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook demonstrates the approximate marginalisation of the hyperparameters during testing time. A Laplace approximation is used here and is described in Garnett et. al. (2013)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from matplotlib import rc\n", + "rc('text', usetex=True)\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "import GPflow\n", + "import GPflowOpt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we set up a test dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "np.random.seed(3)\n", + "x = np.random.rand(8, 1) * 8-4\n", + "y = np.cos(x) +np.random.randn(8,1)*0.1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We proceed by constructing a Marginal GP wrapper around a GPR object and defining some suitable priors on the hyperparameters. Eventually we optimise the model." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + " fun: 11.219668379985972\n hess_inv: <3x3 LbfgsInvHessProduct with dtype=float64>\n jac: array([ -8.31933750e-06, 6.32051531e-06, -1.65760996e-06])\n message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n nfev: 9\n nit: 6\n status: 0\n success: True\n x: array([ 0.77306105, 0.02511576, -1.60659824])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "m = GPflowOpt.models.MGP(GPflow.gpr.GPR(x, y, GPflow.kernels.RBF(1, lengthscales=1, variance=1)))\n", + "m.kern.lengthscales.prior = GPflow.priors.Gamma(3, 1/3)\n", + "m.kern.variance.prior = GPflow.priors.Gamma(3, 1/3)\n", + "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 1)\n", + "m.optimize()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we compare the prediction of the MGP and the regular GPR model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Evaluated\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEFCAYAAADzHRw3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "X = np.array(np.linspace(-4, 4, 100)[:, None])\n", + "fms, fvs = m.predict_f(X)\n", + "print('Evaluated')\n", + "\n", + "plt.subplot(1, 2, 1)\n", + "plt.scatter(x, y)\n", + "plt.plot(X.flatten(), fms.flatten())\n", + "plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()),\n", + " alpha=0.2)\n", + "plt.title('MGP - GPR')\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(x, y)\n", + "fm, fv = m.wrapped.predict_f(X)\n", + "plt.plot(X.flatten(), fm.flatten())\n", + "plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()),\n", + " alpha=0.2)\n", + "plt.title('GPR')\n", + "plt.show()" + ] + }, + { + "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.0 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.5.2" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From d8845388338fb4aee1a083d2024d40bc18e11502 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:56:59 +0100 Subject: [PATCH 19/54] Update notebook MGP --- doc/source/notebooks/mgp.ipynb | 46 ++++++++++++++++------------------ 1 file changed, 21 insertions(+), 25 deletions(-) diff --git a/doc/source/notebooks/mgp.ipynb b/doc/source/notebooks/mgp.ipynb index bc03569..e9d0b09 100644 --- a/doc/source/notebooks/mgp.ipynb +++ b/doc/source/notebooks/mgp.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -61,28 +61,26 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "collapsed": true }, "outputs": [ { - "data": { - "text/plain": [ - " fun: 11.219668379985972\n hess_inv: <3x3 LbfgsInvHessProduct with dtype=float64>\n jac: array([ -8.31933750e-06, 6.32051531e-06, -1.65760996e-06])\n message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n nfev: 9\n nit: 6\n status: 0\n success: True\n x: array([ 0.77306105, 0.02511576, -1.60659824])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "name_MGP.name.kern.\u001b[1mlengthscales\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 1.47220582]\nname_MGP.name.kern.\u001b[1mvariance\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 0.75133993]\nname_MGP.name.likelihood.\u001b[1mvariance\u001b[0m transform:+ve prior:logN([ 0.],[ 30.])\n[ 0.01172159]\n\n" + ] } ], "source": [ "m = GPflowOpt.models.MGP(GPflow.gpr.GPR(x, y, GPflow.kernels.RBF(1, lengthscales=1, variance=1)))\n", "m.kern.lengthscales.prior = GPflow.priors.Gamma(3, 1/3)\n", "m.kern.variance.prior = GPflow.priors.Gamma(3, 1/3)\n", - "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 1)\n", - "m.optimize()" + "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 30)\n", + "m.optimize()\n", + "print(m)" ] }, { @@ -94,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "scrolled": false }, @@ -108,9 +106,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEFCAYAAADzHRw3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJztvXm4XFWV9//ZNQ+36s43Exm4SQhDBEkuIINKILQM2goG\nUGxaxDa0rbb92t3Q2N2+/rTfV8GfbbfQ2sR2pFGBSCsKqAQQEcOQhMkgCUkgCSHDnW/N437/OFXh\nktyh6tQ+dU7V3Z/n4UlVnapzNrd2rbP22mt9l5BSotFoNJrGx2X3ADQajUajBm3QNRqNpknQBl2j\n0WiaBG3QNRqNpknQBl2j0WiaBG3QNRqNpknQBr0ChBA7hRB3T/D6TUIIecRrK4QQD5Y+s1MIcdO4\nY8NCiM2l45vHHzM5LlPXmuDYbbWMQ6Mpo+ekvWiDXjm9E7y2GhgpPxFCrADuBm6QUi6WUi4Gnj7i\nM+dLKS+QUq4sfcaUUVdwrfHHduofkKZW9Jy0H23QK2eDEGJN+YkQohfYdMR7voUxmbeUX5BSrp/i\nnHcCK0yOR+W11gN9Jseh0ZTRc9JmtEGvnDuBK8c9vw7DGwFACNEGrJhmAh/JjcCD1Q7EgmvdgPH/\np9GYQs9JZ+CxewANxC7eHHZZLaW8QQhRft5Res90PDTuM3dKKW82MRYV1yofW4HhVZkZh0ZTRs9J\nB6ANenWUwy5bOHryDjHO4JfedyPQK6VsH/e+86WUI9SGimudL6UcEUI8iPH/o9HUgp6TDkCHXKrj\nNoywy5rS48OUJukWIcTq0vP15Y2fahFC3F3a6d9citW/CZXXwlja1pRto9HoOekMtEGvAillOexy\ngZRywwRv+Rhw20RGuMrrXC6lXFn6b7JlrKprbQF2jd/w1WhMouekzeiQS/VsYOIURqSUW4QQl/Pm\nSX2XFYNQfK0bMDanqtnQ0mjehJ6T9iO0HrpGo9E0BzrkotFoNE2CNugajUbTJGiDrtFoNE2CNuga\njUbTJNQ1y6Wrq0suWrSonpfUzCA2b948IKXstuPaem5rrKTSuV1Xg75o0SI2bTpSz0qjUYMQYrdd\n19ZzW2Mllc5tHXLRaDSaJkEbdI1Go2kSag65CCHWlh4ullLeUOv5NBqNRmOOmjz0khDPBinlOqC3\nLMyj0TQKpS47kx27qfTv2sneo9E4iVpDLr0YbdjgaL1wjcbRlByQo3rFjmOtEGInlel8azS2U1PI\npeSZl1mB7jCiaSCklBuEEFMZ649V2YFHo7EVJZuipWXrlvG9BMcdWyuE2CSE2NTf36/ichpNvegV\nQqwWQlxv90A0mkpQleWyerINUSnlOilln5Syr7vblpoPZ1HIQfwQjL4GiUEoFu0ekWYSpJQ3l3Tv\nO/X+UBXkUhA7UJrjA1DI2z2iGYOSLJdy7z8hxOpJGj9oADJxGH4FiuMmeGw/tC8Cf4ttw9IcTWkj\ndKgUchlkgv2h0nvWAixYsKC+A3QiUsLoXkgOvvn1sX0Q7obIHHijn6jGAlRkudwkhNgphBhWNKbm\nJJeCoZ1vNuYAxRwM7oDkkD3j0ryJUvd6gE0YzUwAFpeevwm9+hyHlDC062hjDiCLED8I/dsgn6n/\n2GYQNRl0KeUGKWW7lHJx6V/tnU9EsQjDrxoTe0IkjOyBlL4n1pNSi7O+I1qdPQSH26BdUTq2c6L9\nIc04Rl+DzNjU78mnDKOeidVnTDMQ3YKuHsQPQD49zZskDO8Glwf8kboMa6ZTCqesP+K1leMerzvq\nQ5qjSQ1DcqCy98oCDO6EtgUQ6rB2XDMQXfpvNfksJCrN7pEw9IoRntFoGoFiEcZer/JDEkZ2Gxun\nGqVog2418QNThFomQBaMWGQhZ92YNBpVxA9AIWvus7H9RihSZ3opQxt0KynkzW12FrLGsrRYUD8m\njUYVhXwVq89JSA3DwHbITReS1FSCNuhWkhwApLnP5lOGp669F41TSRyqbvU5GfkUDGwz6jI0NaEN\nulVIaRRV1EI2Xkp11EZd4zCKhdrn93hkEUb3GCvTvMkQjkYbdMtIjxo55rWSjcPgy7raTuMskkPG\nfo9qMmPQ/5JO4TWJNuhWkVJYKJRLGkvSbFLdOTWaWqg0TdEMsmBslo7uM1a6morRBt0KCnlIT1Nk\nUfU5s4anHtcCZxqbycQqqKtQQOJQqSBPG/VK0QbdCtIjmN4MnQpZhLHXYGCHzgrQ2Ec9ZSrSI0bO\nuqYitEG3gtSItefPxow448hena+uqS/FYslhqSOpYV2EVCHaoKumkDcMruVII4556EUY26+XpZr6\nkB5Rk6pYLbH9WgOmArRBV029vRdZNKr1+l/SkgEa67Ez+2Rkjy62mwZt0FWTHrXnuvm0UXFn1/U1\nzU8hb6+XXMganrpmUrRBV0mxYO+ElyWZXr001VhBehRLNvurITGgEwKmQBt0lWTGsH3Cy6Kh2Kir\n7TSqqXc4cUKk0QFJMyHaoKvEKeEOWTBSvfRGqUYVdq8+x5MZg2zC7lE4Em3QVSGlcyY8GJIBKrU2\nNDMbJ4RbxqPTGCdEG3RVZBNH9wu1m9h+rQGjUYNTVp9lMmM6q2sCtEFXxXT9FO1AFnRWgKZ2nLb6\nLBM/ZPcIHIc26Kpw4oQHowu73iDV1EImZo2yYq2khnWl9BFog66CQs5QRHQk0ig80mjM4sTVJ2BU\nS+umGOPRBl0FTvXOyySHtJc+CUKIFVMcWyOEWC2EuL6eY3IcqpVDVaIN+pvQBl0FTtswOgpZe+/H\nJkQIsRq4e5JjKwCklBuAkakMf1OTz0AhY/coJqeQbYDfX/3QBl0F2bjdI5ie5KDWwTiCkrHeNcnh\nK4FyJc0uYHVdBuU0nOydl9Fe+mG0Qa8VJ6YrToQs6IlfHW3AeOHvTrsGYiuOjZ+PIz2mN0dLeOwe\nAGCkRQlh9yjM4fT4+XgSA9DSY/comgYhxFpgLcCCBQtsHo0FFIuWrD4f2dbP7Rt30x9L0x0JcPWZ\nC1m1rLuGM0oj40XPbYd46PlM4wruNJJBL2R0vLFyRoCO0uM24KjljZRynZSyT0rZ191di0FyKNm4\ncu3zR7b1c+vDOzgUSyOBQ7E0tz68g0e21bjHU88uSg7GGQYdGrPLd7HQeJoSWg5gSoQQbaWHdwK9\npce9wAZ7RmQjFjgrt2/cTSb/5r2cTL7A7RtrbDOXT+nKUZwScgFDyS06x+5RVEcmhqP0LSohM2as\niDx+u0diO0KINUCfEGKNlHJ96eWHgJVSyi1CiL5SJsyIlHKLfSO1CQsMen9s4pV4fyxdeygmNQze\noKKRNibOMej5NGST4AvZPZLKaaRwy3iSgxCda/cobKdkxNcf8drKcY/X1X1QTqGQM7xexXRHAhya\nwKhHAh5ufXjHYe+9HIoBKjfqqeEZP6+dE3KBxgu7NLJB19K6mqmwaG5ffeZC/B73m17ze9yGXEyt\noZhCFjINkEJsIc4y6I4Q0K8QpxdcTEUx33g3T019sShdcdWybj553hJ6IgEE0BMJ8MnzlhDPTJz6\nO1mIZlJm+Lx2TsgFjDtsNgG+sN0jmZ5G9c7LJAch1DH9+zQzEws93VXLuo8Ko9y+cfeEoZjuSKC6\nk6dHQB7TuGnQNeIsDx0g1SBeeiMUXExFNt64qaIaa8mloFjfQp3JQjFXn7mwuhMV841RuW0RzjPo\njRB2kbI5YnVJncKomQCLV59FKdkzmmfbYI541shznywUY6rgaAaHXZSEXIQQK5SldTVC2CUbd6Y+\ndLUkhyAyF1zOu69rbMQig34oUeAbm+L8YnuKgZRhyF0CVs7xcd2KFs4/rqvGitES6dHGrj6vgZoN\neilP9zZgce3DKZEacbZBb/T4eRlZMLyZ8MyUKdFMgJSWhCx++lKSf3xklExBcuHiAGfP99Pic/Hy\nUI57XkrxF78Y4pKlAb50XhtRf40ORjFv/EYDUTWDbyBqNuhSyg1CiMkU68yRHoHWeUpPqZRmMehg\nhF20QbeOQg7cXrtHUTmKy/2llHxlY4xvbIpz+lwfN61u49i28WYnyKdOi/CtZ+J8dWOMnUMD/PCy\nTjqC7knPWRHpkRlp0J251i6HXZyIo7sTmSCXbI79AKfSCPKz41E8F27+vWHMP7g8xB2Xdh5hzA28\nbsFf9UX43ns7eGUkz1X/M0gsU+NNpRx2mWE406CDc0Wk6vgDfWRbP9d+bxPvueV3XPu9TbULGE2G\n3hy1jkKDCc8pXH3+8A8Jvrk5zlXLQ/zfVa143VPHtN++IMC6d3fw8mCev31whGItBrkcdplhWG7Q\nhRBrhRCbhBCb+vurMEhOTV+sU7qiZap0E5Ea0XrSVtIoKa7FgrLV5+b9WT73m1HOXejni+e2Iirc\noHznwgCfPSfKr3el+fYzNa7SGyFjTjGWFxaV9DDWAfT19VV+yy1knKftImXd7vqTqdJ967c7FWtJ\ng9GibqDxxNEahfRYY2h1KxKbi2WKfPpXw8xpcfPvF7bjdlWXbXLtW8M8uS/LVzaOsWqRnyUdJvcg\nZmC2S80e+njFOgXjeTNOC7vUMV1xspLnsXTeGq89OWA0NNCoJxtvjPZ/ipyVLz42xuuxAv/2rnZa\nTWSsCCH4l1WthLyCGx4aQZoNvRTzjbM6UkTNBl1KuV5K2T5OflQdTlsy1fEGU2nJsxItaSjpuzRA\nk4CG3OiSjWFYFKQr/n5vhrteTHLdihZWzvGZPk9P2M1nz2ll8/4cP9tWg+qjU0O3FuHcTVEwJHWd\nJFpfxw3RiUqhJ6NqAaPJiB9ytsEsFo050Yg4Pdsln635b5vJS/7pkREWRN18+oxIzUNac0KQk3u8\nfOnxMZI5k6vHGZbt4myDDs65w+bSdVVXnKgUOuKfeMujagGjyShknLcqGk823rg/TqdnXCgY3/ee\nS7BrpMAXzm0l4Kk9bu0Sgs+9I8rBRJHvPmtyg1QWGmN1pAhnqS1OhFM6GdkQzz9Sla6c+TJ+s9SU\ngNFUxA9BsF3d+VSSjUOgbfr3OZFiznmb/OPJ1mbQB5MFbn06xqpFfs5dpMjBAPrm+jlvkZ91W+Jc\nfXLYXBVpagQCrcrG5GSc76E7JexSJ4NeKEo27ErzN78a5tzvH+TUdQc4+7sH+ci9g/Tnw/zFOxar\nETCajFzSeZvRZRq9AMrJnmKNHvotT8dJ5iSfPVt9deZn3hZhNCPNe+kzKOzifA8djDusnb0C81nI\nWV+5+vjeDJ/7zSg7h/N0Bl30zfUxK+xiLCN59kCW6x8aoTvk4oazT+T9xwcrzu2tmtgB53k0CnOk\nbSM9BpHZdo/iaLJJY1PcJK+N5bnjhQRXnBhiaad6mYPlPT5WHxvgu8/F+diKMCFvlX6oLBhGPdig\nq7sqaAyDbnfYxWKPNV+U3PT4GN96JsGCqJtbLmznwsWBN1XWSSl5+vUsX3p8jL97cITH9mT40nmt\n1U/uSsgljZuok34A2TgN15D7SHIJKOTB7bCfXY3e+defiiOAT51e+0boZHy8r4X3353mrheTXHNK\nS/UnSDtsPluE80MuYH/YxcKNwmSuyLX3DvGtZxL8+ckhfv1nPbznuOBRZdJCCE6f5+cnl3fx92dG\nuHdbij//6VDtmheTETtgzXnN4lRtn2pxYtilBoO+ZzTPT/6Y5EMnh5kbqVFQawpWzvHRN8fHt7Yk\nyBdN3NjTozOizqIxDDrYJ1pfyFnWASWVK3LNz4YOe9tfOLdt2uwAlxB84rQIt17UzrMHs1xz7yDp\nvAWeaz5l6KU7hUaPn5dxmkEvFmua39/cHMftgr9cYcJrrpKPrQizL1bgwV0m0itl0dkZXIpoIINu\n05dh0Y0kV5B84oFhNu3P8u8XtvPB5dXpv1+yNMjX39XOlv05/vbXw7UJGU1GbL8zvJpi0ZL4uRBi\njRBitRDi+kmO31T6d62yi2Ziztqgy4xhNpS1P1Zg/YtJrjgxxKwW67zzMquPDTAv4ub7z5ndHNUG\n3TkUMvYsuy0y6F/47SgPv5rhi+e28qfHmdvwvXhpkBvPiXLfjjT/udkCD7aQhcQh9eetFgvi50KI\nFWDo+QMj5edHsFYIsRNQp/dfzDsrfFRDuOW/nolTlHDdSuu9cwC3S3D1ySGe2JflpQETYnLpMWMP\no4lpHIMO9Q+75NKWeIZ3bk1w+wtJ1q4I86G31NaZ6WOnhrlkaYCvbozx9OsWFD7FD9qvxGhNyOtK\noOyy7QJWT/Cej0kpF5eMvjqcFHYxOZbRTJEfb03y7uOCzI/Wb5P3yhPD+N3w3y+YuSnKpvfSG8+g\n13O5aoG2yUsDOf75N6OcM9/H9WfVnrMrhODL57UxL+LmM78eIZFVHCKRRRjbp/ac1WJN/LwNGP8F\nT9S2qXeakIw5aWinVI3m0sYqzAR3vJAgkZOsrUPsfDztQRcXLwnys20pc3IATd5AurEMejFfv6IX\nKZVvCqbzkr/+5TBRv4uvvasdT5WyopMR8bv4ygVt7B0r8JWNFhiL1LB9Rsii+HklSClvLnnnnaXe\nuUceXyel7JNS9nV3V1HclUvav+oB0955tiD5/nMJzpnv46Tu+rfX+8DyELGs5L6XTWyOZuNGXUmT\n0lgGHeqnCJgeNcq1FfLVjWNsH8rz1Qva6A6p3UQ6Y56fD58c5vvPJXj2gAUTdvQ1ezbzrMs/HwE6\nSo/bgMHxB0ved1kSehDoVXp1J4h1mXSOHtiR4mCiyEdPra93Xub0uT562z386A8m9yIaQVXUJI1n\n0NNj9fFukoPTv6cKNr2e4b+eSfCht4R450J1Whfj+bszI3SFXPzvR0fVZ73k00Y8vd5YlDIK3Mkb\nRroX2AAghChXn2wqvwYsLj1XR8ZmeYWCuc1ZKSXffiZBb7uHdy70WzCw6RFCcOWJIbYcyLFz2MQm\npxPDLopWDY1n0FEfCjmKfEbpxlUmL7nhoVHmRtzcaIHWRZmI38Vnz4ny3MEc61+0oBArftD429QT\nizJCpJRbAEqhlJHyc+ChccevKHnpO8cdV4Pd6Ysm0xW3HMjx/KEcHzkljMvGTkCXHh/EJeCeP5oI\nx+XTzso0AmXSIg1o0FHuPR9FQm3T5HVb4uwczvMvq1pp8Vn7J3/fsiCnzvby1Sdq0JCeDFk0Qi/1\noli09IdXioFvKLVJLL+28ojj66WUN6u/eNHezVGT4ZYfPJ8g4hNcdryN2koYDTDeudDPPS8lKZip\nHHVS0Rwom+eNadALGes2R4tFpTeMPaN5bnk6xiVLAqxSKCs6GUII/vEcQ0O65ia7E5EZq9+StRn0\nW6bCLlVLk71xDyUK3P9yijUnhghb7JhUwvuPD7E/XuT3r5lYNdY7Y24qpDQE0hRg/7diFsVe9GGS\nA0r7hn7xsTE8LsE/v6N+6oV9c/38SW+A2zbHGUlbUOk59np9Kkiti587A7vy0TNjpub4j7cmyRXh\n6hprJ1SxujdAxCf4qZkWdbLgnJz0XNJYsSmgcQ16Zky9YFexqHTj79HdaR7cleZTp7Uwuw6l0eP5\n2zMjJHKSdVssqiCN10G8q1n0WyajkFXmmVWFiZVBvij54QsJ3r7AT2+7M9QiAx7BhUsC/GpH2pye\nkVPCLgrDio1r0MHorqOS5EBNutDjyRcl//LYGIta3Vz71vqndy3r9PLu44J877kEg0kLOs7HD1m7\nQdoM+ueVYIeXbsKgP/xKmgOJIn/2Fmd1XLp0WYh4zmgKUzWZmDPqARSuRBvboKeG1RmVYkGpd/6j\nPyR5eSjPjedE8Svor2iGT5/eQion+bbZTi9TIo3Qi1U0e/y8TL3j6JmYKaflv19IMjvs4vxjrd8H\nqoYz5hlNYEyFXeqRMVcJCldpjW3QkYYioApi+5V557FMkX97MsYZ83z8Sa99P4AlHV4uXhrgB88l\nGLUilp4esS4LxSnl8VaTS9a3ctGEaume0Ty/3ZPhA8vDyqqbVeF2Cd69NMhvd6cZNdMbwOqMuenI\nZ5QWMDa4Qcfw0muNpedSSjdZ122JM5gq8o/nRK1rE1chnzwtQjwn+Z5ZydHpGFN0Qz2SmWLQob5y\nFiY2An+8NYlLwJUnOivcUuY9xwXJFuHXO02EXQoZe/dqFDtEjW/QobbcaClhZA+qlveHEgX+65kE\n714a4ORZPiXnrIUTurycv8jP959LkFKdlw5Gt3jVZez5rFH8MVOol0HPjFW9Cs0VJHe9mOS8RQHm\nWNiRqBZOmeVlftTNz7ebdOzs9NK1QZ+AbBwSJr+U2H6lm29ffypGrij5+zOtqwitlutWtjCULrL+\njxa18VPdrm4meedgzN966HSbCLdseCXNQLLIVcst9M5FbWZICCPs8vjeDEMpEwkA6RFjD80OtEGf\nhLF9hhxoNaSGlW6E7h7J8+OtST5wUoiFbc5I7QI4ba6PU2d7Wbclbq6qbjpyCbVeupP0wuuCtN5L\nL5rLu/7hH5LMbXFbo9sSbIeek2DOKdC5FNzmV7SXLA1SkPArM2EXWbRH36VYMFo9KqR5DLoswPCr\nld9pM/FSqEUd//ZkDI9L8NcWdj83gxCC61a0sHeswK/NpHdVgqobo5TNX1A0EVYblNRI1cUre8fy\n/G5PhstPDOJWvRka6oT2ReApGXF/C3QtA7e5G8dJ3R4Wtbq534ykLtgTdrEgoaB5DDoYd7uhXdMb\n9fQYDO1UVp0FsH0wx0+3pfjwKWF6ws6LNV7QG2B+1G2NHAAYRljF5lI2rizbqKHIWpwTbUIy9q6t\nRijyipMUh1u8IWidf/Trbo9h5Kn+5iGE4OKlQX7/msmwSy5Z/yIvbdArIBuHgZcn/nKKRSN3WrEx\nB/jXJ2KEvaIu3c/N4HYJrjklzKb9WWv00kGNl+4EnXC7sKoRei5d9aonX5Tc/WKSdy70My+iMnwo\noG0hTJb95QtBZLapM1+8pIawC9TfS9cGvULyKRjYBoM7jYrGxIARXjm01RJN7z8cyvLLnWmuPTVM\ne9C5f9IrTgzR4hXWpTBmxmr3cuwSrHICVoVdktWn5P52d4YDiSIfUL0ZGu4C7zS1GeEecFXfCemk\nbg8LW908sMOkQU8N10ejCIzQoiLJ3PE41/qoIDNmbJaO7jXuvhYt5b/2RIyoX/AXNnVwqZSI38Xl\nJ4W47+UUhxIW7erXcsPMpY284JlKLlH9xv50FIumqiF/vDVJV9DF+SoVQoUbWirwvl0uiMyp/vRC\ncNESI+xiSpSunoJduZTyKAE0u0GvA88eyPLQqxnWrmgh6nf+n/PDJ4fJF812Ta+A9Ih5o+TETjL1\nRnV7tNRQ1cqKhxIFHnolzftPDOF1K9wMDXcbcfJKCHWYynq5eEmAfBEeNLv5Xy8pAIsqrJ1vgRzO\n156M0R5wcc0pzpAUnY5FbR7OW+Tnhy8kyZhRqKsEs166NujqDUqiv+qPrP9jkoI0QnTKEC7DoFf8\nflHd+0u8pcfLvIibB3aYTAfMxurTlStrTa2FNug1sHl/lkd3Z1i7Imx5JyKVfPiUMAOpIr/caVGh\nUWq4en2SbGJmh1vKFHPqNkdTI1VX3EopuWtrktPn+lisUiY32F65d14m1GmEaarACLsE+N2eDDEz\n2i5Qn81R7aE7j397IkZn0MWfn9wY3nmZcxb46W1z832rNkeR1eulO0H1zimoMigm5KWf3Jfl1dEC\nH1Cdqhjuqf4zLrdxI6iSCxcHyBbh4VdrCLtY2c0ol7ZsP08bdJNsej3DY3szXLeyxRHtuKrBJQRX\nnxxmy4EcLxyyKIUxOVT50rWQVx87bmQyY7VvjqZHTWVR3Lk1ScRneLnK8EWmz2yZjHBX1R9ZMcdH\nd8hlPn2xmLM228rCPrmNZYkcxNeejNEVdDlO8L9S3n9CiKBHcPvzVhVTVKGXnhywZMd/OoQQa4QQ\nq4UQ15s5bimJGpu3mFDBHE0XuX9HivctCxL0KjQN4U7zn/UGwVvdCtglBO9aHOCRVzPmBemsDLtY\nWAmtDboJntqX4fG9Wf5yZQshlRO/jkT9Lt53fJCfbUtao5UORsbLdNWjxaJ1/WGnQAixAkBKuQEY\nKT+v9LjlJIfM66Qnh0xphPxsW4pMAa48SWEI0eWFQFtt5whVf0O4cHGQVF7y6B6T+zJWdjNyskG3\n1Yuxia89GaMr5OJDDeqdl7n6LWEyBbj7RQtLnkf3Tl2sEXtdqcB/FVwJlHcfdwGrqzxuMdJctlCx\nYNReVHs1Kfnx1gTLu70s76m+qGdSgu2TV4VWfI62qhUZz5jno9UvzGmkA0Y3Iwu89HzG6CVrETUZ\ndNu9GBt44rUMG1/L8vGVLWqXpTZwYreXvjk+/vuFBEWrNoHyacOoT0Q2YSqtThFtwPjA/ZFu4HTH\nrSc5WH0sfex1UxtuLxzK8eJAnitVb4aa8K6PwuWGQGtVH/G6BRf0BtjwSppsweTctmKj3sL4OdTu\nodvsxdQXKSVfezJGT9jFh97SWJktk3H1ySFeHS3wO7NL00pIDRlNSMbfNDJxQ5qhgRFCrBVCbBJC\nbOrvt+LGJKtr3pIeNVXmD/CjrUkCHsF7lwVNfX5CvGHzm6FHEuyo+iMXLg4ylpE88ZrJuV3IqNfm\nt1jrv1aDPq0XY/2krx+/fy3Lk/uyfKIvQsCmxs+quXBxkM6gi9tfsFhpLtEP/dtgdJ+hiDm4o+oK\nRsWMAGUr0QYcub6e7jhSynVSyj4pZV93d/VFMBWRjVW2x5DPmpaDTmSL3LstxSVLA2qrnVV452X8\nkar1Xc5Z4CfsFTxgOuyC+v0di6WhLY8Z1GXS1wEpJf/6xBhzWlzql6U24vcIrjwpxEOvpNkXs1i2\nNp8ysjfSo6hq+VcDdwK9pce9wAYAIUTbVMdtYfS1qTeXC3njBmkyt/kXL6dI5CQfVDmvhcuIfSs7\nn6j6fAGP4NxFfh7clTbf2CU9qq6blMXxc6jdoE/rxTQ6j2zr59rvbWLVLVvYvD/HBQtoGu+8zFXL\nQ0gJP/pDnfWgbURKuQVACLEaGCk/Bx6a5rgNSGNVM1EFaTYJA9tNVdmW5/bnHzpI2JVjbExh7nWg\n1Yh9q8RUkVGQgWSRLaYlo6W6Gok6tFastbb3TqCv9NheL8YCHtnWz60P7yCdK3CAeXjJ8cL213lk\nvptVyxrUs0tPAAAgAElEQVR3tXEkx0Q9nH+snx//Iclfnx7Bp1KQycFIKddN8NrKqY7bhizA8CuQ\njBppgEIY3qPJ1U55bo/k3KQIMLs4wH888jpCCDVz20TMe1p8YaOjURU3r1WL/Pjc8MCONKfNNdlG\nLzkILSYqXY+kDq0Va/LQneXFqOf2jbvJ5AvECJHGTw/D5AoFbt+4u74DCXXCrOUw91ToXFJ1oUUl\nnNyRZyBV5Pz/eJZrv7eJR7Y19n5H05IZg9E9MLK7JPVqLpRQntvDRBAUaSNOJq9obru8ELCoSXqV\nYZcWn4t3LPDzq51ppNlMrny69m5cUqrp6DUNNcfQSzHyDY7yZhTRH0sjJRykAx9Z2ogffr1uROdB\n2wJwlzaE/BHDqPvV/WAe2dbPb57bhY8cg7RyKJbm1od3aKPexPTH0hSkYIQIURJ4RPHw6zUTssA7\nL1NlkdIj2/rZt/8A+2IFLv/O8+bntMnsocNkE3VJAmjsRGqL6Y4EGKGFDD5mMXy4PqI7olDnYipC\nXRMv9VwuaD/WdEPdI7l9426yhQIdjJEkQEr61HlrGkfSHQkwSgtFXHQy9qbXa8aKcEsZX6jieV8O\nK8lSWOrVhMe8o1Lr5mgd4uegDfqUfOCMBfTTToAMUYyCAL/HzdVnLrT+4m6f4Z1PhssF7Qsx01D3\nSMpeWTsxBEWGiL7pdU3zcfWZCxkRUfxkCGLEpJXMbW9IXe75ZFS4OVoOK3lEkTApxgiTzpl0VGSx\nts3ROsTPQRv0KdmXCZHFy7JQHJeAnkiAT563pD4botF5htGeCl/YlBrdkZS9MrcwYqkjtJCXrvqt\nRDR1p6OtlaT0szCQUju3rfTOD1+jsrDLeIeklQRZfGTwmndUzOak57OQq08Gmcp23k1FLFPk1qfj\nnHWMjzsuXY6oVY+iGrzhyjd/WmaX9JvNx+euPnMhtz68g0zeCLsMEyXmauXqMxXs7GscyQ+eTxD2\nCn7y4eOJKCsmEqZSC6vGGwRPYNrmHd2RAIdKxjtKkteRjNLCgojJxi6FjBF6qVKGoJ6Nz7WHPgm3\nbYkzmCpyw9nR+hpzgMisyt/r9kBLFe+fgFXLuvnkeUvoiQQIiSyt7gxZfzvvWFq7969xHkOpAj/f\nnuLS44MKjTlGZku1XYlMX2t6o3r1mQvxe4xceI8oECJNjHBtYSUzXnodDbr20Cdgf6zAt7bEee+y\nIKfMqr5RbU14Q9V7AOFuowKzhi4oq5Z1H15u3/dyik88MMzDr2a4oFeHXZqNu15Mki3A1ao7bdUj\n3FIm0DatGmV5Pt++cTf9sTTHBDJsT7dxTFcNFayZMciljFVCJRRylpf7j0cb9An4ysYxpIS/OzNS\n/4ubaIyLq9SAN1Z9U4OJeNfiAHNb3Hz32bg26E1Gvii5/fkkZ8zzsaxToUyuy1u9I1IL5WyXaYqM\nxjsqB+MF3vadgzywM83SWv7f4wehfVFl700OUU+ZCx1yOYJnDmS556UUHz21hfnROt/vXB7zzQDC\n3VU31J0Mj0tw9ckhfv9alj8O2KJVrrGIDa+k2Rcr8JFTFHvnoY7adc+rpcobyKwWN31zfdz/co3N\n0VMjlbdXrHNrRW3Qx1GUkv/v0VG6Qy4+cVpL/QcQ6pw+s2UyXG6lBR0fXB4m4BF891lr9Zs19eX7\nzyWYF3GzWvXKq57hlsPXrN75uWRpgJcG8+wYqsVRkZWthrOJaTduVaMN+jjWv5ji2YM5bjg7Sosd\njZ9rlRsN96AiLx2gLeBizQlBfvpSkkMJW2VuNYrY2p9j42tZrj45hMel0Jv2tVifez7hdcNGvUYV\nXLQ4iADue7lGQ5saNmLpU2Gm41SNaINeYiRd5MuPj9E3x8dlxysU+a8UXwQ8NVZ+enxK45gfPbWF\nXBFuf1576c3At5+JE/IKPqiyZyio1T2vFhNhl9Pm+riv1rALTN18JJuoa3ZLGW3QS9z0+BijmSJf\nOLcVV71jgaAuXKJCFa7EsW0eVvcGuP2FBEmz3dM1juBg3EhVvOLEEK0BhT97l6c+ueeTYWLP6d1L\ng2wfyrNtsMb9oWwc4pPICIypSVCoFm3QMfqE/mhrko+eGubEboU7/5Ui3LV3Ri/jCytVY7xuRZiR\ntOQuKxtJayznu88lKEjUb4YGbdgMHY+/pepORhctDeAS8PPtCrz0sX1H69SP7jM6TdnAjDfoqVyR\nGx8e4Ziom785w4Y0RTA2d8xuhk5Eizppgr65fk6b6+NbWxLkzDbb1djKWKbIHS8kuGhJgIVtijO3\nFEhP1EyVYZfukJuzjvFx77aUeUndw0gYftUIv6RGjMeJQzWe0zwz3qB/ZWOMV0YK3Hx+GyGvTX8O\n1RkCgbaqN4um4i9XtrAvVlDj0Wjqzh0vJIhlJR9fqThzK9Ba+76PCkxku/zpcSH2jBV47qCKtFxp\n9MwdfsXYLLWRGWnQD7eV+/omvvNsnPPmuzhrvk0T0+03lo0qEcJcgdIknLfIz/FdHm7dFDffm1Fj\nC6lckW8/m+Dt8/0s71Fc9axwjtWEr8WI5VfBu5YE8Lng3iZzUhxh0H/23IEa80Irp6yR/PpYlr30\n4CPH0P5X7WvmYFUzgFCn0ahXAUIIPnVahF3Dee7foSV1G4kfbU0ykCzyqdMVOw3ekNFsxQkIUXXD\nl1a/i1XHBrh3e4p8Ezkpthv0RCbP//nVy3zgnkFernXXuQJu37ibdK7Aa/RQwM18DpEv5O1r5mBV\nQYbLrTSd7KIlAZa0e7jlqZj20huEdF7yn5vjnDHPx+nzFK9AneKdlzERdrl0mdFA+vG91TfYdiq2\nG/Sw38MPr1mBAD5wzyBb+6016v2xNIdoJ06IOQwQFNnDr9cdX8TIHbcKhT86lxB8+owI24fyOpbe\nINzxQoJDiSKfPl2xJ+3225uqOBH+aNXSF6sWBWj1C/7npeaZz7YbdIAlPWHufH8Xfrfgg/cMsHl/\n1rJrFfzt9NNOO2O080ZqkS3NHKzsvQjGhpWqdEiMsunjuzx87cmYznhxOIlskW9sinP2fJ/6/aGW\nHntTFSdCiKobU/s9gkuWBvnVzjTxbHPUWTjCoAP0tnu4a00nnUEXV90zwK93qr9rPrYnzbZMOxGR\nZg4Dh+dk3drKjUdl7vlUKCw0cgnB370tyu7RAnc2QV66EGKNEGK1EOL6SY7fVPp3bX1HVjvffjbB\nYKrI352prpk4YGRP2VkZOhUmqqTff0KIVF5yf61SAA7BMQYd4Jioh/Vruji+y8t19w1z2+a4gjxR\ng9/vzfAXPx9iaaeHL69qYXY0gKDObeXGozr3fDJ8YSMLQBHnH+vn9Lk+/u2JGLFM43o1QogVAFLK\nDcBI+fkRrBVC7AR2mb2OqvlbCeXsrQu/vpF/f2KUlT2CU2crDum1zHaed17GH6VaLaMVs730tnu4\n+4+N76CAwww6QGfIzY8v6+TiJQG+9PgYn3xguGbDcf/LKa65d5CFrR7ueF8nlyzv4TvX9PHzT53D\nd67pq78xh/p6OQq9dCEE//j2KAOpIt/cXD/hfgu4EiiX+O0CVk/wno9JKReXjH7VbH19lMt+sL0u\n4mbl7K1DsTQHaaeIID30mtrsLU/A+jBhLbjcVWfeCCG4/IQgT7+e5ZUR8w1inILjDDpA0Ovilova\nueGsCL/cmeaiH/Wz8bXqd6LzRcn/v3GMTzwwzFt6vNz5/i46Q2o0w2vCEzQ853oRaDWuqYhTZvm4\ndFmQ/9oSb+QfQRswXqx6ojts7zQhmbVCiE1CiE39/UcbTo/LxUuH0vzV/cNkLd5zKHe4T0o/w0To\nYBRRyKjN3oo42DsvYyKMednxIdwC7tza+F66Iw06GPHaj/dFuGtNFx4BH7xnkL/+5TCvVmhAnjuY\n5bK7Brj16TiXnxjijku7aA865H/XjpQvhV46wI3nRPG5BZ9/dLRuYYWBZIEnXqlfJZ6U8uaSd94p\nhDjKg5dSrpNS9kkp+7q7j/5Ol82OcPMlC9i0P8sXf2ut8l5/LI2U8DpdeCjQw/Dh15Xga3FeZstE\nBFqpNuwyq8XNeccGWP9i0vIbr9U4vgXdyjk+7r+qm//cHOe2zXF+8XKKC3oDvPe4IG87xkdH8A2P\neyRd5LE9Ge5+Mclv92ToDrm45cJ23nOcDXK4kyHc9vwwgu2GKH9BTQZRT9jN/3pbhC8+Nsa921O8\nd1lIyXknI52XrP3FEC8PD/C7G3poDU0vyDTJZuauctwcKMcP2oDBCT47JKVcXzrWa2bc7zmxnRf2\n9LNuS4ITur1ctdyalVl3JMCLY37S+DmGg7iFPPy6EqLz1JzHatweY/VbZR/Pq5aHeHBXmg270ly8\n1EH2okocb9ABQl4Xn3lblD97S5jvPJtg/R+T/Gqn4Xl0BFxE/YJ4TjKQNGLtPWEX158V4eq3hNV2\nNVdBLV2JakEIowHG2BQazlVyzSlhfr49xecfHePs+X66LApnSSm54aERthzI8c0rT6rImJc+t26K\nw3cCfaXHvcAGACFEm5RyBNjEG5uhi4HbTA0euOGsKNsG83zuN6MsbPVwtgUyE6tPXsAjv8sSIUEr\nhn69suytUJfRw7NRCLRVbdDfscDPvIibO/6QaGiD7jBrNzU9YTf/cHaUJ66dxd1rOrnhrAgXLglw\n8iwfq48NcOPZUe5e08nGj8zir/oizjPmqNVYqZpQZ9WaF1Phdgm+srqNRLbI9RtGLAu93Pz7GD/b\nluLvz4xw0UlqQkdSyi0ApVDKSPk58NC441cIIdYAO8cdrxq3S3DLhe30tnn4y/uGatfhPoJMXvLj\n7YKQx8XJLTFcQmH2lssL0blqBlovTKQvul2Cq5aHeHxvti4V61bREB76kXhcgtPm+jltrgOU3qoh\n2G5tZeh0uFyGtxU/oOyUSzu9fPbtUT7/6BjffS7BtW9Vqxny7WfifHNznKuWh/irPrXnnsiDl1Ku\nnOq4WaJ+F9/50w4uu3uAP//pIOsv71LWhPxLj4/x/KEc/3lJOxcuVmx8W+cZ2SONhMdnaM3kqtvk\n/MBJIf79qRjffz7Bv6yqQ42IBTjNhW1uWmbZPQJjhaBItKvMh08Oc0FvgP/7uzFT2UiT8aM/JPji\nY2NcuDjAF85tRTg9w2Iajol6+MF7O0nlJR+6Z5B9sdozhO7amuR7zyW49q1hLlysOFQQaGuMjdCJ\nMOGld4bc/OlxQe55KcVog9ZYaINeL4Id9jTSPRK3+pZhQgj+9YI2FrV6+Pj9Q0qUM3/wXIIbHx7l\n3IV+/v1d7WqbGtvI8V1efvDeTobTRa78yWBNaZ+PvJrmxodHeMcCPzeerbgi1OWF1vlqz1lPTPbW\n/chbW0jmJD98oTH76GqDXg+ECyJz7B7FG4TVpjACRPwuvv2eDjwuwYf+Z5DdJg2VlJKvbhzjc4+O\nsvrYALdd0oHf0xzGvMxbZ/u449JOklnJZXcN8NS+6lc1D+5Kc90vhjihy8s3Lm7H61b8N2qbb9z8\nGxVv0BARq5KTur28fb6f7zybIJ1vvBRGbdDrQcsse2PnR+INVK0fXQkL2zz89/s6yRQk718/wPMH\nq0uRHM0U+fj9w9zydJwrTwzxzYvbm86Ylzl5lo97ruiiLSD44D2D/MfTsYp0uaWU/OfmGNfdN8QJ\n3V7uuLSTFp/in3G427SH6yiqFOsqc93KFvqTRf7npfoVGj29L0UyW3sIrikMelnD4j23/I5rv7fJ\nvmYVE+EJOiN2fiSKC43KHN/lZf2aLgIeweXrB/jOs3GK47JfJvuuHnolzcU/7GfDK2n+6ZwoXz6/\nVb3X6TAWtXn42ZXdXLg4wFc2xnj3j/t56JX0m/5e43n+YJYrfjLIlx+PcdHiAD+8tJPWgOKfsDfU\nODnn02HypnT2fB9v6fHyjU3xuqiK7ovlueae/fzzT7fWfK4GXlMZlDUsMnlDL+NQLM2tD+8AsEej\nZTzCBW0LnFku7Y8YN5u8elXLJR1efnpFF9dvGOELvx3jrheTfHxlC/5CnG89uvPwd3VgLMMXN+zj\nS0/l2T4sOa7Dw91rutQLSjmYqN/FrRe1856dab742Bgf/fkQx0TdnLvQz5IOD24h2Bcr8Pu9GZ4/\nlKM94OLL57Vy5Ukh9ZvEwgVtC505X81Qbk1XrM7zFULwv86IcO3Ph/jJH5N8wKJiMDBWXJ99eBQJ\n/M3qpTWfr+ENelnDYjyZfIHbN+6236C3znd2QUa4G0b3WHLqrpCbb7+ng3u3p/jaEzE+/asRXEh8\nzMZNkQIuMniRBRf+kTyff2c7Vy0P42tyr3wihBBcuCTI+ccGuO/lFD/fnuKel1Ikc4Z36HUZsd3P\nvSPKmhNCRK2qr2id74yNe1WUW9OlhqZ/7xGsWuTnlFlebnk6zvuODxGwKPR39x9TPLo7w+dXdTG/\no3Zb0fAGfTKtCls6EI0neoyzlemgJAfwetUeTKUIIXjvshDvXhrkqdezfOqenaTxUUTgoUALKVpI\n0iLTXHNKA2dUKMLrFrzv+BDvOz6ElJLBVJGiNPpfWr6XEOxw/nw1Q8CcQRdCcP1ZUT70P4N8/7kE\n161U3JMV2DuW5wuPjnL6XB9//lY1e1pKbvWTaEnXhcm0KmzpQARvLFtbHNZzcSJcLut6mo7D7RKc\neYyfk6NJFokD9Ir9LBIHmC2GaBFpeqJN5BUqQghBV8hNT9htvTH3BBo7RXEq/NWLdZU5e76f8xf5\nufXpGANJtRLI+aLkb39tqDd/9U/acCkKc9Vs0Eul03crGIsprj5zIX7PmyvZbOlABMbyrmtZY3k6\n4a66XcpR35WmhDAcEDv0heqBy1W1Rvp4bjwnSiov+dLjYwoHBbc8FeOp17N84dxWZRXDoMCgl5Tr\nTHd0qZVVy7r55HlL6InY1IHI5THK6buWQefixotBevyWpDBOhO3fleZoonOdvc+jghpSMJd0eLlu\nRQs/+WOKx/aoCeP+dneaW56O8/4Tglx2gtq/veUx9JIM6VqABQsWWHKNVcu662sUhNtoIRdoM+7+\njZ4VEOqEjFoPZDLq/l1pJscXsSx91VEEWmF0r+mPf+r0CA/sSPEPD41y3wd9tNWQKrp7JM+nfjnM\ncR0evniu+lx/y9dZ0zUBaCjcPiPWOGu5kY4YiDa+MQdjwrsqk6TVNAnCbczhmYDba+TXmyTgEfzr\nn7RzMFGoSVV0MFngmnsHEQLWvbuDkFe9+Z3WQ5+mScDMIdxjlO83Y6xRCCPuHz9o90g09aL1GGdV\nL1tNoLVq9cXxvHW2j384K8q//G6Mrz0Z4zNvqy5MOZou8pF7h3g9VuCHl3WxoNWa4Mi0Z1UpIdqQ\nuDzGppHJMuKGIdRpuUF/ZFs/t2/cTX8sTXckwNVnLtThFzvwRxtr414F/qjRsasGPnpqmO1Deb7+\nVJyOoItrTqkslfFQosA1Pxtkx1Ceb17Swco51t1Ia75NlBoA9Akh1pTadTUPbh90NOBGpxk8fiOm\nmo1ZcnpHV/Q6GOU3QeFq3hTFqfCFjN9zDS0YhRD8n1WtDKeLfP7RMQ4linzmbRE8LjHp97R5f5a/\nun+I0YzkW+/p4J0LrbUlNRv0khFvLkMOxpffuXRmLUtDHZYZdEdX9DoUS26Ckbkza06Pxx+F5EBN\np/C6Bd+8uJ1/emSUb2yK8/u9GS5aWORXW3aRLbzxPX31oVf5/tYCj75WZF7UzT2Xd3Jit/X7VA1f\nKWoJLo/hmc+0iR9oA/EaSLVFFODgil4Ho/wm6A01RsGbVQRaazboYHRM+9J5rZw138/nfzPKl54q\n4mMuATIIJBl8pPM+xGsFrnlrC585o37tMJtwh69WBLQvmhlhliNxuYx0TAtwXEVvA6D2JihmZqhl\nPP6Ikd2jACEEf3pckMc/0sM8+vGTJY2fJAHcFOlhmGXs4X+/o7WuvY21QT+S6LyaKssaHoukAHSV\naPUovQmGu5q/gGg6hFD+2w56XSyL5lgoDnKc2MsysZdjxX56xAhzo/VPBdYGfTyBtpm9JAXwt5jq\n9DIdTq0SnUqHSAixRgixWghxfT3HVEbZTdDldVbHLDuxoHGHk5wVHUMv4/bPnEKL6Qh11JziNRFO\nqxIt6RDdBiye4NgKMKQthBC9QogVUsot9Rxf+W9Vc5ZLdC641IQaGp5AWaxLXeMKZd+TArRBBwyB\nogV60pcJWmPQnUbJWE+mQ3Ql8GDp8S5gNVBXgw4KboK+lpmXcz4VLrfxN1GczeUUZ0WHXMDQs/Cr\n1ztuWDw+Iyd9ZtMGjBfS7rRrIOYRRkWo5s00Q7/USdAG3RPU8cWJCLbbPQLHI4RYK4TYJITY1N/v\noD62ZcLd4A3aPQrn0cQGfYaHXIRze37aTbANxl4DWbR7JKapUYdoBCjHKtqAwSPfUJLFWAfQ19dn\nfTfhanB5ITLb7lE4E4/PyMmvQdvFqcxsg97So1O5JsPlNjyZ1LDdIzGNGR0iIUSblHIEuBPoK73c\nCzSWGJ3eCJ2aGsW6nMrMDbl4AjrUMh1NHnYZr0M07uWHAMoZLaVMmJF6Z7jUxEwU36qWgDUFdHYz\ncz10HWqZHn/UWLoXc3aPxBIm0iGSUq4c97jxlEaFS2+EVoI3YDh1eTXSE05REp2ZHnq4B3xhu0fh\nfIRoei+96WiZZShnaqZH0eZoWUTtUCyN5A0RtUe21X+jfOYZdLdfh1qqQS/dGwdPwDDomspQFHaZ\nSkSt3sw8g942vzm7DlmFN2ikdmqcT+t8HUasBl9IicyFk5REZ5ZlC3XObOEts4QasKZmphHq0sVx\nZlAQUnSSkujMMegur6GkqKmeYDuG/oXGkbi8RpqipnoUyEVrcS47aD1G5+Waxe0xeqqmR+0eiWYi\n2ubruW2WckgxnzJ9Ci3OVW8CbZY1bpgxhDq1QXciwfamLmWvC8F2iJk36KDFueqHy6M7tagg0Gr0\nWdU4B5cHojrnvGaaKJOr+Q16dJ4RMtDUjt4cdRatx+i5rQK31yiiawKa26D7Ik1197WdUCd6c9Qh\nBFp10ZdKmuRv2bwGXbiMzSKNOtxevRfhBIRbhxFVE2w3QlgNTvMadF0CbQ3hHrtHoInOM26uGnUI\nYVmD9HrSnAZdl0Bbhy+kuxnZia8FwnovwxLCXXaPoGaa06DrEmhradFeuj0IHWqxEo+/4VNAm8+g\nBzt0CbTVBKLaS7eDlh5D9lVjHQ2+sm8ugy7cury/Xuj2ZvXF7YMW/Te3HF+4oZ2V5jLokTk6L7de\n+Ft0Xno9ic7TKqH1Itq48trNM0O8oabY1GgoovMMYSiNtfijOl20nvjCDZuX3jwGPTpPb4TWG5cb\nOnqNnH+NRQgdRrSD6DwjhNtgNMcvMdiuN0LtwheC9mOnKMoQhocZmQOtC4wfSqAVXXFaIeFuvRFq\nB25vQxYmNn7AWbi0B2M3gSh0Hw/xQ5CJGa95A4YhD7ROIO3aA/ksjO6FzFjdh9swuDx689lOgu2Q\nS0H8oN0jqZjG99BbZuuqOSfg9kLrPOg53vivfZGhozOZTrfHB52Lba88FUKsmOLYTaV/19ZvROOI\nzNE653YTndtQqYyNbdDdfl3k0ui0zjPap9mAEGI1cPcUb1krhNgJ7KrTkN7AE9RZRE4hOhc6l5QU\nGUuhQuEyEjFCnUaEoHW+YfgV9CithcYOuUTn6o3QZqD1GMinIRuv62WllBuEEFMZ649JKdfXbUDj\n0XPbWfgjxn9SgixOvnKKzoXYAeM/ZF2HCI3sofsiOpWrWRAC2hY4MVumVwixWghx/UQHhRBrhRCb\nhBCb+vv71V3VHzX2JTTOQ4jpw2CR2dBe/36i0MgGvVVvhDYVHr/jKiGllDdLKTcAnaXwzJHH10kp\n+6SUfd3dqtqP6TTFpiDYbks3qZpDLuM2jBZLKW+o9XwVEeo0mrtqmouWHkgOQiGj5HSTbGbuKhnp\nSj47VAq5DAK9SgY1HaFOnabYLLR0QzZW1168NRn0kteyQUq5SwhxtxBidSU/lpoQbojMtfQSGpsQ\nwii7Hn5VyemklOuqH4Jok1KOAJt4YzN0MXCbkkFNeXG3kdmiaR5aF0D2JSjm6nK5WkMuvUB5KbqL\nCbwY5XHGyGyt19LMBNvBG67LpYQQa4C+0r9lHgKQUm4Brigd21l6bi1ai6j5cHuMjdI6UdPsOcID\nWgHcOcl71gH09fXVtu3r9huVc5rmJjoHBndYfplSOGX9Ea+tHPe4ag/fNJ6g1iJqVkIdkBquSxGd\nkk3RUnHGFsu9mFat1zIj8EcaWsLUFHpuNzfRedRD7mJaD73CjaXVlm+IlsvINTODyGwYjNk9ivoQ\nbDduYprmxRswoguJQ5ZeZlqDPt2yUwixVkp5c+mxNZuiwmUUn2hmDv4Ww0vPNrlR101ZZg6R2Ubo\nxcIN0ppCLqUsl5uEEDuFEMOKxnQ0LbOMPGXNzGImCFNF52otopmCy/osplo3RTcA1irBewINJY6j\nUYi/xQi1Nasioy+iN0JnGuFOSA5ALmnJ6Z1fKdo6X28WzWSaNS9buA25A83Mw8IQm7MNerhbN66Y\n6fhCEGhCzZ7WYwwJYc3Mw99iWYs75xp0T1BXhGoMonNpqg5HwQ4jN1kzc7GoxZ0zDbpwGWplusu5\nBowN8WYpKPOGjDCiZmbj9lpSQepMi9m2QItvad5MZDa4GjwbxOUt9V915s9OU2fCXeBTG1J23syK\nzLEsvqRpYFzuxpZMdnmMlns6bq4Zj+I+AM4y6OHumZF7rDFHsN1IY200XF6jhZledWqOxONXqpvu\nHGm3yBxtzDXT02jhCk8Auo7TnrlmcsKdRls7BTjDoHsD4NXGXNOE6GwWTSW0qNn0bzB3R6PRaDST\noQ26RqPRNAnaoGs0Gk2ToA26RqPRNAnaoGs0Gk2ToA26RqPRNAnaoGs0Gk2ToA26RqPRNAnaoGs0\nGk2TIKSU9buYEP3A7kkOdwEDdRvM5DhlHKDHMhFTjWOhlNIWnd0p5rZT/m6gxzIRThkHKJjbdTXo\nU6RvyP4AAAJQSURBVCGE2CSl7NPjeAM9FueOo1KcNF49FueOA9SMRYdcNBqNpknQBl2j0WiaBCcZ\n9HV2D6CEU8YBeiwT4ZRxVIqTxqvHcjROGQcoGItjYugajUajqQ0neegaTUUIIa63ewwajWpUzGvH\nGvSZ/qMVQqwRQqy2++8ghFhb+u8mO8dRRgixGrjA7nHUgt3fqZ04ZV6XxuKYua1qXjvSoDvlR2vX\nFy6EWAEgpdwAjJSf15vS97BBSrkO6C0919TATJ7bTpnXpbE05dx2pEF3AjZ/4VcCI6XHuwC7Jlvv\nuGvvKj23DSHEipIx0NSAjXPbKfMaHDS3Vc5rxxl0B/1o7fzC24Chcc8763jtw0gp15V+9AArgE12\njGMcDd2gU89tZ8xrcNzcVjavndEk+s044kc77ssG4wu/066x2E1pabxFSrnFzjE4xBjWgp7bDsPu\nua16XtfdoAsh1k7w8i4p5QYn/mht+sJHeOPH3wYM1vHaE7FaSnmDzWPoFUL0YvxdOkpzxbYbzETo\nuT0tTpvXYP/cVjqv627Qj/AOjqSuP9qpfoDjntvxhd8JlDUdegHbDIEQYq2U8ubS49V2GSUp5fry\neDCMgePQc3taHDOvwRlzW/W8dmRhUel/7gbgcpuX+WvLP9J6f+Glv8EuoHcaQ2HlGFYDd2PEPTsw\nvg9HeZmNxkyf206Y16VxNOXcdqRBdwLN+oVrNHpuNy/aoGs0Gk2T4Li0RY1Go9GYQxt0jUajaRK0\nQddoNJomQRt0jUajaRK0QddoNJomQRt0jUajaRL+H7wsCZuovLFEAAAAAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlsAAAGeCAYAAACjCMTrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -122,19 +120,17 @@ "fms, fvs = m.predict_f(X)\n", "print('Evaluated')\n", "\n", - "plt.subplot(1, 2, 1)\n", + "plt.figure(figsize=(10,7))\n", "plt.scatter(x, y)\n", - "plt.plot(X.flatten(), fms.flatten())\n", + "plt.plot(X.flatten(), fms.flatten(), color='b', label='GPR-MGP')\n", "plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()),\n", - " alpha=0.2)\n", - "plt.title('MGP - GPR')\n", - "plt.subplot(1, 2, 2)\n", - "plt.scatter(x, y)\n", + " alpha=0.2, color='b')\n", + "\n", "fm, fv = m.wrapped.predict_f(X)\n", - "plt.plot(X.flatten(), fm.flatten())\n", + "plt.plot(X.flatten(), fm.flatten(), color='r', label='GPR')\n", "plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()),\n", - " alpha=0.2)\n", - "plt.title('GPR')\n", + " alpha=0.2, color='r')\n", + "plt.legend()\n", "plt.show()" ] }, From c0a41e7d22064e72ed8196284ee0b804c26b0a42 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:42:15 +0100 Subject: [PATCH 20/54] Make use of the free_vars instead of collecting the variables manually --- GPflowOpt/models.py | 34 +++++++++++++-------------------- doc/source/notebooks/testmgp.py | 32 +++++++++++++++---------------- 2 files changed, 29 insertions(+), 37 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 8f551e2..a1a4afd 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -14,17 +14,18 @@ def rowwise_gradients(Y, X): This is done with while_loop, because of a known incompatibility between map_fn and gradients. """ num_rows = tf.shape(Y)[0] + num_feat = tf.shape(X)[0] def body(old_grads, row): - g = tf.stack(tf.gradients(Y[row], X), axis=1) + g = tf.expand_dims(tf.gradients(Y[row], X)[0], axis=0) new_grads = tf.concat([old_grads, g], axis=0) return new_grads, row + 1 def cond(_, row): return tf.less(row, num_rows) - shape_invariants = [tf.TensorShape([None, len(X)]), tf.TensorShape([])] - grads, _ = tf.while_loop(cond, body, [tf.zeros([0, len(X)], float_type), tf.constant(0)], + shape_invariants = [tf.TensorShape([None, None]), tf.TensorShape([])] + grads, _ = tf.while_loop(cond, body, [tf.zeros([0, num_feat], float_type), tf.constant(0)], shape_invariants=shape_invariants) return grads @@ -86,31 +87,22 @@ def _unwrap(self, p, c): self._unwrap(p2, c) def _compute_hessian(self, x, y): - mat = [] - for v1 in y: - temp = [] - for v2 in y: - # computing derivative twice, first w.r.t v2 and then w.r.t v1 - temp.append(tf.gradients(tf.gradients(x, v2)[0], v1)[0]) - temp = [tf.constant(0, dtype=float_type) if t is None else t for t in - temp] - temp = tf.stack(temp) - mat.append(temp) - mat = tf.squeeze(tf.stack(mat)) - return mat + l = tf.unstack(tf.gradients(x, y)[0]) + lll=[] + for ll in l: + lll.append(tf.gradients(ll, y)) + return tf.stack(lll, axis=1) def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) - c = [] - self._unwrap(self.wrapped, c) - C = tf.expand_dims(tf.stack(c, axis=0), 1) + + c = self._predict_f_AF_storage['free_vars'] + h = tf.hessians(self.build_likelihood() + self.build_prior(), c)[0] + L = tf.cholesky(-h) Dfmean = rowwise_gradients(fmean, c) Dfvar = rowwise_gradients(fvar, c) - h = -self._compute_hessian(self.build_likelihood() + self.build_prior(), c) - L = tf.cholesky(h) - tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py index 699195a..e4bdf9a 100644 --- a/doc/source/notebooks/testmgp.py +++ b/doc/source/notebooks/testmgp.py @@ -1,33 +1,33 @@ from GPflow.gpr import GPR import numpy as np from GPflow.kernels import RBF, White +from GPflow.priors import Gamma, LogNormal from GPflowOpt.models import MGP +from GPflow.transforms import Log1pe import matplotlib.pyplot as plt -x = np.random.randn(4, 1)*2 -y = np.sin(x) +np.random.seed(3) +x = np.random.rand(8, 1) * 8-4 +y = np.cos(x) +np.random.randn(8,1)*0.1 -m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1) + White(1))) -m.optimize() +m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1))) +m.kern.lengthscales.prior = Gamma(3, 1/3) +m.kern.variance.prior = Gamma(3, 1/3) +m.likelihood.variance.prior = LogNormal(0, 1) +m.optimize(display=True) print(m) print('Trained') -X = np.array(np.linspace(-3, 3, 100)[:, None]) -fm = [] -fv = [] -for xn in X: - fms, fvs = m.predict_f(xn.reshape(-1, 1)) - fm.append(fms) - fv.append(fvs) -fm = np.stack(fm, axis=0) -fv = np.stack(fv, axis=0) +X = np.array(np.linspace(-4, 4, 100)[:, None]) +fms, fvs = m.predict_f(X) +print(fms, fvs) print('Evaluated') plt.subplot(1, 2, 1) plt.scatter(x, y) -plt.plot(X.flatten(), fm.flatten()) -plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), +plt.plot(X.flatten(), fms.flatten()) +plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()), alpha=0.2) plt.title('MGP - GPR') plt.subplot(1, 2, 2) @@ -37,4 +37,4 @@ plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), alpha=0.2) plt.title('GPR') -plt.show() +plt.show() \ No newline at end of file From c83eb7312e825d08f44d4d47a0c457aa181980f2 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:43:39 +0100 Subject: [PATCH 21/54] Remove unnecessary functions --- GPflowOpt/models.py | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a1a4afd..74883cc 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -76,23 +76,6 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - def _unwrap(self, p, c): - """ - Unwrap all the parameters captured in the model - """ - if isinstance(p, Param): - c.append(p._tf_array) - elif isinstance(p, Parameterized): - for p2 in p.sorted_params: - self._unwrap(p2, c) - - def _compute_hessian(self, x, y): - l = tf.unstack(tf.gradients(x, y)[0]) - lll=[] - for ll in l: - lll.append(tf.gradients(ll, y)) - return tf.stack(lll, axis=1) - def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) From c0f5c001fa80b0b72d1c9c9dc1c52946eca98ec7 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:57:40 +0100 Subject: [PATCH 22/54] Can hanle predict_f and predict_y --- GPflowOpt/models.py | 43 +++++++++++++++++++++------------ doc/source/notebooks/testmgp.py | 2 +- 2 files changed, 28 insertions(+), 17 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 74883cc..a49a5e8 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -1,5 +1,5 @@ from GPflow.param import Parameterized, AutoFlow, Param -from GPflow.model import GPModel +from GPflow.model import Model, GPModel from GPflow.likelihoods import Gaussian import GPflow import tensorflow as tf @@ -31,7 +31,7 @@ def cond(_, row): return grads -class MGP(GPModel): +class MGP(Model): """ Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation Key reference: @@ -51,13 +51,7 @@ def __init__(self, obj): assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj - self.cov_chol = None - super(MGP, self).__init__(None, None, None, None, 1, name=obj.name + "_MGP") - del self.kern - del self.mean_function - del self.likelihood - del self.X - del self.Y + super(MGP, self).__init__(name=obj.name + "_MGP") def __getattr__(self, item): """ @@ -76,17 +70,34 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - def build_predict(self, Xnew, full_cov=False): - fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) - - c = self._predict_f_AF_storage['free_vars'] - h = tf.hessians(self.build_likelihood() + self.build_prior(), c)[0] + def build_predict(self, fmean, fvar, theta): + h = tf.hessians(self.build_likelihood() + self.build_prior(), theta)[0] L = tf.cholesky(-h) - Dfmean = rowwise_gradients(fmean, c) - Dfvar = rowwise_gradients(fvar, c) + Dfmean = rowwise_gradients(fmean, theta) + Dfvar = rowwise_gradients(fvar, theta) tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) + + @AutoFlow((float_type, [None, None])) + def predict_f(self, Xnew): + """ + Compute the mean and variance of the latent function(s) at the points + Xnew. + """ + theta = self._predict_f_AF_storage['free_vars'] + fmean, fvar = self.wrapped.build_predict(Xnew) + return self.build_predict(fmean, fvar, theta) + + @AutoFlow((float_type, [None, None])) + def predict_y(self, Xnew): + """ + Compute the mean and variance of held-out data at the points Xnew + """ + theta = self._predict_y_AF_storage['free_vars'] + pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) + fmean, fvar= self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) + return self.build_predict(fmean, fvar, theta) \ No newline at end of file diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py index e4bdf9a..09f682c 100644 --- a/doc/source/notebooks/testmgp.py +++ b/doc/source/notebooks/testmgp.py @@ -20,7 +20,7 @@ print('Trained') X = np.array(np.linspace(-4, 4, 100)[:, None]) -fms, fvs = m.predict_f(X) +fms, fvs = m.predict_y(X) print(fms, fvs) print('Evaluated') From 958eb4949ac7a40a983d5416a3ed2d778dc56ceb Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:31:30 +0100 Subject: [PATCH 23/54] Can handle multi-output GP --- GPflowOpt/models.py | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a49a5e8..d71e0e2 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -49,7 +49,6 @@ class MGP(Model): def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" - assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj super(MGP, self).__init__(name=obj.name + "_MGP") @@ -74,13 +73,19 @@ def build_predict(self, fmean, fvar, theta): h = tf.hessians(self.build_likelihood() + self.build_prior(), theta)[0] L = tf.cholesky(-h) - Dfmean = rowwise_gradients(fmean, theta) - Dfvar = rowwise_gradients(fvar, theta) + N = tf.shape(fmean)[0] + D = tf.shape(fmean)[1] - tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) - tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) - return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ - + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) + fmeanf = tf.reshape(fmean, [N * D, 1]) # N*D x 1 + fvarf = tf.reshape(fvar, [N * D, 1]) # N*D x 1 + + Dfmean = rowwise_gradients(fmeanf, theta) # N*D x k + Dfvar = rowwise_gradients(fvarf, theta) # N*D x k + + tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) # N*D x k + tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) # N*D x k + return fmean, 4 / 3 * fvar + tf.reshape(tf.reduce_sum(tf.square(tmp1), axis=1), [N, D]) \ + + 1 / 3 / (fvar + 1E-3) * tf.reshape(tf.reduce_sum(tf.square(tmp2), axis=1), [N, D]) @AutoFlow((float_type, [None, None])) def predict_f(self, Xnew): @@ -89,7 +94,7 @@ def predict_f(self, Xnew): Xnew. """ theta = self._predict_f_AF_storage['free_vars'] - fmean, fvar = self.wrapped.build_predict(Xnew) + fmean, fvar = self.wrapped.build_predict(Xnew) return self.build_predict(fmean, fvar, theta) @AutoFlow((float_type, [None, None])) @@ -99,5 +104,5 @@ def predict_y(self, Xnew): """ theta = self._predict_y_AF_storage['free_vars'] pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) - fmean, fvar= self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) - return self.build_predict(fmean, fvar, theta) \ No newline at end of file + fmean, fvar = self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) + return self.build_predict(fmean, fvar, theta) From 06573287fe81fae3819dcf5ca0b68ccd6a6973f0 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:44:59 +0100 Subject: [PATCH 24/54] Add predict_density --- GPflowOpt/models.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index d71e0e2..186f664 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -106,3 +106,17 @@ def predict_y(self, Xnew): pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) fmean, fvar = self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) return self.build_predict(fmean, fvar, theta) + + @AutoFlow((float_type, [None, None]), (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. + """ + theta = self._predict_f_AF_storage['free_vars'] + pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) + pred_f_mean, pred_f_var = self.build_predict(pred_f_mean, pred_f_var, theta) + return self.likelihood.predict_density(pred_f_mean, pred_f_var, Ynew) From 8f79822159cb8c14f0cc49920401dcd2188c7d0e Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:45:26 +0100 Subject: [PATCH 25/54] Models tests --- testing/test_models.py | 57 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 57 insertions(+) create mode 100644 testing/test_models.py diff --git a/testing/test_models.py b/testing/test_models.py new file mode 100644 index 0000000..7b041e3 --- /dev/null +++ b/testing/test_models.py @@ -0,0 +1,57 @@ +import GPflowOpt +import GPflow +import numpy as np +import unittest +from GPflowOpt.models import MGP + + +def parabola2d(X): + return np.atleast_2d(np.sum(X ** 2, axis=1)).T + + +class TestMGP(unittest.TestCase): + @property + def domain(self): + return np.sum([GPflowOpt.domain.ContinuousParameter("x{0}".format(i), -1, 1) for i in range(1, 3)]) + + def create_parabola_model(self, design=None): + if design is None: + design = GPflowOpt.design.LatinHyperCube(16, self.domain) + X, Y = design.generate(), parabola2d(design.generate()) + m = GPflow.gpr.GPR(X, Y, GPflow.kernels.RBF(2, ARD=True)) + return m + + def test_object_integrity(self): + m = self.create_parabola_model() + Xs, Ys = m.X.value, m.Y.value + n = MGP(m) + + self.assertEqual(n.wrapped, m) + self.assertEqual(m._parent, n) + self.assertTrue(np.allclose(Xs, n.X.value)) + self.assertTrue(np.allclose(Ys, n.Y.value)) + + def test_predict_scaling(self): + m = self.create_parabola_model() + n = MGP(self.create_parabola_model()) + m.optimize() + n.optimize() + + Xt = GPflowOpt.design.RandomDesign(20, self.domain).generate() + fr, vr = m.predict_f(Xt) + fs, vs = n.predict_f(Xt) + self.assertTrue(np.shape(fr) == np.shape(fs)) + self.assertTrue(np.shape(vr) == np.shape(vs)) + self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + + fr, vr = m.predict_y(Xt) + fs, vs = n.predict_y(Xt) + self.assertTrue(np.shape(fr) == np.shape(fs)) + self.assertTrue(np.shape(vr) == np.shape(vs)) + self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + + fr, vr = m.predict_f_full_cov(Xt) + fs, vs = n.predict_f_full_cov(Xt) + self.assertTrue(np.shape(fr) == np.shape(fs)) + self.assertTrue(np.shape(vr) == np.shape(vs)) + self.assertTrue(np.allclose(fr, fs, atol=1e-3)) From 2c940bce8a02915733fa64600ec0ceb3d41fb4fd Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:47:25 +0100 Subject: [PATCH 26/54] Models tests --- testing/test_models.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/testing/test_models.py b/testing/test_models.py index 7b041e3..9635cd7 100644 --- a/testing/test_models.py +++ b/testing/test_models.py @@ -49,9 +49,3 @@ def test_predict_scaling(self): self.assertTrue(np.shape(fr) == np.shape(fs)) self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) - - fr, vr = m.predict_f_full_cov(Xt) - fs, vs = n.predict_f_full_cov(Xt) - self.assertTrue(np.shape(fr) == np.shape(fs)) - self.assertTrue(np.shape(vr) == np.shape(vs)) - self.assertTrue(np.allclose(fr, fs, atol=1e-3)) From 3b3bd35ba66c5c45647a78f2adc086620825a89d Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:28:35 +0100 Subject: [PATCH 27/54] Approximate marginalisation during prediction time using Laplace approximation --- GPflowOpt/models.py | 136 +++++++++++++++++--------------------------- 1 file changed, 53 insertions(+), 83 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 186f664..12599b1 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -1,5 +1,5 @@ from GPflow.param import Parameterized, AutoFlow, Param -from GPflow.model import Model, GPModel +from GPflow.model import GPModel from GPflow.likelihoods import Gaussian import GPflow import tensorflow as tf @@ -7,50 +7,14 @@ float_type = GPflow.settings.dtypes.float_type -def rowwise_gradients(Y, X): - """ - For a 2D Tensor Y, compute the derivatiave of each columns w.r.t a 2D tensor X. - - This is done with while_loop, because of a known incompatibility between map_fn and gradients. - """ - num_rows = tf.shape(Y)[0] - num_feat = tf.shape(X)[0] - - def body(old_grads, row): - g = tf.expand_dims(tf.gradients(Y[row], X)[0], axis=0) - new_grads = tf.concat([old_grads, g], axis=0) - return new_grads, row + 1 - - def cond(_, row): - return tf.less(row, num_rows) - - shape_invariants = [tf.TensorShape([None, None]), tf.TensorShape([])] - grads, _ = tf.while_loop(cond, body, [tf.zeros([0, num_feat], float_type), tf.constant(0)], - shape_invariants=shape_invariants) - - return grads - - -class MGP(Model): - """ - Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation - Key reference: - - :: - - @article{garnett2013active, - title={Active learning of linear embeddings for Gaussian processes}, - author={Garnett, Roman and Osborne, Michael A and Hennig, Philipp}, - journal={arXiv preprint arXiv:1310.6740}, - year={2013} - } - """ - +class MGP(Parameterized): def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" + assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj - super(MGP, self).__init__(name=obj.name + "_MGP") + self.cov_chol = None + super(MGP, self).__init__() def __getattr__(self, item): """ @@ -69,54 +33,60 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - def build_predict(self, fmean, fvar, theta): - h = tf.hessians(self.build_likelihood() + self.build_prior(), theta)[0] - L = tf.cholesky(-h) - - N = tf.shape(fmean)[0] - D = tf.shape(fmean)[1] - - fmeanf = tf.reshape(fmean, [N * D, 1]) # N*D x 1 - fvarf = tf.reshape(fvar, [N * D, 1]) # N*D x 1 - - Dfmean = rowwise_gradients(fmeanf, theta) # N*D x k - Dfvar = rowwise_gradients(fvarf, theta) # N*D x k - - tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) # N*D x k - tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) # N*D x k - return fmean, 4 / 3 * fvar + tf.reshape(tf.reduce_sum(tf.square(tmp1), axis=1), [N, D]) \ - + 1 / 3 / (fvar + 1E-3) * tf.reshape(tf.reduce_sum(tf.square(tmp2), axis=1), [N, D]) - @AutoFlow((float_type, [None, None])) def predict_f(self, Xnew): """ Compute the mean and variance of the latent function(s) at the points Xnew. """ - theta = self._predict_f_AF_storage['free_vars'] - fmean, fvar = self.wrapped.build_predict(Xnew) - return self.build_predict(fmean, fvar, theta) + return self.build_predict(Xnew) - @AutoFlow((float_type, [None, None])) - def predict_y(self, Xnew): - """ - Compute the mean and variance of held-out data at the points Xnew + def _unwrap(self, p, c): """ - theta = self._predict_y_AF_storage['free_vars'] - pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) - fmean, fvar = self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) - return self.build_predict(fmean, fvar, theta) - - @AutoFlow((float_type, [None, None]), (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. + Unwrap all the parameters captured in the model """ - theta = self._predict_f_AF_storage['free_vars'] - pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) - pred_f_mean, pred_f_var = self.build_predict(pred_f_mean, pred_f_var, theta) - return self.likelihood.predict_density(pred_f_mean, pred_f_var, Ynew) + if isinstance(p, Param): + c.append(p._tf_array) + elif isinstance(p, Parameterized): + for p2 in p.sorted_params: + self._unwrap(p2, c) + + def _compute_hessian(self, x, y): + mat = [] + for v1 in y: + temp = [] + for v2 in y: + # computing derivative twice, first w.r.t v2 and then w.r.t v1 + temp.append(tf.gradients(tf.gradients(x, v2)[0], v1)[0]) + temp = [tf.constant(0, dtype=float_type) if t is None else t for t in + temp] + temp = tf.stack(temp) + mat.append(temp) + mat = tf.squeeze(tf.stack(mat)) + return mat + + def build_predict(self, Xnew, full_cov=False): + fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) + c = [] + self._unwrap(self.wrapped, c) + L = self.cov_chol + Dfmean = tf.stack(tf.gradients(fmean, c)) + Dfvar = tf.stack(tf.gradients(fvar, c)) + + tmp1 = tf.matrix_triangular_solve(L, Dfmean) + tmp2 = tf.matrix_triangular_solve(L, Dfvar) + return fmean, 4 / 3 * fvar + tf.reduce_sum(tf.square(tmp1)) + 1 / 3 / (fvar+1E-3) * tf.reduce_sum(tf.square(tmp2)) + + @AutoFlow() + def _variance_cholesky(self): + c = [] + self._unwrap(self.wrapped, c) + h = -self._compute_hessian(self.build_likelihood(), c) + diag = tf.expand_dims(tf.matrix_diag_part(h), -1) + h = 1/diag*h/tf.transpose(diag) +tf.eye(len(c), dtype=float_type)*1E-3 + L = diag*tf.cholesky(h) + return L + + def optimize(self, **kwargs): + self.wrapped.optimize(**kwargs) + self.cov_chol = Param(self._variance_cholesky()) From e9d3fd254e19b988dc737c772a338cb8c82c8b9e Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:42:29 +0100 Subject: [PATCH 28/54] Adding docstring --- GPflowOpt/models.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 12599b1..a2e990b 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -8,6 +8,19 @@ class MGP(Parameterized): + """ + Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation + Key reference: + + :: + + @article{garnett2013active, + title={Active learning of linear embeddings for Gaussian processes}, + author={Garnett, Roman and Osborne, Michael A and Hennig, Philipp}, + journal={arXiv preprint arXiv:1310.6740}, + year={2013} + } + """ def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" From 908cadd3c9d216138212e484cecf7e892a39d31c Mon Sep 17 00:00:00 2001 From: nknudde Date: Sat, 22 Jul 2017 14:45:20 +0100 Subject: [PATCH 29/54] Small example Interfacing still needs cleaning up --- doc/source/notebooks/testmgp.py | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py index 09f682c..699195a 100644 --- a/doc/source/notebooks/testmgp.py +++ b/doc/source/notebooks/testmgp.py @@ -1,33 +1,33 @@ from GPflow.gpr import GPR import numpy as np from GPflow.kernels import RBF, White -from GPflow.priors import Gamma, LogNormal from GPflowOpt.models import MGP -from GPflow.transforms import Log1pe import matplotlib.pyplot as plt +x = np.random.randn(4, 1)*2 -np.random.seed(3) -x = np.random.rand(8, 1) * 8-4 -y = np.cos(x) +np.random.randn(8,1)*0.1 +y = np.sin(x) -m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1))) -m.kern.lengthscales.prior = Gamma(3, 1/3) -m.kern.variance.prior = Gamma(3, 1/3) -m.likelihood.variance.prior = LogNormal(0, 1) -m.optimize(display=True) +m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1) + White(1))) +m.optimize() print(m) print('Trained') -X = np.array(np.linspace(-4, 4, 100)[:, None]) -fms, fvs = m.predict_y(X) -print(fms, fvs) +X = np.array(np.linspace(-3, 3, 100)[:, None]) +fm = [] +fv = [] +for xn in X: + fms, fvs = m.predict_f(xn.reshape(-1, 1)) + fm.append(fms) + fv.append(fvs) +fm = np.stack(fm, axis=0) +fv = np.stack(fv, axis=0) print('Evaluated') plt.subplot(1, 2, 1) plt.scatter(x, y) -plt.plot(X.flatten(), fms.flatten()) -plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()), +plt.plot(X.flatten(), fm.flatten()) +plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), alpha=0.2) plt.title('MGP - GPR') plt.subplot(1, 2, 2) @@ -37,4 +37,4 @@ plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), alpha=0.2) plt.title('GPR') -plt.show() \ No newline at end of file +plt.show() From 451f3dd52d88ffd1521ca09d289ca7028bc00bc5 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:46:41 +0100 Subject: [PATCH 30/54] Adding predictions for multiple points --- GPflowOpt/models.py | 70 ++++++++++++++++++++++++++------------------- 1 file changed, 41 insertions(+), 29 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a2e990b..8f551e2 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -7,7 +7,30 @@ float_type = GPflow.settings.dtypes.float_type -class MGP(Parameterized): +def rowwise_gradients(Y, X): + """ + For a 2D Tensor Y, compute the derivatiave of each columns w.r.t a 2D tensor X. + + This is done with while_loop, because of a known incompatibility between map_fn and gradients. + """ + num_rows = tf.shape(Y)[0] + + def body(old_grads, row): + g = tf.stack(tf.gradients(Y[row], X), axis=1) + new_grads = tf.concat([old_grads, g], axis=0) + return new_grads, row + 1 + + def cond(_, row): + return tf.less(row, num_rows) + + shape_invariants = [tf.TensorShape([None, len(X)]), tf.TensorShape([])] + grads, _ = tf.while_loop(cond, body, [tf.zeros([0, len(X)], float_type), tf.constant(0)], + shape_invariants=shape_invariants) + + return grads + + +class MGP(GPModel): """ Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation Key reference: @@ -21,13 +44,19 @@ class MGP(Parameterized): year={2013} } """ + def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj self.cov_chol = None - super(MGP, self).__init__() + super(MGP, self).__init__(None, None, None, None, 1, name=obj.name + "_MGP") + del self.kern + del self.mean_function + del self.likelihood + del self.X + del self.Y def __getattr__(self, item): """ @@ -46,14 +75,6 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - @AutoFlow((float_type, [None, None])) - def predict_f(self, Xnew): - """ - Compute the mean and variance of the latent function(s) at the points - Xnew. - """ - return self.build_predict(Xnew) - def _unwrap(self, p, c): """ Unwrap all the parameters captured in the model @@ -82,24 +103,15 @@ def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) c = [] self._unwrap(self.wrapped, c) - L = self.cov_chol - Dfmean = tf.stack(tf.gradients(fmean, c)) - Dfvar = tf.stack(tf.gradients(fvar, c)) + C = tf.expand_dims(tf.stack(c, axis=0), 1) - tmp1 = tf.matrix_triangular_solve(L, Dfmean) - tmp2 = tf.matrix_triangular_solve(L, Dfvar) - return fmean, 4 / 3 * fvar + tf.reduce_sum(tf.square(tmp1)) + 1 / 3 / (fvar+1E-3) * tf.reduce_sum(tf.square(tmp2)) + Dfmean = rowwise_gradients(fmean, c) + Dfvar = rowwise_gradients(fvar, c) - @AutoFlow() - def _variance_cholesky(self): - c = [] - self._unwrap(self.wrapped, c) - h = -self._compute_hessian(self.build_likelihood(), c) - diag = tf.expand_dims(tf.matrix_diag_part(h), -1) - h = 1/diag*h/tf.transpose(diag) +tf.eye(len(c), dtype=float_type)*1E-3 - L = diag*tf.cholesky(h) - return L - - def optimize(self, **kwargs): - self.wrapped.optimize(**kwargs) - self.cov_chol = Param(self._variance_cholesky()) + h = -self._compute_hessian(self.build_likelihood() + self.build_prior(), c) + L = tf.cholesky(h) + + tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) + tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) + return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ + + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) From 673fbd4b4203f7e8610bd8714fe53f5e790479a4 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:47:06 +0100 Subject: [PATCH 31/54] Add notebook for MGP --- doc/source/notebooks/mgp.ipynb | 46 ++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 21 deletions(-) diff --git a/doc/source/notebooks/mgp.ipynb b/doc/source/notebooks/mgp.ipynb index e9d0b09..bc03569 100644 --- a/doc/source/notebooks/mgp.ipynb +++ b/doc/source/notebooks/mgp.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": { "collapsed": true }, @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -61,26 +61,28 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "collapsed": true }, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "name_MGP.name.kern.\u001b[1mlengthscales\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 1.47220582]\nname_MGP.name.kern.\u001b[1mvariance\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 0.75133993]\nname_MGP.name.likelihood.\u001b[1mvariance\u001b[0m transform:+ve prior:logN([ 0.],[ 30.])\n[ 0.01172159]\n\n" - ] + "data": { + "text/plain": [ + " fun: 11.219668379985972\n hess_inv: <3x3 LbfgsInvHessProduct with dtype=float64>\n jac: array([ -8.31933750e-06, 6.32051531e-06, -1.65760996e-06])\n message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n nfev: 9\n nit: 6\n status: 0\n success: True\n x: array([ 0.77306105, 0.02511576, -1.60659824])" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ "m = GPflowOpt.models.MGP(GPflow.gpr.GPR(x, y, GPflow.kernels.RBF(1, lengthscales=1, variance=1)))\n", "m.kern.lengthscales.prior = GPflow.priors.Gamma(3, 1/3)\n", "m.kern.variance.prior = GPflow.priors.Gamma(3, 1/3)\n", - "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 30)\n", - "m.optimize()\n", - "print(m)" + "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 1)\n", + "m.optimize()" ] }, { @@ -92,7 +94,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "scrolled": false }, @@ -106,9 +108,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlsAAAGeCAYAAACjCMTrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEFCAYAAADzHRw3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -120,17 +122,19 @@ "fms, fvs = m.predict_f(X)\n", "print('Evaluated')\n", "\n", - "plt.figure(figsize=(10,7))\n", + "plt.subplot(1, 2, 1)\n", "plt.scatter(x, y)\n", - "plt.plot(X.flatten(), fms.flatten(), color='b', label='GPR-MGP')\n", + "plt.plot(X.flatten(), fms.flatten())\n", "plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()),\n", - " alpha=0.2, color='b')\n", - "\n", + " alpha=0.2)\n", + "plt.title('MGP - GPR')\n", + "plt.subplot(1, 2, 2)\n", + "plt.scatter(x, y)\n", "fm, fv = m.wrapped.predict_f(X)\n", - "plt.plot(X.flatten(), fm.flatten(), color='r', label='GPR')\n", + "plt.plot(X.flatten(), fm.flatten())\n", "plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()),\n", - " alpha=0.2, color='r')\n", - "plt.legend()\n", + " alpha=0.2)\n", + "plt.title('GPR')\n", "plt.show()" ] }, From d24da1809f85db078dc6b99dbf6c80e0d7e1c2f2 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 15:56:59 +0100 Subject: [PATCH 32/54] Update notebook MGP --- doc/source/notebooks/mgp.ipynb | 46 ++++++++++++++++------------------ 1 file changed, 21 insertions(+), 25 deletions(-) diff --git a/doc/source/notebooks/mgp.ipynb b/doc/source/notebooks/mgp.ipynb index bc03569..e9d0b09 100644 --- a/doc/source/notebooks/mgp.ipynb +++ b/doc/source/notebooks/mgp.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "collapsed": true }, @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -61,28 +61,26 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "collapsed": true }, "outputs": [ { - "data": { - "text/plain": [ - " fun: 11.219668379985972\n hess_inv: <3x3 LbfgsInvHessProduct with dtype=float64>\n jac: array([ -8.31933750e-06, 6.32051531e-06, -1.65760996e-06])\n message: b'CONVERGENCE: NORM_OF_PROJECTED_GRADIENT_<=_PGTOL'\n nfev: 9\n nit: 6\n status: 0\n success: True\n x: array([ 0.77306105, 0.02511576, -1.60659824])" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "name_MGP.name.kern.\u001b[1mlengthscales\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 1.47220582]\nname_MGP.name.kern.\u001b[1mvariance\u001b[0m transform:+ve prior:Ga([ 3.],[ 0.33333333])\n[ 0.75133993]\nname_MGP.name.likelihood.\u001b[1mvariance\u001b[0m transform:+ve prior:logN([ 0.],[ 30.])\n[ 0.01172159]\n\n" + ] } ], "source": [ "m = GPflowOpt.models.MGP(GPflow.gpr.GPR(x, y, GPflow.kernels.RBF(1, lengthscales=1, variance=1)))\n", "m.kern.lengthscales.prior = GPflow.priors.Gamma(3, 1/3)\n", "m.kern.variance.prior = GPflow.priors.Gamma(3, 1/3)\n", - "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 1)\n", - "m.optimize()" + "m.likelihood.variance.prior = GPflow.priors.LogNormal(0, 30)\n", + "m.optimize()\n", + "print(m)" ] }, { @@ -94,7 +92,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "scrolled": false }, @@ -108,9 +106,9 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEFCAYAAADzHRw3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlsAAAGeCAYAAACjCMTrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAElFTkSuQmCC\n", "text/plain": [ - "" + "" ] }, "metadata": {}, @@ -122,19 +120,17 @@ "fms, fvs = m.predict_f(X)\n", "print('Evaluated')\n", "\n", - "plt.subplot(1, 2, 1)\n", + "plt.figure(figsize=(10,7))\n", "plt.scatter(x, y)\n", - "plt.plot(X.flatten(), fms.flatten())\n", + "plt.plot(X.flatten(), fms.flatten(), color='b', label='GPR-MGP')\n", "plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()),\n", - " alpha=0.2)\n", - "plt.title('MGP - GPR')\n", - "plt.subplot(1, 2, 2)\n", - "plt.scatter(x, y)\n", + " alpha=0.2, color='b')\n", + "\n", "fm, fv = m.wrapped.predict_f(X)\n", - "plt.plot(X.flatten(), fm.flatten())\n", + "plt.plot(X.flatten(), fm.flatten(), color='r', label='GPR')\n", "plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()),\n", - " alpha=0.2)\n", - "plt.title('GPR')\n", + " alpha=0.2, color='r')\n", + "plt.legend()\n", "plt.show()" ] }, From a31dfe71c1a32a34a649faaa3e5974cb168eb6d7 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:42:15 +0100 Subject: [PATCH 33/54] Make use of the free_vars instead of collecting the variables manually --- GPflowOpt/models.py | 34 +++++++++++++-------------------- doc/source/notebooks/testmgp.py | 32 +++++++++++++++---------------- 2 files changed, 29 insertions(+), 37 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 8f551e2..a1a4afd 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -14,17 +14,18 @@ def rowwise_gradients(Y, X): This is done with while_loop, because of a known incompatibility between map_fn and gradients. """ num_rows = tf.shape(Y)[0] + num_feat = tf.shape(X)[0] def body(old_grads, row): - g = tf.stack(tf.gradients(Y[row], X), axis=1) + g = tf.expand_dims(tf.gradients(Y[row], X)[0], axis=0) new_grads = tf.concat([old_grads, g], axis=0) return new_grads, row + 1 def cond(_, row): return tf.less(row, num_rows) - shape_invariants = [tf.TensorShape([None, len(X)]), tf.TensorShape([])] - grads, _ = tf.while_loop(cond, body, [tf.zeros([0, len(X)], float_type), tf.constant(0)], + shape_invariants = [tf.TensorShape([None, None]), tf.TensorShape([])] + grads, _ = tf.while_loop(cond, body, [tf.zeros([0, num_feat], float_type), tf.constant(0)], shape_invariants=shape_invariants) return grads @@ -86,31 +87,22 @@ def _unwrap(self, p, c): self._unwrap(p2, c) def _compute_hessian(self, x, y): - mat = [] - for v1 in y: - temp = [] - for v2 in y: - # computing derivative twice, first w.r.t v2 and then w.r.t v1 - temp.append(tf.gradients(tf.gradients(x, v2)[0], v1)[0]) - temp = [tf.constant(0, dtype=float_type) if t is None else t for t in - temp] - temp = tf.stack(temp) - mat.append(temp) - mat = tf.squeeze(tf.stack(mat)) - return mat + l = tf.unstack(tf.gradients(x, y)[0]) + lll=[] + for ll in l: + lll.append(tf.gradients(ll, y)) + return tf.stack(lll, axis=1) def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) - c = [] - self._unwrap(self.wrapped, c) - C = tf.expand_dims(tf.stack(c, axis=0), 1) + + c = self._predict_f_AF_storage['free_vars'] + h = tf.hessians(self.build_likelihood() + self.build_prior(), c)[0] + L = tf.cholesky(-h) Dfmean = rowwise_gradients(fmean, c) Dfvar = rowwise_gradients(fvar, c) - h = -self._compute_hessian(self.build_likelihood() + self.build_prior(), c) - L = tf.cholesky(h) - tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py index 699195a..e4bdf9a 100644 --- a/doc/source/notebooks/testmgp.py +++ b/doc/source/notebooks/testmgp.py @@ -1,33 +1,33 @@ from GPflow.gpr import GPR import numpy as np from GPflow.kernels import RBF, White +from GPflow.priors import Gamma, LogNormal from GPflowOpt.models import MGP +from GPflow.transforms import Log1pe import matplotlib.pyplot as plt -x = np.random.randn(4, 1)*2 -y = np.sin(x) +np.random.seed(3) +x = np.random.rand(8, 1) * 8-4 +y = np.cos(x) +np.random.randn(8,1)*0.1 -m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1) + White(1))) -m.optimize() +m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1))) +m.kern.lengthscales.prior = Gamma(3, 1/3) +m.kern.variance.prior = Gamma(3, 1/3) +m.likelihood.variance.prior = LogNormal(0, 1) +m.optimize(display=True) print(m) print('Trained') -X = np.array(np.linspace(-3, 3, 100)[:, None]) -fm = [] -fv = [] -for xn in X: - fms, fvs = m.predict_f(xn.reshape(-1, 1)) - fm.append(fms) - fv.append(fvs) -fm = np.stack(fm, axis=0) -fv = np.stack(fv, axis=0) +X = np.array(np.linspace(-4, 4, 100)[:, None]) +fms, fvs = m.predict_f(X) +print(fms, fvs) print('Evaluated') plt.subplot(1, 2, 1) plt.scatter(x, y) -plt.plot(X.flatten(), fm.flatten()) -plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), +plt.plot(X.flatten(), fms.flatten()) +plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()), alpha=0.2) plt.title('MGP - GPR') plt.subplot(1, 2, 2) @@ -37,4 +37,4 @@ plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), alpha=0.2) plt.title('GPR') -plt.show() +plt.show() \ No newline at end of file From 43daf625eff846b016605a8ef8d3622f7eeda07a Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:43:39 +0100 Subject: [PATCH 34/54] Remove unnecessary functions --- GPflowOpt/models.py | 17 ----------------- 1 file changed, 17 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a1a4afd..74883cc 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -76,23 +76,6 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - def _unwrap(self, p, c): - """ - Unwrap all the parameters captured in the model - """ - if isinstance(p, Param): - c.append(p._tf_array) - elif isinstance(p, Parameterized): - for p2 in p.sorted_params: - self._unwrap(p2, c) - - def _compute_hessian(self, x, y): - l = tf.unstack(tf.gradients(x, y)[0]) - lll=[] - for ll in l: - lll.append(tf.gradients(ll, y)) - return tf.stack(lll, axis=1) - def build_predict(self, Xnew, full_cov=False): fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) From 4e69a7f1716466263b2f29d8a9e03ce82b23062f Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 23 Jul 2017 19:57:40 +0100 Subject: [PATCH 35/54] Can hanle predict_f and predict_y --- GPflowOpt/models.py | 43 +++++++++++++++++++++------------ doc/source/notebooks/testmgp.py | 2 +- 2 files changed, 28 insertions(+), 17 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 74883cc..a49a5e8 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -1,5 +1,5 @@ from GPflow.param import Parameterized, AutoFlow, Param -from GPflow.model import GPModel +from GPflow.model import Model, GPModel from GPflow.likelihoods import Gaussian import GPflow import tensorflow as tf @@ -31,7 +31,7 @@ def cond(_, row): return grads -class MGP(GPModel): +class MGP(Model): """ Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation Key reference: @@ -51,13 +51,7 @@ def __init__(self, obj): assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj - self.cov_chol = None - super(MGP, self).__init__(None, None, None, None, 1, name=obj.name + "_MGP") - del self.kern - del self.mean_function - del self.likelihood - del self.X - del self.Y + super(MGP, self).__init__(name=obj.name + "_MGP") def __getattr__(self, item): """ @@ -76,17 +70,34 @@ def __setattr__(self, key, value): super(MGP, self).__setattr__(key, value) - def build_predict(self, Xnew, full_cov=False): - fmean, fvar = self.wrapped.build_predict(Xnew=Xnew, full_cov=full_cov) - - c = self._predict_f_AF_storage['free_vars'] - h = tf.hessians(self.build_likelihood() + self.build_prior(), c)[0] + def build_predict(self, fmean, fvar, theta): + h = tf.hessians(self.build_likelihood() + self.build_prior(), theta)[0] L = tf.cholesky(-h) - Dfmean = rowwise_gradients(fmean, c) - Dfvar = rowwise_gradients(fvar, c) + Dfmean = rowwise_gradients(fmean, theta) + Dfvar = rowwise_gradients(fvar, theta) tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) + + @AutoFlow((float_type, [None, None])) + def predict_f(self, Xnew): + """ + Compute the mean and variance of the latent function(s) at the points + Xnew. + """ + theta = self._predict_f_AF_storage['free_vars'] + fmean, fvar = self.wrapped.build_predict(Xnew) + return self.build_predict(fmean, fvar, theta) + + @AutoFlow((float_type, [None, None])) + def predict_y(self, Xnew): + """ + Compute the mean and variance of held-out data at the points Xnew + """ + theta = self._predict_y_AF_storage['free_vars'] + pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) + fmean, fvar= self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) + return self.build_predict(fmean, fvar, theta) \ No newline at end of file diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py index e4bdf9a..09f682c 100644 --- a/doc/source/notebooks/testmgp.py +++ b/doc/source/notebooks/testmgp.py @@ -20,7 +20,7 @@ print('Trained') X = np.array(np.linspace(-4, 4, 100)[:, None]) -fms, fvs = m.predict_f(X) +fms, fvs = m.predict_y(X) print(fms, fvs) print('Evaluated') From 0b14297383b28ba583c42f07df515dc47461d77c Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:31:30 +0100 Subject: [PATCH 36/54] Can handle multi-output GP --- GPflowOpt/models.py | 25 +++++++++++++++---------- 1 file changed, 15 insertions(+), 10 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a49a5e8..d71e0e2 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -49,7 +49,6 @@ class MGP(Model): def __init__(self, obj): assert isinstance(obj, GPModel), "Class has to be a GP model" assert isinstance(obj.likelihood, Gaussian), "Likelihood has to be Gaussian" - assert obj.Y.shape[1] == 1, "Only one dimensional functions are allowed" self.wrapped = obj super(MGP, self).__init__(name=obj.name + "_MGP") @@ -74,13 +73,19 @@ def build_predict(self, fmean, fvar, theta): h = tf.hessians(self.build_likelihood() + self.build_prior(), theta)[0] L = tf.cholesky(-h) - Dfmean = rowwise_gradients(fmean, theta) - Dfvar = rowwise_gradients(fvar, theta) + N = tf.shape(fmean)[0] + D = tf.shape(fmean)[1] - tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) - tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) - return fmean, 4 / 3 * fvar + tf.expand_dims(tf.reduce_sum(tf.square(tmp1), axis=1), 1) \ - + 1 / 3 / (fvar + 1E-3) * tf.expand_dims(tf.reduce_sum(tf.square(tmp2), axis=1), 1) + fmeanf = tf.reshape(fmean, [N * D, 1]) # N*D x 1 + fvarf = tf.reshape(fvar, [N * D, 1]) # N*D x 1 + + Dfmean = rowwise_gradients(fmeanf, theta) # N*D x k + Dfvar = rowwise_gradients(fvarf, theta) # N*D x k + + tmp1 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfmean))) # N*D x k + tmp2 = tf.transpose(tf.matrix_triangular_solve(L, tf.transpose(Dfvar))) # N*D x k + return fmean, 4 / 3 * fvar + tf.reshape(tf.reduce_sum(tf.square(tmp1), axis=1), [N, D]) \ + + 1 / 3 / (fvar + 1E-3) * tf.reshape(tf.reduce_sum(tf.square(tmp2), axis=1), [N, D]) @AutoFlow((float_type, [None, None])) def predict_f(self, Xnew): @@ -89,7 +94,7 @@ def predict_f(self, Xnew): Xnew. """ theta = self._predict_f_AF_storage['free_vars'] - fmean, fvar = self.wrapped.build_predict(Xnew) + fmean, fvar = self.wrapped.build_predict(Xnew) return self.build_predict(fmean, fvar, theta) @AutoFlow((float_type, [None, None])) @@ -99,5 +104,5 @@ def predict_y(self, Xnew): """ theta = self._predict_y_AF_storage['free_vars'] pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) - fmean, fvar= self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) - return self.build_predict(fmean, fvar, theta) \ No newline at end of file + fmean, fvar = self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) + return self.build_predict(fmean, fvar, theta) From c85fc6e74bd6cf9b25089531e73451761b1622d9 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:44:59 +0100 Subject: [PATCH 37/54] Add predict_density --- GPflowOpt/models.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index d71e0e2..186f664 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -106,3 +106,17 @@ def predict_y(self, Xnew): pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) fmean, fvar = self.wrapped.likelihood.predict_mean_and_var(pred_f_mean, pred_f_var) return self.build_predict(fmean, fvar, theta) + + @AutoFlow((float_type, [None, None]), (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. + """ + theta = self._predict_f_AF_storage['free_vars'] + pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) + pred_f_mean, pred_f_var = self.build_predict(pred_f_mean, pred_f_var, theta) + return self.likelihood.predict_density(pred_f_mean, pred_f_var, Ynew) From 96c63070e179436f932b476085f623affebe6705 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:45:26 +0100 Subject: [PATCH 38/54] Models tests --- testing/test_models.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/testing/test_models.py b/testing/test_models.py index 9635cd7..7b041e3 100644 --- a/testing/test_models.py +++ b/testing/test_models.py @@ -49,3 +49,9 @@ def test_predict_scaling(self): self.assertTrue(np.shape(fr) == np.shape(fs)) self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + + fr, vr = m.predict_f_full_cov(Xt) + fs, vs = n.predict_f_full_cov(Xt) + self.assertTrue(np.shape(fr) == np.shape(fs)) + self.assertTrue(np.shape(vr) == np.shape(vs)) + self.assertTrue(np.allclose(fr, fs, atol=1e-3)) From 01a67d1e273d66d38a6a0b4fd88bb75170d30638 Mon Sep 17 00:00:00 2001 From: nknudde Date: Sun, 6 Aug 2017 19:47:25 +0100 Subject: [PATCH 39/54] Models tests --- testing/test_models.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/testing/test_models.py b/testing/test_models.py index 7b041e3..9635cd7 100644 --- a/testing/test_models.py +++ b/testing/test_models.py @@ -49,9 +49,3 @@ def test_predict_scaling(self): self.assertTrue(np.shape(fr) == np.shape(fs)) self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) - - fr, vr = m.predict_f_full_cov(Xt) - fs, vs = n.predict_f_full_cov(Xt) - self.assertTrue(np.shape(fr) == np.shape(fs)) - self.assertTrue(np.shape(vr) == np.shape(vs)) - self.assertTrue(np.allclose(fr, fs, atol=1e-3)) From cd6e969754a2ccbc9d1930711a8a6e6cd1851882 Mon Sep 17 00:00:00 2001 From: nknudde Date: Mon, 7 Aug 2017 21:53:52 +0100 Subject: [PATCH 40/54] Add objective to __init__ --- GPflowOpt/__init__.py | 1 + 1 file changed, 1 insertion(+) diff --git a/GPflowOpt/__init__.py b/GPflowOpt/__init__.py index e8a294c..252f8ba 100644 --- a/GPflowOpt/__init__.py +++ b/GPflowOpt/__init__.py @@ -19,4 +19,5 @@ from . import design from . import transforms from . import scaling +from . import objective from . import models \ No newline at end of file From 34ca364ec5fd0eaf11dd9bdbd275f1826f14fb11 Mon Sep 17 00:00:00 2001 From: Nicolas Knudde Date: Mon, 7 Aug 2017 21:55:20 +0100 Subject: [PATCH 41/54] Delete testmgp.py --- doc/source/notebooks/testmgp.py | 40 --------------------------------- 1 file changed, 40 deletions(-) delete mode 100644 doc/source/notebooks/testmgp.py diff --git a/doc/source/notebooks/testmgp.py b/doc/source/notebooks/testmgp.py deleted file mode 100644 index 09f682c..0000000 --- a/doc/source/notebooks/testmgp.py +++ /dev/null @@ -1,40 +0,0 @@ -from GPflow.gpr import GPR -import numpy as np -from GPflow.kernels import RBF, White -from GPflow.priors import Gamma, LogNormal -from GPflowOpt.models import MGP -from GPflow.transforms import Log1pe -import matplotlib.pyplot as plt - - -np.random.seed(3) -x = np.random.rand(8, 1) * 8-4 -y = np.cos(x) +np.random.randn(8,1)*0.1 - -m = MGP(GPR(x, y, RBF(1, lengthscales=1, variance=1))) -m.kern.lengthscales.prior = Gamma(3, 1/3) -m.kern.variance.prior = Gamma(3, 1/3) -m.likelihood.variance.prior = LogNormal(0, 1) -m.optimize(display=True) -print(m) -print('Trained') - -X = np.array(np.linspace(-4, 4, 100)[:, None]) -fms, fvs = m.predict_y(X) -print(fms, fvs) -print('Evaluated') - -plt.subplot(1, 2, 1) -plt.scatter(x, y) -plt.plot(X.flatten(), fms.flatten()) -plt.fill_between(X.flatten(), fms.flatten() - 2 * np.sqrt(fvs.flatten()), fms.flatten() + 2 * np.sqrt(fvs.flatten()), - alpha=0.2) -plt.title('MGP - GPR') -plt.subplot(1, 2, 2) -plt.scatter(x, y) -fm, fv = m.wrapped.predict_f(X) -plt.plot(X.flatten(), fm.flatten()) -plt.fill_between(X.flatten(), fm.flatten() - 2 * np.sqrt(fv.flatten()), fm.flatten() + 2 * np.sqrt(fv.flatten()), - alpha=0.2) -plt.title('GPR') -plt.show() \ No newline at end of file From 19a69370d08e9f2df97ac25cc13ba8ee0440b4e2 Mon Sep 17 00:00:00 2001 From: Nicolas Knudde Date: Mon, 7 Aug 2017 22:08:04 +0100 Subject: [PATCH 42/54] Update .travis.yml --- .travis.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index b3ebd70..1f29369 100644 --- a/.travis.yml +++ b/.travis.yml @@ -8,7 +8,7 @@ python: cache: pip install: - pip install -U pip wheel - - pip install tensorflow==1.0.1 + - pip install tensorflow==1.3.0rc0 - pip install --process-dependency-links . - pip install .[test] - pip install codecov From 94e1028a70b6cd91cb3ec1e9eb37dd016c4034f8 Mon Sep 17 00:00:00 2001 From: Nicolas Knudde Date: Tue, 8 Aug 2017 20:34:13 +0100 Subject: [PATCH 43/54] Update test_models.py --- testing/test_models.py | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/testing/test_models.py b/testing/test_models.py index 9635cd7..a3a7737 100644 --- a/testing/test_models.py +++ b/testing/test_models.py @@ -49,3 +49,8 @@ def test_predict_scaling(self): self.assertTrue(np.shape(fr) == np.shape(fs)) self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + + Yt = parabola2d(Xt) #+ np.random.rand(20, 1) * 0.05 + fr = m.predict_density(Xt, Yt) + fs = n.predict_density(Xt, Yt) + self.assertTrue(np.shape(fr) == np.shape(fs)) From 982a9577e595b8f50fc22790590915ef33b4fe6a Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Wed, 9 Aug 2017 02:45:53 +0200 Subject: [PATCH 44/54] Refactoring DataScaler to parameterized --- GPflowOpt/scaling.py | 61 ++++++++++++++------------------------ testing/test_datascaler.py | 8 ++--- 2 files changed, 27 insertions(+), 42 deletions(-) diff --git a/GPflowOpt/scaling.py b/GPflowOpt/scaling.py index baa4f08..bc2d451 100644 --- a/GPflowOpt/scaling.py +++ b/GPflowOpt/scaling.py @@ -12,17 +12,18 @@ # See the License for the specific language governing permissions and # limitations under the License. -from GPflow.param import DataHolder, AutoFlow, Parameterized -from GPflow.model import Model, GPModel +from GPflow.param import DataHolder, AutoFlow +from GPflow.model import GPModel from GPflow import settings import numpy as np from .transforms import LinearTransform, DataTransform from .domain import UnitCube +from .models import ModelWrapper float_type = settings.dtypes.float_type -class DataScaler(GPModel): +class DataScaler(ModelWrapper): """ Model-wrapping class, primarily intended to assure the data in GPflow models is scaled. One DataScaler wraps one GPflow model, and can scale the input as well as the output data. By default, if any kind of object attribute @@ -59,13 +60,9 @@ def __init__(self, model, domain=None, normalize_Y=False): :param normalize_Y: (default: False) enable automatic scaling of output values to zero mean and unit variance. """ - # model sanity checks - assert (model is not None) + # model sanity checks, slightly stronger conditions than the wrapper assert (isinstance(model, GPModel)) - self._parent = None - - # Wrap model - self.wrapped = model + super(DataScaler, self).__init__(model) # Initial configuration of the datascaler n_inputs = model.X.shape[1] @@ -74,34 +71,8 @@ def __init__(self, model, domain=None, normalize_Y=False): self._normalize_Y = normalize_Y self._output_transform = LinearTransform(np.ones(n_outputs), np.zeros(n_outputs)) - # The assignments in the constructor of GPModel take care of initial re-scaling of model data. - super(DataScaler, self).__init__(model.X.value, model.Y.value, None, None, 1, name=model.name+"_datascaler") - del self.kern - del self.mean_function - del self.likelihood - - def __getattr__(self, item): - """ - If an attribute is not found in this class, it is searched in the wrapped model - """ - return self.wrapped.__getattribute__(item) - - def __setattr__(self, key, value): - """ - If setting :attr:`wrapped` attribute, point parent to this object (the datascaler) - """ - if key is 'wrapped': - object.__setattr__(self, key, value) - value.__setattr__('_parent', self) - return - - super(DataScaler, self).__setattr__(key, value) - - def __eq__(self, other): - return self.wrapped == other - - def __str__(self, prepend=''): - return self.wrapped.__str__(prepend) + self.X = model.X.value + self.Y = model.Y.value @property def input_transform(self): @@ -216,6 +187,20 @@ def build_predict(self, Xnew, full_cov=False): f, var = self.wrapped.build_predict(self.input_transform.build_forward(Xnew), full_cov=full_cov) return self.output_transform.build_backward(f), self.output_transform.build_backward_variance(var) + @AutoFlow((float_type, [None, None])) + def predict_f(self, Xnew): + """ + Compute the mean and variance of held-out data at the points Xnew + """ + return self.build_predict(Xnew) + + @AutoFlow((float_type, [None, None])) + def predict_f_full_cov(self, Xnew): + """ + Compute the mean and variance of held-out data at the points Xnew + """ + return self.build_predict(Xnew, full_cov=True) + @AutoFlow((float_type, [None, None])) def predict_y(self, Xnew): """ @@ -230,6 +215,6 @@ def predict_density(self, Xnew, Ynew): """ Compute the (log) density of the data Ynew at the points Xnew """ - mu, var = self.build_predict(Xnew) + mu, var = self.wrapped.build_predict(self.input_transform.build_forward(Xnew)) Ys = self.output_transform.build_forward(Ynew) return self.likelihood.predict_density(mu, var, Ys) diff --git a/testing/test_datascaler.py b/testing/test_datascaler.py index 0abe6fd..13c9b41 100644 --- a/testing/test_datascaler.py +++ b/testing/test_datascaler.py @@ -80,7 +80,7 @@ def test_enabling_transforms(self): def test_predict_scaling(self): m = self.create_parabola_model() - n = DataScaler(self.create_parabola_model(), self.domain) + n = DataScaler(self.create_parabola_model(), self.domain, normalize_Y=True) m.optimize() n.optimize() @@ -103,6 +103,6 @@ def test_predict_scaling(self): Yt = parabola2d(Xt) #+ np.random.rand(20, 1) * 0.05 fr = m.predict_density(Xt, Yt) fs = n.predict_density(Xt, Yt) - print(fr) - print(fs) - np.testing.assert_allclose(fr, fs, rtol=1e-3) + #print(fr) + #print(fs) + np.testing.assert_allclose(fr, fs, rtol=1e-2) From 2cc18555345783666e6e22d03ffa80c68e643f85 Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Wed, 9 Aug 2017 07:14:39 +0200 Subject: [PATCH 45/54] Bugfix in modelwrapper, make sure compile flag is set correctly --- GPflowOpt/models.py | 64 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+) create mode 100644 GPflowOpt/models.py diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py new file mode 100644 index 0000000..9e95d8a --- /dev/null +++ b/GPflowOpt/models.py @@ -0,0 +1,64 @@ +# Copyright 2017 Joachim van der Herten +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +from GPflow.param import Parameterized +from GPflow.model import Model + + +class ModelWrapper(Parameterized): + """ + Modelwrapper class + """ + def __init__(self, model): + """ + :param model: model to be wrapped + """ + super(ModelWrapper, self).__init__() + + # Wrap model + assert (isinstance(model, Model)) + self.wrapped = model + + def __getattr__(self, item): + """ + If an attribute is not found in this class, it is searched in the wrapped model + """ + + # Exception for AF storages, if a method with the same name exists in this class, do not find the cache + # in the wrapped model. + if item.endswith('_AF_storage'): + method = item[1:].rstrip('_AF_storage') + if method in dir(self): + raise AttributeError("{0} has no attribute {1}".format(self.__class__.__name__, item)) + + return getattr(self.wrapped, item) + + def __setattr__(self, key, value): + """ + If setting :attr:`wrapped` attribute, point parent to this object (the datascaler) + """ + if key is 'wrapped': + object.__setattr__(self, key, value) + value.__setattr__('_parent', self) + return + + if key is '_needs_recompile': + setattr(self.wrapped, key, value) + + super(ModelWrapper, self).__setattr__(key, value) + + def __eq__(self, other): + return self.wrapped == other + + def __str__(self, prepend=''): + return self.wrapped.__str__(prepend) From 948965d0a0da7a7814cb7b57433df32665fd0b0e Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Wed, 9 Aug 2017 08:12:04 +0200 Subject: [PATCH 46/54] Adding tests for the wrapping super class --- GPflowOpt/__init__.py | 1 + GPflowOpt/models.py | 1 + testing/test_datascaler.py | 6 +----- 3 files changed, 3 insertions(+), 5 deletions(-) diff --git a/GPflowOpt/__init__.py b/GPflowOpt/__init__.py index 89b71d8..e83d54b 100644 --- a/GPflowOpt/__init__.py +++ b/GPflowOpt/__init__.py @@ -21,3 +21,4 @@ from . import scaling from . import objective from . import pareto +from . import models diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 9e95d8a..78c3424 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -54,6 +54,7 @@ def __setattr__(self, key, value): if key is '_needs_recompile': setattr(self.wrapped, key, value) + return super(ModelWrapper, self).__setattr__(key, value) diff --git a/testing/test_datascaler.py b/testing/test_datascaler.py index 13c9b41..cd4a4ed 100644 --- a/testing/test_datascaler.py +++ b/testing/test_datascaler.py @@ -26,8 +26,6 @@ def test_object_integrity(self): Xs, Ys = m.X.value, m.Y.value n = DataScaler(m, self.domain) - self.assertEqual(n.wrapped, m) - self.assertEqual(m._parent, n) self.assertTrue(np.allclose(Xs, n.X.value)) self.assertTrue(np.allclose(Ys, n.Y.value)) @@ -100,9 +98,7 @@ def test_predict_scaling(self): self.assertTrue(np.allclose(fr, fs, atol=1e-3)) self.assertTrue(np.allclose(vr, vs, atol=1e-3)) - Yt = parabola2d(Xt) #+ np.random.rand(20, 1) * 0.05 + Yt = parabola2d(Xt) fr = m.predict_density(Xt, Yt) fs = n.predict_density(Xt, Yt) - #print(fr) - #print(fs) np.testing.assert_allclose(fr, fs, rtol=1e-2) From 44720791e15d7f5871a0108602d79100f2ac8446 Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Wed, 9 Aug 2017 08:12:34 +0200 Subject: [PATCH 47/54] Forgot adding the file --- testing/test_modelwrapper.py | 71 ++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 testing/test_modelwrapper.py diff --git a/testing/test_modelwrapper.py b/testing/test_modelwrapper.py new file mode 100644 index 0000000..eccbb25 --- /dev/null +++ b/testing/test_modelwrapper.py @@ -0,0 +1,71 @@ +import GPflowOpt +import unittest +import GPflow +import numpy as np + +float_type = GPflow.settings.dtypes.float_type + + +class MethodOverride(GPflowOpt.models.ModelWrapper): + + def __init__(self, m): + super(MethodOverride, self).__init__(m) + self.A = GPflow.param.DataHolder(np.array([1.0])) + + @GPflow.param.AutoFlow((float_type, [None, None])) + def predict_f(self, Xnew): + """ + Compute the mean and variance of held-out data at the points Xnew + """ + m, v = self.build_predict(Xnew) + return self.A * m, v + + +class TestModelWrapper(unittest.TestCase): + + def simple_model(self): + x = np.random.rand(10,2) * 2 * np.pi + y = np.sin(x[:,[0]]) + m = GPflow.gpr.GPR(x,y, kern=GPflow.kernels.RBF(1)) + return m + + def test_object_integrity(self): + m = self.simple_model() + w = GPflowOpt.models.ModelWrapper(m) + self.assertEqual(w.wrapped, m) + self.assertEqual(m._parent, w) + self.assertEqual(w.optimize, m.optimize) + + def test_optimize(self): + m = self.simple_model() + w = GPflowOpt.models.ModelWrapper(m) + logL = m.compute_log_likelihood() + self.assertTrue(np.allclose(logL, w.compute_log_likelihood())) + + # Check if compiled & optimized, verify attributes are set in the right object. + w.optimize(maxiter=5) + self.assertTrue(hasattr(m, '_minusF')) + self.assertFalse('_minusF' in w.__dict__) + self.assertGreater(m.compute_log_likelihood(), logL) + + def test_af_storage_detection(self): + # Regression test for a bug with predict_f/predict_y... etc. + m = self.simple_model() + x = np.random.rand(10,2) + m.predict_f(x) + self.assertTrue(hasattr(m, '_predict_f_AF_storage')) + w = MethodOverride(m) + self.assertFalse(hasattr(w, '_predict_f_AF_storage')) + w.predict_f(x) + self.assertTrue(hasattr(w, '_predict_f_AF_storage')) + + def test_set_recompile(self): + # Regression test for setting recompile in the wrong object + m = self.simple_model() + w = GPflowOpt.models.ModelWrapper(m) + w._needs_recompile = False + self.assertFalse('_needs_recompile' in w.__dict__) + self.assertTrue('_needs_recompile' in m.__dict__) + self.assertFalse(w._needs_recompile) + self.assertFalse(m._needs_recompile) + From b4c3615b7f203a920ed5c91d53a401026d24e1a4 Mon Sep 17 00:00:00 2001 From: nknudde Date: Wed, 9 Aug 2017 20:42:19 +0100 Subject: [PATCH 48/54] Bugfix --- GPflowOpt/models.py | 2 +- testing/test_models.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 186f664..dd49be1 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -116,7 +116,7 @@ def predict_density(self, Xnew, Ynew): ignoring correlations between them. The result is a matrix the same shape as Ynew containing the log densities. """ - theta = self._predict_f_AF_storage['free_vars'] + theta = self._predict_density_AF_storage['free_vars'] pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) pred_f_mean, pred_f_var = self.build_predict(pred_f_mean, pred_f_var, theta) return self.likelihood.predict_density(pred_f_mean, pred_f_var, Ynew) diff --git a/testing/test_models.py b/testing/test_models.py index a3a7737..333e3f3 100644 --- a/testing/test_models.py +++ b/testing/test_models.py @@ -31,7 +31,7 @@ def test_object_integrity(self): self.assertTrue(np.allclose(Xs, n.X.value)) self.assertTrue(np.allclose(Ys, n.Y.value)) - def test_predict_scaling(self): + def test_predict(self): m = self.create_parabola_model() n = MGP(self.create_parabola_model()) m.optimize() @@ -50,7 +50,7 @@ def test_predict_scaling(self): self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) - Yt = parabola2d(Xt) #+ np.random.rand(20, 1) * 0.05 + Yt = parabola2d(Xt) fr = m.predict_density(Xt, Yt) fs = n.predict_density(Xt, Yt) self.assertTrue(np.shape(fr) == np.shape(fs)) From f8bc92fa2eecb3da82297c1eaaeb442751c1cacb Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Thu, 10 Aug 2017 01:44:36 +0200 Subject: [PATCH 49/54] Moving rowwise_gradients to tf_wraps --- GPflowOpt/models.py | 27 ++-------------- GPflowOpt/tf_wraps.py | 42 +++++++++++++++++++++++++ testing/{test_models.py => test_mgp.py} | 0 3 files changed, 44 insertions(+), 25 deletions(-) create mode 100644 GPflowOpt/tf_wraps.py rename testing/{test_models.py => test_mgp.py} (100%) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index a683b65..63db9fb 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -11,8 +11,9 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. +from .tf_wraps import rowwise_gradients -from GPflow.param import Parameterized, AutoFlow, Param +from GPflow.param import Parameterized, AutoFlow from GPflow.model import Model, GPModel from GPflow.likelihoods import Gaussian from GPflow import settings @@ -72,30 +73,6 @@ def __str__(self, prepend=''): return self.wrapped.__str__(prepend) -def rowwise_gradients(Y, X): - """ - For a 2D Tensor Y, compute the derivative of each columns w.r.t a 2D tensor X. - - This is done with while_loop, because of a known incompatibility between map_fn and gradients. - """ - num_rows = tf.shape(Y)[0] - num_feat = tf.shape(X)[0] - - def body(old_grads, row): - g = tf.expand_dims(tf.gradients(Y[row], X)[0], axis=0) - new_grads = tf.concat([old_grads, g], axis=0) - return new_grads, row + 1 - - def cond(_, row): - return tf.less(row, num_rows) - - shape_invariants = [tf.TensorShape([None, None]), tf.TensorShape([])] - grads, _ = tf.while_loop(cond, body, [tf.zeros([0, num_feat], float_type), tf.constant(0)], - shape_invariants=shape_invariants) - - return grads - - class MGP(ModelWrapper): """ Marginalisation of the hyperparameters during evaluation time using a Laplace Approximation diff --git a/GPflowOpt/tf_wraps.py b/GPflowOpt/tf_wraps.py new file mode 100644 index 0000000..860dc8c --- /dev/null +++ b/GPflowOpt/tf_wraps.py @@ -0,0 +1,42 @@ +# Copyright 2017 Joachim van der Herten, Nicolas Knudde +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import tensorflow as tf +from GPflow import settings + +float_type = settings.dtypes.float_type + + +def rowwise_gradients(Y, X): + """ + For a 2D Tensor Y, compute the derivative of each columns w.r.t a 2D tensor X. + + This is done with while_loop, because of a known incompatibility between map_fn and gradients. + """ + num_rows = tf.shape(Y)[0] + num_feat = tf.shape(X)[0] + + def body(old_grads, row): + g = tf.expand_dims(tf.gradients(Y[row], X)[0], axis=0) + new_grads = tf.concat([old_grads, g], axis=0) + return new_grads, row + 1 + + def cond(_, row): + return tf.less(row, num_rows) + + shape_invariants = [tf.TensorShape([None, None]), tf.TensorShape([])] + grads, _ = tf.while_loop(cond, body, [tf.zeros([0, num_feat], float_type), tf.constant(0)], + shape_invariants=shape_invariants) + + return grads \ No newline at end of file diff --git a/testing/test_models.py b/testing/test_mgp.py similarity index 100% rename from testing/test_models.py rename to testing/test_mgp.py From 79c7761e786cd4f5b7c8a5b9f0d5ecbe6995cacb Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Thu, 10 Aug 2017 03:08:50 +0200 Subject: [PATCH 50/54] Added test directives to verify variance of MGP --- GPflowOpt/models.py | 1 - testing/test_mgp.py | 2 ++ 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 63db9fb..5fad9fb 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -144,4 +144,3 @@ def predict_density(self, Xnew, Ynew): pred_f_mean, pred_f_var = self.wrapped.build_predict(Xnew) pred_f_mean, pred_f_var = self.build_predict(pred_f_mean, pred_f_var, theta) return self.likelihood.predict_density(pred_f_mean, pred_f_var, Ynew) - diff --git a/testing/test_mgp.py b/testing/test_mgp.py index 333e3f3..b21b9b5 100644 --- a/testing/test_mgp.py +++ b/testing/test_mgp.py @@ -43,12 +43,14 @@ def test_predict(self): self.assertTrue(np.shape(fr) == np.shape(fs)) self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + self.assertTrue(np.all(vs >= vr)) fr, vr = m.predict_y(Xt) fs, vs = n.predict_y(Xt) self.assertTrue(np.shape(fr) == np.shape(fs)) self.assertTrue(np.shape(vr) == np.shape(vs)) self.assertTrue(np.allclose(fr, fs, atol=1e-3)) + self.assertTrue(np.all(vs >= vr)) Yt = parabola2d(Xt) fr = m.predict_density(Xt, Yt) From 8e7d9b3f8ee60e013f5178b2a14f06ec8ec487b0 Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Thu, 10 Aug 2017 03:25:42 +0200 Subject: [PATCH 51/54] Enable wrapping of modelwrappers --- GPflowOpt/models.py | 2 +- testing/test_modelwrapper.py | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index 78c3424..aa2abac 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -26,7 +26,7 @@ def __init__(self, model): super(ModelWrapper, self).__init__() # Wrap model - assert (isinstance(model, Model)) + assert isinstance(model, (Model, ModelWrapper)) self.wrapped = model def __getattr__(self, item): diff --git a/testing/test_modelwrapper.py b/testing/test_modelwrapper.py index eccbb25..3b02296 100644 --- a/testing/test_modelwrapper.py +++ b/testing/test_modelwrapper.py @@ -69,3 +69,14 @@ def test_set_recompile(self): self.assertFalse(w._needs_recompile) self.assertFalse(m._needs_recompile) + def test_double_wrap(self): + m = self.simple_model() + n = GPflowOpt.models.ModelWrapper(MethodOverride(m)) + n.optimize(maxiter=10) + Xt = np.random.rand(10,2) + n.predict_f(Xt) + self.assertFalse('_predict_f_AF_storage' in n.__dict__) + self.assertTrue('_predict_f_AF_storage' in n.wrapped.__dict__) + self.assertFalse('_predict_f_AF_storage' in n.wrapped.wrapped.__dict__) + + From e423653e657e432280d9383edd57e20fb510b2a4 Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Thu, 10 Aug 2017 03:44:35 +0200 Subject: [PATCH 52/54] Documentation --- GPflowOpt/models.py | 14 ++++++++++---- doc/source/interfaces.rst | 8 ++++++++ 2 files changed, 18 insertions(+), 4 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index aa2abac..e5c845c 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -17,7 +17,13 @@ class ModelWrapper(Parameterized): """ - Modelwrapper class + Class for fast implementation of a wrapper for models defined in GPflow. Once wrapped, all lookups for attributes + which are not found in the wrapper class are automatically forwarded to the wrapped model. + + To influence the I/O of methods on the wrapped class, simply implement the method in the wrapper and call the + appropriate methods on the wrapped class. Specific logic is included to make sure that if AutoFlow methods are + influenced following this pattern, the original AF storage (if existing) is unaffected and a new storage is added + to the subclass. """ def __init__(self, model): """ @@ -25,15 +31,14 @@ def __init__(self, model): """ super(ModelWrapper, self).__init__() - # Wrap model assert isinstance(model, (Model, ModelWrapper)) + #: Wrapped model self.wrapped = model def __getattr__(self, item): """ If an attribute is not found in this class, it is searched in the wrapped model """ - # Exception for AF storages, if a method with the same name exists in this class, do not find the cache # in the wrapped model. if item.endswith('_AF_storage'): @@ -45,7 +50,8 @@ def __getattr__(self, item): def __setattr__(self, key, value): """ - If setting :attr:`wrapped` attribute, point parent to this object (the datascaler) + 1) If setting :attr:`wrapped` attribute, point parent to this object (the datascaler). + 2) If setting the recompilation attribute, always do this on the wrapped class. """ if key is 'wrapped': object.__setattr__(self, key, value) diff --git a/doc/source/interfaces.rst b/doc/source/interfaces.rst index 6756e40..86b0b0f 100644 --- a/doc/source/interfaces.rst +++ b/doc/source/interfaces.rst @@ -36,3 +36,11 @@ Transform :special-members: .. autoclass:: GPflowOpt.transforms.DataTransform :special-members: + +ModelWrapper +------------ +.. automodule:: GPflowOpt.models + :special-members: +.. autoclass:: GPflowOpt.models.ModelWrapper + :members: + :special-members: From 2bf2c4451396b41d9116ba93c33598cfa0f62e80 Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Sun, 13 Aug 2017 17:14:47 +0200 Subject: [PATCH 53/54] Solving asserts, and allow modelwrappers as input in acquisition --- GPflowOpt/acquisition/acquisition.py | 6 +++++- GPflowOpt/acquisition/ei.py | 1 - GPflowOpt/scaling.py | 1 - 3 files changed, 5 insertions(+), 3 deletions(-) diff --git a/GPflowOpt/acquisition/acquisition.py b/GPflowOpt/acquisition/acquisition.py index 907ef8a..aa48e7f 100644 --- a/GPflowOpt/acquisition/acquisition.py +++ b/GPflowOpt/acquisition/acquisition.py @@ -14,8 +14,10 @@ from ..scaling import DataScaler from ..domain import UnitCube +from ..models import ModelWrapper from GPflow.param import Parameterized, AutoFlow, ParamList +from GPflow.model import Model from GPflow import settings import numpy as np @@ -48,7 +50,9 @@ def __init__(self, models=[], optimize_restarts=5): :param optimize_restarts: number of optimization restarts to use when training the models """ super(Acquisition, self).__init__() - self._models = ParamList([DataScaler(m) for m in np.atleast_1d(models).tolist()]) + models = np.atleast_1d(models) + assert all(isinstance(model, (Model, ModelWrapper))for model in models) + self._models = ParamList([DataScaler(m) for m in models]) self._default_params = list(map(lambda m: m.get_free_state(), self._models)) assert (optimize_restarts >= 0) diff --git a/GPflowOpt/acquisition/ei.py b/GPflowOpt/acquisition/ei.py index 90507cb..2c9ce87 100644 --- a/GPflowOpt/acquisition/ei.py +++ b/GPflowOpt/acquisition/ei.py @@ -57,7 +57,6 @@ def __init__(self, model): :param model: GPflow model (single output) representing our belief of the objective """ super(ExpectedImprovement, self).__init__(model) - assert (isinstance(model, Model)) self.fmin = DataHolder(np.zeros(1)) self.setup() diff --git a/GPflowOpt/scaling.py b/GPflowOpt/scaling.py index bc2d451..141cb57 100644 --- a/GPflowOpt/scaling.py +++ b/GPflowOpt/scaling.py @@ -61,7 +61,6 @@ def __init__(self, model, domain=None, normalize_Y=False): variance. """ # model sanity checks, slightly stronger conditions than the wrapper - assert (isinstance(model, GPModel)) super(DataScaler, self).__init__(model) # Initial configuration of the datascaler From 0301ffaa163f037bf999ea93522ba9d054e0f0c9 Mon Sep 17 00:00:00 2001 From: Joachim van der Herten Date: Sun, 13 Aug 2017 21:55:50 +0200 Subject: [PATCH 54/54] Improving setattr in modelwrapper to cope with some inconsistensies due to multiple wrap operations --- GPflowOpt/models.py | 25 +++++++++++++++++++----- testing/test_modelwrapper.py | 38 +++++++++++++++++++++++++++++++++--- 2 files changed, 55 insertions(+), 8 deletions(-) diff --git a/GPflowOpt/models.py b/GPflowOpt/models.py index e5c845c..bd46ecb 100644 --- a/GPflowOpt/models.py +++ b/GPflowOpt/models.py @@ -45,7 +45,6 @@ def __getattr__(self, item): method = item[1:].rstrip('_AF_storage') if method in dir(self): raise AttributeError("{0} has no attribute {1}".format(self.__class__.__name__, item)) - return getattr(self.wrapped, item) def __setattr__(self, key, value): @@ -58,11 +57,27 @@ def __setattr__(self, key, value): value.__setattr__('_parent', self) return - if key is '_needs_recompile': - setattr(self.wrapped, key, value) - return + try: + # If attribute is in this object, set it. Test by using getattribute instead of hasattr to avoid lookup in + # wrapped object. + self.__getattribute__(key) + super(ModelWrapper, self).__setattr__(key, value) + except AttributeError: + # Attribute is not in wrapper. + # In case no wrapped object is set yet (e.g. constructor), set in wrapper. + if 'wrapped' not in self.__dict__: + super(ModelWrapper, self).__setattr__(key, value) + return - super(ModelWrapper, self).__setattr__(key, value) + if hasattr(self, key): + # Now use hasattr, we know getattribute already failed so if it returns true, it must be in the wrapped + # object. Hasattr is called on self instead of self.wrapped to account for the different handling of + # AF storages. + # Prefer setting the attribute in the wrapped object if exists. + setattr(self.wrapped, key, value) + else: + # If not, set in wrapper nonetheless. + super(ModelWrapper, self).__setattr__(key, value) def __eq__(self, other): return self.wrapped == other diff --git a/testing/test_modelwrapper.py b/testing/test_modelwrapper.py index 3b02296..aa2cfa1 100644 --- a/testing/test_modelwrapper.py +++ b/testing/test_modelwrapper.py @@ -20,6 +20,22 @@ def predict_f(self, Xnew): m, v = self.build_predict(Xnew) return self.A * m, v + @property + def X(self): + return self.wrapped.X + + @X.setter + def X(self, Xc): + self.wrapped.X = Xc + + @property + def foo(self): + return 1 + + @foo.setter + def foo(self, val): + self.wrapped.foo = val + class TestModelWrapper(unittest.TestCase): @@ -59,8 +75,8 @@ def test_af_storage_detection(self): w.predict_f(x) self.assertTrue(hasattr(w, '_predict_f_AF_storage')) - def test_set_recompile(self): - # Regression test for setting recompile in the wrong object + def test_set_wrapped_attributes(self): + # Regression test for setting certain keys in the right object m = self.simple_model() w = GPflowOpt.models.ModelWrapper(m) w._needs_recompile = False @@ -73,10 +89,26 @@ def test_double_wrap(self): m = self.simple_model() n = GPflowOpt.models.ModelWrapper(MethodOverride(m)) n.optimize(maxiter=10) - Xt = np.random.rand(10,2) + Xt = np.random.rand(10, 2) n.predict_f(Xt) self.assertFalse('_predict_f_AF_storage' in n.__dict__) self.assertTrue('_predict_f_AF_storage' in n.wrapped.__dict__) self.assertFalse('_predict_f_AF_storage' in n.wrapped.wrapped.__dict__) + n = MethodOverride(GPflowOpt.models.ModelWrapper(m)) + Xn = np.random.rand(10, 2) + Yn = np.random.rand(10, 1) + n.X = Xn + n.Y = Yn + self.assertTrue(np.allclose(Xn, n.wrapped.wrapped.X.value)) + self.assertTrue(np.allclose(Yn, n.wrapped.wrapped.Y.value)) + self.assertFalse('Y' in n.wrapped.__dict__) + self.assertFalse('X' in n.wrapped.__dict__) + + n.foo = 5 + self.assertTrue('foo' in n.wrapped.__dict__) + self.assertFalse('foo' in n.wrapped.wrapped.__dict__) + + +