From 432525f16a31887bd7f2d01108496e7169cebbeb Mon Sep 17 00:00:00 2001 From: bwengals Date: Sat, 8 Jan 2022 20:08:21 -0800 Subject: [PATCH 1/5] cp over hsgp class --- pymc_experimental/gp/__init__.py | 1 + pymc_experimental/gp/hsgp.py | 104 +++++++++++++++++++++++++++++++ 2 files changed, 105 insertions(+) create mode 100644 pymc_experimental/gp/hsgp.py diff --git a/pymc_experimental/gp/__init__.py b/pymc_experimental/gp/__init__.py index e69de29bb..a077addb0 100644 --- a/pymc_experimental/gp/__init__.py +++ b/pymc_experimental/gp/__init__.py @@ -0,0 +1 @@ +from hsgp import HSGP diff --git a/pymc_experimental/gp/hsgp.py b/pymc_experimental/gp/hsgp.py new file mode 100644 index 000000000..659704875 --- /dev/null +++ b/pymc_experimental/gp/hsgp.py @@ -0,0 +1,104 @@ +import pymc as pm +import aesara.tensor as at + + +class HSGP(Latent): + ## inputs, M, c + + def __init__(self, M, c=3/2, *, mean_func=pm.gp.mean.Zero(), cov_func=pm.gp.cov.Constant(0.0)): + ## TODO: specify either c or L + self.M = M + self.c = c + super().__init__(mean_func=mean_func, cov_func=cov_func) + + def _validate_cov_func(self, cov_func): + ## TODO: actually validate it + cov, scaling_factor = cov_func.factor_list + return scaling_factor, cov.ls, cov.spectral_density + + def prior(self, name, X, **kwargs): + f, Phi, L, spd, beta, Xmu, Xsd = self._build_prior(name, X, **kwargs) + self.X, self.f = X, f + self.Phi, self.L, self.spd, self.beta = Phi, L, spd, beta + self.Xmu, self.Xsd = Xmu, Xsd + return f + + def _generate_basis(self, X, L): + indices = at.arange(1, self.M + 1) + m1 = (np.pi / (2.0 * L)) * at.tile(L + X, self.M) + m2 = at.diag(indices) + Phi = at.sin(m1 @ m2) / at.sqrt(L) + omega = (np.pi * indices) / (2.0 * L) + return Phi, omega + + def _build_prior(self, name, X, **kwargs): + n_obs = pm.gp.util.infer_size(X, kwargs.get("n_obs")) + + # standardize input + X = at.as_tensor_variable(X) + Xmu = at.mean(X, axis=0) + Xsd = at.std(X, axis=0) + Xz = (X - Xmu) / Xsd + + # define L using Xz and c + La = at.abs(at.min(Xz)).eval() + Lb = at.max(Xz) + L = self.c * at.max([La, Lb]) + + # make basis and omega, spectral density + Phi, omega = self._generate_basis(Xz, L) + scale, ls, spectral_density = self._validate_cov_func(self.cov_func) + spd = scale * spectral_density(omega, ls / Xsd).flatten() + + beta = pm.Normal(f'{name}_coeffs_', size=self.M) + f = pm.Deterministic(name, self.mean_func(X) + at.dot(Phi * at.sqrt(spd), beta)) + return f, Phi, L, spd, beta, Xmu, Xsd + + def _build_conditional(self, Xnew, Xmu, Xsd, L, beta): + Xnewz = (Xnew - Xmu) / Xsd + Phi, omega = self._generate_basis(Xnewz, L) + scale, ls, spectral_density = self._validate_cov_func(self.cov_func) + spd = scale * spectral_density(omega, ls / Xsd).flatten() + return self.mean_func(Xnew) + at.dot(Phi * at.sqrt(spd), beta) + + def conditional(self, name, Xnew): + # warn about extrapolation + Xmu, Xsd = self.Xmu, self.Xsd + L, beta = self.L, self.beta + fnew = self._build_conditional(Xnew, Xmu, Xsd, L, beta) + return pm.Deterministic(name, fnew) + + + +# ExpQuad +#staticmethod +def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + return at.sqrt(2 * np.pi) * ls * at.exp(-0.5 * ls**2 * omega**2) + +# Matern52 +#staticmethod +def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + # https://arxiv.org/pdf/1611.06740.pdf + lam = at.sqrt(5) * (1.0 / ls) + return (16.0 / 3.0) * lam**5 * (1.0 / (lam**2 + omega**2)**3) + +# Matern32 +#staticmethod +def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + # https://arxiv.org/pdf/1611.06740.pdf + lam = np.sqrt(3.0) * (1.0 / ls) + return 4.0 * lam**3 * (1.0 / at.square(lam**2 + omega**2)) + +# Matern12 +#@staticmethod +def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + # https://arxiv.org/pdf/1611.06740.pdf + lam = 1.0 / ls + return 2.0 * lam * (1.0 / (lam**2 + omega**2)) + + + From da6407bef0fcf35b3a8ae36b63229074228f396b Mon Sep 17 00:00:00 2001 From: bwengals Date: Sat, 8 Jan 2022 20:40:37 -0800 Subject: [PATCH 2/5] copy over pymc gitignore --- .gitignore | 45 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..2c9cee843 --- /dev/null +++ b/.gitignore @@ -0,0 +1,45 @@ +*.pyc +*.sw[op] +examples/*.png +nb_examples/ +nb_tutorials/ +build/* +dist/* +*.egg-info/ +.ipynb_checkpoints +tmtags +tags +.DS_Store +.cache +# IntelliJ IDE +.idea +*.iml + +# Sphinx +_build +docs/jupyter_execute +docs/**/generated/* + +# Merge tool +*.orig + +# Docker development +# notebooks/ + +# air speed velocity (asv) +benchmarks/env/ +benchmarks/html/ +benchmarks/results/ +.pytest_cache/ + +# Visual Studio / VSCode +.vs/ +.vscode/ +.mypy_cache + +pytestdebug.log +.dir-locals.el +.pycheckers + +# Codespaces +pythonenv* From 6efc0aa7537c97fde41a075b517f4fb7a42da3eb Mon Sep 17 00:00:00 2001 From: bwengals Date: Sat, 8 Jan 2022 21:29:55 -0800 Subject: [PATCH 3/5] add basic DTC/projectedprocess implementation --- pymc_experimental/gp/__init__.py | 2 +- pymc_experimental/gp/hsgp.py | 104 ----------------- pymc_experimental/gp/latent_approx.py | 160 ++++++++++++++++++++++++++ 3 files changed, 161 insertions(+), 105 deletions(-) delete mode 100644 pymc_experimental/gp/hsgp.py create mode 100644 pymc_experimental/gp/latent_approx.py diff --git a/pymc_experimental/gp/__init__.py b/pymc_experimental/gp/__init__.py index a077addb0..d04008e69 100644 --- a/pymc_experimental/gp/__init__.py +++ b/pymc_experimental/gp/__init__.py @@ -1 +1 @@ -from hsgp import HSGP +from pymc_experimental.gp.latent_approx import HSGP, ProjectedProcess \ No newline at end of file diff --git a/pymc_experimental/gp/hsgp.py b/pymc_experimental/gp/hsgp.py deleted file mode 100644 index 659704875..000000000 --- a/pymc_experimental/gp/hsgp.py +++ /dev/null @@ -1,104 +0,0 @@ -import pymc as pm -import aesara.tensor as at - - -class HSGP(Latent): - ## inputs, M, c - - def __init__(self, M, c=3/2, *, mean_func=pm.gp.mean.Zero(), cov_func=pm.gp.cov.Constant(0.0)): - ## TODO: specify either c or L - self.M = M - self.c = c - super().__init__(mean_func=mean_func, cov_func=cov_func) - - def _validate_cov_func(self, cov_func): - ## TODO: actually validate it - cov, scaling_factor = cov_func.factor_list - return scaling_factor, cov.ls, cov.spectral_density - - def prior(self, name, X, **kwargs): - f, Phi, L, spd, beta, Xmu, Xsd = self._build_prior(name, X, **kwargs) - self.X, self.f = X, f - self.Phi, self.L, self.spd, self.beta = Phi, L, spd, beta - self.Xmu, self.Xsd = Xmu, Xsd - return f - - def _generate_basis(self, X, L): - indices = at.arange(1, self.M + 1) - m1 = (np.pi / (2.0 * L)) * at.tile(L + X, self.M) - m2 = at.diag(indices) - Phi = at.sin(m1 @ m2) / at.sqrt(L) - omega = (np.pi * indices) / (2.0 * L) - return Phi, omega - - def _build_prior(self, name, X, **kwargs): - n_obs = pm.gp.util.infer_size(X, kwargs.get("n_obs")) - - # standardize input - X = at.as_tensor_variable(X) - Xmu = at.mean(X, axis=0) - Xsd = at.std(X, axis=0) - Xz = (X - Xmu) / Xsd - - # define L using Xz and c - La = at.abs(at.min(Xz)).eval() - Lb = at.max(Xz) - L = self.c * at.max([La, Lb]) - - # make basis and omega, spectral density - Phi, omega = self._generate_basis(Xz, L) - scale, ls, spectral_density = self._validate_cov_func(self.cov_func) - spd = scale * spectral_density(omega, ls / Xsd).flatten() - - beta = pm.Normal(f'{name}_coeffs_', size=self.M) - f = pm.Deterministic(name, self.mean_func(X) + at.dot(Phi * at.sqrt(spd), beta)) - return f, Phi, L, spd, beta, Xmu, Xsd - - def _build_conditional(self, Xnew, Xmu, Xsd, L, beta): - Xnewz = (Xnew - Xmu) / Xsd - Phi, omega = self._generate_basis(Xnewz, L) - scale, ls, spectral_density = self._validate_cov_func(self.cov_func) - spd = scale * spectral_density(omega, ls / Xsd).flatten() - return self.mean_func(Xnew) + at.dot(Phi * at.sqrt(spd), beta) - - def conditional(self, name, Xnew): - # warn about extrapolation - Xmu, Xsd = self.Xmu, self.Xsd - L, beta = self.L, self.beta - fnew = self._build_conditional(Xnew, Xmu, Xsd, L, beta) - return pm.Deterministic(name, fnew) - - - -# ExpQuad -#staticmethod -def spectral_density(omega, ls): - # univariate spectral denisty, implement multi - return at.sqrt(2 * np.pi) * ls * at.exp(-0.5 * ls**2 * omega**2) - -# Matern52 -#staticmethod -def spectral_density(omega, ls): - # univariate spectral denisty, implement multi - # https://arxiv.org/pdf/1611.06740.pdf - lam = at.sqrt(5) * (1.0 / ls) - return (16.0 / 3.0) * lam**5 * (1.0 / (lam**2 + omega**2)**3) - -# Matern32 -#staticmethod -def spectral_density(omega, ls): - # univariate spectral denisty, implement multi - # https://arxiv.org/pdf/1611.06740.pdf - lam = np.sqrt(3.0) * (1.0 / ls) - return 4.0 * lam**3 * (1.0 / at.square(lam**2 + omega**2)) - -# Matern12 -#@staticmethod -def spectral_density(omega, ls): - # univariate spectral denisty, implement multi - # https://arxiv.org/pdf/1611.06740.pdf - lam = 1.0 / ls - return 2.0 * lam * (1.0 / (lam**2 + omega**2)) - - - diff --git a/pymc_experimental/gp/latent_approx.py b/pymc_experimental/gp/latent_approx.py new file mode 100644 index 000000000..5b5e539b9 --- /dev/null +++ b/pymc_experimental/gp/latent_approx.py @@ -0,0 +1,160 @@ +import numpy as np +import aesara.tensor as at +import pymc as pm + +from pymc.gp.util import ( + JITTER_DEFAULT, + cholesky, + conditioned_vars, + infer_size, + replace_with_values, + solve_lower, + solve_upper, + stabilize, +) + + +class ProjectedProcess(pm.gp.Latent): + def __init__(self, n_inducing, *, mean_func=pm.gp.mean.Zero(), cov_func=pm.gp.cov.Constant(0.0)): + self.n_inducing = n_inducing + super().__init__(mean_func=mean_func, cov_func=cov_func) + + def _build_prior(self, name, X, Xu, jitter=JITTER_DEFAULT, **kwargs): + mu = self.mean_func(X) + Kuu = self.cov_func(Xu) + L = cholesky(stabilize(Kuu, jitter)) + + n_inducing_points = infer_size(Xu, kwargs.pop("size", None)) + v = pm.Normal(name + "_u_rotated_", mu=0.0, sigma=1.0, size=n_inducing_points, **kwargs) + u = pm.Deterministic(name + "_u", L @ v) + + Kfu = self.cov_func(X, Xu) + Kuuiu = solve_upper(at.transpose(L), solve_lower(L, u)) + + return pm.Deterministic(name, mu + Kfu @ Kuuiu), Kuuiu, L + + def prior(self, name, X, Xu=None, jitter=JITTER_DEFAULT, **kwargs): + if Xu is None and self.n_inducing is None: + raise ValueError + elif Xu is None: + if isinstance(X, np.ndarray): + Xu = pm.gp.util.kmeans_inducing_points(self.n_inducing, X, **kwargs) + + f, Kuuiu, L = self._build_prior(name, X, Xu, jitter, **kwargs) + self.X, self.Xu = X, Xu + self.L, self.Kuuiu = L, Kuuiu + self.f = f + return f + + def _build_conditional(self, name, Xnew, Xu, L, Kuuiu, jitter, **kwargs): + Ksu = self.cov_func(Xnew, Xu) + mu = self.mean_func(Xnew) + Ksu @ Kuuiu + tmp = solve_lower(L, at.transpose(Ksu)) + Qss = at.transpose(tmp) @ tmp #Qss = tt.dot(tt.dot(Ksu, tt.nlinalg.pinv(Kuu)), Ksu.T) + Kss = self.cov_func(Xnew) + Lss = cholesky(stabilize(Kss - Qss, jitter)) + return mu, Lss + + def conditional(self, name, Xnew, jitter, **kwargs): + mu, chol = self._build_conditional(name, Xnew, self.Xu, self.L, self.Kuuiu, jitter, **kwargs) + return pm.MvNormal("fnew", mu=mu, chol=chol) + + +class HSGP(pm.gp.Latent): + ## inputs, M, c + + def __init__(self, n_basis, c=3/2, *, mean_func=pm.gp.mean.Zero(), cov_func=pm.gp.cov.Constant(0.0)): + ## TODO: specify either c or L + self.M = n_basis + self.c = c + super().__init__(mean_func=mean_func, cov_func=cov_func) + + def _validate_cov_func(self, cov_func): + ## TODO: actually validate it. Right now this fails unless cov func is exactly + # in the form eta**2 * pm.gp.cov.Matern12(...) and will error otherwise. + cov, scaling_factor = cov_func.factor_list + return scaling_factor, cov.ls, cov.spectral_density + + def prior(self, name, X, **kwargs): + f, Phi, L, spd, beta, Xmu, Xsd = self._build_prior(name, X, **kwargs) + self.X, self.f = X, f + self.Phi, self.L, self.spd, self.beta = Phi, L, spd, beta + self.Xmu, self.Xsd = Xmu, Xsd + return f + + def _generate_basis(self, X, L): + indices = at.arange(1, self.M + 1) + m1 = (np.pi / (2.0 * L)) * at.tile(L + X, self.M) + m2 = at.diag(indices) + Phi = at.sin(m1 @ m2) / at.sqrt(L) + omega = (np.pi * indices) / (2.0 * L) + return Phi, omega + + def _build_prior(self, name, X, **kwargs): + n_obs = pm.gp.util.infer_size(X, kwargs.get("n_obs")) + + # standardize input + X = at.as_tensor_variable(X) + Xmu = at.mean(X, axis=0) + Xsd = at.std(X, axis=0) + Xz = (X - Xmu) / Xsd + + # define L using Xz and c + La = at.abs(at.min(Xz)).eval() + Lb = at.max(Xz) + L = self.c * at.max([La, Lb]) + + # make basis and omega, spectral density + Phi, omega = self._generate_basis(Xz, L) + scale, ls, spectral_density = self._validate_cov_func(self.cov_func) + spd = scale * spectral_density(omega, ls / Xsd).flatten() + + beta = pm.Normal(f'{name}_coeffs_', size=self.M) + f = pm.Deterministic(name, self.mean_func(X) + at.dot(Phi * at.sqrt(spd), beta)) + return f, Phi, L, spd, beta, Xmu, Xsd + + def _build_conditional(self, Xnew, Xmu, Xsd, L, beta): + Xnewz = (Xnew - Xmu) / Xsd + Phi, omega = self._generate_basis(Xnewz, L) + scale, ls, spectral_density = self._validate_cov_func(self.cov_func) + spd = scale * spectral_density(omega, ls / Xsd).flatten() + return self.mean_func(Xnew) + at.dot(Phi * at.sqrt(spd), beta) + + def conditional(self, name, Xnew): + # warn about extrapolation + fnew = self._build_conditional(Xnew, self.Xmu, self.Xsd, self.L, self.beta) + return pm.Deterministic(name, fnew) + + +class ExpQuad(pm.gp.cov.ExpQuad): + @staticmethod + def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + return at.sqrt(2 * np.pi) * ls * at.exp(-0.5 * ls**2 * omega**2) + +class Matern52(pm.gp.cov.Matern52): + @staticmethod + def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + # https://arxiv.org/pdf/1611.06740.pdf + lam = at.sqrt(5) * (1.0 / ls) + return (16.0 / 3.0) * lam**5 * (1.0 / (lam**2 + omega**2)**3) + +class Matern32(pm.gp.cov.Matern32): + @staticmethod + def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + # https://arxiv.org/pdf/1611.06740.pdf + lam = np.sqrt(3.0) * (1.0 / ls) + return 4.0 * lam**3 * (1.0 / at.square(lam**2 + omega**2)) + +class Matern12(pm.gp.cov.Matern12): + @staticmethod + def spectral_density(omega, ls): + # univariate spectral denisty, implement multi + # https://arxiv.org/pdf/1611.06740.pdf + lam = 1.0 / ls + return 2.0 * lam * (1.0 / (lam**2 + omega**2)) + + + From e674f9ce23e39628ff66df1caa83a010fcbac187 Mon Sep 17 00:00:00 2001 From: bwengals Date: Mon, 10 Jan 2022 22:05:47 -0800 Subject: [PATCH 4/5] add KarhunenLoeveExpansion, add notebook --- notebooks/latent_approx.ipynb | 541 ++++++++++++++++++++++++++ pymc_experimental/gp/__init__.py | 2 +- pymc_experimental/gp/latent_approx.py | 62 ++- 3 files changed, 600 insertions(+), 5 deletions(-) create mode 100644 notebooks/latent_approx.ipynb diff --git a/notebooks/latent_approx.ipynb b/notebooks/latent_approx.ipynb new file mode 100644 index 000000000..01fe551d4 --- /dev/null +++ b/notebooks/latent_approx.ipynb @@ -0,0 +1,541 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "31fd5d6b-39de-434c-b003-ad9b6f208426", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import pymc as pm\n", + "import pymc_experimental as pmx" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "97906a1c-8e9e-4263-8860-9a54202171ff", + "metadata": {}, + "outputs": [], + "source": [ + "from pymc_experimental.gp import HSGP, ProjectedProcess, KarhunenLoeveExpansion\n", + "from pymc_experimental.gp.latent_approx import ExpQuad, Matern52, Matern32, Matern12" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6bd0b161-438e-4d8a-b528-52fce7652731", + "metadata": {}, + "outputs": [], + "source": [ + "eta_t = 1.0\n", + "ell_t = 1.0\n", + "cov_t = eta_t**2 * pm.gp.cov.ExpQuad(1, ls=ell_t)\n", + "\n", + "x = np.linspace(0, 20, 100)\n", + "f = np.random.multivariate_normal(np.zeros(len(x)), cov_t(x[:, None]).eval(), 1).flatten()\n", + "\n", + "sigma_t = 0.1\n", + "y = f + sigma_t * np.random.randn(len(x))" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bccea532-5f86-4405-8caa-5c5dedbd186e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x, f, color='b');\n", + "plt.plot(x, y, 'k.');" + ] + }, + { + "cell_type": "markdown", + "id": "49f63d2c-3446-4d51-8631-4d9ba86e622c", + "metadata": {}, + "source": [ + "# Karhunen Loeve Expansion" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dc2c796b-6af1-4378-981b-7e50d8fcc63c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + " warnings.warn(\n", + "Multiprocess sampling (3 chains in 3 jobs)\n", + "NUTS: [_gp_f_coefs, sigma]\n", + "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [6000/6000 00:02<00:00 Sampling 3 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 3 chains for 1_000 tune and 1_000 draw iterations (3_000 + 3_000 draws total) took 2 seconds.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6.04 s, sys: 2.61 s, total: 8.65 s\n", + "Wall time: 6.4 s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "with pm.Model() as model:\n", + " eta = eta_t\n", + " ell = ell_t\n", + " cov = eta**2 * pm.gp.cov.ExpQuad(1, ls=ell)\n", + " gp = KarhunenLoeveExpansion(n_eigs=15, cov_func=cov)\n", + " \n", + " f = gp.prior(\"f\", X=x[:, None])\n", + " \n", + " sigma = pm.HalfNormal(\"sigma\", sd=1)\n", + " pm.Normal(\"lik\", mu=f, sd=sigma, observed=y)\n", + " \n", + "with model:\n", + " tr = pm.sample(target_accept=0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8de31cdf-45fc-45be-b115-ec43fba05567", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pm.plot_trace(tr, var_names=['sigma']);" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "19daf5c6-e21f-4f00-9bbf-d2504bc5b713", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f = tr.posterior['f'].stack({\"f\": [\"chain\", \"draw\"]}).values\n", + "upper = np.percentile(f, 95, axis=1)\n", + "lower = np.percentile(f, 5, axis=1)\n", + "\n", + "plt.plot(x, y, 'k.');\n", + "plt.fill_between(x, lower, upper, alpha=0.5);" + ] + }, + { + "cell_type": "markdown", + "id": "bc501b49-0112-406b-9521-bbbffbe1be96", + "metadata": {}, + "source": [ + "# Projected Process / DTC" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "dd9f5768-02da-4c3b-ba9c-b7f1111a9e58", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + " warnings.warn(\n", + "Multiprocess sampling (3 chains in 3 jobs)\n", + "NUTS: [eta, ell, f_u_rotated_, sigma]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [6000/6000 02:32<00:00 Sampling 3 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 3 chains for 1_000 tune and 1_000 draw iterations (3_000 + 3_000 draws total) took 153 seconds.\n", + "The number of effective samples is smaller than 25% for some parameters.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 7.51 s, sys: 227 ms, total: 7.74 s\n", + "Wall time: 2min 40s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "with pm.Model() as model:\n", + " eta = pm.HalfNormal('eta', sd=1)\n", + " ell = pm.Gamma('ell', alpha=2, beta=1)\n", + " cov = eta**2 * ExpQuad(1, ls=ell)\n", + " gp = ProjectedProcess(n_inducing=15, cov_func=cov)\n", + "\n", + " f = gp.prior(\"f\", X=x[:, None])\n", + " \n", + " sigma = pm.HalfNormal(\"sigma\", sd=1)\n", + " pm.Normal(\"lik\", mu=f, sd=sigma, observed=y)\n", + " \n", + "with model:\n", + " tr = pm.sample(target_accept=0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a447d5b5-861b-406f-9705-57d1fa8fee42", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pm.plot_trace(tr, var_names=['eta', 'ell', 'sigma']);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e3bc10c4-830f-4b46-834e-965dd16c463a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f = tr.posterior['f'].stack({\"f\": [\"chain\", \"draw\"]}).values\n", + "upper = np.percentile(f, 95, axis=1)\n", + "lower = np.percentile(f, 5, axis=1)\n", + "\n", + "plt.plot(x, y, 'k.');\n", + "plt.fill_between(x, lower, upper, alpha=0.5);" + ] + }, + { + "cell_type": "markdown", + "id": "b2fafa59-2934-41e4-8865-0b3dae97f32f", + "metadata": {}, + "source": [ + "# Hilbert Space GP (HSGP)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "1170f7dd-c92c-469b-9d2f-87eb8e0d208d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Auto-assigning NUTS sampler...\n", + "Initializing NUTS using jitter+adapt_diag...\n", + "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + " warnings.warn(\n", + "Multiprocess sampling (3 chains in 3 jobs)\n", + "NUTS: [eta, ell, f_coeffs_, sigma]\n", + "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [6000/6000 00:39<00:00 Sampling 3 chains, 0 divergences]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 3 chains for 1_000 tune and 1_000 draw iterations (3_000 + 3_000 draws total) took 40 seconds.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CPU times: user 6.09 s, sys: 222 ms, total: 6.31 s\n", + "Wall time: 44.3 s\n" + ] + } + ], + "source": [ + "%%time\n", + "\n", + "with pm.Model() as model:\n", + " eta = pm.HalfNormal('eta', sd=1)\n", + " ell = pm.Gamma('ell', alpha=2, beta=1)\n", + " cov = eta**2 * ExpQuad(1, ls=ell)\n", + " gp = HSGP(n_basis=20, cov_func=cov)\n", + " \n", + " f = gp.prior(\"f\", X=x[:, None])\n", + " \n", + " sigma = pm.HalfNormal(\"sigma\", sd=1)\n", + " pm.Normal(\"lik\", mu=f, sd=sigma, observed=y)\n", + " \n", + "with model:\n", + " tr = pm.sample(target_accept=0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c84d2817-8342-481e-a0ed-024c4db50d11", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "pm.plot_trace(tr, var_names=['eta', 'ell', 'sigma']);" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "2cdc8fc0-d0e4-4c49-b80a-97fe5403f2df", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "f = tr.posterior['f'].stack({\"f\": [\"chain\", \"draw\"]}).values\n", + "upper = np.percentile(f, 95, axis=1)\n", + "lower = np.percentile(f, 5, axis=1)\n", + "\n", + "plt.plot(x, y, 'k.');\n", + "plt.fill_between(x, lower, upper, alpha=0.5);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b80fa037-9762-4f34-a248-f8d034554528", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eb8d895c-ae75-424c-960e-47a7b624797f", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7f192ef1-c58e-4f76-b7d3-adf726c82c44", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "hsgp", + "language": "python", + "name": "hsgp" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pymc_experimental/gp/__init__.py b/pymc_experimental/gp/__init__.py index d04008e69..d8a9c6d3a 100644 --- a/pymc_experimental/gp/__init__.py +++ b/pymc_experimental/gp/__init__.py @@ -1 +1 @@ -from pymc_experimental.gp.latent_approx import HSGP, ProjectedProcess \ No newline at end of file +from pymc_experimental.gp.latent_approx import HSGP, ProjectedProcess, KarhunenLoeveExpansion \ No newline at end of file diff --git a/pymc_experimental/gp/latent_approx.py b/pymc_experimental/gp/latent_approx.py index 5b5e539b9..a1061408e 100644 --- a/pymc_experimental/gp/latent_approx.py +++ b/pymc_experimental/gp/latent_approx.py @@ -14,7 +14,13 @@ ) +class LatentApprox(pm.gp.Latent): + ## TODO: use strings to select approximation, like pm.gp.MarginalApprox? + pass + + class ProjectedProcess(pm.gp.Latent): + ## AKA: DTC def __init__(self, n_inducing, *, mean_func=pm.gp.mean.Zero(), cov_func=pm.gp.cov.Constant(0.0)): self.n_inducing = n_inducing super().__init__(mean_func=mean_func, cov_func=cov_func) @@ -61,7 +67,7 @@ def conditional(self, name, Xnew, jitter, **kwargs): class HSGP(pm.gp.Latent): - ## inputs, M, c + ## inputs: M, c def __init__(self, n_basis, c=3/2, *, mean_func=pm.gp.mean.Zero(), cov_func=pm.gp.cov.Constant(0.0)): ## TODO: specify either c or L @@ -93,14 +99,14 @@ def _generate_basis(self, X, L): def _build_prior(self, name, X, **kwargs): n_obs = pm.gp.util.infer_size(X, kwargs.get("n_obs")) - # standardize input + # standardize input scale X = at.as_tensor_variable(X) Xmu = at.mean(X, axis=0) Xsd = at.std(X, axis=0) Xz = (X - Xmu) / Xsd # define L using Xz and c - La = at.abs(at.min(Xz)).eval() + La = at.abs(at.min(Xz))#.eval()? Lb = at.max(Xz) L = self.c * at.max([La, Lb]) @@ -157,4 +163,52 @@ def spectral_density(omega, ls): return 2.0 * lam * (1.0 / (lam**2 + omega**2)) - +class KarhunenLoeveExpansion(pm.gp.Latent): + def __init__(self, variance_limit=None, n_eigs=None, *, mean_func=pm.gp.mean.Zero(), cov_func=pm.gp.cov.Constant(0.0)): + self.variance_limit = variance_limit + self.n_eigs = n_eigs + super().__init__(mean_func=mean_func, cov_func=cov_func) + + def _build_prior(self, name, X, jitter=1e-6, **kwargs): + mu = self.mean_func(X) + Kxx = pm.gp.util.stabilize(self.cov_func(X), jitter) + vals, vecs = at.linalg.eigh(Kxx) + ## NOTE: REMOVED PRECISION CUTOFF + if self.variance_limit is None: + n_eigs = self.n_eigs + else: + if self.variance_limit == 1: + n_eigs = len(vals) + else: + n_eigs = ((vals[::-1].cumsum() / vals.sum()) > self.variance_limit).nonzero()[0][0] + U = vecs[:, -n_eigs:] + s = vals[-n_eigs:] + basis = U * at.sqrt(s) + + coefs_raw = pm.Normal(f"_gp_{name}_coefs", mu=0, sigma=1, size=n_eigs) + #weight = pm.HalfNormal(f"_gp_{name}_sd") + #coefs = weight * coefs_raw # dont understand this prior, why weight * coeffs_raw? + f = basis @ coefs_raw + return f, U, s, n_eigs + + def prior(self, name, X, jitter=1e-6, **kwargs): + f, U, s, n_eigs = self._build_prior(name, X, jitter, **kwargs) + self.U, self.s, self.n_eigs = U, s, n_eigs + self.X = X + self.f = f + return pm.Deterministic(name, f) + + def _build_conditional(self, Xnew, X, f, U, s, jitter): + Kxs = self.cov_func(X, Xnew) + Kss = self.cov_func(Xnew) + Kxxpinv = U @ at.diag(1.0 / s) @ U.T + mus = Kxs.T @ Kxxpinv @ f + K = Kss - Kxs.T @ Kxxpinv @ Kxs + L = pm.gp.util.cholesky(pm.gp.util.stabilize(K, jitter)) + return mus, L + + def conditional(self, name, Xnew, jitter=1e-6, **kwargs): + X, f = self.X, self.f + U, s = self.U, self.s + mu, L = self._build_conditional(Xnew, X, f, U, s, jitter) + return pm.MvNormal(name, mu=mu, chol=L, **kwargs) \ No newline at end of file From b3df866c068627ad0954f8699da174091caadb29 Mon Sep 17 00:00:00 2001 From: lucianopaz Date: Mon, 7 Feb 2022 10:34:52 +0100 Subject: [PATCH 5/5] Add conditional draws to latent_approx notebook --- notebooks/latent_approx.ipynb | 307 +++++++++++++++++--------- pymc_experimental/gp/latent_approx.py | 6 +- 2 files changed, 211 insertions(+), 102 deletions(-) diff --git a/notebooks/latent_approx.ipynb b/notebooks/latent_approx.ipynb index 01fe551d4..3be462310 100644 --- a/notebooks/latent_approx.ipynb +++ b/notebooks/latent_approx.ipynb @@ -5,12 +5,32 @@ "execution_count": 1, "id": "31fd5d6b-39de-434c-b003-ad9b6f208426", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + "Your Python environment has Theano(-PyMC) 1.1.2 installed, but you are importing PyMC 4.0.0 which uses Aesara as its backend.\n", + "For PyMC 4.0.0 to work as expected you should uninstall Theano(-PyMC).\n", + "See https://github.com/pymc-devs/pymc/wiki for update instructions.\n", + "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + "You are importing PyMC 4.0.0, but your environment also has the legacy version PyMC3 3.11.2 installed.\n", + "For PyMC 4.0.0 to work as expected you should uninstall PyMC3.\n", + "See https://github.com/pymc-devs/pymc/wiki for update instructions.\n", + "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n", + "You are running the v4 development version of PyMC which currently still lacks key features. You probably want to use the stable v3 instead which you can either install via conda or find on the v3 GitHub branch: https://github.com/pymc-devs/pymc/tree/v3\n" + ] + } + ], "source": [ - "import numpy as np\n", + "import arviz as az\n", "import matplotlib.pyplot as plt\n", - "\n", + "import numpy as np\n", "import pymc as pm\n", + "from aesara import tensor as at\n", + "\n", "import pymc_experimental as pmx" ] }, @@ -21,8 +41,8 @@ "metadata": {}, "outputs": [], "source": [ - "from pymc_experimental.gp import HSGP, ProjectedProcess, KarhunenLoeveExpansion\n", - "from pymc_experimental.gp.latent_approx import ExpQuad, Matern52, Matern32, Matern12" + "from pymc_experimental.gp import HSGP, KarhunenLoeveExpansion, ProjectedProcess\n", + "from pymc_experimental.gp.latent_approx import ExpQuad, Matern12, Matern32, Matern52" ] }, { @@ -34,13 +54,20 @@ "source": [ "eta_t = 1.0\n", "ell_t = 1.0\n", - "cov_t = eta_t**2 * pm.gp.cov.ExpQuad(1, ls=ell_t)\n", + "cov_t = eta_t ** 2 * pm.gp.cov.ExpQuad(1, ls=ell_t)\n", "\n", - "x = np.linspace(0, 20, 100)\n", - "f = np.random.multivariate_normal(np.zeros(len(x)), cov_t(x[:, None]).eval(), 1).flatten()\n", + "x = np.linspace(0, 20, 20)\n", + "x_cond = np.linspace(0, 20, 100)\n", + "x_all = np.concatenate([x, x_cond])\n", + "rng = np.random.default_rng(seed=42)\n", + "f_all = rng.multivariate_normal(\n", + " np.zeros(len(x_all)), cov_t(x_all[:, None]).eval(), 1\n", + ").flatten()\n", + "f = f_all[: len(x)]\n", + "f_cond_true = f_all[len(x) :]\n", "\n", "sigma_t = 0.1\n", - "y = f + sigma_t * np.random.randn(len(x))" + "y = f + sigma_t * rng.normal(size=len(x))" ] }, { @@ -51,7 +78,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -63,8 +90,8 @@ } ], "source": [ - "plt.plot(x, f, color='b');\n", - "plt.plot(x, y, 'k.');" + "plt.plot(x_cond, f_cond_true, color=\"b\")\n", + "plt.plot(x, y, \"k.\");" ] }, { @@ -87,11 +114,11 @@ "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", - "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + "/home/lpaz/repos/pymc3/pymc/model.py:925: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", " warnings.warn(\n", - "Multiprocess sampling (3 chains in 3 jobs)\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [_gp_f_coefs, sigma]\n", - "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + "/home/lpaz/repos/pymc3/pymc/model.py:925: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", " warnings.warn(\n" ] }, @@ -112,8 +139,8 @@ " background: #F44336;\n", " }\n", " \n", - " \n", - " 100.00% [6000/6000 00:02<00:00 Sampling 3 chains, 0 divergences]\n", + " \n", + " 100.00% [4000/4000 00:03<00:00 Sampling 2 chains, 0 divergences]\n", " \n", " " ], @@ -128,15 +155,44 @@ "name": "stderr", "output_type": "stream", "text": [ - "Sampling 3 chains for 1_000 tune and 1_000 draw iterations (3_000 + 3_000 draws total) took 2 seconds.\n" + "Sampling 2 chains for 1_000 tune and 1_000 draw iterations (2_000 + 2_000 draws total) took 4 seconds.\n" ] }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [2000/2000 00:05<00:00]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6.04 s, sys: 2.61 s, total: 8.65 s\n", - "Wall time: 6.4 s\n" + "CPU times: user 14.2 s, sys: 255 ms, total: 14.5 s\n", + "Wall time: 12.4 s\n" ] } ], @@ -146,16 +202,20 @@ "with pm.Model() as model:\n", " eta = eta_t\n", " ell = ell_t\n", - " cov = eta**2 * pm.gp.cov.ExpQuad(1, ls=ell)\n", + " cov = eta ** 2 * pm.gp.cov.ExpQuad(1, ls=ell)\n", " gp = KarhunenLoeveExpansion(n_eigs=15, cov_func=cov)\n", - " \n", + "\n", " f = gp.prior(\"f\", X=x[:, None])\n", - " \n", + "\n", " sigma = pm.HalfNormal(\"sigma\", sd=1)\n", " pm.Normal(\"lik\", mu=f, sd=sigma, observed=y)\n", - " \n", + "\n", + "with model:\n", + " tr = pm.sample(target_accept=0.9)\n", + "\n", "with model:\n", - " tr = pm.sample(target_accept=0.9)" + " f_cond = gp.conditional(\"f_cond\", x_cond[:, None])\n", + " ppc = pm.sample_posterior_predictive(tr, var_names=[\"f_cond\"])" ] }, { @@ -166,7 +226,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -178,7 +238,7 @@ } ], "source": [ - "pm.plot_trace(tr, var_names=['sigma']);" + "pm.plot_trace(tr, var_names=[\"sigma\"]);" ] }, { @@ -189,7 +249,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABFD0lEQVR4nO29d3xc1Znw/32mSVa3JMtyl41NkQ1GxggLgxHYgG06CXkh2QWS/S0Ju/zesLvJS1h+m+y77IY4ye6SSkk2MSQEUggtmOYWHBhjG3dchS3bsmz1XmbuzJzfH1M8kkdWmT5zvp+PPpp775l7nrlz7zPnPOcpopRCo9FoNKmPKd4CaDQajSY2aIWv0Wg0aYJW+BqNRpMmaIWv0Wg0aYJW+BqNRpMmWOItwLkoLi5WZWVl8RZDo9FokoaPP/64WSk1IdSxhFb4ZWVlbNu2Ld5iaDQaTdIgIseGOqZNOhqNRpMmaIWv0Wg0aUJEFL6I/EJEGkVk7xDHq0WkQ0R2+v6+GYl+NRqNRjNyImXDXw38GHj+HG02KaVujlB/Go1GoxklERnhK6XeB1ojcS6NRqPRRIdY2vCrRGSXiLwlInOHaiQiD4jINhHZ1tTUFEPxNBqNJrWJlcLfDsxQSs0HfgS8OlRDpdSzSqmFSqmFEyaEdCXVjAK73c4TTzyB3W6PtygajSbOxMQPXynVGfR6jYj8VESKlVLNseg/3bDb7WzcuJGioiIefvhhnE4nNpuNdevWUVVVFW/xNBpNnIiJwheRUqBBKaVEpBLvzKIlFn2nMn7FXl1dHVDkdrudpUuX4nQ6ERE8Hg8ejwen08nGjRu1wtdo0piIKHwReRGoBopFpA74FmAFUEo9DXwWeFBEXEAfcLfSlVfCIlix22w2nnzySVpaWjh+/DhOpxO3243JZMJsNiMi2Gw2qqur4y22RqOJIxFR+Eqpe4Y5/mO8bpuaCLFx48aAYnc4HDz00EN4PB7MZjMWi/drDf4hCJ4FaDSa9CShc+lohqa6uhqbzRYw3bjdbjweDwB3feE+Lpg9kxuXLdVKXqPRBNAKP0mpqqpi3bp1bNy4EUtWHo898jWUYWCyWClZcANlCytZcPn0eIup0WgSCElkU/rChQuVzpZ5bnbXtbPxYBOf7t1Oza4tzJ5fSVl5BQBzJuZw8yWT4yyhRqOJJSLysVJqYahjeoSfxBw83cW6/Y0AlJVXBBS9n8MN3Ww/3saC6ePjIZ5Go0kwdLbMJKWxq5/39p0ett1fDjdzqqMvBhJpNJpERyv8JKTP6eZPu05huIc3x7k9ii1HdZojjUajFX7SoZRizZ5TdPQZI35PbXMv3Q5XFKXSaDTJgFb4ScZHR1s53to7qvd4lGL/qc7hG2o0mpRGK/wkoq6tl4+OjM0888nJjghLo9Fokg3tpZMk9DndvL33NJ4h3GiLcmzMn1pAR59Ba4+TUx399BvuwPG2XoO6tl6mjs+KlcgaDSdae6lp7KYkL4Op47PIH2eNt0hpjVb4SYBSinf3naar/2w7vAhcNmM8VbOKsJjPTNgau/r57ZYTuDxnfiA+qe/UCl8TE0539PNBTfNZ5scZRVncMn8yVrM2LsQDfdWTgE2HmznS1HPWfpvFxF0Lp3H1nAkDlD1ASW4m115YMmBfTWM3DpcbjSaanOro43fbToRcazrW0ssbu+pxuT1xkEyjFX6MGGshku3H2/j4WNtZ+0Vg+bxSphSMG/K986bkM3dyXmDb6fJwuKF7VP1rNKOh33CzZs9p3J6hXYaPtfTyxm6t9OOBNunEgMGpjEdaiOTg6S7ePxS6zONVs4s5b0LOsOe49sISGrocNHc5ADjS3MO8Kfmj+wAazQhZu7+BziCX4dp9O85K+QFeV+GNB5tYVj4xHmKmLVrhRxF/gZLgHPUjLUTiz5ETao127uQ8FpYVjkgGq9nEopmF/Gn3KQBOtvWhlEJERv15NJpzsetE+4AZZO2+HTz1yP24DCcWq40HV60eoPT31ndw6fQCinMy4iFuWqIVfpQIHtUPzlF/rkIkPQ4X7+1r4Gjz2TZ7gIl5mSy9aHSjolkTchhnM9PndNNvuGnqclCSlzmqc2g056LX6WLT4YGz0ZpdW3AZTpTHg8swqNm1ZYDCV8qb+uP2iimxFjdtiVTFq18ANwONSql5IY4L8ANgJdAL3K+U2h6JvhOV4AIlAH/7t3/L9OnTQxYi8XgUpzv7OdbSy666dvqcoRdWM6wmbrp4EmbT6EbnZpNwYWkuO463A3CirVcrfE1E2XG8PZDqw2/Gyc4rwGK14TIMLFYr2XkFrH3xmQHmnaPNPRxv6WV6kfYeiwWRGuGvxlvR6vkhjq8A5vj+rgCe8v1PWYILlFisVqYsvJGpcyv4FDj60XFEwK+2W3udOIyBC1ihbJ/XXzSR/Kyx+THPm5IfUPh1bX1cNmOMH0yjGUS/4WbniXbgbDPO7V/5Z3o628nOK+DVp78d0rzz/uEmvlA4XZsZY0CkShy+LyJl52hyG/C8r47tZhEpEJFJSqlTkeg/EZl/2eV8/Qe/Zpv9A2bPryR7enlg4XQ4Qtk+b7/xWuZMzB2zPMU5GZTmZ3K6o5+6tj48HoVplDMFjSYUO0+043R5ByyDzTgWo5tVj3+TJ//zu7iHMO80dTnYf6qL8iCPMk10iJVb5hTgRNB2nW/fWYjIAyKyTUS2NTWF9lBJdLodLv7wcR0FZfNYds+Xz8pTPxyDH5rGQ9u5ek5x2HLNnZxH7b4drPnVU7y57s9hn0+jcbo8gdE9wOz5lVisNkwmMxk2G//vX93OvCn5/M1dN5ORkeFdzwoy79Tu2wF43Y810SdWi7ahhpIhHXWVUs8Cz4K34lU0hYoGHX0Gf9xeR3vv0Nksh3JV8+N/aPy2zy//r1sCgVV+z5+xFCVvO7o3MHNY9+JTbFg/MvdQjWYo9pz0rjkF39Pf+OEL2JoOsPS6awP3V3BJTlNmLv/y6NcHzGBrgX1vPccty6/X92QUiZXCrwOmBW1PBepj1HdMeW9fw7DKfihXteCH5sFVq6ndu5W/u+dWqpdcBYzdn9/Ph3/ZhNswUB4PhjEy91CNZig8HsX2Y+1n3dNvrHmHGx/457PaV1VVUVVVxRNPPIHbZQRmsFvfe5Vta1/FbRg8+b3vjPq+1oycWJl0XgfuFS+LgI5UtN+faO3lxDCpi0O5qsGZH4K3nnuSpx65H4tJ+PGqf+PG65YEonSff/75s/z5R4N/IVlMZswWK1cvuWasH1Wj4WhLD90O14B72uMy2P7RB+d8X3V1NRk2W8C8A+AynHg8Y7uvNSMnUm6ZLwLVQLGI1AHfAqwASqmngTV4XTJr8LplfjES/SYaH37aPGpzzez5lcDAHwK3YTCu5SDTCj83Zn/+UFRVVfHWO+/y/ede4bxLKpk5d3RrCxpNMP4aC/572u0yRnRf+s07GzZsoH/ChXT0Gmxb+6rvmRj9fa0ZOZHy0rlnmOMK+PtI9JWoHG3u4cMP7eeMLARvsfEHV60O/CgArH3xmYDPsttlkGGzcdONy4DR+fOPhOolV1Fnm0ZTl4MTrb3nzMWj0QxFv+EOJPQrK6/gH/7reXLbDg+w258Lv3nneEsvL2+vCzwTly1arM05UURH2kYApRQffto8ZGShxSRMGT8OEehzeshdcDkXXbqQw7s/5kdfvw+34cRqs/HtVd/H6O0coMyD/fltNhv33ntv2A/E9MIsmrocbHz/Azb89pMx/3ho0peDp7v4dO/2wMDlC7deT+XMu0Z9nulFWcwszobyisDg6ERrL9MKdSBWNNAKPwJ82tRNY6fjLHPN1UuWcOulk5lemBUy//cTH/4Oj8vA4/uBMHo7efTRRwe0CfZuiJRinlaYxctvreepR+7H45uG64UyzWh49d0NA2azdyx4D2ZeNaZzXT2nmGMtvYHiPn9Ys47+E3v1QCQKaIUfAXbXecsHBptrrl6yhK/fe+s50yAMHr0PZbv0T38jxZSCcRzZfWY2MtKEbhoNQGuPky0f/OXMmpPLwP6XTVRfPTaFX5STwbwpeeyu6wg4L/gHIk8++SQtLS1a+UcIrfDDpN9wU9fWF9guK69g8ZVXcseCKcPmvInG6H0k2CwmKq+8inde+GngwdILZZqRsv9U55mFWsO75hTu/bNg+nj2nOwYYBZ1OBw89NBDeDwePQuNEFrhh0ltS8+AYg/FuRnceunIS7hFevQ+UpZWX03zqtU4Tuzhvs/cpB8kzYhQSrH/VGdgNtt7bDdfuuvmsO+f8dk2ZhRlDfD4MYngdrvx6FloxNAKP0xqGgdWkFp6YQmZVnOcpBk508ZnUVZewcwlV1Gl09NqRsipjv5AbeVZcxfwpS/fSW5mZAqTXzK1gFrfD8nRvVtZcdkc/ukf/2FYk6dm5GiFHwYut4cN73/Age2bmT2/kiVXLWZykrg5TsrPxGoWGrv64y2KJokIrq08oygrYsoeYFZxNnnjrJT5PHaunz+ZdfMvibnJM5XRCj8MXn1nAz/62r0BT4VrX1uDN2tE4mMxm5iUP47jrb109RsRfXA1qcunTWdmtJHObikizJ+az6bDzQAcbuhiRZxMnqmKLmIeBmveXTfAU2H/9s3xFmlU+H2dG0eYtlmT3rT1ONm+9SPWvvgM9Yd2Mas4O+J9zJ2cj8Xn7HCkuUcXOo8weoQ/Bux2Oxs2bMBhyQ743duSMCR8Ur636lVDZ/+ICqJr0ptX39kQlG3Vxp0LpkZ89D3OZub80lz21XfidHmobelldom+NyOFVvijJDi3jcli5fav/DNmo5v//Ve3J93Uc0JuBiLeAhQazXC8u279gEjyaHnNzJ2cx756b56emsYurfAjiFb4oyQ4t41HQU9nO//57W9xYWnyVevJtJopGGeloVMv3GrOTa/TxcQLFgR876PpNTOlYBy5mRa6+l0cbe7V1dkiiFb4o8QfHetwOjFbrJxfcYU3F0iSMjEvkwOnu/TCrWZI7HY7v339bVRpOQ+uWo3r5F7+6o6VUZvRighzJuay/Vgb/Yabk+19OrdOhNAKf5RUVVXx9jvv8d3Vf+S8Syq5evGVZFgS3+9+KEp8Cr+xy6EVvuYs/CZMh8OJ2Wrl7777HN99/FtkZ0RXdVzgU/jgzUSrFX5k0F46Y6CsvIKld3tr1Sb7YufEvAwAbdbRhMRvwvR43N76ygc/jrqyByjNzyR/nHcAcrS5Z5jWmpGiFf4YqO/w5s4RgfOSfEFJL9xqzkV1dTVWq7dKmsVq5YZl18Ws7wtKcwFvsrb2XmfM+k1lIqLwRWS5iBwUkRoR+UaI49Ui0iEiO31/34xEv/HilE/hT8zLJCcGo51okmExMz7LRnO3fqA0Z1NVVcX3fvl7Vtz3VR5ctZo7lsdO4Z8/MTfw+kiKj/L9ZUztdntU+wlbW4mIGfgJcD3eYuVbReR1pdS+QU03KaVuDre/eKOUor7da/5IFXexiXkZHDjdhcPlTur1CE10yJlWzrJ75lCSlxEws8SCCbkZFOXYaOl2cqSphwXTx8es71gS7Ood7aygkRjhVwI1SqkjSikn8BJwWwTOm5A0dztxurzRf8luv/dTkpeJUtCiR/maQXT0GrT1GkB87nf/KL++vY9+wx3z/mNBsKt3tIu4R0LhTwFOBG3X+fYNpkpEdonIWyIyd6iTicgDIrJNRLY1NTVFQLzI4jfnFGbbKMy2xVmayDAxzxtxqxW+ZjC1LWdMKfFQ+P5ZtNujON7aG/P+Y4Hf1dtsNkc9K2gkFH6oiAg1aHs7MEMpNR/4EfDqUCdTSj2rlFqolFo4YcKECIgXWerbvQo/VUb3ACW5GZhEaO7WC7eagfgVfkGWlQm5GTHvvzgng4IsrxkpOFNnKuEvhPT444+zbt06gKjZ8yOx4lgHTAvangrUBzdQSnUGvV4jIj8VkWKlVHME+o8pfvv9jKLU8Qu2mk0UZlu1wtcEsNvtrN+wgda8OUy9YH5cBzizJuSw/VgbtS09KKUQSb2oW38hpGjb8yMxwt8KzBGRmSJiA+4GXg9uICKl4vuWRKTS129LBPqOKT0OFx19BmaTUOpLPJYqlORlak+dKNPY2c/uunbq2nrpc56xR8fKQ2Ok+JXOt775TX70tXup3bcjru7H/qycfU43p1M8XiTa9vywR/hKKZeIPAS8A5iBXyilPhGRr/iOPw18FnhQRFxAH3C3Umqw2Sfh8ZtzJuRmjLiEYbJQmpfJvvpOuh2upHc1TUT6nG7++4U/sXurndnzK5k5t4LPLJhK3cFdMfPQGCmD80Ud/2Qrk/M/Fzd5phSMI9Nqpt9wc7S5h0n5yVFkaDQ0dPaz43g7zgkXYrJ4TVjRsOdH5MlWSq0B1gza93TQ6x8DP45EX/GkvsM7upiSJFWtRsOx/TtZ+9IbzHDdxJ0rYudrnQ4opfjBb97kP//hrwPFch5ctZp3M63U/3n9WSO6eCv8QL4oXzqFJUuq42pGMZmEmcVZvLXufTa/sh3569sBUqISlsvt4aOjrWyrbcOjFHkz5vLgqtXktR9m5Q1LI/7Z9FBuFDT4FH6ylDEcKXa7nbtvX0m/w8G6F59iw/r4jzJTia21bWx6/88DUgtvfe9VanZtYfa0SdhstoSq21pVVcXra97hv59/ldnzK1m57Jp4i0THsU8Cufhf/Z8nERFcLlfCzIrGQkefwWs7T57lHVdWXsF9V94RFS9ArfBHiFKKpm4HIqk3wvdP4ZXHg2EkxigzVWjo7Mf+aQuz51cGiuWYzGa2vvtH3G4XFquNb/77KsxGT0KNVkvnXMKyeyZiEkkIB4VDOz8K/GAahjcuQCmVMLOi0dLndPPqjpO09sR23Sy1DNFRpL3XwOnyUJhtY5wttaJR/VN4k9mMxWJNiFFmqrC7rgOPUpSVV/DgqtWsuO+rVN5wJ263KzDa33boOP/49f+TUErrWIvX531SfiaZ1vjf78uuuy6Q08dsscbMbz0aGG4Pr++KvbIHPcIfMU0+l8XJKbhg5PcDXv2HN8kuu4QrrlgUb5FSArdHUdN4puh3WXkFZeUV1O7bwba1r+IyDCxWKzPmXs7+U11cOq0gfsIGodSZIKeyBKn1UFVVxc9eeo3fvv4OF122iDsuncL77/85oWZFI0EpxVt7Twfcu2ONVvgjxJ9Ncsr41FP44H2gxs+cy1t7TtPeZ6RMFHE8OdrcEzIdgH+0X7NrC7PnV1JWXsHuuvaEUfinO/sDcpcVx9+c4+f25dfSkl0GwPSLpvLo4ivjK9AY2H68jU+DBgGxRiv8EeJX+Km2YBtMUbY3krKl26EVfgQ4eLprwLbZJChFwMRTVl4RONbS7eR4Sy/TE8Be7jfn5GRYKMlNnHiTvExrIJlabUvyFUVp73Xym9fXcmDHR4Ef+lijFf4IaezqJzfTEtNsgbGmMNuG2SQ0dTuYE5SaVjN6HC43R5oGjuSWzyvlvAk5tPY4ae52sP5AYyARH8CuuvaEUPjHfQo/ERZrB1NWlO1V+M09XD0n8VKvDIVSip+8tIYfff2+Aa65sVb6etF2BPQ4XPQ43CnnnTMYs0kYn2XVSdQiQE1jNy6PonbfDta++Ay2lsOcPzEXs0mYkJvBRZPyuOb8gQrrSFMPnf1GnCT20m+4OeVzP07EWs1lRV6ZmruddPTF91qNhj0nO/jwL5sGuObW7NoSczm0wh8B6WDO8VOck0GLzqkTNgdPd1G7bwdPPXI/bz/3A77+pbvOSp0wb0r+ABu5RylefGNtXNMs1LX14lEKk0hCzDYGM2X8OGwWr9qqTZKiKF39BpsONwdcc/3Vw7LzClj74jPU7tsBwDibmSybmZwMC6Yoxblpk84I8HvopFr+nFAU52ZwsKELl9uDJcXSR8SKHoeLE6191OzaEhjRDeUvvuyiifxq8zEchifwA+FxGXELKAq4YxZkJmQxHLNJmDp+HEeaeqht6WF+gix0n4sPP23B6fIMWKzPzivg1ae/jcvwBty99uY73HjNkqjLop/oEdDY6eD4gZ38/Mf/lTAJrqJFUbYNpaBV1xAdM0eaevAoxez5lcP6i+dmWgOmHf8PhD/NwvPPPx/z0b5f4ftNJ4mIX7YTrb243J5hWseXpi4H+08FkgVTVl7Bsnu+TE9nO27DCJh3tn/0QUzk0SP8EWC3f8hPv34fbpfBfyRxKPdIKM71e+o4E8pDI5k42e5TmuUVvPKnt9m55cNz+ovPnZzP9mNtgSm/22VgNpv55S9/GdP0AW09Z+ziZQlozvHjjw0w3Iq6tr6EiRUIxabDTQxOE2kxCZ+/fTkbXnoq5ik1tMIfBqfLw84tH+IyDDyexElwFS3yMq1kWE1xiQJMFfxBNcU5NlZUXcOKpcPnopk/rYDmbu+U/+ieLZSae/jF//w8pknVjvqKnWRnmONS7GSk5I+zUphto7XHydHmnoRV+MdaegIzJj8ZVhO3XzqFyQVzmLVuXcwTwGmFPwzN3Q7Ou6QSq80WsLclWyj3aCnOztDFUMZIt8PFro+3ULNrC7evvB4oG9H7LizN4y81zQH//NL+4/z6V8/HdAR41FdRanphdsIXGSkrzg4o/GvjLUwIlFJsOnx2facb55YGnD/8RU9iiVb4w9DU5aCsvILfv76GvdvsSRfKPRaKcmwpWz802ry5dmMgq+OGl55i3pSRmWJsFhPlk/LYcbwdgHFTL2JdDEeADpebk756D4nojjmYsqIsth9ro6PPoLXHmXCBggcbugLefX4umzE+7qVRtcIfhsYuByYRll+7hFuur463ODGhOCeDPSc7MNyelCv0Em3WrtswrGfOUFw6rYCdJ9pRCo639nLj1ZUxG1wca+nF7VGIJGbA1WCmFHjdM50uD0ebexJK4Sul2Hq0dcC+yQWZXDW7OE4SnSEiT7OILBeRgyJSIyLfCHFcROSHvuO7RWRBJPqNBc3dDgqzrWml+IpyfJ462o4/aqaWL8RiHVsmx4IsW8ADxe1RHG7sGuYdkcNfILw0LzGyYw6HxWxiqi+vVaL543/a1D2gXGim1czKiydhipZz/SgIW4uJiBn4CbACKAfuEZHyQc1WAHN8fw8AT4XbbyxQStHS7WBCmnmrFOec8dTRjByny0NB2TweXLWax775r2PyrAn2Kz9wOjYKXylFrW/BdkYCu2MOxm96OtneFzJJXbzYcrRtwPYVswrJzUyMlCyRGLZWAjVKqSNKKSfwEnDboDa3Ac8rL5uBAhGZFIG+o8p7Gzfx1q+f5vThXfEWJaZkWs1kZ5hp6dELt6PhdEc/HqWoqqri/37z/xuTOaasKIvcTK+ltb69LyapFk519AeKqidSdszh8HvnuD2Kowkyyj/a3ENDUKH1/HFW5k8tiJ9Ag4iEwp8CnAjarvPtG20bAETkARHZJiLbmpqaIiDe2LDb7dy2cjlvPfckD37hjpQPuArGbrfz59/9jA8/TJ/PHAnqO7yLnuGkJBARLij1Jq5TCg43RH+U7zfnZFrNlOYlz2w2L9NKcY7Xdv9pU/xSDgez5WjLgO3Fs4sxJ4Apx08kFH6oT6PG0Ma7U6lnlVILlVILJ0yIXza8AWX/fItv6YDdbmfp0qW89NT3+Zcv/6+0+qELl3qfl0u4RXL8Ch+ib9ax2+388L++S+2+HZQVZSW8O+Zg/KP8Yy3xj7o90do7oLBJaX4m50+Mr1fOYCLhpVMHTAvangrUj6FNQlFdXY3FasVlkBa+9378P3QejxsMWLd+Q8q7oUYCj0dxqqMfEW8emnAoyc0M5H1v7HREze3Q/+Pe73Bgsdoo/PdV7PxTYtXWHY6yomz+sGY9Nbu2UNK3krtWLo2bLB8fG2i7v2p2ccL9gEZC4W8F5ojITOAkcDfw+UFtXgceEpGXgCuADqXUqQj0HTWqqqr4Pz98gROfbOPLd9+SNA9AuPjr2zqdTkwWK5dWJl9VoXjQ3OPA6fJQnJsRkaRjF0zM5cNur3ngwOlOrjwv8i59GzduxOHwpet1Ovn3R7+GUp64JW4bC8f37wzEPax78adMXb8+LnK3dDsCC98AjpP7+fW2lxPuxzNsha+UconIQ8A7gBn4hVLqExH5iu/408AaYCVQA/QCXwy332jjcnsonnUxt99YzWUzCuMtTszw17ddu249zbmzmTk39lV5kpFTvqn85AhlVL2gNJcPP/Uq/EOnu6Ki8P2zWMMAkwgejxvPGOIH4sn77/85kITMcBps2BCfGenHx9oCOXNq9+3g2Ue/iOGLkn7yySdpaWlJCOUfkcArpdQavEo9eN/TQa8V8PeR6CtWtPY48SiVlgnE/CHfP990RLtmjpBI10woyLJRmp/J6Y5+2noNGjr7mRihBVW73c7GjRu5bNFivuJL1zt/zlSefPyxmCfzChf/jNThdGK2Wim/LPYKtcfhGlDOsuHgdgynN+upw+HgoYcewuNJjJmTjrQdAn8OfL9PejpSmG3TrpkjxH+/hLtgG8wFpbmc9lWfOnC6KyIK32+3dzqdWKxWvvyd1Sy758vcWzWDW6oXxTyZV7hUVVXx5tvv8F/Pv8p5l1SSP2NuzGXYeaIdl+eMD8pnbrqe11f/CKfTiYjgdifOzEkr/CFo6XaSk2FhnC3xow6jRVFORkzcApMdj8cboJeTYSE/K3IBNudPzOX9Q00B98wlc8JfBPQvyrvdbpTy5uC/dGElRTkZcUnmFQmuu+ZqGsbN4HRHP582dVN9wYSYLZY6XR5213UEtguzbXx22VKm+vIgFRUV8fDDDyfMzEkr/CFo7nZQnJs4+TniQVG2je39LvoNd1KE28eL9j4Dw60oK46s+S8nw8K08Vkcb+2lq99bRSvcsoODF+Vnz69M2PTCo2FWcTanO/rp6ndR19bHtMLYBJB9Ut8xIMr3shnjEZEBP54XX3xxwsyctMIfgpZu5wB/6HSkKMdG7b4d/N9NL3HriuvjfrMmKn77/aQImnP8XFCaG8hcuvtke9gK378o/9zLb5Ix7WLKyiuYlQIK/7ySnMAi975TnTFR+B6P4vdr1rNry4fMnl/JOKuZ17Yeouvaawc8K4k0c9IKPwR9TjfdDlda2+8BDu3+mKceuR+3y+AH3/9O3BecEhV/7YApUShyP7skhw0HGqnZu531L20h697bue6aq8M6Z1VVFfvdpXT0GdgsJqaOT550CkNRnJNB/jgrHX0GNY3dXHdh9DO9/vbNdXz/4b/CZTgxmS1eTye3K6Gr4qVPCshR4H+A092k8+FfNuEynHiCqi5pzqapy4HVLFGpEpVpNdN3cj9PPXI/b65+kpXLbww7+vlUR19QKcPshAr9D4dZE7wzFafLQ01j9FMtvLLm3UAqbI/LGFCPOFGfFa3wQ9DS48QkQlF2eo/wq6ursVptmMaQ6jedaO52UJKXGTXF2XBwe0CxGE4nGzZsCOt8wYuMiRb6Hw7BxUWCC4dHg6PNPUy68DIsVhtiMmOxWoctWJ8IaIUfguYubw78VBn5jJWqqir++7mXufmLDyfsFDXe9DnddPW7aDmyhyeeeCIquYduX3F9QLGYrVYuqFg05nN1B/mM2yymlFiw9TOlYFzAucC70B2ZTKN2u/2s73ZrbStl5d4axCvu+yqvvPkOGzZs4PHHH0/oZ0Xb8EPQ0uOgKM3t936WXLUYR+Fs5lXMjLcoCUlTl8MbWfmNL2L4ah5H+oG/+qrFrPr571m7fgOz51dinXzhmM+183g7bp/P+Kzi7JQq7GMyCWVFWRw43YVS3tiFy8vCi5IPjlvwf7fN3Q6ee/ENr4dTeQWLF1/JTQu9qcISVdH70Qp/EEopmrudzCxOnaluOAQXQ0mUIg6JRFO3g5pdWzAG2W8j/eDfsfxamHg+4C023tVvjPr7cLo87D7ZHtieMzH1vNDOK8kJZBjdf6ozbIUfHLfgdDp5/vnn+cUvV2MYTixWGw+uWs3Nd6+MhOgxIXV+3iNEZ5/LmwQrJ70XbP0UZtsQObOQrRlIU5eDCyquiLr9dnphFtkZXnOFRym2DKqZOhL2nOzAYXhTCNssJsqSoHbtaJlRlIXFZ4pt6XZS19Yb1vn8cQv+77bX4cLwrae4DIMT+7bFvTD5aNAKfxCBlApR8LhIRmwWE3mZ1gE1OjVnaO52sODyK1i3bl1U7bcmk3DRpLzA9t6TnQH//5Hg8Sh2nmgPbJ83IQdLCplz/GRYzMyccGZdYnDK4tHij1vwf7cXLbllwELtzTcuS4hatSNFm3QG0dztIMPqVXIaL0U5OqdOKNweRWuPN0Cvam70g2sumVIQyMroUYr3DzXxmcumjui9Bxu66Ow7s4iZSt45g7mwNJfDDV63zKPNPbR0h7cm5w+cOtXRx+buEzzoSzh34YJFfP6WZZESOyak3k98mDR3O9I+4GowxTkZtHY78XhCFilLW1p7nLg9Kmb3S36WlelBEaTHW3tHVNqvq9/gz4fOlAvNtJqTqlj5aJlZnBPw1lEKtoU5yvdj90XylpVXsOyeL3PL9dckXcoRrfAH0dLt1Pb7QRTl2HB5FO190S+onUz4TSoTYjhAuGRq/oDtTYeaAl43oVBK8fbe04Ei5QBzSnJS2uXYbBLmlORQu28Ha198hrfXv0+3wxXWOevb+zjWcmY9wCRCxfTx4Yoac7RJJwjD7aG916BiekG8RUkoznjqOKJSai9Z8Zu5ohFhOxSzinPIybAEFFhbr8GfDzVSfX5JSFvy5iOt1LX1BbZFSIv7u+fEvkAlrPd+Y+P8iTk8+LmxedMon/ksmDkTc8gfl3xm37BG+CJSKCLvichh3/+QP3kiUisie0Rkp4hsC6fPaOIveqJNOgMZn2XDbJLAgrbGS2tP7FNom0zC3Cl5A/btOtHBH7bXnTWKPd7Se5Y3T1lRdlrEmHzysT0QnewyDN5+b/2ArJajYfvxdk519A/Yd9mM5BvdQ/gmnW8A65RSc4B1vu2huFYpdalSamGYfUaNpi4HIl4ThuYMZpMwPsuqq18NoqXbGZd8S/Om5GMalO/9ZFsfv/noGLvr2ll/oIHVHxzl5e11eHx19/zmDRoPxVzeeHDttddis53xpsnIzufvvv4vo46E7ug1sH/aPGDf1PHjIlZ9LNaEa9K5Daj2vX4O2Ag8EuY540Zzt4PcTGtEilCnGkU5GTR09g/fME0w3B46+w3Oj0PwUl6mldklORwaVJymx+Fm3f7Gs9rX7tvhzXpqONnw0lMJHfofKaqqqnjlT2/z4xdeJzuvgFef/jYuw8mLzzzJ+vUj//xr9zdguAeukVTOTN4a1+GO8CcqpU4B+P6XDNFOAe+KyMci8sC5TigiD4jINhHZ1tTUdK6mEUcv2A5NUbaNjj4Dh2ts0+JUo63HiVLxy6h61eziQIDRcNTs2uLNehpUZi8dWLH0Gu578GF6OtsD5h2n08nadeuHfa/dbufhR7/F+3/5YMD+yQWZSe3hNOwIX0TWAqUhDj02in4WK6XqRaQEeE9EDiil3g/VUCn1LPAswMKFC2PqB9jc7YDGQzzx1vMJUZ0mkSjKyUApr9krFfKnh0trr9e8Fa/1nvwsKwtmjB9RxO3s+ZVYrDY8LiOhMzlGAn+Bdv/zu7BsPB/4Pr/LMDBbreSUzR/2HNddtxSH0xFIn1BWXgHAollFsfgYUWNYha+UGjKyQEQaRGSSUuqUiEwCzp5Pes9R7/vfKCKvAJVASIUfL3ocLvbt3BbVJFjJjH/moxW+l9ZuJxaTUJgVvxnh5WWFvPHuRvZsswcSeYWirLyC1b97g2OfbE3pgUyoRGeLFi1iYeUVgWCp2fMrYeL5bDnaysIZ4/noo81nlR986bW3cDgdgQXfml1bKCuvSPrRPYRvw38duA/4ju//a4MbiEg2YFJKdfle3wD8W5j9RpzmGCXBSlbyx1mxmoXGUYTzpzItPU4Kc2xxCav3j2KLior4wT89HHIkGszcyXncMHcZ3JpcUaGjZXCiM//ze9mMQpq7KwZcmw9qmnlr3Z/5zv/+AobvB+KVP71N7vRymDQ3MCOwWL11fyH5R/cQvsL/DvA7Efkb4DhwF4CITAZ+rpRaCUwEXvFVkbcAv1FKvR1mvxGnudvB+RVXsOElW8JUmE8kRITC7Ayt8H209jgpzY+9p0bwKFZE8Hg8Z41EgynOzeDaC4daWkstggu0Bz+/F5bmYj/SMiC1BMCWD/+Cw+EdyTscTn7469dYdk9pIM+9f0aQKqN7CFPhK6VagKUh9tcDK32vjwDnNpolAM3dzkASrESpMJ9oNNbsZu36DZS57uTqqxbHW5y44fYo2nsN5g3yh48FwaNYk8mE2WxGRAaMRMHrmXN071b+/p5bsZpnxFzOeOBPdDb4+TWZhAXTC9h4cKATyOxBtv3g61dWfmZGYBLhmvNT40dTlErc/CgLFy5U27bFJk7rhY+OUZhlY8XFk2LSX7Jht9u59rqlOJ0OMjIyWJ/G6xst3Q6etx9juquOQzs/iungYLCd+sknn6SlpYXq6mqyp13Enw820fTpHr771S/gMgy9FuXDcHv45QdH6XEM9DKr3bdjwEg+FAvLxnP1nAmxEDMiiMjHQ8U76dQK+LIedjuZU5J6BSEixcaNGwN5wI00X99o7XFSu28Hjz36xQELhLG4HkONYv2UT8rje1v+gMsw9FpUEFazievLS3lt50mCx7jBI/lQFOXYqEoB270frfDxjthcHqV98M9BdXU1GTYb/Q4nFqs1rdc3WnqcHN27NeQCYSzwp+sdTPBibihbdrozszibS6cVsON4+4jam0S4vnxiStUN0AofeHfDJta+9jbzrLczq/rqeIuTkPhHlt/95ctUXLE4rUeMbT1OLrtiMWtf+GnCKNVzmXrS+bsazFWziznR1kdzCOeDweady8vGMyl/XBykjB5pr/Dtdjv/z9234nSmT9j5WKmqquK+zOnUtfXi8aikqvQTSVp6nFyxaFFCLfAPdklsaWnh0UcfjatMiYjFbGLFvFJe2nJ8QMoEf/oJl69W7dO/eZUrZ58fR0mjQ9oqfP/09/jx4xjOM2HX2t55bkpyMzja3ENrrzMts4oqpWjrcXL+xFwq50W/ytVIGcolUXM2h/dsp2HTOsZNv5hxUy8CzqSfUB4PHpdBw8HtwI3xFTQKpKXCD57+ms1mTGYLiFs/KCPAn/u9qSs9K4N19Bm4PCrh6gIMt5ir8TLY9PXL37+OddKFLL/+Ota9+BQuI7V/MNNS4QdPfwEql9/FZXPn8PnbV+gHZRhKcr3BRo1dDi5KQw/W1h5vDp2iBFP4MPRiruYMg01fR3Zv5dGblsGCqSwsS/0fzLRU+MHTX4vVxuXX387X/voWphXqHDHDkZ9lJcNqojFNUyW39nhz6CRjtSPNuU1f6fCDmZYKP3j6O276xaiS82Napi7ZKcnNpLGrH6UUIum1cNva46Qgy5q2C9bJTrqbvtJS4cOZX/NfbT6G0+VJuurz8WRCbgYnWntp6Um/hdvWHieF2en1mVONdBjJD0XqRBSMAcPtobXbqUf3o6TEd73q2/uGaZl6tPUaCbdgq9GMlLRW+E1dDjxKBRSYZmSkq8LvcbjoN9y65rEmaUlrhe+v0apH+KOjMNuG1SycbE+vhVu/h44e4WuSlTRX+N7waj3CHx0iwoTcDDr7DLodrniLEzPaep2YRBgfxypXGk04pLXCb+zqZ5zNTG6mdrEbLY01e1j74jO8uXZjvEWJGZv+8gGb/vAsWz7aHG9RNJoxEZbCF5G7ROQTEfGISMj8y752y0XkoIjUiMg3wukzUvQbblp7nHp0Pwbsdjv/50t38dZzT3LfZ2/BbrfHW6SoY7fb+cf7P8srP/tvli5dmhafWZN6hDvC3wvcyTkKkouIGfgJsAIoB+4RkfIw+w2burY+lNL2+7EwIDe+YbBx48Z4ixR1/J/Z4zmTDlmjSTbCUvhKqf1KqYPDNKsEapRSR5RSTuAl4LZw+o0EJ9p6gTOpAjQjxx+taDKZMVusLL5qSbxFijpXXb0Ei9WG2WxO6VwrmtQmFoFXU4ATQdt1wBVDNRaRB4AHAKZPnx41oepavQpfj/BHjz9a8Ye/fpWS8xecs2JQqnDB/Mt4cNVqcloPcfPyZWkbuKNJboZV+CKyFigNcegxpdRrI+gjVAz6kIV0lVLPAs+Ct6btCM4/anocLpq7ndgsJsZn6QXbsVBVVYVnwhy2HG3lZHsf04tSOw9RW4/BzLkV/F31Xdgsae3roElihlX4SqllYfZRB0wL2p4K1Id5zrDwm3OKc2xplwsmkkwu8FYDSocArNYeJzkZFq3sNUlNLO7ercAcEZkpIjbgbuD1GPQ7JCdavQpK2+/DY1J+JiJwurMfjycqk7GEoa3XqQOuNElPuG6Zd4hIHVAFvCki7/j2TxaRNQBKKRfwEPAOsB/4nVLqk/DEDo8T2n4fETKtZoqybRza/TGPfuvfUtpVsbXHyXit8DVJTliLtkqpV4BXQuyvB1YGba8B1oTTV6To6DPo6DMAHWEbCdprP+GpR+7HbRj86D9XpWRNYKUU7b1OLp6SH29RNJqwSDuDpH90bzEJRWmW2jcaHNnjrQWayv7pnf0uDHfilTXUaEZL2ir8iXmZmHURi7BZecMyLFYbYjJjTVH/9DadNE2TIqRdARS/h47fw0QTHtdXX80//fev2L3Vzp0335By5hy73c4Lr7xF5oyLyb7+/HiLo9GERVop/Pr2Pnoc3sLlU8ZrhR8prlq8mJLZl5BTkFpeT3a7naVLl+JwOLFYrXxmwdSU+0HTpBdpZdLZc7IDABGvS6EmMkz2KfpTHf30OlMnXfLGjRtxOr3rEy5XeuQM0qQ2aaPw+w03hxu6ACjKydA1bCPIFJ95TCk40tQTZ2kiR3DOIKs1NdcnNOlF2ij8/ac6Mdze4KCp2n4fUYpzMsiwem+lI82po/Crqqr401vvsPy+r/Krl9/Q5hxN0pM2Cn/vyQ5q9+1g7YvP0FCzO97ipBQmkzCzKBvwekG53J44SxQ5Zs+7jGX3fJnrq6+OtygaTdikhcI/2d7Hti0f8dQj9/PWc0/ypc/dmtJRofFg1oQcAJwuD4cauuMsTeRo6XFgMQl5uiqaJgVIC4W/p66Dml3eACHl8aRsgFA8KSvOwmwSavft4N/+/T9S5ge1pdtJQZYVk47Z0KQAKe+W2et0cbihi9nzK7FYbbhdhi5gEQUyLGZ6TuzjqUfux2U4eW31j1ifAmkWdA4dTSqR0grf6fLw2s56XB5FWXkFD65aDaf2cfdty5NeESUi9fs/PmsWlezXuaXHydRCnUNHkxqkrEnH5fbw+q56Tnf0B/aVlVfwrX95LOmVUKJy24rrA2kWzBYrixZfFW+RwqLb4aLfcOuUCpqUISVH+B6PYs3e04G8OX5yMiz64Y0iy6qv5p9//AJbP/yA2fMryZ42N94ihUVrtzeHTlG2TrKnSQ1SUuE3dTv4tPFsT5HzS3PjIE16ceO115A/Yx4Au+vaWThj/FkLnna7nY0bN1JdXZ3Qs63mHgcmEV0GU5MypKTCV0HFl2r37aBm1xZmz6/kC4tui59QacJ5E7LZfKQFgD3bt/IPb67m7ttWBBS7Pz+N0+nEZrMldP781m4n+eMsWMwpa/nUpBlhKXwRuQv4V+AioFIptW2IdrVAF+AGXEqpheH0O1Jq9+0IeI1YrTburlxPSYIql1ShJC+TgiwrO7dtCVz7n/3w+wHF7s9P43a7E35ht6XHoWsmaFKKcIcue4E7gfdH0PZapdSlsVL2wADfe7dOfhUzLpmaP+DaO4LiHvz5acxmc8K7x7b0OCnSaz6aFCIsha+U2q+UOhgpYSKN3/feZEp85ZJKzJ2cz4ULFg3w2CmbdzngzU+zbt06Hn/8cdatWwfAE088kXCBWl39Bg7Do0f4mpQiVjZ8BbwrIgp4Rin1bCw69fveNx/ewUNfuC1hTQepRqbVzMqlS3CtWh1YP+nIm0mPw0V2hoWqqiqqqqoS2p7fqqtcaVKQYRW+iKwFSkMcekwp9doI+1mslKoXkRLgPRE5oJQKaQYSkQeABwCmT58+wtMPTVl5BX/72eXM0wWoY8r8aQXsLq+grLwCgD6nm9d21vOZy6aQYfGmpk5ke35zt1N76GhSjmFNOkqpZUqpeSH+RqrsUUrV+/43Aq8Aledo+6xSaqFSauGECRNG2sWQWM3CnIk5YZ9HMzqKczKYVpg1YF9DZz+v7azH8GXTTGR7fmuPN4eO9tDRpBJRv5tFJFtEcv2vgRvwLvbGhOoLSgIjSk1suXRawVn7Trb18cauetwedZY9P1FG9wDN3Q5tztGkHOG6Zd4B/AiYALwpIjuVUjeKyGTg50qplcBE4BUR8ff3G6XU22HKPSIumzFem3LiyHkTsinIstLeawzYf6yll9d2nuSmSyYF7PmJhMejaO5yMKMoa/jGGk0SEa6XzitKqalKqQyl1ESl1I2+/fU+ZY9S6ohSar7vb65S6j8iIfhwnFeSw9VzimPRlWYIRISlF04MeexYSy+/23qCjj4j5PF40trrxOVROqWCJuVISQPlvp1b2f2n1WzevDneoqQ904uymDclP1BtrHbfjsCx5m4nv916nIbO/nOcIfY0djoA7aGjST1SLrWC3W7n5hU34nQ6+fZ/JJarX7pibTkciLq1WG08uGp1wHunx+Hm5e113FkxldL8zDhL6qWxqx+TiFb4mpQj5Ub4oVz9NPHF/pdNuF0GyuPBZRjU7Noy4LjD8PDHHXUJM9Jv7HJQkGXFrKtcaVKMlFP4iezql65UV1eTYbNhMpuxWK3Mnn+2V67D8PDy9vgrfaUUTV0OinL06F6TeqScScfv6pcM6XfTBf93smHDBsZNvwQmnh+yncPw8Mauej5/xXSybPG5NTv6DA7t/pg9J/ZQ9Jmb9P2jSSlEBecSTjAWLlyotm0LmYBTk6R4PIq39p7mUEPXkG2mF2Zx54Ip+Fx5Y8pv31zLX3/mFtwug4wES/eg0YwEEfl4qCSVKWfS0SQ2JpOwfF7pOaOfj7f2Yvfl1I8169dvxGU48eg1IE0KohW+JuaYTcJNF0/i8rLCIdtsOdpKbXNPDKXyUnbx5Viseg1Ik5qknA1fkxyICFfNKaYgy8r6A424PQNNi0rB2v0N3HdlGdYY5rMpnDmPb/7kRcyN+/UakCbl0ApfE1fmTcknN9PCG7vqObxneyCdcll5BV39LrbWtnLledGPmLbb7byzdh1teXO4ffm1XHvB7VHvU6OJNVrha+LOjKJspjjr+McQwVnbj7Uxd3I++eOil6bYn5ff4XRitlipnPk6XHB91PrTaOKFtuFrEoIDOzbjCRGcZbgVmw43RbVvf7Cex+3GZRjs365TcmhSE63wNQlBcMDc4OCsww3dnGjtjXrf/sCwFdcvjVpfGk080SYdTUIQHDCXP2s+jsLZA45vOtzM568IvwLaufr+7i9f5tIrFrN48ZVR6UejiTda4WsSBn9ufI9H8fuPT1DffibNQkNnP0ebe5hZnB2VvudcvIAldxVxyVRdP0GTumiTjibhMJmEFRdPItM6sFLZlqPRC8bym4xKchMjY6dGEw3CUvgi8j0ROSAiu0XkFREpGKLdchE5KCI1IvKNcPrUpAd5mVaWXlQyYF99e3/UbPl1bX0AlOTpoiea1CXcEf57wDyl1CXAIeDRwQ1ExAz8BFgBlAP3iEh5mP1q0oCWI3vZ9tovBhRN2RyFlAtKKera+jCJUKRz4GtSmLBs+Eqpd4M2NwOfDdGsEqhRSh0BEJGXgNuAfeH0rUlt/L7xTqcTk8Ua8Muva+vjZHsfUwrGRayvpi4H/Yab4twMLDGM6tVoYk0kF22/BPw2xP4pwImg7Trgigj2q0lBggvZKGDre68GonC3FGdxR8XUsPuw2+1s3LiR0gsWQO5MSnK1OUeT2gyr8EVkLVAa4tBjSqnXfG0eA1zAC6FOEWLfkDmZReQB4AGA6dOj44anSXz8vvFOpxOz2czWd/+I2+3CYrXBqtUsnn1bWAuswTMIs8XKV1atpvqCGyL4CTSaxGNYha+UWnau4yJyH3AzsFSFTq5fB0wL2p4K1J+jv2eBZ8GbD384+TSpSbBf/vHjx3n2Zz8bEIW7rXYJKy+eNObzD5hBKKjZtYWJ990awU+g0SQe4XrpLAceAW5VSg3lPrEVmCMiM0XEBtwNvB5Ov5r0oKqqikcffZR7773XWyLRdCYK93BDN+29zjGfOziy12y1cmHFFUzM0y6ZmtQmXBv+j4EM4D1fdaLNSqmviMhk4OdKqZVKKZeIPAS8A5iBXyilPgmzX00a4R/tv/Ta2zCpnLLyCjxK8fGxNpZeNDGsc/76lTVYpszjyiuv1EXLNSmPLnGoSRrcHsXqD2vp7DMAsJiEL101k+yMsY9b/ri9jmMtvSyeXUzlzKELsmg0yYIucahJCcwm4fKy8YFtl0fxq9fe44knnsBut4/6fH1ONyd9AVdTx0fOzVOjSVR0Lh1NUjF3cj5bjrbS1e+idt8OnnrkfjwuA9sYCo7vO9WJy6OwWUyUavu9Jg3QI3xNUmE2CQt9tXBrdm3BZXg9bcZScHzvyQ4AJhdkYtL2e00aoBW+JumYOzmPLJuZ2fMrsVi93js2m42ioqIRm3dOtPbS2uP18pk6PivaIms0CYE26WiSDqvZxPxpBfQ6K3hw1Wpqdm2hbOpEHn74YZxO54jMO3t8o3uAaVrha9IEPcLXJCWXTivAZjFRVl7Bsnu+TG1dQyCQajjzTq/TRU1jNwA2i0mnVNCkDVrha5KSTKuZ8sl5ge3Z8ysxW6yYzV7zTnV19ZDv3VffidvjdUeeUjBO2+81aYM26WiSlgXTx7P7RAcepSgrr+Arq1bTe2w3X7rr5iHNOS63Z6A5p1C7Y2rSB63wNUlL/jgr50/M4cDpLgDKyiugvILsaSUh23s8ijV7T9PeawT2afu9Jp3QJh1NUrOwrBAZZJHZcKDprMpYSine3dfAuo2bWPviM9Tu20Fhto0S7X+vSSP0CF+T1EzIzWBOSS6HGroC+zxK8afdp7hoUi6l+ZlMyhvH9hNtvLXuzzz1yP24DCcWq41nfvMqUBYv0TWamKMVvibpWTSrkMONXQSnheo33Ow43g5A7b4d1OzaQltjPS7DifJ4cBsGJ/ZtgztvjI/QGk0c0Apfk/QU5WRwYWku+091nXXMn37BZTgxmS2YzRbcuLFYrVy/9Lo4SKvRxA+t8DUpwaJZRRw83Y1nUPZXf/oF5fHgwc2iFXcxvmQyf/O5m0aVd0ejSQW0wtckHf5atNXV1QGlXZBlo3xyXiA/jh9/+gWXYWCxWrn8+tu55LJK7lhcFgfJNZr4ohW+JqkIrkU7OIXColmF1DR202+4A+3Lys+kX5g9v5Ky8grmTc5DBrv2aDRpgHbL1CQVwbVoB6dQyM20smJe6Vlumv70C2XlFWRYTcydkh9boTWaBCHcmrbfE5EDIrJbRF4RkYIh2tWKyB4R2SkiuoSVZswE16INlUKhrDibqllFId9rMQm3zp9MThgVsjSaZCbcEf57wDyl1CXAIeDRc7S9Vil16VCltzSakeCvRfv4448PmRGzcmYhxqkDgQArAJMIKy+ZpFMha9KasIY6Sql3gzY3A58NTxyNZniqqqrO6WGzefNm/vUrd+NwOrFarTzywxf43E1LOW9CTgyl1GgSj0ja8L8EvDXEMQW8KyIfi8gD5zqJiDwgIttEZFtTU1MExdOkC347v8ftxmUYZDYfZO5kbbfXaIYd4YvIWqA0xKHHlFKv+do8BriAF4Y4zWKlVL2IlADvicgBpdT7oRoqpZ4FngVYuHChCtVGozkXfju/35PnXKmSNZp0YliFr5Radq7jInIfcDOwVCkVUkErpep9/xtF5BWgEgip8DWacPHb+Qf76ms06U5YNnwRWQ48AlyjlOodok02YFJKdfle3wD8Wzj9ajTDMZydX6NJR8K14f8YyMVrptkpIk8DiMhkEVnjazMR+IuI7AK2AG8qpd4Os1+NRqPRjJJwvXRmD7G/Hljpe30EmB9OPxqNRqMJHx1pq9FoNGmCVvgajUaTJmiFr9FoNGmCVvgajUaTJsgQrvMJgYg0AcfG+PZioDmC4kQKLdfo0HKNDi3X6EhFuWYopSaEOpDQCj8cRGRbIiZq03KNDi3X6NByjY50k0ubdDQajSZN0Apfo9Fo0oRUVvjPxluAIdByjQ4t1+jQco2OtJIrZW34Go1GoxlIKo/wNRqNRhOEVvgajUaTJiS1wheR5SJyUERqROQbIY6LiPzQd3y3iCyIkVzTRGSDiOwXkU9E5Ksh2lSLSIcvy+hOEflmjGQ7Z0H5eFwzEbkg6DrsFJFOEXl4UJuYXC8R+YWINIrI3qB9hSLynogc9v0fP8R7z3k/RkGu74nIAd/39IqIFAzx3nN+51GQ619F5GTQd7VyiPfG+nr9NkimWhHZOcR7o3m9QuqGmN1jSqmk/APMwKfALMAG7ALKB7VZibfsogCLgI9iJNskYIHvdS7eAu+DZasG/hSH61YLFJ/jeFyu2aDv9TTe4JGYXy9gCbAA2Bu077vAN3yvvwGsGsv9GAW5bgAsvterQsk1ku88CnL9K/C1EXzPMb1eg47/J/DNOFyvkLohVvdYMo/wK4EapdQRpZQTeAm4bVCb24DnlZfNQIGITIq2YEqpU0qp7b7XXcB+YEq0+40QcblmQSwFPlVKjTXCOiyUt/Rm66DdtwHP+V4/B9we4q0juR8jKpdS6l2llMu3uRmYGqn+wpFrhMT8evkREQE+B7wYqf5Gyjl0Q0zusWRW+FOAE0HbdZytVEfSJqqISBlQAXwU4nCViOwSkbdEZG6MRBquoHy8r9ndDP0gxuN6AUxUSp0C7wMLlIRoE+/r9iW8M7NQDPedR4OHfKamXwxhnojn9boaaFBKHR7ieEyu1yDdEJN7LJkVvoTYN9jHdCRtooaI5AAvAw8rpToHHd6O12wxH/gR8GqMxFqslFoArAD+XkSWDDoet2smIjbgVuD3IQ7H63qNlHhet8cAF/DCEE2G+84jzVPAecClwCm85pPBxPPZvIdzj+6jfr2G0Q1Dvi3EvlFds2RW+HXAtKDtqUD9GNpEBRGx4v1CX1BK/XHwcaVUp1Kq2/d6DWAVkeJoy6WCCsoD/oLywcTtmuF9wLYrpRoGH4jX9fLR4Ddr+f43hmgTl+smIvcBNwNfUD5D72BG8J1HFKVUg1LKrZTyAD8bor94XS8LcCfw26HaRPt6DaEbYnKPJbPC3wrMEZGZvpHh3cDrg9q8Dtzr8zxZBHT4p03RxGcj/B9gv1Lqv4ZoU+prh4hU4v0uWqIsV7aI5Ppf41302zuoWVyumY8hR17xuF5BvA7c53t9H/BaiDYjuR8jiogsBx4BblVK9Q7RZiTfeaTlCl7zuWOI/mJ+vXwsAw4opepCHYz29TqHbojNPRaNlehY/eH1KDmEd+X6Md++rwBf8b0W4Ce+43uAhTGS6yq8U63dwE7f38pBsj0EfIJ3pX0zcGUM5Jrl62+Xr+9EumZZeBV4ftC+mF8vvD84pwAD74jqb4AiYB1w2Pe/0Nd2MrDmXPdjlOWqwWvT9d9jTw+Wa6jvPMpy/cp37+zGq5AmJcL18u1f7b+ngtrG8noNpRtico/p1AoajUaTJiSzSUej0Wg0o0ArfI1Go0kTtMLXaDSaNEErfI1Go0kTtMLXaDSaNEErfI1Go0kTtMLXaDSaNOH/B+4+CcKwIqyzAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -201,12 +261,13 @@ } ], "source": [ - "f = tr.posterior['f'].stack({\"f\": [\"chain\", \"draw\"]}).values\n", + "f = ppc.posterior_predictive[\"f_cond\"].stack({\"f\": [\"chain\", \"draw\"]}).values\n", "upper = np.percentile(f, 95, axis=1)\n", "lower = np.percentile(f, 5, axis=1)\n", "\n", - "plt.plot(x, y, 'k.');\n", - "plt.fill_between(x, lower, upper, alpha=0.5);" + "plt.plot(x, y, \"k.\")\n", + "plt.plot(x_cond, f_cond_true, \"-r\")\n", + "plt.fill_between(x_cond, lower, upper, alpha=0.5);" ] }, { @@ -229,9 +290,9 @@ "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", - "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + "/home/lpaz/repos/pymc3/pymc/model.py:925: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", " warnings.warn(\n", - "Multiprocess sampling (3 chains in 3 jobs)\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [eta, ell, f_u_rotated_, sigma]\n" ] }, @@ -252,8 +313,8 @@ " background: #F44336;\n", " }\n", " \n", - " \n", - " 100.00% [6000/6000 02:32<00:00 Sampling 3 chains, 0 divergences]\n", + " \n", + " 100.00% [4000/4000 00:30<00:00 Sampling 2 chains, 85 divergences]\n", " \n", " " ], @@ -268,16 +329,48 @@ "name": "stderr", "output_type": "stream", "text": [ - "Sampling 3 chains for 1_000 tune and 1_000 draw iterations (3_000 + 3_000 draws total) took 153 seconds.\n", - "The number of effective samples is smaller than 25% for some parameters.\n" + "Sampling 2 chains for 1_000 tune and 1_000 draw iterations (2_000 + 2_000 draws total) took 31 seconds.\n", + "There were 80 divergences after tuning. Increase `target_accept` or reparameterize.\n", + "The acceptance probability does not match the target. It is 0.6343, but should be close to 0.9. Try to increase the number of tuning steps.\n", + "There were 5 divergences after tuning. Increase `target_accept` or reparameterize.\n", + "The estimated number of effective samples is smaller than 200 for some parameters.\n" ] }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [2000/2000 00:06<00:00]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 7.51 s, sys: 227 ms, total: 7.74 s\n", - "Wall time: 2min 40s\n" + "CPU times: user 20 s, sys: 424 ms, total: 20.4 s\n", + "Wall time: 45.3 s\n" ] } ], @@ -285,18 +378,22 @@ "%%time\n", "\n", "with pm.Model() as model:\n", - " eta = pm.HalfNormal('eta', sd=1)\n", - " ell = pm.Gamma('ell', alpha=2, beta=1)\n", - " cov = eta**2 * ExpQuad(1, ls=ell)\n", + " eta = pm.HalfNormal(\"eta\", sd=1)\n", + " ell = pm.Gamma(\"ell\", alpha=2, beta=1)\n", + " cov = eta ** 2 * ExpQuad(1, ls=ell)\n", " gp = ProjectedProcess(n_inducing=15, cov_func=cov)\n", "\n", " f = gp.prior(\"f\", X=x[:, None])\n", - " \n", + "\n", " sigma = pm.HalfNormal(\"sigma\", sd=1)\n", " pm.Normal(\"lik\", mu=f, sd=sigma, observed=y)\n", - " \n", + "\n", "with model:\n", - " tr = pm.sample(target_accept=0.9)" + " tr = pm.sample(target_accept=0.9)\n", + "\n", + "with model:\n", + " f_cond = gp.conditional(\"f_cond\", x_cond[:, None])\n", + " ppc = pm.sample_posterior_predictive(tr, var_names=[\"f_cond\"])" ] }, { @@ -307,7 +404,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -319,7 +416,7 @@ } ], "source": [ - "pm.plot_trace(tr, var_names=['eta', 'ell', 'sigma']);" + "pm.plot_trace(tr, var_names=[\"eta\", \"ell\", \"sigma\"]);" ] }, { @@ -330,7 +427,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -342,12 +439,13 @@ } ], "source": [ - "f = tr.posterior['f'].stack({\"f\": [\"chain\", \"draw\"]}).values\n", + "f = ppc.posterior_predictive[\"f_cond\"].stack({\"f\": [\"chain\", \"draw\"]}).values\n", "upper = np.percentile(f, 95, axis=1)\n", "lower = np.percentile(f, 5, axis=1)\n", "\n", - "plt.plot(x, y, 'k.');\n", - "plt.fill_between(x, lower, upper, alpha=0.5);" + "plt.plot(x, y, \"k.\")\n", + "plt.plot(x_cond, f_cond_true, \"-r\")\n", + "plt.fill_between(x_cond, lower, upper, alpha=0.5);" ] }, { @@ -370,11 +468,11 @@ "text": [ "Auto-assigning NUTS sampler...\n", "Initializing NUTS using jitter+adapt_diag...\n", - "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + "/home/lpaz/repos/pymc3/pymc/model.py:925: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", " warnings.warn(\n", - "Multiprocess sampling (3 chains in 3 jobs)\n", + "Multiprocess sampling (2 chains in 2 jobs)\n", "NUTS: [eta, ell, f_coeffs_, sigma]\n", - "/home/bill/miniconda3/envs/hsgp/lib/python3.10/site-packages/pymc/model.py:984: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", + "/home/lpaz/repos/pymc3/pymc/model.py:925: FutureWarning: `Model.initial_point` has been deprecated. Use `Model.recompute_initial_point(seed=None)`.\n", " warnings.warn(\n" ] }, @@ -395,8 +493,8 @@ " background: #F44336;\n", " }\n", " \n", - " \n", - " 100.00% [6000/6000 00:39<00:00 Sampling 3 chains, 0 divergences]\n", + " \n", + " 100.00% [4000/4000 00:11<00:00 Sampling 2 chains, 0 divergences]\n", " \n", " " ], @@ -411,15 +509,45 @@ "name": "stderr", "output_type": "stream", "text": [ - "Sampling 3 chains for 1_000 tune and 1_000 draw iterations (3_000 + 3_000 draws total) took 40 seconds.\n" + "Sampling 2 chains for 1_000 tune and 1_000 draw iterations (2_000 + 2_000 draws total) took 12 seconds.\n", + "The number of effective samples is smaller than 25% for some parameters.\n" ] }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " \n", + " 100.00% [2000/2000 00:00<00:00]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "name": "stdout", "output_type": "stream", "text": [ - "CPU times: user 6.09 s, sys: 222 ms, total: 6.31 s\n", - "Wall time: 44.3 s\n" + "CPU times: user 6.65 s, sys: 247 ms, total: 6.9 s\n", + "Wall time: 17.9 s\n" ] } ], @@ -427,18 +555,22 @@ "%%time\n", "\n", "with pm.Model() as model:\n", - " eta = pm.HalfNormal('eta', sd=1)\n", - " ell = pm.Gamma('ell', alpha=2, beta=1)\n", - " cov = eta**2 * ExpQuad(1, ls=ell)\n", + " eta = pm.HalfNormal(\"eta\", sd=1)\n", + " ell = pm.Gamma(\"ell\", alpha=2, beta=1)\n", + " cov = eta ** 2 * ExpQuad(1, ls=ell)\n", " gp = HSGP(n_basis=20, cov_func=cov)\n", - " \n", + "\n", " f = gp.prior(\"f\", X=x[:, None])\n", - " \n", + "\n", " sigma = pm.HalfNormal(\"sigma\", sd=1)\n", " pm.Normal(\"lik\", mu=f, sd=sigma, observed=y)\n", - " \n", + "\n", + "with model:\n", + " tr = pm.sample(target_accept=0.9)\n", + "\n", "with model:\n", - " tr = pm.sample(target_accept=0.9)" + " f_cond = gp.conditional(\"f_cond\", x_cond[:, None])\n", + " ppc = pm.sample_posterior_predictive(tr, var_names=[\"f_cond\"])" ] }, { @@ -449,7 +581,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -461,7 +593,7 @@ } ], "source": [ - "pm.plot_trace(tr, var_names=['eta', 'ell', 'sigma']);" + "pm.plot_trace(tr, var_names=[\"eta\", \"ell\", \"sigma\"]);" ] }, { @@ -472,7 +604,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -484,44 +616,21 @@ } ], "source": [ - "f = tr.posterior['f'].stack({\"f\": [\"chain\", \"draw\"]}).values\n", + "f = ppc.posterior_predictive[\"f_cond\"].stack({\"f\": [\"chain\", \"draw\"]}).values\n", "upper = np.percentile(f, 95, axis=1)\n", "lower = np.percentile(f, 5, axis=1)\n", "\n", - "plt.plot(x, y, 'k.');\n", - "plt.fill_between(x, lower, upper, alpha=0.5);" + "plt.plot(x, y, \"k.\")\n", + "plt.plot(x_cond, f_cond_true, \"-r\")\n", + "plt.fill_between(x_cond, lower, upper, alpha=0.5);" ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "b80fa037-9762-4f34-a248-f8d034554528", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "eb8d895c-ae75-424c-960e-47a7b624797f", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "7f192ef1-c58e-4f76-b7d3-adf726c82c44", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { "kernelspec": { - "display_name": "hsgp", + "display_name": "Python 3", "language": "python", - "name": "hsgp" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -533,7 +642,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.1" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/pymc_experimental/gp/latent_approx.py b/pymc_experimental/gp/latent_approx.py index a1061408e..a0bbaa0e6 100644 --- a/pymc_experimental/gp/latent_approx.py +++ b/pymc_experimental/gp/latent_approx.py @@ -61,9 +61,9 @@ def _build_conditional(self, name, Xnew, Xu, L, Kuuiu, jitter, **kwargs): Lss = cholesky(stabilize(Kss - Qss, jitter)) return mu, Lss - def conditional(self, name, Xnew, jitter, **kwargs): + def conditional(self, name, Xnew, jitter=1e-6, **kwargs): mu, chol = self._build_conditional(name, Xnew, self.Xu, self.L, self.Kuuiu, jitter, **kwargs) - return pm.MvNormal("fnew", mu=mu, chol=chol) + return pm.MvNormal(name, mu=mu, chol=chol) class HSGP(pm.gp.Latent): @@ -211,4 +211,4 @@ def conditional(self, name, Xnew, jitter=1e-6, **kwargs): X, f = self.X, self.f U, s = self.U, self.s mu, L = self._build_conditional(Xnew, X, f, U, s, jitter) - return pm.MvNormal(name, mu=mu, chol=L, **kwargs) \ No newline at end of file + return pm.MvNormal(name, mu=mu, chol=L, **kwargs)