From 4e9880aa93b240927b5c1c03b09dece5e7b4a618 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Mon, 29 Jul 2024 11:07:25 -0300 Subject: [PATCH 01/29] extracting taking last --- blackjax/smc/tempered.py | 41 ++++++++++++++++++++++++++------------ blackjax/smc/waste_free.py | 23 +++++++++++++++++++++ 2 files changed, 51 insertions(+), 13 deletions(-) create mode 100644 blackjax/smc/waste_free.py diff --git a/blackjax/smc/tempered.py b/blackjax/smc/tempered.py index 43b83d034..5a1fcfb18 100644 --- a/blackjax/smc/tempered.py +++ b/blackjax/smc/tempered.py @@ -141,26 +141,16 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: shared_mcmc_step_fn = partial(mcmc_step_fn, **shared_mcmc_parameters) - def mcmc_kernel(rng_key, position, step_parameters): - state = mcmc_init_fn(position, tempered_logposterior_fn) - - def body_fn(state, rng_key): - new_state, info = shared_mcmc_step_fn( - rng_key, state, tempered_logposterior_fn, **step_parameters - ) - return new_state, info - - keys = jax.random.split(rng_key, num_mcmc_steps) - last_state, info = jax.lax.scan(body_fn, state, keys) - return last_state.position, info + update_fn = mutate_and_take_last(mcmc_init_fn, tempered_logposterior_fn, shared_mcmc_step_fn, num_mcmc_steps) smc_state, info = smc.base.step( rng_key, SMCState(state.particles, state.weights, unshared_mcmc_parameters), - jax.vmap(mcmc_kernel), + update_fn, jax.vmap(log_weights_fn), resampling_fn, ) + tempered_state = TemperedSMCState( smc_state.particles, smc_state.weights, state.lmbda + delta ) @@ -170,6 +160,31 @@ def body_fn(state, rng_key): return kernel +def mutate_and_take_last(mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + num_mcmc_steps): + """ + Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and + returns the last values, waisting the previous num_mcmc_steps-1 + samples per chain. + """ + def mcmc_kernel(rng_key, position, step_parameters): + state = mcmc_init_fn(position, tempered_logposterior_fn) + + def body_fn(state, rng_key): + new_state, info = shared_mcmc_step_fn( + rng_key, state, tempered_logposterior_fn, **step_parameters + ) + return new_state, info + + keys = jax.random.split(rng_key, num_mcmc_steps) + last_state, info = jax.lax.scan(body_fn, state, keys) + return last_state.position, info + + return jax.vmap(mcmc_kernel) + + def as_top_level_api( logprior_fn: Callable, loglikelihood_fn: Callable, diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py new file mode 100644 index 000000000..dd5069976 --- /dev/null +++ b/blackjax/smc/waste_free.py @@ -0,0 +1,23 @@ +def mutate_waste_free( mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + num_mcmc_steps): + """ + Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and + returns the last values, waisting the previous num_mcmc_steps-1 + samples per chain. + """ + def mcmc_kernel(rng_key, position, step_parameters): + state = mcmc_init_fn(position, tempered_logposterior_fn) + + def body_fn(state, rng_key): + new_state, info = shared_mcmc_step_fn( + rng_key, state, tempered_logposterior_fn, **step_parameters + ) + return new_state, info + + keys = jax.random.split(rng_key, num_mcmc_steps) + last_state, info = jax.lax.scan(body_fn, state, keys) + return last_state.position, info + + return jax.vmap(mcmc_kernel) \ No newline at end of file From 753b89bb7a6176c28ca148ae13f0faf0d2a41e51 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Mon, 29 Jul 2024 15:41:43 -0300 Subject: [PATCH 02/29] test passing --- blackjax/__init__.py | 60 ++------------------------ blackjax/smc/tempered.py | 67 ++++++++++++++++------------- blackjax/smc/waste_free.py | 50 +++++++++++++++------- tests/smc/test_waste_free_smc.py | 72 ++++++++++++++++++++++++++++++++ 4 files changed, 150 insertions(+), 99 deletions(-) create mode 100644 tests/smc/test_waste_free_smc.py diff --git a/blackjax/__init__.py b/blackjax/__init__.py index dfdcfc545..6c85e2afc 100644 --- a/blackjax/__init__.py +++ b/blackjax/__init__.py @@ -3,11 +3,7 @@ from blackjax._version import __version__ -from .adaptation.chees_adaptation import chees_adaptation -from .adaptation.mclmc_adaptation import mclmc_find_L_and_step_size -from .adaptation.meads_adaptation import meads_adaptation -from .adaptation.pathfinder_adaptation import pathfinder_adaptation -from .adaptation.window_adaptation import window_adaptation + from .base import SamplingAlgorithm, VIAlgorithm from .diagnostics import effective_sample_size as ess from .diagnostics import potential_scale_reduction as rhat @@ -28,19 +24,11 @@ normal_random_walk, rmh_as_top_level_api, ) -from .optimizers import dual_averaging, lbfgs -from .sgmcmc import csgld as _csgld -from .sgmcmc import sghmc as _sghmc -from .sgmcmc import sgld as _sgld -from .sgmcmc import sgnht as _sgnht + from .smc import adaptive_tempered from .smc import inner_kernel_tuning as _inner_kernel_tuning from .smc import tempered -from .vi import meanfield_vi as _meanfield_vi -from .vi import pathfinder as _pathfinder -from .vi import schrodinger_follmer as _schrodinger_follmer -from .vi import svgd as _svgd -from .vi.pathfinder import PathFinderAlgorithm + """ The above three classes exist as a backwards compatible way of exposing both the high level, differentiable @@ -73,15 +61,6 @@ def __call__(self, *args, **kwargs) -> VIAlgorithm: return self.differentiable(*args, **kwargs) -@dataclasses.dataclass -class GeneratePathfinderAPI: - differentiable: Callable - approximate: Callable - sample: Callable - - def __call__(self, *args, **kwargs) -> PathFinderAlgorithm: - return self.differentiable(*args, **kwargs) - def generate_top_level_api_from(module): return GenerateSamplingAPI( @@ -123,41 +102,10 @@ def generate_top_level_api_from(module): smc_family = [tempered_smc, adaptive_tempered_smc] "Step_fn returning state has a .particles attribute" -# stochastic gradient mcmc -sgld = generate_top_level_api_from(_sgld) -sghmc = generate_top_level_api_from(_sghmc) -sgnht = generate_top_level_api_from(_sgnht) -csgld = generate_top_level_api_from(_csgld) -svgd = generate_top_level_api_from(_svgd) - -# variational inference -meanfield_vi = GenerateVariationalAPI( - _meanfield_vi.as_top_level_api, - _meanfield_vi.init, - _meanfield_vi.step, - _meanfield_vi.sample, -) -schrodinger_follmer = GenerateVariationalAPI( - _schrodinger_follmer.as_top_level_api, - _schrodinger_follmer.init, - _schrodinger_follmer.step, - _schrodinger_follmer.sample, -) - -pathfinder = GeneratePathfinderAPI( - _pathfinder.as_top_level_api, _pathfinder.approximate, _pathfinder.sample -) - __all__ = [ "__version__", - "dual_averaging", # optimizers - "lbfgs", - "window_adaptation", # mcmc adaptation - "meads_adaptation", - "chees_adaptation", - "pathfinder_adaptation", - "mclmc_find_L_and_step_size", # mclmc adaptation + "ess", # diagnostics "rhat", ] diff --git a/blackjax/smc/tempered.py b/blackjax/smc/tempered.py index 5a1fcfb18..091c65aa8 100644 --- a/blackjax/smc/tempered.py +++ b/blackjax/smc/tempered.py @@ -12,7 +12,7 @@ # See the License for the specific language governing permissions and # limitations under the License. from functools import partial -from typing import Callable, NamedTuple +from typing import Callable, NamedTuple, Optional import jax import jax.numpy as jnp @@ -48,12 +48,39 @@ def init(particles: ArrayLikeTree): return TemperedSMCState(particles, weights, 0.0) +def mutate_and_take_last(mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + num_mcmc_steps, + n_particles): + """ + Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and + returns the last values, waisting the previous num_mcmc_steps-1 + samples per chain. + """ + def mcmc_kernel(rng_key, position, step_parameters): + state = mcmc_init_fn(position, tempered_logposterior_fn) + + def body_fn(state, rng_key): + new_state, info = shared_mcmc_step_fn( + rng_key, state, tempered_logposterior_fn, **step_parameters + ) + return new_state, info + + keys = jax.random.split(rng_key, num_mcmc_steps) + last_state, info = jax.lax.scan(body_fn, state, keys) + return last_state.position, info + + return jax.vmap(mcmc_kernel), n_particles + + def build_kernel( logprior_fn: Callable, loglikelihood_fn: Callable, mcmc_step_fn: Callable, mcmc_init_fn: Callable, resampling_fn: Callable, + update_strategy: Callable = mutate_and_take_last ) -> Callable: """Build the base Tempered SMC kernel. @@ -141,7 +168,11 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: shared_mcmc_step_fn = partial(mcmc_step_fn, **shared_mcmc_parameters) - update_fn = mutate_and_take_last(mcmc_init_fn, tempered_logposterior_fn, shared_mcmc_step_fn, num_mcmc_steps) + update_fn, num_resampled = update_strategy(mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + n_particles=state.weights.shape[0], + num_mcmc_steps=num_mcmc_steps) smc_state, info = smc.base.step( rng_key, @@ -149,6 +180,7 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: update_fn, jax.vmap(log_weights_fn), resampling_fn, + num_resampled ) tempered_state = TemperedSMCState( @@ -160,31 +192,6 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: return kernel -def mutate_and_take_last(mcmc_init_fn, - tempered_logposterior_fn, - shared_mcmc_step_fn, - num_mcmc_steps): - """ - Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and - returns the last values, waisting the previous num_mcmc_steps-1 - samples per chain. - """ - def mcmc_kernel(rng_key, position, step_parameters): - state = mcmc_init_fn(position, tempered_logposterior_fn) - - def body_fn(state, rng_key): - new_state, info = shared_mcmc_step_fn( - rng_key, state, tempered_logposterior_fn, **step_parameters - ) - return new_state, info - - keys = jax.random.split(rng_key, num_mcmc_steps) - last_state, info = jax.lax.scan(body_fn, state, keys) - return last_state.position, info - - return jax.vmap(mcmc_kernel) - - def as_top_level_api( logprior_fn: Callable, loglikelihood_fn: Callable, @@ -192,7 +199,8 @@ def as_top_level_api( mcmc_init_fn: Callable, mcmc_parameters: dict, resampling_fn: Callable, - num_mcmc_steps: int = 10, + num_mcmc_steps: Optional[int] = 10, + update_strategy = mutate_and_take_last ) -> SamplingAlgorithm: """Implements the (basic) user interface for the Adaptive Tempered SMC kernel. @@ -219,12 +227,15 @@ def as_top_level_api( A ``SamplingAlgorithm``. """ + + kernel = build_kernel( logprior_fn, loglikelihood_fn, mcmc_step_fn, mcmc_init_fn, resampling_fn, + update_strategy ) def init_fn(position: ArrayLikeTree, rng_key=None): diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py index dd5069976..666dd09b2 100644 --- a/blackjax/smc/waste_free.py +++ b/blackjax/smc/waste_free.py @@ -1,23 +1,43 @@ -def mutate_waste_free( mcmc_init_fn, - tempered_logposterior_fn, - shared_mcmc_step_fn, - num_mcmc_steps): +import jax.lax +import jax +import jax.numpy as jnp + + +def mutate_waste_free(mcmc_init_fn, + logposterior_fn, + mcmc_step_fn, + n_particles: int, + p: int, + num_mcmc_steps=None): """ - Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and - returns the last values, waisting the previous num_mcmc_steps-1 - samples per chain. + Given M particles, mutates them using p-1 steps. Returns M*P-1 particles, + consistent of the initial plus all the intermediate steps, thus implementing a + waste-free update function + See Algorithm 2: https://arxiv.org/abs/2011.02328 """ + if num_mcmc_steps is not None: + raise ValueError("Can't use waste free SMC with a num_mcmc_steps parameter") + + num_mcmc_steps = p-1 + num_resampled = 25 + def mcmc_kernel(rng_key, position, step_parameters): - state = mcmc_init_fn(position, tempered_logposterior_fn) + state = mcmc_init_fn(position, logposterior_fn) def body_fn(state, rng_key): - new_state, info = shared_mcmc_step_fn( - rng_key, state, tempered_logposterior_fn, **step_parameters + new_state, info = mcmc_step_fn( + rng_key, state, logposterior_fn, **step_parameters ) - return new_state, info + return new_state, (new_state, info) + + _, (states, infos) = jax.lax.scan(body_fn, state, jax.random.split(rng_key, num_mcmc_steps)) + return states, infos + def gather(rng_key, position, step_parameters): + states, infos= jax.vmap(mcmc_kernel)(rng_key, position, step_parameters) + step_particles = jax.tree.map(lambda x: x.reshape((num_resampled * num_mcmc_steps)), states.position) + initial_particles = jax.tree.map(lambda x: x.reshape((num_resampled,)), position) + new_particles = jax.tree.map(lambda x,y: jax.numpy.hstack([x,y]), initial_particles, step_particles) + return new_particles, None - keys = jax.random.split(rng_key, num_mcmc_steps) - last_state, info = jax.lax.scan(body_fn, state, keys) - return last_state.position, info + return gather, num_resampled - return jax.vmap(mcmc_kernel) \ No newline at end of file diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py new file mode 100644 index 000000000..f7762f6e4 --- /dev/null +++ b/tests/smc/test_waste_free_smc.py @@ -0,0 +1,72 @@ +"""Test the tempered SMC steps and routine""" +import functools + +import chex +import jax +import jax.numpy as jnp +import jax.scipy.stats as stats +import numpy as np +from absl.testing import absltest + +import blackjax +import blackjax.smc.resampling as resampling +import blackjax.smc.solver as solver +from blackjax import adaptive_tempered_smc, tempered_smc +from blackjax.smc import extend_params +from blackjax.smc.waste_free import mutate_waste_free +from tests.smc import SMCLinearRegressionTestCase + +#jax.config.update("jax_disable_jit", True) # for easier debugging +class TemperedSMCTest(SMCLinearRegressionTestCase): + """Test posterior mean estimate.""" + + def setUp(self): + super().setUp() + self.key = jax.random.key(42) + @chex.variants(with_jit=True) + def test_fixed_schedule_tempered_smc(self): + ( + init_particles, + logprior_fn, + loglikelihood_fn, + ) = self.particles_prior_loglikelihood() + + num_tempering_steps = 10 + + lambda_schedule = np.logspace(-5, 0, num_tempering_steps) + hmc_init = blackjax.hmc.init + hmc_kernel = blackjax.hmc.build_kernel() + hmc_parameters = extend_params( + { + "step_size": 10e-2, + "inverse_mass_matrix": jnp.eye(2), + "num_integration_steps": 50, + }, + ) + + tempering = tempered_smc( + logprior_fn, + loglikelihood_fn, + hmc_kernel, + hmc_init, + hmc_parameters, + resampling.systematic, + None, + functools.partial(mutate_waste_free, p=4) + ) + init_state = tempering.init(init_particles) + smc_kernel = self.variant(tempering.step) + + def body_fn(carry, lmbda): + i, state = carry + subkey = jax.random.fold_in(self.key, i) + new_state, info = smc_kernel(subkey, state, lmbda) + return (i + 1, new_state), (new_state, info) + + (_, result), _ = jax.lax.scan(body_fn, (0, init_state), lambda_schedule) + self.assert_linear_regression_test_case(result) + + + +if __name__ == "__main__": + absltest.main() From 46676e2f2821740f134a8a0f19ed1481283fe963 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Mon, 29 Jul 2024 15:53:25 -0300 Subject: [PATCH 03/29] layering --- blackjax/smc/tempered.py | 6 +++--- blackjax/smc/waste_free.py | 10 +++++++--- tests/smc/test_waste_free_smc.py | 4 ++-- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/blackjax/smc/tempered.py b/blackjax/smc/tempered.py index 091c65aa8..04990796d 100644 --- a/blackjax/smc/tempered.py +++ b/blackjax/smc/tempered.py @@ -48,7 +48,7 @@ def init(particles: ArrayLikeTree): return TemperedSMCState(particles, weights, 0.0) -def mutate_and_take_last(mcmc_init_fn, +def update_and_take_last(mcmc_init_fn, tempered_logposterior_fn, shared_mcmc_step_fn, num_mcmc_steps, @@ -80,7 +80,7 @@ def build_kernel( mcmc_step_fn: Callable, mcmc_init_fn: Callable, resampling_fn: Callable, - update_strategy: Callable = mutate_and_take_last + update_strategy: Callable = update_and_take_last ) -> Callable: """Build the base Tempered SMC kernel. @@ -200,7 +200,7 @@ def as_top_level_api( mcmc_parameters: dict, resampling_fn: Callable, num_mcmc_steps: Optional[int] = 10, - update_strategy = mutate_and_take_last + update_strategy = update_and_take_last ) -> SamplingAlgorithm: """Implements the (basic) user interface for the Adaptive Tempered SMC kernel. diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py index 666dd09b2..674f902ca 100644 --- a/blackjax/smc/waste_free.py +++ b/blackjax/smc/waste_free.py @@ -1,14 +1,16 @@ import jax.lax import jax import jax.numpy as jnp +import functools -def mutate_waste_free(mcmc_init_fn, +def update_waste_free(mcmc_init_fn, logposterior_fn, mcmc_step_fn, n_particles: int, p: int, - num_mcmc_steps=None): + num_resampled, + num_mcmc_steps): """ Given M particles, mutates them using p-1 steps. Returns M*P-1 particles, consistent of the initial plus all the intermediate steps, thus implementing a @@ -19,7 +21,6 @@ def mutate_waste_free(mcmc_init_fn, raise ValueError("Can't use waste free SMC with a num_mcmc_steps parameter") num_mcmc_steps = p-1 - num_resampled = 25 def mcmc_kernel(rng_key, position, step_parameters): state = mcmc_init_fn(position, logposterior_fn) @@ -32,6 +33,7 @@ def body_fn(state, rng_key): _, (states, infos) = jax.lax.scan(body_fn, state, jax.random.split(rng_key, num_mcmc_steps)) return states, infos + def gather(rng_key, position, step_parameters): states, infos= jax.vmap(mcmc_kernel)(rng_key, position, step_parameters) step_particles = jax.tree.map(lambda x: x.reshape((num_resampled * num_mcmc_steps)), states.position) @@ -41,3 +43,5 @@ def gather(rng_key, position, step_parameters): return gather, num_resampled +def waste_free_smc(n_particles, p): + return functools.partial(update_waste_free, num_resampled=int(n_particles / p), p=p) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index f7762f6e4..5a1ba4a84 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -13,7 +13,7 @@ import blackjax.smc.solver as solver from blackjax import adaptive_tempered_smc, tempered_smc from blackjax.smc import extend_params -from blackjax.smc.waste_free import mutate_waste_free +from blackjax.smc.waste_free import update_waste_free, waste_free_smc from tests.smc import SMCLinearRegressionTestCase #jax.config.update("jax_disable_jit", True) # for easier debugging @@ -52,7 +52,7 @@ def test_fixed_schedule_tempered_smc(self): hmc_parameters, resampling.systematic, None, - functools.partial(mutate_waste_free, p=4) + waste_free_smc(100,4) ) init_state = tempering.init(init_particles) smc_kernel = self.variant(tempering.step) From 1c264051c93b69f496808dd6b7a791cf0dea1f7a Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 6 Aug 2024 19:03:58 -0300 Subject: [PATCH 04/29] example --- blackjax/smc/to_debug.py | 0 logistic_regression.ipynb | 662 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 662 insertions(+) create mode 100644 blackjax/smc/to_debug.py create mode 100644 logistic_regression.ipynb diff --git a/blackjax/smc/to_debug.py b/blackjax/smc/to_debug.py new file mode 100644 index 000000000..e69de29bb diff --git a/logistic_regression.ipynb b/logistic_regression.ipynb new file mode 100644 index 000000000..07ba642aa --- /dev/null +++ b/logistic_regression.ipynb @@ -0,0 +1,662 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3cdc536d", + "metadata": {}, + "source": [ + "# Waste Free SMC comparison\n", + "\n", + "In this notebook we demonstrate the use of the random walk Rosenbluth-Metropolis-Hasting algorithm on a simple logistic regression." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de1922dd", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7dba964", + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import sklearn\n", + "\n", + "plt.rcParams[\"axes.spines.right\"] = False\n", + "plt.rcParams[\"axes.spines.top\"] = False\n", + "plt.rcParams[\"figure.figsize\"] = (12, 8)\n", + "import jax\n", + "\n", + "from datetime import date\n", + "rng_key = jax.random.key(int(date.today().strftime(\"%Y%m%d\")))\n", + "import jax.numpy as jnp\n", + "from sklearn.datasets import make_biclusters\n", + "import blackjax" + ] + }, + { + "cell_type": "markdown", + "id": "ee12f75d", + "metadata": {}, + "source": [ + "## The Data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7ec4566a", + "metadata": {}, + "outputs": [], + "source": [ + "num_points = 50\n", + "X, rows, cols = make_biclusters(\n", + " (num_points, 2), 2, noise=0.6, random_state=314, minval=-3, maxval=3\n", + ")\n", + "y = rows[0] * 1.0 # y[i] = whether point i belongs to cluster 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40210fca", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "colors = [\"tab:red\" if el else \"tab:blue\" for el in rows[0]]\n", + "plt.scatter(*X.T, edgecolors=colors, c=\"none\")\n", + "plt.xlabel(r\"$X_0$\")\n", + "plt.ylabel(r\"$X_1$\");" + ] + }, + { + "cell_type": "markdown", + "id": "49f196c9", + "metadata": {}, + "source": [ + "## The Model\n", + "\n", + "We use a simple logistic regression model to infer to which cluster each of the points belongs. We note $y$ a binary variable that indicates whether a point belongs to the first cluster :\n", + "\n", + "$$\n", + "y \\sim \\operatorname{Bernoulli}(p)\n", + "$$\n", + "\n", + "The probability $p$ to belong to the first cluster commes from a logistic regression:\n", + "\n", + "$$\n", + "p = \\operatorname{logistic}(\\Phi\\,\\boldsymbol{w})\n", + "$$\n", + "\n", + "where $w$ is a vector of weights whose priors are a normal prior centered on 0:\n", + "\n", + "$$\n", + "\\boldsymbol{w} \\sim \\operatorname{Normal}(0, \\sigma)\n", + "$$\n", + "\n", + "And $\\Phi$ is the matrix that contains the data, so each row $\\Phi_{i,:}$ is the vector $\\left[1, X_0^i, X_1^i\\right]$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3c7dd2f", + "metadata": { + "tags": [ + "hide-stderr" + ] + }, + "outputs": [], + "source": [ + "Phi = jnp.c_[jnp.ones(num_points)[:, None], X]\n", + "N, M = Phi.shape\n", + "\n", + "\n", + "def sigmoid(z):\n", + " return jnp.exp(z) / (1 + jnp.exp(z))\n", + "\n", + "\n", + "def log_sigmoid(z):\n", + " return z - jnp.log(1 + jnp.exp(z))\n", + "\n", + "def logprior(w, alpha=1.0):\n", + " prior_term = alpha * w @ w / 2\n", + " return -prior_term\n", + " \n", + "def loglikelihood(w, alpha=1.0):\n", + " \"\"\"The log-probability density function of the posterior distribution of the model.\"\"\"\n", + " log_an = log_sigmoid(Phi @ w)\n", + " an = Phi @ w\n", + " log_likelihood_term = y * log_an + (1 - y) * jnp.log(1 - sigmoid(an))\n", + " return log_likelihood_term.sum()\n", + " \n", + "def logdensity_fn(w, alpha=1.0):\n", + " return logprior(w,alpha) + loglikelihood(w,alpha)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "043aff76", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression" + ] + }, + { + "cell_type": "markdown", + "id": "93778681", + "metadata": {}, + "source": [ + "## Posterior Sampling\n", + "\n", + "We use `blackjax`'s Random Walk RMH kernel to sample from the posterior distribution." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9889d938", + "metadata": {}, + "outputs": [], + "source": [ + "rng_key, init_key = jax.random.split(rng_key)\n", + "\n", + "w0 = jax.random.multivariate_normal(init_key, 0.1 + jnp.zeros(M), jnp.eye(M))\n", + "rmh = blackjax.rmh(logdensity_fn, blackjax.mcmc.random_walk.normal(jnp.ones(M) * 0.05))\n", + "initial_state = rmh.init(w0)\n", + "\n", + "def inference_loop(rng_key, kernel, initial_state, num_samples):\n", + " @jax.jit\n", + " def one_step(state, rng_key):\n", + " state, _ = kernel(rng_key, state)\n", + " return state, state\n", + "\n", + " keys = jax.random.split(rng_key, num_samples)\n", + " _, states = jax.lax.scan(one_step, initial_state, keys)\n", + "\n", + " return states\n", + "\n", + "rng_key, sample_key = jax.random.split(rng_key)\n", + "states = inference_loop(sample_key, rmh.step, initial_state, 5_000)" + ] + }, + { + "cell_type": "markdown", + "id": "3301e09c", + "metadata": {}, + "source": [ + "Trace display:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69816b03", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [], + "source": [ + "burnin = 300\n", + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.plot(states.position[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + " axi.axvline(x=burnin, c=\"tab:red\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1f1306a6", + "metadata": {}, + "outputs": [], + "source": [ + "burnin = 300\n", + "chains = states.position[burnin:, :]\n", + "nsamp, _ = chains.shape" + ] + }, + { + "cell_type": "markdown", + "id": "daa2e425", + "metadata": {}, + "source": [ + "# Classic SMC" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "263a7714", + "metadata": {}, + "outputs": [], + "source": [ + "import jax.numpy as jnp\n", + "import numpy as np\n", + "\n", + "from blackjax import adaptive_tempered_smc\n", + "from blackjax.smc import resampling, extend_params\n", + "from blackjax.smc.inner_kernel_tuning import StateWithParameterOverride\n", + "from blackjax.smc.tempered import TemperedSMCState\n", + "import jax\n", + "from jax import numpy as jnp\n", + "from datetime import date\n", + "import numpy as np\n", + "import pandas as pd\n", + "import functools\n", + "from jax.scipy.stats import multivariate_normal\n", + "from blackjax import additive_step_random_walk, inner_kernel_tuning\n", + "from blackjax.mcmc.random_walk import normal\n", + "from blackjax.smc.tuning.from_particles import (\n", + " particles_covariance_matrix\n", + ")\n", + "\n", + "n_predictors = 3\n", + "def initial_particles_multivariate_normal(key, n_samples):\n", + " return jax.random.multivariate_normal(\n", + " key, jnp.zeros(n_predictors) + 0.1, jnp.eye(n_predictors), (n_samples,)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88ccaf4c", + "metadata": {}, + "outputs": [], + "source": [ + "n_particles = 20000\n", + "key = jax.random.PRNGKey(10)\n", + "key, initial_particles_key, iterations_key = jax.random.split(key, 3)\n", + "initial_particles = initial_particles_multivariate_normal(initial_particles_key, n_particles)\n", + "initial_parameter_value = extend_params({\"cov\": particles_covariance_matrix(initial_particles)})\n", + "\n", + "\n", + "def mcmc_parameter_update_fn(state: TemperedSMCState, info):\n", + " sigma_particles = particles_covariance_matrix(state.particles) * 0.75\n", + " return extend_params({\"cov\":sigma_particles})\n", + "\n", + "def step_fn(key, state, logdensity, cov):\n", + " return blackjax.rmh(logdensity, normal(cov)).step(key, state)\n", + "\n", + "\n", + "kernel_tuned_proposal = inner_kernel_tuning(\n", + " logprior_fn=logprior,\n", + " loglikelihood_fn=loglikelihood,\n", + " mcmc_step_fn=step_fn,\n", + " mcmc_init_fn=blackjax.rmh.init,\n", + " resampling_fn=resampling.systematic,\n", + " smc_algorithm=adaptive_tempered_smc,\n", + " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", + " initial_parameter_value=initial_parameter_value,\n", + " target_ess=0.5,\n", + " num_mcmc_steps=5,\n", + ")\n", + "\n", + "from blackjax.smc.base import SMCInfo\n", + "def loop(kernel, rng_key, initial_state):\n", + " normalizing_constant = jnp.zeros((1000))\n", + "\n", + " def cond(carry):\n", + " _, state, _ = carry\n", + " return state.sampler_state.lmbda < 1\n", + "\n", + " def body(carry):\n", + " i, state, op_key = carry\n", + " op_key, subkey = jax.random.split(op_key, 2)\n", + " state, info = kernel(subkey, state)\n", + " normalizing_constant.at[i].set(info.log_likelihood_increment)\n", + " return i + 1, state, op_key\n", + "\n", + " def f(initial_state, key):\n", + " total_iter, final_state, _ = jax.lax.while_loop(\n", + " cond, body, (0, initial_state, key)\n", + " )\n", + " return total_iter, final_state\n", + "\n", + " total_iter, final_state = f(initial_state, rng_key)\n", + " return total_iter, final_state, normalizing_constant" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c0ccdccc", + "metadata": {}, + "outputs": [], + "source": [ + "total_steps, final_state, normalizing_constant = loop(kernel_tuned_proposal.step, iterations_key, kernel_tuned_proposal.init(initial_particles))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6a672bcc", + "metadata": {}, + "outputs": [], + "source": [ + "np.exp(normalizing_constant[:total_steps])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "81dae2ae", + "metadata": {}, + "outputs": [], + "source": [ + "particles = final_state.sampler_state.particles" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6e10f1f1", + "metadata": {}, + "outputs": [], + "source": [ + "final_state.sampler_state.weights" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "85dd9f86", + "metadata": {}, + "outputs": [], + "source": [ + "burnin = 300\n", + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(states.position[burnin:, i])\n", + " axi.hist(particles[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "191ea71c", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(particles[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4032de45", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(initial_particles[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "db7cd2eb", + "metadata": {}, + "outputs": [], + "source": [ + "def predict(x, w):\n", + " return sigmoid(x@w)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a58e1879", + "metadata": {}, + "outputs": [], + "source": [ + "pred=(predict(Phi,np.mean(particles, axis=0))>0.5).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e3a9df9", + "metadata": {}, + "outputs": [], + "source": [ + "pred2=(predict(Phi,np.mean(states.position, axis=0))>0.5).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5a6a5dc6", + "metadata": {}, + "outputs": [], + "source": [ + "import sklearn\n", + "sklearn.metrics.confusion_matrix(y, pred)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1bc4fd5c", + "metadata": {}, + "outputs": [], + "source": [ + "sklearn.metrics.confusion_matrix(y, pred2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6834a6e5", + "metadata": {}, + "outputs": [], + "source": [ + "def posterior_predictive_plot(samples):\n", + " xmin, ymin = X.min(axis=0) - 0.1\n", + " xmax, ymax = X.max(axis=0) + 0.1\n", + " step = 0.1\n", + " Xspace = jnp.mgrid[xmin:xmax:step, ymin:ymax:step]\n", + " _, nx, ny = Xspace.shape\n", + " \n", + " # Compute the average probability to belong to the first cluster at each point on the meshgrid\n", + " Phispace = jnp.concatenate([jnp.ones((1, nx, ny)), Xspace])\n", + " Z_mcmc = sigmoid(jnp.einsum(\"mij,sm->sij\", Phispace, samples))\n", + " Z_mcmc = Z_mcmc.mean(axis=0)\n", + " \n", + " plt.contourf(*Xspace, Z_mcmc)\n", + " plt.scatter(*X.T, c=colors)\n", + " plt.xlabel(r\"$X_0$\")\n", + " plt.ylabel(r\"$X_1$\");" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c36ad97c", + "metadata": {}, + "outputs": [], + "source": [ + "posterior_predictive_plot(chains)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0aa89f5a", + "metadata": {}, + "outputs": [], + "source": [ + "posterior_predictive_plot(particles)" + ] + }, + { + "cell_type": "markdown", + "id": "0a9dba30", + "metadata": {}, + "source": [ + "# Waste-Free SMC" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "647d1be6", + "metadata": {}, + "outputs": [], + "source": [ + "import importlib\n", + "importlib.reload(blackjax)\n", + "from blackjax.smc.waste_free import waste_free_smc\n", + "\n", + "waste_free_smc_kernel = inner_kernel_tuning(\n", + " logprior_fn=logprior,\n", + " loglikelihood_fn=loglikelihood,\n", + " mcmc_step_fn=step_fn,\n", + " mcmc_init_fn=blackjax.rmh.init,\n", + " resampling_fn=resampling.systematic,\n", + " smc_algorithm=adaptive_tempered_smc,\n", + " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", + " initial_parameter_value=initial_parameter_value,\n", + " target_ess=0.5,\n", + " num_mcmc_steps=None,\n", + " update_strategy=waste_free_smc(n_particles,10)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4e3d2364", + "metadata": {}, + "outputs": [], + "source": [ + "total_steps_waste_free, final_state_waste_free, normalizing_constant_waste_free = loop(waste_free_smc_kernel.step, iterations_key, waste_free_smc_kernel.init(initial_particles))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a2adf9e7", + "metadata": {}, + "outputs": [], + "source": [ + "posterior_predictive_plot(final_state_waste_free.sampler_state.particles)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "630b6a13", + "metadata": {}, + "outputs": [], + "source": [ + "particles_waste_free = final_state_waste_free.sampler_state.particles" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c1997aa9", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(chains[:,i])\n", + " axi.hist(particles[:, i])\n", + " axi.hist(particles_waste_free[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9c90387f", + "metadata": {}, + "outputs": [], + "source": [ + " final_state_waste_free.sampler_state" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "df47baa9", + "metadata": {}, + "outputs": [], + "source": [ + "final_state_waste_free" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b2088325", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jupytext": { + "formats": "md,ipynb" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 6929d55d2a1b78ed56805894bd02a466107e9330 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 6 Aug 2024 19:04:10 -0300 Subject: [PATCH 05/29] more --- blackjax/smc/adaptive_tempered.py | 4 ++++ blackjax/smc/to_debug.py | 0 blackjax/smc/waste_free.py | 29 ++++++++++++++++++++--------- tests/smc/test_waste_free_smc.py | 9 +++++++++ 4 files changed, 33 insertions(+), 9 deletions(-) delete mode 100644 blackjax/smc/to_debug.py diff --git a/blackjax/smc/adaptive_tempered.py b/blackjax/smc/adaptive_tempered.py index 10fb194fa..7cbf3ff08 100644 --- a/blackjax/smc/adaptive_tempered.py +++ b/blackjax/smc/adaptive_tempered.py @@ -34,6 +34,7 @@ def build_kernel( resampling_fn: Callable, target_ess: float, root_solver: Callable = solver.dichotomy, + **extra_parameters ) -> Callable: r"""Build a Tempered SMC step using an adaptive schedule. @@ -88,6 +89,7 @@ def compute_delta(state: tempered.TemperedSMCState) -> float: mcmc_step_fn, mcmc_init_fn, resampling_fn, + **extra_parameters ) def kernel( @@ -116,6 +118,7 @@ def as_top_level_api( target_ess: float, root_solver: Callable = solver.dichotomy, num_mcmc_steps: int = 10, + **extra_parameters, ) -> SamplingAlgorithm: """Implements the (basic) user interface for the Adaptive Tempered SMC kernel. @@ -155,6 +158,7 @@ def as_top_level_api( resampling_fn, target_ess, root_solver, + **extra_parameters, ) def init_fn(position: ArrayLikeTree, rng_key=None): diff --git a/blackjax/smc/to_debug.py b/blackjax/smc/to_debug.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py index 674f902ca..a7efbb1f9 100644 --- a/blackjax/smc/waste_free.py +++ b/blackjax/smc/waste_free.py @@ -18,7 +18,7 @@ def update_waste_free(mcmc_init_fn, See Algorithm 2: https://arxiv.org/abs/2011.02328 """ if num_mcmc_steps is not None: - raise ValueError("Can't use waste free SMC with a num_mcmc_steps parameter") + raise ValueError("Can't use waste free SMC with a num_mcmc_steps parameter, set num_mcmc_steps = None") num_mcmc_steps = p-1 @@ -34,14 +34,25 @@ def body_fn(state, rng_key): _, (states, infos) = jax.lax.scan(body_fn, state, jax.random.split(rng_key, num_mcmc_steps)) return states, infos - def gather(rng_key, position, step_parameters): - states, infos= jax.vmap(mcmc_kernel)(rng_key, position, step_parameters) - step_particles = jax.tree.map(lambda x: x.reshape((num_resampled * num_mcmc_steps)), states.position) - initial_particles = jax.tree.map(lambda x: x.reshape((num_resampled,)), position) - new_particles = jax.tree.map(lambda x,y: jax.numpy.hstack([x,y]), initial_particles, step_particles) - return new_particles, None - - return gather, num_resampled + def update(rng_key, position, step_parameters): + """ + Given the initial particles, runs a chain starting at each. + The combines the initial particles with all the particles generated + at each step of each chain. + """ + states, infos = jax.vmap(mcmc_kernel)(rng_key, position, step_parameters) + # step particles is num_resmapled, num_mcmc_steps, dimension_of_variable + # want to transformed into num_resampled * num_mcmc_steps, dimension of variable + def reshape_step_particles(x): + if len(x.shape) > 2: + return x.reshape((x.shape[0]*x.shape[1], -1)) + else: + return x.flatten() + + step_particles = jax.tree.map(reshape_step_particles, states.position) + new_particles = jax.tree.map(lambda x,y: jnp.concatenate([x,y]), position, step_particles) + return new_particles, None # TODO also update Info? + return update, num_resampled def waste_free_smc(n_particles, p): return functools.partial(update_waste_free, num_resampled=int(n_particles / p), p=p) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index 5a1ba4a84..4f74f719a 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -67,6 +67,15 @@ def body_fn(carry, lmbda): self.assert_linear_regression_test_case(result) +#class UpdateWasteFreeTest(chex.TestCase): +# update_waste_free(mcmc_init_fn, +# logposterior_fn, +# mcmc_step_fn, +# n_particles: int, +# p: int, +# num_resampled, +# num_mcmc_steps): + if __name__ == "__main__": absltest.main() From e46e86cc94dc9c93fdd1529345343182b62f45f3 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Wed, 7 Aug 2024 18:02:28 -0300 Subject: [PATCH 06/29] Adding another example --- blackjax/smc/waste_free.py | 2 +- logistic_regression-different-prior.ipynb | 1165 +++++++++++++++++++++ logistic_regression.ipynb | 643 ++++++++++-- tests/smc/test_waste_free_smc.py | 13 +- 4 files changed, 1742 insertions(+), 81 deletions(-) create mode 100644 logistic_regression-different-prior.ipynb diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py index a7efbb1f9..eca6472c6 100644 --- a/blackjax/smc/waste_free.py +++ b/blackjax/smc/waste_free.py @@ -51,7 +51,7 @@ def reshape_step_particles(x): step_particles = jax.tree.map(reshape_step_particles, states.position) new_particles = jax.tree.map(lambda x,y: jnp.concatenate([x,y]), position, step_particles) - return new_particles, None # TODO also update Info? + return new_particles, infos return update, num_resampled def waste_free_smc(n_particles, p): diff --git a/logistic_regression-different-prior.ipynb b/logistic_regression-different-prior.ipynb new file mode 100644 index 000000000..770bfb808 --- /dev/null +++ b/logistic_regression-different-prior.ipynb @@ -0,0 +1,1165 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3cdc536d", + "metadata": {}, + "source": [ + "# Waste Free SMC comparison\n", + "\n", + "In this notebook we take again a Logistic Regression model, and compare MH, SMC and Waste-Free SMC" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "de1922dd", + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e7dba964", + "metadata": { + "tags": [ + "hide-cell" + ] + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import sklearn\n", + "\n", + "plt.rcParams[\"axes.spines.right\"] = False\n", + "plt.rcParams[\"axes.spines.top\"] = False\n", + "plt.rcParams[\"figure.figsize\"] = (12, 8)\n", + "import jax\n", + "\n", + "from datetime import date\n", + "rng_key = jax.random.key(int(date.today().strftime(\"%Y%m%d\")))\n", + "import jax.numpy as jnp\n", + "from sklearn.datasets import make_biclusters\n", + "import blackjax" + ] + }, + { + "cell_type": "markdown", + "id": "ee12f75d", + "metadata": {}, + "source": [ + "## The Data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7ec4566a", + "metadata": {}, + "outputs": [], + "source": [ + "num_points = 50\n", + "X, rows, cols = make_biclusters(\n", + " (num_points, 2), 2, noise=0.6, random_state=314, minval=-3, maxval=3\n", + ")\n", + "y = rows[0] * 1.0 # y[i] = whether point i belongs to cluster 1" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "40210fca", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "colors = [\"tab:red\" if el else \"tab:blue\" for el in rows[0]]\n", + "plt.scatter(*X.T, edgecolors=colors, c=\"none\")\n", + "plt.xlabel(r\"$X_0$\")\n", + "plt.ylabel(r\"$X_1$\");" + ] + }, + { + "cell_type": "markdown", + "id": "49f196c9", + "metadata": {}, + "source": [ + "## The Model\n", + "\n", + "We use a simple logistic regression model to infer to which cluster each of the points belongs. We note $y$ a binary variable that indicates whether a point belongs to the first cluster :\n", + "\n", + "$$\n", + "y \\sim \\operatorname{Bernoulli}(p)\n", + "$$\n", + "\n", + "The probability $p$ to belong to the first cluster commes from a logistic regression:\n", + "\n", + "$$\n", + "p = \\operatorname{logistic}(\\Phi\\,\\boldsymbol{w})\n", + "$$\n", + "\n", + "where $w$ is a vector of weights whose priors are a normal prior centered on 0:\n", + "\n", + "$$\n", + "\\boldsymbol{w} \\sim \\operatorname{Normal}(0, \\sigma)\n", + "$$\n", + "\n", + "And $\\Phi$ is the matrix that contains the data, so each row $\\Phi_{i,:}$ is the vector $\\left[1, X_0^i, X_1^i\\right]$" + ] + }, + { + "cell_type": "markdown", + "id": "9af4ac0f-a441-4c2f-a22a-3b5112599c3d", + "metadata": {}, + "source": [ + "Note that X is not normalized" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "f3c7dd2f", + "metadata": { + "tags": [ + "hide-stderr" + ] + }, + "outputs": [], + "source": [ + "Phi = jnp.c_[jnp.ones(num_points)[:, None], X]\n", + "N, M = Phi.shape\n", + "\n", + "\n", + "def sigmoid(z):\n", + " return jnp.exp(z) / (1 + jnp.exp(z))\n", + "\n", + "\n", + "def log_sigmoid(z):\n", + " return z - jnp.log(1 + jnp.exp(z))\n", + "\n", + "def logprior(w, alpha=0.01):\n", + " prior_term = alpha * w @ w / 2\n", + " return -prior_term\n", + " \n", + "def loglikelihood(w):\n", + " \"\"\"The log-probability density function of the posterior distribution of the model.\"\"\"\n", + " log_an = log_sigmoid(Phi @ w)\n", + " an = Phi @ w\n", + " log_likelihood_term = y * log_an + (1 - y) * jnp.log(1 - sigmoid(an))\n", + " return log_likelihood_term.sum()\n", + " \n", + "def logdensity_fn(w, alpha=0.01):\n", + " return logprior(w,alpha) + loglikelihood(w)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a5e8505c-aabb-4da5-ad73-cac475cfece9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Prior')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "w = jnp.linspace(0, 10).reshape(-1,1)\n", + "for alpha in [0.1, 0.5, 1, 2]:\n", + " plt.plot(w, jax.vmap(lambda x:jnp.exp(logprior(x, alpha)))(w), label=alpha)\n", + "\n", + "plt.legend()\n", + "plt.xlabel(\"Squared norm of w\")\n", + "plt.title(\"Prior\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "043aff76", + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.linear_model import LogisticRegression" + ] + }, + { + "cell_type": "markdown", + "id": "93778681", + "metadata": {}, + "source": [ + "## Posterior Sampling\n", + "\n", + "We use `blackjax`'s Random Walk RMH kernel to sample from the posterior distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9889d938", + "metadata": {}, + "outputs": [], + "source": [ + "rng_key, init_key = jax.random.split(rng_key)\n", + "\n", + "w0 = jax.random.multivariate_normal(init_key, 0.1 + jnp.zeros(M), jnp.eye(M))\n", + "rmh = blackjax.rmh(logdensity_fn, blackjax.mcmc.random_walk.normal(jnp.ones(M) * 0.05))\n", + "initial_state = rmh.init(w0)\n", + "\n", + "def inference_loop(rng_key, kernel, initial_state, num_samples):\n", + " @jax.jit\n", + " def one_step(state, rng_key):\n", + " state, _ = kernel(rng_key, state)\n", + " return state, state\n", + "\n", + " keys = jax.random.split(rng_key, num_samples)\n", + " _, states = jax.lax.scan(one_step, initial_state, keys)\n", + "\n", + " return states\n", + "\n", + "rng_key, sample_key = jax.random.split(rng_key)\n", + "states = inference_loop(sample_key, rmh.step, initial_state, 5_000)" + ] + }, + { + "cell_type": "markdown", + "id": "3301e09c", + "metadata": {}, + "source": [ + "Trace display:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "69816b03", + "metadata": { + "tags": [ + "hide-input" + ] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "burnin = 300\n", + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.plot(states.position[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + " axi.axvline(x=burnin, c=\"tab:red\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "1f1306a6", + "metadata": {}, + "outputs": [], + "source": [ + "burnin = 300\n", + "chains = states.position[burnin:, :]\n", + "nsamp, _ = chains.shape" + ] + }, + { + "cell_type": "markdown", + "id": "daa2e425", + "metadata": {}, + "source": [ + "# Classic SMC" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "263a7714", + "metadata": {}, + "outputs": [], + "source": [ + "import jax.numpy as jnp\n", + "import numpy as np\n", + "\n", + "from blackjax import adaptive_tempered_smc\n", + "from blackjax.smc import resampling, extend_params\n", + "from blackjax.smc.inner_kernel_tuning import StateWithParameterOverride\n", + "from blackjax.smc.tempered import TemperedSMCState\n", + "import jax\n", + "from jax import numpy as jnp\n", + "from datetime import date\n", + "import numpy as np\n", + "import pandas as pd\n", + "import functools\n", + "from jax.scipy.stats import multivariate_normal\n", + "from blackjax import additive_step_random_walk, inner_kernel_tuning\n", + "from blackjax.mcmc.random_walk import normal\n", + "from blackjax.smc.tuning.from_particles import (\n", + " particles_covariance_matrix\n", + ")\n", + "\n", + "n_predictors = 3\n", + "def initial_particles_multivariate_normal(key, n_samples):\n", + " return jax.random.multivariate_normal(\n", + " key, jnp.zeros(n_predictors) + 0.1, jnp.eye(n_predictors), (n_samples,)\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "88ccaf4c", + "metadata": {}, + "outputs": [], + "source": [ + "n_particles = 20000\n", + "key = jax.random.PRNGKey(10)\n", + "key, initial_particles_key, iterations_key = jax.random.split(key, 3)\n", + "initial_particles = initial_particles_multivariate_normal(initial_particles_key, n_particles)\n", + "initial_parameter_value = extend_params({\"cov\": particles_covariance_matrix(initial_particles)})\n", + "\n", + "\n", + "def mcmc_parameter_update_fn(state: TemperedSMCState, info):\n", + " sigma_particles = particles_covariance_matrix(state.particles) * 2.38 / np.sqrt(n_predictors) \n", + " return extend_params({\"cov\":sigma_particles})\n", + "\n", + "def step_fn(key, state, logdensity, cov):\n", + " return blackjax.rmh(logdensity, normal(cov)).step(key, state)\n", + "\n", + "\n", + "kernel_tuned_proposal = inner_kernel_tuning(\n", + " logprior_fn=logprior,\n", + " loglikelihood_fn=loglikelihood,\n", + " mcmc_step_fn=step_fn,\n", + " mcmc_init_fn=blackjax.rmh.init,\n", + " resampling_fn=resampling.systematic,\n", + " smc_algorithm=adaptive_tempered_smc,\n", + " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", + " initial_parameter_value=initial_parameter_value,\n", + " target_ess=0.5,\n", + " num_mcmc_steps=5,\n", + ")\n", + "\n", + "from blackjax.smc.base import SMCInfo\n", + "def loop(kernel, rng_key, initial_state):\n", + " normalizing_constant = jnp.zeros((1000))\n", + "\n", + " def cond(carry):\n", + " _, state, _ = carry\n", + " return state.sampler_state.lmbda < 1\n", + "\n", + " def body(carry):\n", + " i, state, op_key = carry\n", + " op_key, subkey = jax.random.split(op_key, 2)\n", + " state, info = kernel(subkey, state)\n", + " normalizing_constant.at[i].set(info.log_likelihood_increment)\n", + " return i + 1, state, op_key\n", + "\n", + " def f(initial_state, key):\n", + " total_iter, final_state, _ = jax.lax.while_loop(\n", + " cond, body, (0, initial_state, key)\n", + " )\n", + " return total_iter, final_state\n", + "\n", + " total_iter, final_state = f(initial_state, rng_key)\n", + " return total_iter, final_state, normalizing_constant" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "c0ccdccc", + "metadata": {}, + "outputs": [], + "source": [ + "total_steps, final_state, normalizing_constant = loop(kernel_tuned_proposal.step, iterations_key, kernel_tuned_proposal.init(initial_particles))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "6a672bcc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(0., dtype=float32)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum(normalizing_constant[:total_steps]) #" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "50955c99-a2fd-46f8-8b4d-cad4ed0bbd48", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "np.float32(1.0)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.exp(np.sum(normalizing_constant[:total_steps]))" + ] + }, + { + "cell_type": "markdown", + "id": "105399cb-61bc-4283-a65b-8b2cc517dde9", + "metadata": {}, + "source": [ + "Why the log normalizing constant is always 0? Is it because of the prior shape?" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "81dae2ae", + "metadata": {}, + "outputs": [], + "source": [ + "particles = final_state.sampler_state.particles" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "85dd9f86", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "burnin = 300\n", + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(states.position[burnin:, i])\n", + " axi.hist(particles[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "191ea71c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+IAAADbCAYAAADphyuzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxNklEQVR4nO3de3RU5b3/8U/uCSEzMcEkUAKkB5eQAkoAYaT1cMki2qFKjfawGi4KgtgJmsRySUsRsRKKIqhEIkqBs0oW4jpalcglDRKqhItRWi4l2iM0HHASejAZoZCQZH5//GQfRoKakMyeSd6vtfZazPM8e+/vs8l84Zt9C3C73W4BAAAAAACvCDQ7AAAAAAAAOhMKcQAAAAAAvIhCHAAAAAAAL6IQBwAAAADAiyjEAQAAAADwIgpxAAAAAAC8iEIcAAAAAAAvohAHAAAAAMCLKMQBAAAAAPAiCnEAAAAAALyIQhwAAAAAAC+iEAcAAAAAwIsoxNFhZWVlKT4+3qNt7ty5CggIUH5+vtHmdDoVEhKiNWvWmBAlAHgf+REAmkd+hLdQiKPDio6O1rlz54zPFy5c0Nq1axUcHKyamhqj/fe//70iIyOVkZFhUqQA4F3kRwBoHvkR3kIhjg4rOjpaFy5cUFNTkySpsLBQwcHBGjt2rJFIm5qa9Morr2jq1KmKjIw0OWIA8A7yIwA0j/wIb6EQR4cVHR0tt9ut8+fPS5JWrVqlGTNmqFu3bkYi3bFjh06cOKFHHnnE5GgBwHvIjwDQPPIjvIVCHB1WdHS0JOncuXN6//33dejQIT388MOyWCxGIn355Zc1ZswY9evXT5J05swZ2e12RUZG6uabb1ZJSYmpcwCA9tCa/Lh69WqlpKQoJCREixYtMjV+AGgvLc2PdXV1mjZtmnr16iWLxaIRI0aorKzM5FnAH1CIo8O6MpGuWrVKd999txITE41Eevr0aW3ZskUOh8NYx+FwKCEhQWfOnNEzzzyjn/3sZzp79qyJswCAttea/Ni9e3ctWrRI6enpJkYOAO2rpfmxoaFBffr00fvvv6+amhplZWXpJz/5icd95kBzKMTRYV1OpJ9++qneeOMNZWZmSpKRSNeuXav4+Hjdfffd0lcJ949//KOefPJJdenSRXfffbcGDhyot956y9R5AEBba2l+lKQJEybo7rvvNtYFgI6opfkxMjJSCxcuVK9evRQYGKiJEycqNDRUFRUVps4Dvo9CHB3W5UT67LPPqm/fvhozZoz0VSI9e/asXn31VT388MMKDg6Wvkq4Xbt2Vc+ePY1tDBw4UEeOHDFpBgDQPlqaHwGgs7je/Pjpp5/q7Nmz6tu3r1fjhv/hX1h0WJcT6XvvvacXX3zRaLdYLPrss88UEhKiGTNmGO3nzp2TxWLx2IbFYtH//u//ejFqAGh/Lc2PANBZXE9+vHDhgiZNmqTc3FxZrVavxQz/RCGODstisSggIECRkZGaMmWK0X45Mf70pz9VQkKC0d61a1e5XC6PbbhcLnXt2tWLUQNA+2tpfgSAzqK1+fHSpUu6//771bdvXy1cuNCrMcM/UYijwwoMDDTeAXmle+65R263+6r2m266SefOndOpU6f0ve99T5J0+PBhjyQMAB1BS/MjAHQWrcmPTU1Nmjx5sgICArRhwwYFBAR4IVL4O+4RB77StWtX3XPPPXriiSd04cIFbdmyRX/96191zz33mB0aAJiuoaFBFy9eVGNjo8efAaCze/jhh/X555/r9ddf59ka+M4C3PzqGzCcOXNGU6dO1a5du9SzZ0+99NJLSk1NNTssADDdokWL9OSTT3q0rVu3Tg888IBpMQGA2f7xj3+oT58+Cg8PV1BQkNG+detW/ehHPzI1Nvg2CnEAAAAAALyIS9MBAAAAAPAiCnEAAAAAALyIQhwAAAAAAC/qsIW42+2Wy+XiNSwA8DXkRwBoHvkRgLd02EL8yy+/lNVq1Zdffml2KADgU8iPANA88iMAb+mwhTgAAAAAAL6IQhwAAAAAAC+iEAcAAAAAwIsoxAEAAAAA8CIKcQAAALSrU6dOadKkSYqNjVVERIQGDhyoDz/80Oh3u91auHChunfvroiICKWmpurTTz/12MbZs2eVkZEhi8Wi6OhoTZ8+XefOnfMY89e//lU/+tGPFB4ersTERC1btsxrcwSAlqAQBwAAQLv54osvNHLkSIWEhGjr1q06evSoli9frhtuuMEYs2zZMr3wwgsqKCjQvn37FBkZqbS0NF28eNEYk5GRoSNHjqi4uFhbtmzR7t27NXPmTKPf5XJp3Lhx6t27t8rLy/XMM89o0aJFWrNmjdfnDADfJsDdQV+U6HK5ZLVaVVtbK4vFYnY4AOAzyI8AvGn+/Pn64IMP9Oc//7nZfrfbrR49eujxxx/XL3/5S0lSbW2t4uPjtX79ek2cOFF/+9vflJycrAMHDmjo0KGSpG3btunHP/6x/ud//kc9evTQ6tWr9etf/1pOp1OhoaHGvv/4xz/q2LFj3ylW8iMAbwk2OwAA16fP/KJ238eJpfZ23weA747vPfzJ22+/rbS0NN1///0qLS3V9773Pf3iF7/QjBkzJEnHjx+X0+lUamqqsY7VatXw4cNVVlamiRMnqqysTNHR0UYRLkmpqakKDAzUvn379NOf/lRlZWW64447jCJcktLS0vS73/1OX3zxhccZ+Mvq6upUV1dnfHa5XO14JEDuAv4Pl6YDAACg3Xz22WdavXq1brrpJm3fvl2PPPKIHn30UW3YsEGS5HQ6JUnx8fEe68XHxxt9TqdTcXFxHv3BwcGKiYnxGNPcNq7cx9fl5eXJarUaS2JiYpvNGwC+CYU4AAAA2k1TU5NSUlK0ZMkSDR48WDNnztSMGTNUUFBgdmjKzc1VbW2tsZw8edLskAB0EhTiAAAAaDfdu3dXcnKyR1v//v1VWVkpSUpISJAkVVVVeYypqqoy+hISElRdXe3R39DQoLNnz3qMaW4bV+7j68LCwmSxWDwWAPAGCnEAAAC0m5EjR6qiosKj7ZNPPlHv3r0lSUlJSUpISFBJSYnR73K5tG/fPtlsNkmSzWZTTU2NysvLjTE7d+5UU1OThg8fbozZvXu3Ll26ZIwpLi7WzTff3Oz94QBgJgpxAAAAtJvs7Gzt3btXS5Ys0d///ncVFhZqzZo1cjgckqSAgABlZWXpt7/9rd5++20dOnRIU6ZMUY8ePTRhwgTpqzPod955p2bMmKH9+/frgw8+UGZmpiZOnKgePXpIkn7+858rNDRU06dP15EjR/Taa6/p+eefV05OjqnzB4Dm8NR0AAAAtJthw4bpzTffVG5urhYvXqykpCStXLlSGRkZxpi5c+fq/PnzmjlzpmpqavTDH/5Q27ZtU3h4uDFm48aNyszM1NixYxUYGKj09HS98MILRr/VatWOHTvkcDg0ZMgQdevWTQsXLvR41zgA+AoKcQAAALSr8ePHa/z48dfsDwgI0OLFi7V48eJrjomJiVFhYeE37mfQoEHXfF85APgSLk0HAAAAAMCLKMQBAAAAAPAiCnEAAAAAALyIQhwAAAAAAC+iEAcAAAAAwIsoxAEAAAAA8CIKcQAAAAAAvIhCHAAAAAAAL6IQBwAAAADAi4LNDgAAAPiePvOL2n0fJ5ba230fAAD4Is6IAwAAAADgRRTiAAAAAAB4EZemAwDQhrxxSTcAAPBvnBEHAAAAAMCLKMQBAAAAAPCiFhfip06d0qRJkxQbG6uIiAgNHDhQH374odHvdru1cOFCde/eXREREUpNTdWnn37qsY2zZ88qIyNDFotF0dHRmj59us6dO+cx5q9//at+9KMfKTw8XImJiVq2bNn1zBMAAAAAAJ/QokL8iy++0MiRIxUSEqKtW7fq6NGjWr58uW644QZjzLJly/TCCy+ooKBA+/btU2RkpNLS0nTx4kVjTEZGho4cOaLi4mJt2bJFu3fv1syZM41+l8ulcePGqXfv3iovL9czzzyjRYsWac2aNW01bwAAAAAATNGih7X97ne/U2JiotatW2e0JSUlGX92u91auXKlFixYoHvuuUeS9J//+Z+Kj4/XH//4R02cOFF/+9vftG3bNh04cEBDhw6VJL344ov68Y9/rGeffVY9evTQxo0bVV9fr9///vcKDQ3VD37wAx08eFDPPfecR8EOAAAAAIC/adEZ8bfffltDhw7V/fffr7i4OA0ePFivvPKK0X/8+HE5nU6lpqYabVarVcOHD1dZWZkkqaysTNHR0UYRLkmpqakKDAzUvn37jDF33HGHQkNDjTFpaWmqqKjQF1980WxsdXV1crlcHgsAmGXp0qUKCAhQVlaW0Xbx4kU5HA7Fxsaqa9euSk9PV1VVlcd6lZWVstvt6tKli+Li4jRnzhw1NDR4jNm1a5dSUlIUFhamvn37av369V6bFwAAAK5fiwrxzz77TKtXr9ZNN92k7du365FHHtGjjz6qDRs2SJKcTqckKT4+3mO9+Ph4o8/pdCouLs6jPzg4WDExMR5jmtvGlfv4ury8PFmtVmNJTExsydQAoM0cOHBAL7/8sgYNGuTRnp2drXfeeUevv/66SktLdfr0ad17771Gf2Njo+x2u+rr67Vnzx5t2LBB69ev18KFC40xx48fl91u1+jRo3Xw4EFlZWXpoYce0vbt2706RwAAALReiwrxpqYmpaSkaMmSJRo8eLBmzpypGTNmqKCgoP0i/I5yc3NVW1trLCdPnjQ7JACd0Llz55SRkaFXXnnF4/kZtbW1Wrt2rZ577jmNGTNGQ4YM0bp167Rnzx7t3btXkrRjxw4dPXpUf/jDH3Trrbfqrrvu0lNPPaX8/HzV19dLkgoKCpSUlKTly5erf//+yszM1H333acVK1aYNmcAAAC0TIsK8e7duys5OdmjrX///qqsrJQkJSQkSNJVl1pWVVUZfQkJCaqurvbob2ho0NmzZz3GNLeNK/fxdWFhYbJYLB4LAHibw+GQ3W73uEVHksrLy3Xp0iWP9n79+qlXr14et+4MHDjQ44qgtLQ0uVwuHTlyxBjz9W2npaUZ22gOt+4AAAD4lhYV4iNHjlRFRYVH2yeffKLevXtLXz24LSEhQSUlJUa/y+XSvn37ZLPZJEk2m001NTUqLy83xuzcuVNNTU0aPny4MWb37t26dOmSMaa4uFg333yzxxkmAPAlmzZt0kcffaS8vLyr+pxOp0JDQxUdHe3R/vVbd77ttpxrjXG5XLpw4UKzcXHrDgAAgG9pUSGenZ2tvXv3asmSJfr73/+uwsJCrVmzRg6HQ5KMBxP99re/1dtvv61Dhw5pypQp6tGjhyZMmCB9dQb9zjvv1IwZM7R//3598MEHyszM1MSJE9WjRw9J0s9//nOFhoZq+vTpOnLkiF577TU9//zzysnJaY9jAADX7eTJk3rssce0ceNGhYeHmx2OB27dAQAA8C0ten3ZsGHD9Oabbyo3N1eLFy9WUlKSVq5cqYyMDGPM3Llzdf78ec2cOVM1NTX64Q9/qG3btnn8x3Tjxo3KzMzU2LFjFRgYqPT0dL3wwgtGv9Vq1Y4dO+RwODRkyBB169ZNCxcu5NVlAHxWeXm5qqurlZKSYrQ1NjZq9+7dWrVqlbZv3676+nrV1NR4nBX/+q07+/fv99ju12/LudatOxaLRREREc3GFhYWprCwsDacLQAAAK5HiwpxSRo/frzGjx9/zf6AgAAtXrxYixcvvuaYmJgYFRYWfuN+Bg0apD//+c8tDQ8ATDF27FgdOnTIo+3BBx9Uv379NG/ePCUmJiokJEQlJSVKT0+XJFVUVKiystLj1p2nn35a1dXVxtsliouLZbFYjOdz2Gw2vfvuux77KS4uNrYBAAAA39fiQhxA59NnflG77+PEUnu776M9RUVFacCAAR5tkZGRio2NNdqnT5+unJwcxcTEyGKxaPbs2bLZbBoxYoQkady4cUpOTtbkyZO1bNkyOZ1OLViwQA6HwzijPWvWLK1atUpz587VtGnTtHPnTm3evFlFRe3/dwQAAIC2QSEOAF6yYsUK43acuro6paWl6aWXXjL6g4KCtGXLFj3yyCOy2WyKjIzU1KlTPa4wSkpKUlFRkbKzs/X888+rZ8+eevXVV5WWlmbSrAAAANBSFOIA0E527drl8Tk8PFz5+fnKz8+/5jq9e/e+6tLzrxs1apQ+/vjjNosTAAAA3tWip6YDAAAAAIDrwxlxAAAAAB0Cz7WBv+CMOAAAAAAAXkQhDgAAAACAF1GIAwAAAADgRRTiAAAAAAB4EYU4AAAAAABeRCEOAAAAAIAXUYgDAADAa5YuXaqAgABlZWUZbRcvXpTD4VBsbKy6du2q9PR0VVVVeaxXWVkpu92uLl26KC4uTnPmzFFDQ4PHmF27diklJUVhYWHq27ev1q9f77V5AUBLUIgDAADAKw4cOKCXX35ZgwYN8mjPzs7WO++8o9dff12lpaU6ffq07r33XqO/sbFRdrtd9fX12rNnjzZs2KD169dr4cKFxpjjx4/Lbrdr9OjROnjwoLKysvTQQw9p+/btXp0jAHwXwWYHAAAAgI7v3LlzysjI0CuvvKLf/va3Rnttba3Wrl2rwsJCjRkzRpK0bt069e/fX3v37tWIESO0Y8cOHT16VH/6058UHx+vW2+9VU899ZTmzZunRYsWKTQ0VAUFBUpKStLy5cslSf3799f777+vFStWKC0tzbR5+4s+84vMDgHoVDgjDgAAgHbncDhkt9uVmprq0V5eXq5Lly55tPfr10+9evVSWVmZJKmsrEwDBw5UfHy8MSYtLU0ul0tHjhwxxnx922lpacY2AMCXcEYcAAAA7WrTpk366KOPdODAgav6nE6nQkNDFR0d7dEeHx8vp9NpjLmyCL/cf7nvm8a4XC5duHBBERERV+27rq5OdXV1xmeXy3Vd8wSA74oz4gAAAGg3J0+e1GOPPaaNGzcqPDzc7HA85OXlyWq1GktiYqLZIQHoJCjEAQAA0G7Ky8tVXV2tlJQUBQcHKzg4WKWlpXrhhRcUHBys+Ph41dfXq6amxmO9qqoqJSQkSJISEhKueor65c/fNsZisTR7NlyScnNzVVtbaywnT55s07kDwLVQiAMAAKDdjB07VocOHdLBgweNZejQocrIyDD+HBISopKSEmOdiooKVVZWymazSZJsNpsOHTqk6upqY0xxcbEsFouSk5ONMVdu4/KYy9toTlhYmCwWi8cCAN7APeIAAABoN1FRURowYIBHW2RkpGJjY4326dOnKycnRzExMbJYLJo9e7ZsNptGjBghSRo3bpySk5M1efJkLVu2TE6nUwsWLJDD4VBYWJgkadasWVq1apXmzp2radOmaefOndq8ebOKingaOADfQyEOAAAAU61YsUKBgYFKT09XXV2d0tLS9NJLLxn9QUFB2rJlix555BHZbDZFRkZq6tSpWrx4sTEmKSlJRUVFys7O1vPPP6+ePXvq1Vdf5dVlAHwShTgAAAC8ateuXR6fw8PDlZ+fr/z8/Guu07t3b7377rvfuN1Ro0bp448/brM4AaC9cI84AAAAAABeRCEOAAAAAIAXUYgDAAAAAOBFFOIAAAAAAHgRhTgAAAAAAF5EIQ4AAAAAgBdRiAMAAAAA4EXXVYgvXbpUAQEBysrKMtouXrwoh8Oh2NhYde3aVenp6aqqqvJYr7KyUna7XV26dFFcXJzmzJmjhoYGjzG7du1SSkqKwsLC1LdvX61fv/56QgUAAAAAwCe0uhA/cOCAXn75ZQ0aNMijPTs7W++8845ef/11lZaW6vTp07r33nuN/sbGRtntdtXX12vPnj3asGGD1q9fr4ULFxpjjh8/LrvdrtGjR+vgwYPKysrSQw89pO3bt7c2XAAAAAAAfEKrCvFz584pIyNDr7zyim644Qajvba2VmvXrtVzzz2nMWPGaMiQIVq3bp327NmjvXv3SpJ27Niho0eP6g9/+INuvfVW3XXXXXrqqaeUn5+v+vp6SVJBQYGSkpK0fPly9e/fX5mZmbrvvvu0YsWKtpo3AAAAAACmaFUh7nA4ZLfblZqa6tFeXl6uS5cuebT369dPvXr1UllZmSSprKxMAwcOVHx8vDEmLS1NLpdLR44cMcZ8fdtpaWnGNppTV1cnl8vlsQAAAAAA4GuCW7rCpk2b9NFHH+nAgQNX9TmdToWGhio6OtqjPT4+Xk6n0xhzZRF+uf9y3zeNcblcunDhgiIiIq7ad15enp588smWTgcAAAAAAK9q0RnxkydP6rHHHtPGjRsVHh7eflG1Qm5urmpra43l5MmTZocEAAAAAMBVWlSIl5eXq7q6WikpKQoODlZwcLBKS0v1wgsvKDg4WPHx8aqvr1dNTY3HelVVVUpISJAkJSQkXPUU9cufv22MxWJp9my4JIWFhclisXgsAAAAAAD4mhYV4mPHjtWhQ4d08OBBYxk6dKgyMjKMP4eEhKikpMRYp6KiQpWVlbLZbJIkm82mQ4cOqbq62hhTXFwsi8Wi5ORkY8yV27g85vI2AAAAAADwVy26RzwqKkoDBgzwaIuMjFRsbKzRPn36dOXk5CgmJkYWi0WzZ8+WzWbTiBEjJEnjxo1TcnKyJk+erGXLlsnpdGrBggVyOBwKCwuTJM2aNUurVq3S3LlzNW3aNO3cuVObN29WUVFR280cAAAAAAATtPhhbd9mxYoVCgwMVHp6uurq6pSWlqaXXnrJ6A8KCtKWLVv0yCOPyGazKTIyUlOnTtXixYuNMUlJSSoqKlJ2draef/559ezZU6+++qrS0tLaOlygXfWZzy+PAAAAAHi67kJ8165dHp/Dw8OVn5+v/Pz8a67Tu3dvvfvuu9+43VGjRunjjz++3vAAAAAAAPAprXqPOAAAAAAAaB0KcQAAAAAAvIhCHAAAAAAAL6IQBwAAAADAiyjEAQAAAADwIgpxAAAAAAC8iEIcAAAAAAAvohAHAAAAAMCLgs0OAAAAAAD8RZ/5Re2+jxNL7e2+D5iLM+IAAAAAAHgRhTgAtIG8vDwNGzZMUVFRiouL04QJE1RRUeEx5uLFi3I4HIqNjVXXrl2Vnp6uqqoqjzGVlZWy2+3q0qWL4uLiNGfOHDU0NHiM2bVrl1JSUhQWFqa+fftq/fr1XpkjAAAA2gaXpgNAGygtLZXD4dCwYcPU0NCgX/3qVxo3bpyOHj2qyMhISVJ2draKior0+uuvy2q1KjMzU/fee68++OADSVJjY6PsdrsSEhK0Z88eff7555oyZYpCQkK0ZMkSSdLx48dlt9s1a9Ysbdy4USUlJXrooYfUvXt3paWlmXoM/IE3LicEAAD4NgFut9ttdhDtweVyyWq1qra2VhaLxexw0Enxn/7vrqPdC3XmzBnFxcWptLRUd9xxh2pra3XjjTeqsLBQ9913nyTp2LFj6t+/v8rKyjRixAht3bpV48eP1+nTpxUfHy9JKigo0Lx583TmzBmFhoZq3rx5Kioq0uHDh419TZw4UTU1Ndq2bdt3iq0z50e+k51PR8staF/kR/gKclfHx6XpANAOamtrJUkxMTGSpPLycl26dEmpqanGmH79+qlXr14qKyuTJJWVlWngwIFGES5JaWlpcrlcOnLkiDHmym1cHnN5G82pq6uTy+XyWAAAAGAeCnEAaGNNTU3KysrSyJEjNWDAAEmS0+lUaGiooqOjPcbGx8fL6XQaY64swi/3X+77pjEul0sXLlxoNp68vDxZrVZjSUxMbMPZAgAAoKUoxAGgjTkcDh0+fFibNm0yOxRJUm5urmpra43l5MmTZocEAADQqfGwNgBoQ5mZmdqyZYt2796tnj17Gu0JCQmqr69XTU2Nx1nxqqoqJSQkGGP279/vsb3LT1W/cszXn7ReVVUli8WiiIiIZmMKCwtTWFhYG84SAAAA14Mz4gDQBtxutzIzM/Xmm29q586dSkpK8ugfMmSIQkJCVFJSYrRVVFSosrJSNptNkmSz2XTo0CFVV1cbY4qLi2WxWJScnGyMuXIbl8dc3gYAAAB8H2fEAaANOBwOFRYW6q233lJUVJRxT7fValVERISsVqumT5+unJwcxcTEyGKxaPbs2bLZbBoxYoQkady4cUpOTtbkyZO1bNkyOZ1OLViwQA6HwzijPWvWLK1atUpz587VtGnTtHPnTm3evFlFRTztFgAAwF9wRhwA2sDq1atVW1urUaNGqXv37sby2muvGWNWrFih8ePHKz09XXfccYcSEhL0xhtvGP1BQUHasmWLgoKCZLPZNGnSJE2ZMkWLFy82xiQlJamoqEjFxcW65ZZbtHz5cr366qu8QxwAAMCPUIgDQBtwu93NLg888IAxJjw8XPn5+Tp79qzOnz+vN954w7j3+7LevXvr3Xff1b/+9S+dOXNGzz77rIKDPS9eGjVqlD7++GPV1dXpv//7vz32AQC+KC8vT8OGDVNUVJTi4uI0YcIEVVRUeIy5ePGiHA6HYmNj1bVrV6Wnp1/1TIzKykrZ7XZ16dJFcXFxmjNnjhoaGjzG7Nq1SykpKQoLC1Pfvn21fv16r8wRAFqCQhwAAADtqrS0VA6HQ3v37lVxcbEuXbqkcePG6fz588aY7OxsvfPOO3r99ddVWlqq06dP69577zX6GxsbZbfbVV9frz179mjDhg1av369Fi5caIw5fvy47Ha7Ro8erYMHDyorK0sPPfSQtm/f7vU5A8A34R5xAAAAtKtt27Z5fF6/fr3i4uJUXl6uO+64Q7W1tVq7dq0KCws1ZswYSdK6devUv39/7d27VyNGjNCOHTt09OhR/elPf1J8fLxuvfVWPfXUU5o3b54WLVqk0NBQFRQUKCkpScuXL5ck9e/fX++//75WrFjBLTwAfApnxAEAAOBVtbW1kqSYmBhJUnl5uS5duqTU1FRjTL9+/dSrVy+VlZVJksrKyjRw4EDFx8cbY9LS0uRyuXTkyBFjzJXbuDzm8ja+rq6uTi6Xy2MBAG+gEAcAAIDXNDU1KSsrSyNHjtSAAQMkSU6nU6GhoYqOjvYYGx8fb7yFwul0ehThl/sv933TGJfLpQsXLlwVS15enqxWq7EkJia28WwBoHkU4gAAAPAah8Ohw4cPa9OmTWaHotzcXNXW1hrLyZMnzQ4JQCfBPeIAAADwiszMTG3ZskW7d+9Wz549jfaEhATV19erpqbG46x4VVWV8XaJhIQE7d+/32N7l5+qfuWYrz9pvaqqShaLRREREVfFExYWprCwsDaeJQB8O86IAwAAoF253W5lZmbqzTff1M6dO5WUlOTRP2TIEIWEhKikpMRoq6ioUGVlpWw2myTJZrPp0KFDqq6uNsYUFxfLYrEoOTnZGHPlNi6PubwNAPAVLSrEeQckAAAAWsrhcOgPf/iDCgsLFRUVJafTKafTady3bbVaNX36dOXk5Oi9995TeXm5HnzwQdlsNo0YMUKSNG7cOCUnJ2vy5Mn6y1/+ou3bt2vBggVyOBzGWe1Zs2bps88+09y5c3Xs2DG99NJL2rx5s7Kzs02dPwB8XYsKcd4BCQAAgJZavXq1amtrNWrUKHXv3t1YXnvtNWPMihUrNH78eKWnp+uOO+5QQkKC3njjDaM/KChIW7ZsUVBQkGw2myZNmqQpU6Zo8eLFxpikpCQVFRWpuLhYt9xyi5YvX65XX32VV5cB8DkBbrfb3dqVz5w5o7i4OJWWlhrvgLzxxhtVWFio++67T5J07Ngx9e/fX2VlZRoxYoS2bt2q8ePH6/Tp08ZTLQsKCjRv3jydOXNGoaGhmjdvnoqKinT48GFjXxMnTlRNTc1V76G8FpfLJavVqtraWlksltZOEbgufeYXmR2C3zix1G52CJ1GZ86PfCc7H3ILWoL8CF9B7ur4rusecV95ByQAAAAAAP6i1U9NN/MdkM099bKurk51dXXGZ5fL1dqpAQAAAADQblp9RtyX3gGprx4kZ7VajSUxMdHskAAAAAAAuEqrCvHL74B87733rvkOyCt9/R2Qzb3fUdfxDkhJys3NVW1trbGcPHmyNVMDAAAAAKBdtagQ9+V3QIaFhclisXgsAAAAAAD4mhbdI+5wOFRYWKi33nrLeAekvnr3Y0REhMc7IGNiYmSxWDR79uxrvgNy2bJlcjqdzb4DctWqVZo7d66mTZumnTt3avPmzSoq4mmOAAAAAAD/1qIz4rwDEgAAAACA69OiM+Lf5ZXj4eHhys/PV35+/jXH9O7dW+++++43bmfUqFH6+OOPWxIeAAAAAAA+77reIw4AAAAAAFqGQhwAAAAAAC+iEAcAAAAAwItadI840NH0mc+T+AEAAAB4F4U4AADosNr7F64nltrbdfsAgI6JQhwAAADwcVzFB3Qs3CMOAAAAAIAXUYgDAAAAAOBFFOIAAAAAAHgR94gDAAAAgA/xxjMBeNikuTgjDgAAAACAF1GIAwAAAADgRRTiAAAAAAB4EYU4AAAAAABeRCEOAAAAAIAXUYgDAAAAAOBFFOIAAAAAAHgRhTgAAAAAAF5EIQ4AAAAAgBcFmx0AAEhSn/lF7b6PE0vt7b4PAAAA4NtwRhwAAAAAAC+iEAcAAAAAwIu4NB0+yxuXKgMAcD24rQYA0BoU4gAAn8Av3wAAQGfBpekAAAAAAHgRhTgAAAAAAF7EpekAAAAA0MnwjAtzcUYcAAAAAAAv4ow4WoWHKgEAAABA6/h0IZ6fn69nnnlGTqdTt9xyi1588UXddtttZocFAKYjPwKdB5ePthw5EoCv89lC/LXXXlNOTo4KCgo0fPhwrVy5UmlpaaqoqFBcXJzZ4QGAaciPAHBtZuRIrhQE0FIBbrfbbXYQzRk+fLiGDRumVatWSZKampqUmJio2bNna/78+d+6vsvlktVqVW1trSwWixci7lz4Bwf+qKOc8emo+ZG8Apino+RHXWeObG1+JH8B5vHX/OWTZ8Tr6+tVXl6u3Nxcoy0wMFCpqakqKytrdp26ujrV1dUZn2tra6WvEmpnM+CJ7WaHAPik1uSDqKgoBQQEtEs8rWFmfiS3AB1Xa/+/5O85sq3yY1Pdv64rbgCt56v13rflR58sxP/5z3+qsbFR8fHxHu3x8fE6duxYs+vk5eXpySefvKo9MTGx3eIE4F+sK1u+jq+dNSY/AmgPrcmP6gA5kvwI+L/W5q/29m350ScL8dbIzc1VTk6O8bmpqUlnz55VbGysT/2mtr25XC4lJibq5MmTPvUPo6/g+Hwzjs/VoqKizA7hurVlfuwMPyPMsePoDPM0e47+niOvlR9DQkLUq1cvv/3ZMfvn4noRv3n8OXb5WPzflh99shDv1q2bgoKCVFVV5dFeVVWlhISEZtcJCwtTWFiYR1t0dHS7xunLLBaL6T98vozj8804Pr7LV/JjZ/gZYY4dR2eYZ2eY43fR0hx5rfx4+VJXfz+uxG8uf47fn2OXn8QfaHYAzQkNDdWQIUNUUlJitDU1NamkpEQ2m83U2ADATORHALg2ciQAf+GTZ8QlKScnR1OnTtXQoUN12223aeXKlTp//rwefPBBs0MDAFORHwHg2siRAPyBzxbi//Ef/6EzZ85o4cKFcjqduvXWW7Vt27arHr4BT2FhYXriiSeuuswK/x/H55txfPyDmfmxM/yMMMeOozPMszPMsaXaIkf6+3ElfnP5c/z+HLv8LH6ffY84AAAAAAAdkU/eIw4AAAAAQEdFIQ4AAAAAgBdRiAMAAAAA4EUU4gAAAAAAeBGFeAfy9NNP6/bbb1eXLl0UHR3d7JiAgICrlk2bNnk9VjN8l+NTWVkpu92uLl26KC4uTnPmzFFDQ4PXY/UFffr0uepnZenSpWaHBR9x4sQJTZ8+XUlJSYqIiNC//du/6YknnlB9fb3ZoV2X/Px89enTR+Hh4Ro+fLj2799vdkhtKi8vT8OGDVNUVJTi4uI0YcIEVVRUmB1Wu1q6dKkCAgKUlZVldiht7tSpU5o0aZJiY2MVERGhgQMH6sMPPzQ7rA7HH/OdP+ayjpaf/DH3+HNOaWxs1G9+8xuP7+lTTz0lX34uuc++vgwtV19fr/vvv182m01r16695rh169bpzjvvND5fqyjtaL7t+DQ2NsputyshIUF79uzR559/rilTpigkJERLliwxJWazLV68WDNmzDA+R0VFmRoPfMexY8fU1NSkl19+WX379tXhw4c1Y8YMnT9/Xs8++6zZ4bXKa6+9ppycHBUUFGj48OFauXKl0tLSVFFRobi4OLPDaxOlpaVyOBwaNmyYGhoa9Ktf/Urjxo3T0aNHFRkZaXZ4be7AgQN6+eWXNWjQILNDaXNffPGFRo4cqdGjR2vr1q268cYb9emnn+qGG24wO7QOx9/ynb/mso6Un/wx9/h7Tvnd736n1atXa8OGDfrBD36gDz/8UA8++KCsVqseffRRs8Nrnhsdzrp169xWq7XZPknuN9980+sx+ZJrHZ93333XHRgY6HY6nUbb6tWr3RaLxV1XV+flKM3Xu3dv94oVK8wOA35k2bJl7qSkJLPDaLXbbrvN7XA4jM+NjY3uHj16uPPy8kyNqz1VV1e7JblLS0vNDqXNffnll+6bbrrJXVxc7P73f/9392OPPWZ2SG1q3rx57h/+8Idmh9Fp+XK+6yi5zF/zk7/mHn/PKXa73T1t2jSPtnvvvdedkZFhWkzfhkvTOyGHw6Fu3brptttu0+9//3ufvmTDm8rKyjRw4EDFx8cbbWlpaXK5XDpy5IipsZll6dKlio2N1eDBg/XMM8902sv08d3U1tYqJibG7DBapb6+XuXl5UpNTTXaAgMDlZqaqrKyMlNja0+1tbWS5Ld/b9/E4XDIbrd7/J12JG+//baGDh2q+++/X3FxcRo8eLBeeeUVs8PqNHw133WkXOav+clfc4+/55Tbb79dJSUl+uSTTyRJf/nLX/T+++/rrrvuMju0a+LS9E5m8eLFGjNmjLp06aIdO3boF7/4hc6dO+e7l2x4kdPp9CjCJRmfnU6nSVGZ59FHH1VKSopiYmK0Z88e5ebm6vPPP9dzzz1ndmjwQX//+9/14osv+uRlmt/FP//5TzU2NjabA44dO2ZaXO2pqalJWVlZGjlypAYMGGB2OG1q06ZN+uijj3TgwAGzQ2k3n332mVavXq2cnBz96le/0oEDB/Too48qNDRUU6dONTu8Ds2X811HyWX+mp/8Off4e06ZP3++XC6X+vXrp6CgIDU2Nurpp59WRkaG2aFdE2fEfdz8+fObfcDalUtLEutvfvMbjRw5UoMHD9a8efM0d+5cPfPMM+06h/bU1seno2vJ8crJydGoUaM0aNAgzZo1S8uXL9eLL76ouro6s6eBdtSa79SpU6d055136v777/d4pgB8m8Ph0OHDhzvcAztPnjypxx57TBs3blR4eLjZ4bSbpqYmpaSkaMmSJRo8eLBmzpypGTNmqKCgwOzQ/Ab5znf5Y37y99zj7zll8+bN2rhxowoLC/XRRx9pw4YNevbZZ7VhwwazQ7smzoj7uMcff1wPPPDAN475/ve/3+rtDx8+XE899ZTq6uoUFhbW6u2YpS2PT0JCwlVPFa2qqjL6OoLrOV7Dhw9XQ0ODTpw4oZtvvrmdIoTZWvozcvr0aY0ePVq333671qxZ44UI20e3bt0UFBRkfOcvq6qq6jDf/ytlZmZqy5Yt2r17t3r27Gl2OG2qvLxc1dXVSklJMdoaGxu1e/durVq1SnV1dQoKCjI1xrbQvXt3JScne7T1799f//Vf/2VaTP6mI+a7jpDL/DU/+Xvu8fecMmfOHM2fP18TJ06UJA0cOFD/+Mc/lJeX57Nn9CnEfdyNN96oG2+8sd22f/DgQd1www1+WYSrjY+PzWbT008/rerqauOposXFxbJYLFclJn91Pcfr4MGDCgwM9OknruL6teRn5NSpUxo9erSGDBmidevWKTDQfy+yCg0N1ZAhQ1RSUqIJEyZIX50dKCkpUWZmptnhtRm3263Zs2frzTff1K5du5SUlGR2SG1u7NixOnTokEfbgw8+qH79+mnevHk+/R/hlhg5cuRVr3b65JNP1Lt3b9Ni8jcdMd/5cy7z9/zk77nH33PKv/71r6u+l0FBQWpqajItpm9DId6BVFZW6uzZs6qsrFRjY6MOHjwoSerbt6+6du2qd955R1VVVRoxYoTCw8NVXFysJUuW6Je//KXZoXvFtx2fcePGKTk5WZMnT9ayZcvkdDq1YMECORwOv/1FRWuVlZVp3759Gj16tKKiolRWVqbs7GxNmjTJb15jgfZ16tQpjRo1Sr1799azzz6rM2fOGH3+ctbl63JycjR16lQNHTpUt912m1auXKnz58/rwQcfNDu0NuNwOFRYWKi33npLUVFRxvMvrFarIiIizA6vTURFRV11T2lkZKRiY2P96l7Tb5Odna3bb79dS5Ys0c9+9jPt379fa9as8dkztf7M3/Kdv+Yyf89P/p57/D2n/OQnP9HTTz+tXr166Qc/+IE+/vhjPffcc5o2bZrZoV2b2Y9tR9uZOnWqW9JVy3vvved2u93urVu3um+99VZ3165d3ZGRke5bbrnFXVBQ4G5sbDQ7dK/4tuPjdrvdJ06ccN91113uiIgId7du3dyPP/64+9KlS6bGbYby8nL38OHD3Var1R0eHu7u37+/e8mSJe6LFy+aHRp8xLp165r9Pvn7Pysvvviiu1evXu7Q0FD3bbfd5t67d6/ZIbWpa/2drVu3zuzQ2pU/vUKoJd555x33gAED3GFhYe5+/fq516xZY3ZIHZI/5jt/zGUdMT/5W+7x55zicrncjz32mLtXr17u8PBw9/e//333r3/9a59+BXGAm3dXAQAAAADgNb55gwsAAAAAAB0UhTgAAAAAAF5EIQ4AAAAAgBdRiAMAAAAA4EUU4gAAAAAAeBGFOAAAAAAAXkQhDgAAAACAF1GIAwAAAADgRRTiAAAAAAB4EYU4AAAAAABeRCEOAAAAAIAXUYgDAAAAAOBF/w/6HwD9EfaTNwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(particles[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4032de45", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(initial_particles[:, i])\n", + " axi.set_title(f\"$w_{i}$\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "db7cd2eb", + "metadata": {}, + "outputs": [], + "source": [ + "def predict(x, w):\n", + " return sigmoid(x@w)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "a58e1879", + "metadata": {}, + "outputs": [], + "source": [ + "pred=(predict(Phi,np.mean(particles, axis=0))>0.5).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "2e3a9df9", + "metadata": {}, + "outputs": [], + "source": [ + "pred2=(predict(Phi,np.mean(states.position, axis=0))>0.5).astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "5a6a5dc6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[27, 0],\n", + " [ 0, 23]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import sklearn\n", + "sklearn.metrics.confusion_matrix(y, pred)" + ] + }, + { + "cell_type": "markdown", + "id": "3c670f3d-0e3a-42d6-9f62-718397695a74", + "metadata": {}, + "source": [ + "Above: confusion matrix for SMC in sample" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "1bc4fd5c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[19, 8],\n", + " [ 0, 23]])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sklearn.metrics.confusion_matrix(y, pred2)" + ] + }, + { + "cell_type": "markdown", + "id": "c40e4753-633a-4a06-8dfd-4d5fa2c62b3b", + "metadata": {}, + "source": [ + "Above: confusion matrix for MH in sample" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "6834a6e5", + "metadata": {}, + "outputs": [], + "source": [ + "def posterior_predictive_plot(samples):\n", + " from matplotlib import cm, ticker\n", + " xmin, ymin = X.min(axis=0) - 0.1\n", + " xmax, ymax = X.max(axis=0) + 0.1\n", + " step = 0.1\n", + " Xspace = jnp.mgrid[xmin:xmax:step, ymin:ymax:step]\n", + " _, nx, ny = Xspace.shape\n", + " \n", + " # Compute the average probability to belong to the first cluster at each point on the meshgrid\n", + " Phispace = jnp.concatenate([jnp.ones((1, nx, ny)), Xspace])\n", + " Z_mcmc = sigmoid(jnp.einsum(\"mij,sm->sij\", Phispace, samples))\n", + " Z_mcmc = Z_mcmc.mean(axis=0)\n", + " \n", + " plt.contourf(*Xspace, Z_mcmc)\n", + " plt.legend()\n", + " plt.scatter(*X.T, c=colors)\n", + " plt.xlabel(r\"$X_0$\")\n", + " plt.ylabel(r\"$X_1$\")\n", + " plt.show();\n", + " return Z_mcmc" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "c36ad97c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62464/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAKpCAYAAABKPfTmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABw60lEQVR4nO3deXicZ33v/88zM5oZLaORbEteZSvO5iw4GyEJoWmABBpa1pakv18XoD30lCa0Oek5bQMttKelgbb0R3uaphRo4SrQUDgE2gBNQ0qSQsi+kAVnc2TLi2zJWkbbrM/9+0MaedMykmbmeea+36/r0lVLGkk3rmLNW9/7uR/PGGMEAAAAAABqIhL0AgAAAAAAsBnhDQAAAABADRHeAAAAAADUEOENAAAAAEANEd4AAAAAANQQ4Q0AAAAAQA0R3gAAAAAA1JA14W2MUSaTEbclBwAAAACESSzoBVTL+Pi40um0Tv3QnyqaTAa9nIaT68kHvQQAddDbMxj0EgAE7OoNu4JeAoAG8M72J4JeQsM4u2f/ko+xZuKN1Un0x4NeAoA66OvvCnoJAAJ298COoJcAoAHckbkg6CVYhfDGHOIbcENffxcBDjju7oEdBDiAJd2RuYAArxLCG8dJ9McJcMARxDcA4htAJYjv1SO8MS/iG3AD028AxDeAShDfq0N4Y0HEN+AO4htwG1vPAVSCrecrR3hjUWw9B9zB9BsA8Q2gEjbFt/Gb5Rc3yS9unudlk4zfXJWvY83txFBbif44txwDHNHX38VtxwCHleN7xbcd8426n5rWhsenFC0YjZ4SV/8VKRWbmfcANinHd6PedswYT8Wpd0v5q+R5TZK8+R4lYwpS/LuKtXxVnmdW/PU8Y8zKPzpEMpkM9/GuEwIccAPxDWC58d18pKjX/slBpffm5Udn3uaVpFLC08O/vV4DF7XWZqEAAtWI8V2YvFZe8W3q6upQstlbILul7LTR4OCoTOxf1dT6L/N+Lu7jjZpg6zngBraeA1jO1nOvaHT5Hx1Qat/ML+gjpZkXT1I0b3TpJwaU3p2r4WoBBKXRtp4bv1nKX6Wurg51dEaUTHpKzPOSTHrq6Iyoq6tDyl+1qm3nhDdWhGu/AXcQ34DbKj14beMjk2rfX1DEP/l9npkZHZ3+zdHaLBKwWHTaVzQ7z39YIdNIB68Zv1Oe16Rk83xz7pMlmz15XpOM37nir8k13lgVrv0G3FCOb7afA+66e2DHolvPNz08KT+iecNbmnn75ocm9agxklfZk13AWcZo6/fGdfq/jSm9d+a59sgpcb349g7te11bqP8buiNzQQNsPfckzb+9fKFHlz9mpZh4Y9WYfAPuYPoNuG2x6Xcsa+QtMZSLFszMRZMAFmaMzvvMkF5966Da+48OuNJ9eb3mU4d1zheHA11eJRpp+l0vhDeqgq3ngDuIbwDzxXemp0lmkWeWxpPGNzZJkfBO6oAwWP/ktE69KyOVL9OYFZn985nfGNWaXdMBrW55iO+jCG9UFfENuIGD1wCcGN+vXNWuRe+0Y6Td17TXfF1Ao9v+nTH5i1SaH5G2fydTzyWtCvE9g/BG1TH9BtxBfANuO3br+XR3k576lXWSJP+YobaZnXYPvqpZu9+UDmqpQMNIv5Jb8KwEzZ6X0PFKY90hgK3nhDdqiPgG3MD0G0A5vne/Ja0Hbt6gkTMSc+/Ldkb17P+7Rg98eKNME9vMgaWUEosnmpFUSjTmf0vhiW9fRkamwjMnjJGMjKSVny7PqeaoKU49B9zR19/FqeeAw8rxffWrd2ng1a2KTfmKFIzyqQjXdQPLcOCyVp3+jdGFp96etP+ytjqvqnrK8R3kyededFBGIzo0kNLadUnFmuY/4dxIKhaMjgxlZTQiL7ry5zmEN2quPPkmwAH7Ed8AyrcdK7awsRJYid0/ldb2b49JOTN3oFqZH5GKLRH1vbHxz0sI8rZjnldUU+pPlJ36RR04sFOeogvcKszIqCRFn1JT6kvyvOLKv6YxlQ7Ywy2TySidTuvUD/2poslk0MvBAohvwB0EOIDF7vsNYGFrns/qsj89qPiEP3e3gIgvZdNR/eD3N2pse2KpT9FQggpwYzzJpGT8tgXD24tMSN64vEVOjzy7Z/+SX4vwRiAIcMANxDcA4htYmWjO15YfTGjtj7OSpMFzm7X/tW3yLT0rIcit56tFeCPUiG/AHQQ44DbiG0AlGjW+KwlvLr5BYLjtGOAOTj0H3HbsbccAYCE233aM8EbgiG/ADdx2DADxDaASNsY34Y1QIL4BdxDfgNuYfgOohG3Tb8IbocHWc8AdxDcA4htAJWyJb8IboUN8A25g6zkA4htAJWyIb8IbocT0G3AH8Q24ja3nACrR6FvPCW+EGvENuIHpNwDiG0AlGjW+CW+EHtNvwB3EN+A2pt8AKtGI02/CGw2D+AbcQHwDIL4BVKKR4pvwRkMhvgE3sPUcAPENoBKNMv0mvNFw2HoOuIP4BtzG1nMAlQp7fBPeaFjEN+AGpt8AiG8AlQhzfBPeaGhMvwF3EN+A25h+A6hEWLeeE96wAvENuIH4BkB8A6hE2OKb8IY1iG/ADWw9B8D0G0AlwjT9JrxhFbaeA+4gvgEQ3wAqEYb4JrxhJeIbcAPTbwC2xnck52vTQxPq/W5G3U9NSSUT9JKAhhZ0fMcC/epADZXjO9eTD3opAGqsr79LvT2DQS8DQEDK8X31hl1BL2X1jNGp3x7T2f88rKbpo7E9vSaqJ369SwMXtQa6PKCRleP7ne1P1P1rM/GG9Zh+A25g+g3Ahun3af82pvP+4chx0S1JyZGSLrtlYGb6DWBVgph+E95wAtd+A+4gvgG3NfLBa7FpX2ffPjzv+7zZDj/3C0ckw7ZzYLXqffAa4Q2nEN+AG4hvAI0Y3xsfnlQst3BUe0bq2JNXal+hrusCbFav+Ca84RziG3ADW88BNFp8J8ZK8it4dp4YK9VjOYAz6jH9JrzhJLaeA+4gvgG3NdLW8+m1MUX8yh4HoPpqGd+EN5xGfANuYPoNoBHi++CrW1RoiWihzeZ+RDpyZkKTG5vqvDLAHbWKb8IbzmP6DbiD+AbcFvbpt5+I6Kn3rZUnnRTfvieZiPSj964LaHWAO2qx9ZzwBmYR34AbiG8AYY7vvW9o18M3dmt63fHbyTO9cf3XH23WyBnJwNYGuKaa8e0ZY8f9CDKZjNLptE790J8qmuQfJKxcricf9BIA1Elvz2DQSwAQsKs37Ap6CfPzjda8kFNivKTJrpgyvYmgVwQ47Z3tTyz4vrN79i/58Uy8gROw9RxwB9NvAKGdfkc8De9I6uDFrUS3JBmjtn15db6QVZxT3RGA1U6/ORIRWECiP870G3BAOb6ZfgPuuntgR3gn39CmByd09j8Pq332/uV+RDrwmlY98561murmoDnUTzm+F5t+L4SJN7AIpt+AO5h+A24L+8Frrtr23Ywu/fNDSu0vzL0t4kubHp7Ulb+7T82HC4t+PFALK5l+E95ABYhvwA3cdgwA8R0escmSzv/ckIwk74RTqSK+FJ/wdc6Xh4NaHhy33PgmvIEKMf0G3EF8A25j+h0OW34wqUjeyFvg/RFf2vLAhGKTXPONYCzntmOEN7BMxDfgBuIbAPEdrNZDBZno4o+JlKTmEcIb4Ud4AytAfANuYOs5AOI7OIW2iFTBjY8LrSQNwo/vUmCF2HoOuIP4BtzG1vNg7Httmzx/4ff7EWnwrKSyndyoCeFHeAOrRHwDbmD6DYD4rq+p9U3quyolM89F3sabOXDtxz+/JoilActGeANVwPQbcAfxDbiN6Xd9Pfn+Lr1ydbuMNxPb/uw13/nWiB783Q0aOrc56CUCFWFfBlBFif64cj35oJcBoMb6+rvU2zMY9DIABOjugR26esOuoJdhPRPz9OR/79Kun+vUpocm1TTta2Jjkw5e3Cq/aaHzzoHwIbyBKitPvglwwG7lyTcBDriL+K6f7NqYdr8lHfQygBVjqzlQI2w9B9zA1nPAbWw9B1AJwhuoIeIbcAMHrwEgvgEshvAGaoyD1wB3EN+A25h+A1gI4Q3UCfENuIHpNwDiG8CJOFwNqCMOXgPcwcnngNvK8f222DPa+MikYllf41viGriwRSbKadyAawhvIADcdgxwA/ENuCtWKOm6rzyr1z7YL08z96CO+NJ0R1SP/la3Bne2BL1EAHXEVnMgIGw9B9zA1nPATb/0xR/ptQ/2K2Ikz8xEtyQlx0q6/E8OqvOlbNBLBFBHhDcQIA5eA9xBfAPu2HhgXK959IAi5uT3eUaSkXb8y0gQSwMQEMIbCAHiG3AD02/ADa9+7IBKkYWv44740obHpxSb8uu6LgDBIbyBkGD6DbiD+Abs1jpVkFni/DTPSE2EN+AMwhsIGeIbcAPxDdhraG2zIv48+8yPkW+K6NvTZ9VtTQCCRXgDIcT0G3ADW88BOz30mi0y3sIj71LE04OXbFGxKaq7B3Zw32/AAYQ3EGLEN+AG4huwy3h7Qne8YyamT5x7lyKexlNxfestpx/3duIbsBvhDYQc8Q24gek3YJd73rhd//jL52lo3dH7dZc86YnzN+gT/+tyZdLJkz6G+AbsFQt6AQCWVo7vXE8+6KUAqLG+/i719gwGvQwAVfDwJVv0yMWbtfHguBK5kga7WjSRSiz6MeX4vnrDrjqtEkA9MPEGGgjTb8ANTL8Be5iIpwOb2/XK9s4lo/tYTL8BuxDeQIPh4DXAHcQ34DYOXgPsQXgDDYr4BtxAfAMgvoHGF4rwvu2227Rz5061t7ervb1dl112mb7zne8EvSwg9Jh+A25g6zkA4htobKEI7y1btujjH/+4HnvsMT366KN6wxveoLe//e169tlng14a0BCIb8ANxDfgNraeA40rFOH91re+VW95y1t0+umn64wzztDHPvYxtbW16cEHHwx6aUDDIL4BNzD9BkB8A40ndLcTK5VK+upXv6rJyUlddtllCz4ul8spl8vNvZ7JZOq0QiC8uO0Y4A5uOwa4jduOAY0lFBNvSXr66afV1tamRCKhX//1X9cdd9yhs88+e8HH33LLLUqn03MvPT09dV0vEGZMvwE3MPkGwPQbaAyeMcYEvQhJyufz2rt3r8bGxvS1r31Nn/3sZ3XfffctGN/zTbx7enp06of+VNFkso4rB8KN6TfgBqbfAJh+A8H48Dl3LvmY0IT3ia666iqdeuqp+vSnP13R4zOZjNLpNOENzIP4BtxAfAMgvoH6qyS8Q7PV/ES+7x830Qawctx2DHADB68BYOs5EE6hOFzt5ptv1jXXXKOtW7dqfHxcX/7yl3XvvffqrrvuCnppgFUS/XGm34ADOHgNcBsHrwHhE4rwPnz4sH75l39ZBw8eVDqd1s6dO3XXXXfp6quvDnppgHWIb8AN5ck3AQ646+6BHcQ3EBKhCO/Pfe5zQS8BcAq3HQPcwfQbcBvTbyAcQnuNN4Da47pvwA1c9w2Aa7+BYBHegOM4eA1wAwevASC+geAQ3gAkpt+AM4hvwG13D+wgwIEAEN4A5hDfgBuYfgMgvoH6IrwBHIet54A7iG/AbUy/gfohvAHMi/gG3EB8AyC+gdojvAEsiOk34Aa2ngNg+g3UFuENYEnEN+AG4hsA8Q3UBuENoCJMvwE3MP0GQHwD1Ud4A1gW4htwA/ENuI2t50B1Ed4Alo34BtzA9BsA8Q1UB+ENYEXYeg64g/gG3Mb0G1g9whvAqhDfgBuIbwDEN7ByhDeAVWP6DbiBrecAmH4DK0N4A6ga4htwA/ENgPgGlofwBlBVTL8BNzD9BkB8A5UjvAHUBPENuIH4BtzG1nOgMoQ3gJohvgE3MP0GQHwDiyO8AdQUW88BdxDfgNuYfgMLI7wB1AXxDbiB+AZAfAMnI7wB1A3Tb8ANbD0HwPQbOB7hDaDuiG/ADcQ3AOIbmEF4AwgE02/ADUy/ARDfAOENIGDEN+AG4htwG1vP4TrCG0DgiG/ADcQ3AOIbriK8AYQCW88BN7D1HADTb7iI8AYQKsQ34AbiGwDxDZcQ3gBCh+k34Aam3wCYfsMVhDeA0CK+ATcQ3wCIb9iO8AYQasQ34Aam3wCIb9jMuvBO7TVBLwFAlbH1HHAH8Q24ja3nsJV14S1JqT7iG7AR8Q24gfgGQHzDNlaGt4hvwFpMvwE3sPUcANNv2MTa8NZsfBPggJ2Ib8ANxDcA4hs2sDq8y4hvwE5MvwE3MP0GQHyj0TkR3mL6DViN+AbcQHwDbmPrORqZM+FdRnwDdiK+ATcw/QZAfKMRORfeYvoNWIut54A7iG/AbUy/0WicDO8y4huwE/ENNC7PGMULRcks/TOa+AZAfKNRxIJeQNBSfUbjvV7QywBQZeX4zvXkg14KgApsOTKqdz/4jK58brfiJV+jLUl9+/wz9fXXnK3JZGLBjyvHd2/PYB1X29g83+icZw/rnOcGFS352rOtQ49etEm5pPNPC9GgyvF99YZdQS8FWJBnTAW/Um4AmUxG6XRa5//ixxSNJ1f0OQhwwE7ENxBuO/Yf1i2336VYyVfMP/q0pOR5OtCZ0m//0ls03rz0z3bie2lrh6Z0w60Pa8PhSRUjnjxJEd8om4jq799/kXadxS4CNDbiG0H48Dl3LvkYp7ean4it54CduPYbCK+I7+vmb9yrpuLx0S1JUWO0aWRcv/K9xyr6XBy8trhYoaQb//pBdQ1NzbzuG0V9I09SIl/Sb/zdo9pwcDzoZYbeuqEpveMbu/Sbf/2gfuNvH9YV9+9RIlsMelmYxdZzhBXhfQIOXgPsRXwD4XPRKwfUPT6l6AIb8KLG6I3PvqzWbK7iz0l8z+/Cxw9q3ZFpRf2T/64jZmby/cb/fCWQtTWKy3+wV3/0h9/TVffs1lnPH9E5zw7q57/yjP74o9/T5v2ZoJeHWRy8hjAivBdAfAN2Ir6BcDnl8LCK3uKXejWVfG0eWd4klun3yc5/akD+In/VUd/owicO1nNJDeW0F4/oF778tCJGc7+8iEjyJLVM5fWb/+chNeVLQS8TxyC+ESaE9yKYfgN2Yus5EB75aFQRLf2zNh+NrujzE99HJXIlRZb4q24q+PVaTsO56p7d8iPz/+Yi6kup8bxe/eiBuq8Li2P6jbAgvCtAfAN2Ir6B4D1y2pZFY9CXdDjVoj1dHSv+GsT3jAObUiotEI6S5HvSwIa2uq6pYRgzcwr8PNv05x7iSec8d7iuy0LliG8EjfCuEPEN2InpNxCs/WvS+sEZW1VaYLt5RNLtrz1PZont6Eth67n0/ddtXTQcPSPd+5Pb6rqmRhJZ5O9Os39/0RLPF8OM6TeCRHgvA1vPAXsR30BwPvnTP6Gnt26QJBUjnkqe5kL8n1+7U985/4yqfS2X4/vQ+jZ9/R0z0VE65vcYZnba/fS53Xrwki3BLTDMPE97e9KLXiNvPGnPtpXvzED9EN8IQizoBTSiVJ/hnt+AhcrxzX2/gfqaTjTp5p9/k87tP6Qrn9utVDavgx0p3XXe6TrY2V71r1eObxfv+3331afqcHer3vQfL2t736gkabgzqe9deYq+9/pe+VFmMgv53ut79b4vPDXv+3xJfsTTD17bU/d1YWXuHtjBPb9RV54xC9y/o8FkMhml02md/4sfUzSerNvXJcABOxHfgBtcjO+y5HRB0ZLRZGuTtMqt/E4wRr/wpaf1uh/2q+RJ0dln0KWIJxmjz/3KhXriwo1BrxIrQIBjtT58zp1LPoaJ9yox/QbslOiPE9+AA8I6/fZ8o1c9c1hnP3dYsZJR39a0Hrl4s3LJ6j11yzY3Ve1zOcHz9KVfeJV+fNY6vf6+Pm3dO6ZSNKKndq7XPW84Rft60kGvECvE9Bv1wMS7ighwwE4EOOCGsMT32qEpffBvHtL6wSkVI5682YO9como/v6/XaQfn+3udepArRHgWIlKJt5cyFNFHLwG2ImD1wA3hOHgtVihpBv/+kGtOzI987pvFPWNPEnxfEm/8XePaNOB8aCXCViLg9dQK4R3lRHfgJ247RjghqBvO3bR4we17sj0vLf9ipiZW1a94T93B7I2wBXcdgy1QHjXALcdA+xFfANuCCq+z3tqYNFbVkV9owufGKjnkgBnEd+oJsK7hohvwE5MvwE3BDH9TuRKiizx9KGpUKrXcgDnEd+oFsK7xph+A/YivgE31DO+929OzdyeagG+Jx3cmKrbegCw9RzVQXjXCfEN2In4BtxQr/j+r9dtU2Se67vLPCPd+5Pb6rIWAMcjvrEahHcdMf0G7MTWc8AN9dh6Ptjdqv/7zrOk2el2mZl9+dGruvXgJVtqugYAC2P6jZUivANAfAN2Ir4BN9Q6vu+5artu+++vVl9vx9zbhtc062s/e5b+/v0XyY/y9A0IGvGN5YoFvQBXpfqMxnsXObYUQEMqx3euJx/0UgDUUDm+e3sGa/L5f7RzvX60c70S2aKiJV9TLU2Sx/MGIEzK8X31hl1BLwUNgF+ZBoit54C9mH4Dbqj19DuXjGmqNU50AyHG9BuVILxDgPgG7MS134AbgrjtGIBwIb6xFMI7JJh+A/YivgE3EN+A2zh4DYshvEOG+AbsRHwDbiC+ARDfmA/hHUJMvwE7sfUccANbzwEw/caJCO8QI74BOxHfgBuIbwDEN8oI75Bj+g3Yiek34Aam3wCYfkOEd+MgvgE7Ed+AG4hvAMS32wjvBkJ8A3Zi+g24gek3AOLbXYR3g2HrOWAv4htwA/ENuI2t524ivBsU8Q3YifgG3EB8AyC+3RILegFYuXJ8j/d6QS8FQBWV4zvXkw96KQBqqBzfvT2DQS8FQTJG2/aMacv+jAqxiH58VpfG2xNBrwp1Uo7vqzfsCnopqDHC2wKpPkN8AxZK9MeJbyAETjk0rDc++7I6Jqd1JNWiu191mvat7aja5+/r7yK+HbXxwLh+5fNPaMv+cRlJnqRSxNMDl23Rv7z7HBWbokEvEXVy98AO4ttyhLclmH4DdmL6DQQnWvJ147e/r6ue3a1ixJNnJCPp2gef0Tcv2qFPX3WJjFedn7tMv92z5siU/udfPqBEriTNRrckRX2jyx/oV+tkQZ/5bxdKVfoeQ/gx/bYb13hbhmu/ATtx7TdQf7/yvUf1hmd3S5JivlHUGMXMzM/Ztz22S9c98KOqf02u/XbHm+5+WYlcSVH/5OduESNd+OSAtu0ZC2RtCBbXftuJ8LYQ8Q3YiduOAfWTms7qrU/sWvCJkifp5x56RvFCsepfm9uOOcAYXfrQ/nmju6wU8XTJw/vquiyEByef24fwthS3HQPsRXwDtXfhKwfUVPIXfUxrvqBz9h1e0edP5gv6qSdf0I3f/oF+8zsP6HW7+hQ94esR3/ZqKvhK5EuLPsYzRqlxLjNyHfFtD67xthwHrwF24uA1oLbixcWjqKxzYmrZn3vnnoP6g6//p1pzBZUiMz+jr3nqBR1qb9WHr3uT9q9Nzz2Wg9fsVGiKaLI5ptbphXdMGM/TSGeyrutCOHHwmh2YeDuA6TdgJ7aeA7XzSndnRY+7sO/Asj7vxpGM/vdXv6vmfEHe7LXjsdntxmvHp/SJf/53NecKx30MW88t5Hn6weVb537xMp+ob/TDS3vquiyEF1vPGx/h7RDiG7AT8Q1U30sb1mmorVlL/eS8/Pk9aqpwOi5J73jkOcVKvqLzfOKYMVozMa3XP/fyvB9LfNvlu1dt11h7Yt74NpLuvWKbDm5KBbI2hBfx3bgIb8cw/QbsxPQbqL5nt6xf8jHJYknt09mKP+frdr2iqFn457CZjfmFMP22x3gqoT//n6/VM+d0yz+mvaeaY/rXt56hf3n3OUEuDyHG9LsxcY23o7j2G7AT134D1XOwMyXf8xYNZV/SVHzpX3p5xuinH9+ljqncoo+LSEpWcFI6137bYbSzWX/3669W58i0Nh0YV6Epot2ndKrYFA16aWgAXPvdWAhvhxHfgJ3Kk28CHFid+846RT//w6cXfH/J8/TIqZs1nWha/BMZoxu//X1d/fT8W8iPVfQ87e5eU9H6ypNvArzxjXQ2a6SzOehloAGVJ98EePix1dxxbD0H7MXWc2B1+rrX6P4dvcdtAy7zPcn3PH358vOX/DwXv7xPb3r6ZXmz9/9eTMwYffv8M5e3TraeA85j63n4Ed6QOHgNsBbxDazOX/zM63TPOafKzMZ2cfYgrLHmpD5y7VV6ceO6JT/Hzzy+S0Vv8eQu38H7C1dcoFfWVzbxPhbxDYD4Dje2mmNOOb7Zfg7Yha3nwMoVYjH95c/8hL74Exfo0hf3qjlf1N51aT18ao9K0crmF71Do4otcp24JBWjEX3ibT+pB87ctuK1svUcAFvPw4vwxkm49huwEwevASt3ON2mf3312Sv62OmmxZ9u+ZL6ujpXFd3H4uA1ABy8Fj5sNce8uPYbsBO3HQPq7/6zTlFpia3m/7Wjt6pfk9uOARUwRpv2Z3Tai0fUOTId9GqqjtuOhQsTbyyK6TdgJ6bfQP185/wz9I5Hn1NLrnDSrclKnqfxZFx3nXd6Tb42029gfuc/eVBv/+bz2nB4UpJkJD131jp97efO1sCGVNDLqyqm3+HAxBtLYvIN2InpN1AfI20t+t3/56c00jpzu6hixJs7pG0o1aLf/X9/SuPNyZp9fabfwPEufXCf/vtnHlf3bHRr9o4DO54/ot/58we0fmAi0PXVAtPv4HnGLHHaR4PIZDJKp9M6/xc/pmi8dj+8XMf0G7AT02+g9qIlX5e9uFfn9h+SkfT01g168PQe+ZH6zUGYfsN18VxRn7j5u0rkSvPe3q8U8fTs2V267QMXB7C6+mD6XX0fPufOJR/DVnMsC1vPATux9RyovVI0ou/v6NX3q3w993Kw9RyuO//JgQWjW5KivtG5zx5W+1hWmbSdwzy2ngeDreZYNg5eA+zE1nPADWw9h8vWHZmWH1l8iBQxUudotm5rCgJbz+uP8MaKEd+AnYhvwA3EN5YSLfpaPzChrsOT8nw7nvdNtDXJq+BK28lWN34WEt/1w1ZzrEo5vtl+DtilHN9sPwfsVo5vtp/jWNGir5+66yVdeW+f2qYKkqSRjqTuvmq77v3JXpklJsZh9sT5G3XtV5+TFohv35P29qQ1tK6l7msLSjm+2X5eW0y8URVMvwE7Mf0G3MD0G2WRkq8PfPpRveU7L85FtyR1jGZ17dee08/f/vSC0doIxtsTuucNp2i+/wXlt33zbWfWeVXhwPS7tghvVA3XfgN24tpvwA1c+w1JuvjRAzrnuUFFTnhKV55xX/GDfp320nAQS6uab7x9h+5606kqRj0ZSaXZ/3GTrU36+/dfpF1nufvfAdd+1w5bzVF1nHwO2ImTzwE3cPK52674rz3yPZ0U3mWliKfX/WCvXjp9bb2XVjUm4umbb9+h775xu8770YCap4oaWteiZ87tVinGXFKcfF4ThDdqgvgG7ER8A24gvt21/tDkgtGt2dttbRiYqOeSamayLa4HXrs16GWEFtd+Vxe/0kHNsPUcsBNbzwE3sPXcTdPNi8/lfE+abm6q23oQPLaeVwfhjZojvgE7Ed+AG4hvtzxy8Wb5i2xa9Iz0yMWb6rkkhADxvXqEN+qC6TdgJ6bfgBuYfrvj3iu2aaqlSaV5KqEU8TS4rkWPvHpzEEtDwDh4bXUIb9QV8Q3YifgG3EB82y+TTur/+61LNdLZLEkqRjyVZu/bvX9zSp+68VIV4tGAV4kgEd8r4xnTwDfiO0Ymk1E6ndb5v/gxRePJoJeDCnD4GmAnDl8D3MDha3bzfKOznxvUqa+MyPc87dqxTi+d2il5PH/DURy8NuPD59y55GM41RyB4eRzwE6cfA64gZPP7WYinp49t1vPntsd9FIQYtx2rHJsNUeg2HoO2Imt54Ab2HoOgGu/K0N4I3AcvAbYiYPXADdw8BoAce33kghvhAbxDdiJ+AbcQHwDIL4XRngjVJh+A3Zi+g24gek3ALaez4/wRigR34CdiG/ADcQ3AOL7eIQ3QovpN2Anpt+AG5h+A2D6fRThjdAjvgE7Ed+AG4hvAMQ34Y0GQXwDdiK+ATcw/Qbg+vSb8EbDYOs5YCe2ngPuIL4BuBrfhDcaDvEN2In4BtxAfAMI8/Q7Ou0rPlaSStVtjlhVPxtQJ+X4Hu/1gl4KgCoqx3euJx/0UgDUUDm+e3sGg14KqqApX1LHaFb5eFRjHcmgl4MGcvfADl29YVfQy5AkdT09pTP/74i6n85KknLtEe1+c1ovvKNDpeTq59WENxpaqs8Q34CFEv1x4htwQF9/F/HdwJqnCvqZb72gyx/oVyJfkiTt7WnXt685XU+dtyHo5aFBhCG+e+4b16v/+rDMMX2dyPja8bURrX9iSv/1vzeplFhdfLPVHA2Pa78BO3HtN+AGDl5rTMnpgv7nJx/QT96/Zy66JWnLvox+/e8f0xX39wW6PjSWILeex8dLuvBvD0uSIv7x7/OM1PlyTqd/c3TVX4fwhjWIb8BOxDfgBuK7sbz5P17WhkMTivrHP/+KzL567VefUyqTC2ZxaFhBxPfW740rUpIW2kPrGWn7v2ckf3WtQXjDKky/ATsR34AbmH43Bs83+onv752L7HkfY4wue3BfPZcFS9R7+t3enz9ui/l8kmMlNU36iz9oCYQ3rER8A/Zh6zngDuI73FqmCmqdKiz6GN/z1H14om5rgn3qFd+lRGXnRfnx1Z0rRXjDWsQ3YCfiG3AD8R1e+XhU/hIN4knKJpvqtSRYqh7T7wOXtCpSWvj9fkQ6dF6zHYer3XLLLbr44ouVSqXU3d2td7zjHXr++eeDXhYswNZzwE5MvwE3sPU8nArxqJ45p1ulyML1HfWNHr+Qk81RHbWM78FzmzV8ekL+PGVsZq/xfv5nO1f9dUIR3vfdd5+uv/56Pfjgg7r77rtVKBT0pje9SZOTk0EvDZYgvgE7Ed+AG4jv8PnOT50mSZrvqtdSRNp1xlrtPmX1sQKU1Sy+PU8PfGijRk5NSJL86MyL8SS/ydMjv9WtoXOaV/9ljDGhK5LBwUF1d3frvvvu0xVXXFHRx2QyGaXTaZ3/ix9TNJ6s+RrRuLjvN2An7vsNuMHm+35vOjCuzpFpjacS2tvTLnnhfs7yqqcP6b2ff1It2aKKUU+emZl0P3N2lz73Kxco28xWc9RGTe77bYzWPZvVpocnFc35yvTEtffKlApt0SU/9MPn3LnkY2JVWmZVjY2NSZLWrFmz4GNyuZxyuaO3KMhkMnVZGxpfqs8Q34CFEv1x4htwQF9/l3XxfepLw7r2q89q676jz2cPdbXo6+86Wz/auT7QtS3m6Vet1+/dcpUufOKgNh0YVz4e1VM712tfTzropcFydw/sqH58e56Gzm3W0Lmrn27P++nDNvH2fV9ve9vbNDo6qu9///sLPu4P//AP9Ud/9EcnvZ2JN5aDAAfsQ3wD7rAhwE99aVg3/vWDivjmuNtz+bMHlH3mv12oJy7YGOQSgVCryfR7mSqZeIfiGu9jXX/99XrmmWd0++23L/q4m2++WWNjY3Mv/f39dVsj7MG134B9OHgNcEfDX/ttjK77l2dOim4d8yT957/yjCKl1d0/GLBZPe/5vRqh2mp+ww036M4779T999+vLVu2LPrYRCKhRCJRt7XBXmw9B+zE1nPADdXeeu75Ruc+e1gXPDGgRK6ogQ1t+sFrezS8tqVqX6Ns84Fx9ewfX3gtktrH8zrrx0N69tzuqn/9amsbz+mMF44oVvK1Z2uHDm1oC3pJcEQ5vsMw/V5IKMLbGKMPfvCDuuOOO3TvvffqlFNOCXpJcEx58k2AA3YpT74JcMBu5cn3agM8lcnpN//mIW3ZP65SxJNnjMxT0k/d9ZL+77vO1n++obrPUTtHppd8jKnwcUGKFUq69qvP6rU/3Keof3R0//zpa/SFXz5fI2tqc80scKKaXPtdJaHYan799dfri1/8or785S8rlUppYGBAAwMDmp4O9z8ysA9bzwE7sfUccMOqtp4bo9/4u0e08eCENHsf6oiRokaKGOnd//c5nffkQPUWK2m8bendm56kiVSI/w0zRr/2mcd0+QP9x0W3JJ328oj+1ycfUNt4bsEPB6rt7oEdodx+Horwvu222zQ2NqYrr7xSGzdunHv5yle+EvTS4KBUnyHAAQtx7Tfghr7+rhUF+OkvDat3z9hJ8VjmezOT72rasy2tw+tatNizjulkTM+eHd5t5me+cESvenbwpGvUNfvLi/ZMVlfe1xfE0uC4sMV3KMLbGDPvy3vf+96glwaHEd+AnYhvwA3Lje9XPX1YpcjCl5xFjNS7d0ytE1W8dMXz9PV3nSXNbimfzzffdqYK8aXvIxyUSx7av+jfW9SXLn+AQ5ARjDDFdyjCGwgrpt+AnZh+A25YzvQ7VvRlKjjqpalQWv3CjvHUeRv02V+5QBNtM/8mlZ91TCdjuv3ac3TfT/ZW9etVW3osu+AugbLUOOdsIDhh2XoeisPVgLDj5HPATpx8DrihkpPP+7e0K1paPCAnWpuUaa/+XXUev2iTnjx/g85+blBrRrIaT8X1zDndoZ50l412JFWKeIvGdy3+zoDlCvrgNSbeQIWYfAN2YvINuGGpyfejr96kbDImf4Hfs/uedN8VvfKjtXn67EcjeuZV63X/Fdv0xAUbGyK6JemHl25ZNLp9T/r+5VvruiZgIUFOvwlvYBnYeg7Yia3ngBsW23peiEf12V+5QH7EO+6aZTMbj7u3d+quN51ax9U2hpdOW6PHz98w7y8sShFPw2uade9PbgtiacCCgohvwhtYAeIbsBPxDbhhofh+7pxufeJ/Xa7HLtyoYnSmJI+sadYd79ihv/rgJQ0zha4rz9M/vO8C/efrT1EhdjQtjKTnzlqnP//t12qqlX9bET71nn57xhgrCiKTySidTuv8X/yYovFk0MuBQ7j2G7AT134Dbljw2m9jFPFNzbaW2yg5XdBpLw0rVvK1tyet4bUtQS8JqMhqr/3+8Dl3LvkY/iUBVonpN2Anpt+AGxa89tvziO5lyjY36ZlXrdeT528kutFQ6jH95l8ToAq49huwE9d+A25Yzm3HANirlvFNeANVRHwDdiK+UW/Rkq+mYnXvF42lEd8AahXf3McbqLJyfHPtN2AX7vmNerj0hb36uYee1jn7Z647frm7U3dcfI7uOfdUyePnSj2U43up+34DsFc5vqt5328m3kCNMP0G7MPWc9TSz//gKX306/+pHQeG5t7WOzii//mt7+s3/uNByY7zcBsG028A1Zx+E95ADRHfgJ2Ib1TbaQNDes9/PSFJih4T2NHZP771ief1mpf3BbU8ZxHfAKp18BrhDdQYB68BdmL6jWp6y+PPqxhZeCt5yfP0M4/9uK5rwgwOXgOgKky/CW+gTohvwE7EN6rhjIEjivkL/5yIGqPTDg3XdU04HvENYDXTb8IbqCOm34CdmH5jtXJNUS310yEfi9ZpNVgI028AWuH0m/AGAkB8A3YivrFSD5yxbdHwLnmefnDmtjquCIshvgEsd/pNeAMBYfoN2In4xkr8x87TNJGMqzTPLcN8TypGI/q3i84KZG2YH9NvAFrG9JvwBgJGfAP2Yes5lmu8OakP/fyblWlOSLMT7pLnyUjKNjXpI+++SgMdqaCXiXkQ3wAqEQt6AQBm4nu8d+HTbAE0pkR/XLmefNDLQIN4ecNavfcDP6crfvyKztszoIiMntvcrf8851RNJ5qCXh4W0dffpd6ewaCXASDECG8gJMqTbwIcsEt58k2AoxL5ppi+u/N0fXfn6UEvBctUnnwT4ADmw1ZzIGTYeg7Yia3ngBvYeg5gPoQ3EEIcvAbYiWu/ATdw8BqAExHeQIgR34CdiG/ADcQ3gDLCGwg5pt+AnYhvwA1MvwGI8AYaB/EN2Iet54A7iG/AbYQ30ECIb8BOxDfgBqbfgLsIb6DBsPUcsBPTb8AdxDfgHsIbaFDEN2An4htwA/ENuIXwBhoY02/ATky/ATew9RxwB+ENWID4BuxEfANuIL4B+xHegCWYfgN2Ir4BNzD9BuxGeAOWIb4B+7D1HHAH8Q3YifAGLMT0G7AT8Q24gek3YB/CG7AY8Q3Yh+k34A7iG7AH4Q1YjvgG7ER8A24gvgE7EN6AA9h6DtiJ6TfgBraeA42P8AYcQnwDdiK+ATcQ30DjIrwBxzD9BuzE9BtwA9NvoDER3oCjiG/ATsQ34AbiG2gshDfgMKbfgJ2Ib8ANTL+BxkF4AyC+AQux9RxwB/ENhB/hDUAivgFrEd+AG5h+A+FGeAOYw9ZzwE5MvwF3EN9AOBHeAE5CfAN2Ir4BNxDfQPgQ3gDmxfQbsBPTb8ANbD0HwoXwBrAo4huwE/ENuIH4BsKB8AawJKbfgJ2Ib8ANTL+B4BHeACpGfAP2Yes54A7iGwgO4Q1gWYhvwE7EN+AGpt9AMAhvAMvG1nPATky/AXcQ30B9Ed4AVoz4BuxEfANuIL6B+iG8AawK02/ATky/ATew9RyoD8IbQFUQ34CdiG/ADcQ3UFuEN4CqYfoN2InpN+AGpt9A7RDeAKqO+AbsRHwDbiC+geojvAHUBNNvwE7EN+AGpt9AdRHeAGqK+Absw9ZzwB3EN1AdhDeAmiO+ATsR34AbmH4Dq0d4A6gLtp4DdmL6DbiD+AZWjvAGUFfEN2An4htwA/ENrAzhDaDumH4DdmL6DbiBrefA8hHeAAJDfAN2Ir4BNxDfQOUIbwCBYvoN2In4BtzA9BuoDOENIBSIb8A+bD0H3EF8A4sjvAGEBvEN2In4BtzA9BtYGOENIFTYeg7Yiek34A7iGzgZ4Q0glIhvwE7EN+AGpt/A8awL7/a+XNBLAFAlTL8BOzH9BtxBfAMzrAtvSUrvJr4BmxDfgJ2Ib8ANxDdgaXhrNr4JcMAeTL8BOxHfgBvYeg7XWRveZcQ3YBfiG7APW8/rJ+L72rH/sC5+eZ+2HBkNejlwEPENV8WCXkA9lON7bHsi6KUAqIJyfI/3ekEvBUAVJfrjyvXkg16GtV7/zMt6332PqWt8au5tP97UpVvfdKle3rA20LXBLeX47u0ZDHopQN1YP/E+FtNvwC5MvwH7MP2ujWueeF6/c+d/ad0x0S1JZxwc0l988ds65dBwYGuDu5h+wyVOhbeIb8A6xDdgJ+K7eppzBf3afz4iSTpxn1DUGDWVfP3q9x4NZG0A137DFc6Ftzh4DbAOB68BdmL6XR2Xv7BHiUJxwfdHjdFFfQe0dnyyrusCjkV8w3ZOhncZ8Q3YhfgG7ER8r866zKRKkaXPxFh7wjZ0oN6YfsNmToe3mH4D1mH6DdiJ6ffKjbUkFfGX/ndxtCVZl/UASyG+YSPnw7uM+AbsQnwDdiK+l+/7O7apFF34KV/Jk57b1KXDHam6rgtYDPEN29QkvB966KFafNqaY/oN2IXpN2An4nt5xpuTuv2ynfO+z5ckefrHKy+q86qApbH1HDapSXi/+93vrsWnrRviG7AL8Q3Yh63ny/Ply8/TP/7khcrGopKk8r+KR1It+si7r9IzWzcEuj5gMcQ3bBBb6Qdee+21877dGKPh4ca/F2Q5vse2J4JeCoAqSPUZjfcufbgQgMaS6I8r15MPehnh53n6l8t26l8vOksXv7xPbdm8BjpSemrbBvkRrjxE+JXju7dnMOilACuy4vD+7ne/q3/6p39SW1vbcW83xuj++++vxtpCIb07R3wDlihPvglwwC7lyTcBvrRsvEn/ddYpQS8DWLG+/i7iGw1pxeF95ZVXKpVK6YorrjjpfTt3zn8dUaMivgG7MP0G7MT0G3AD0280Is8YY8XFj5lMRul0Wle87iOKxWp3OwwCHLALAQ7YiQAH3EB8IwzufeNfLPmYii/q+cY3vrHa9ViBg9cAu3DwGmAnDl4D3MDJ52gUFYf3ddddp7/+679e9DGWDM+XxG3HALtw2zHATpx8DriD+EbYVRzeX//61/XhD39YN95440nvK5VK+vznP6+zzjqr2usLNeIbsAvxDdiJ+AbcQHwjzCoO75/+6Z/Wfffdp69+9at617vepWw2q3w+r9tuu02nnXaa/sf/+B+67rrrarvaEGL6DdiF6TdgJ+IbcANbzxFWyz5crb+/X295y1sUiUQ0NDSkQqGgG2+8UTfccIPa29trt9Il1OtwtcVw8BpgFw5eA+zEwWuAGzh4DfVSyeFqy7qd2Pj4uL74xS/q0KFDmpiYkOd5evDBB/WqV71qNeu0BrcdA+zCbccAO3HbMcAN3HYMYVLxVvM/+IM/0LZt2/TZz35WH/vYxzQ4OKh3v/vduuqqq/TII4/UdpUNhK3ngF3Yeg7YiYPXAHew9RxhUHF4f+1rX9OnPvUpvfDCC3r/+9+v1tZWff7zn9ev/dqv6fWvf73+9V//tbYrbTDEN2AX4huwE/ENuIFrvxG0ireaP/fcc/K8k7dc/vEf/7G2bt2qa6+9Vn/xF3+hG264odprbFjl+Gb7OWCHcnyz/RywSzm+2X4O2K+vv4ut5whExRPv+aK77P3vf7++/vWv60Mf+lC11mUVpt+AXZh+A3Zi+g24gek3glBxeC/lLW95i+69995qfTrrcO03YBeu/QbsRHwD7iC+UU9VC29JuvDCC6v56axEfAN2Ib4B+3DwGuAO4hv1UtXwRmWYfgN2Ib4BOxHfgBvYeo56ILwDRHwD9mDrOWAnpt+AO4hv1BLhHTDiG7AL8Q3YifgG3MD0G7VCeIcAW88BuzD9BuzE9BtwB/GNaiO8Q4T4BuxCfAN2Ir4BNzD9RjUR3iHD9BuwC9NvwE5MvwF3EN+oBsI7pIhvwC7EN2An4htwA9NvrBbhHWJMvwG7MP0G7ER8A+4gvrFShHcDIL4BuxDfgH3Yeg64g/jGShDeDYLpN2AX4huwE/ENuIGt51guwrvBEN+APdh6DtiJ6TfgDuIblSK8GxDxDdiF+AbsRHwDbmD6jUoQ3g2KreeAXZh+A3Zi+g24g/jGYgjvBkd8A3YhvgE7Ed+AG5h+YyGEtwWYfgN2YfoN2In4BtxBfONEhLdFiG/YphSJqRhNyPeiQS8lEMQ3YB+2ngPuYPqNY8WCXgCqqxzfY9sTQS8FWLFCU7MmW9ep2NQy8wZjFM9PqGVyULFSIejl1VWqz2i81wt6GQCqLNEfV64nH/QyANRBX3+XensGg14GAsbE21JMv9Go8k0tGkv3qBhrPvpGz1M+3qaxjm0qRt2bFLH1HLAT02/AHUy+QXhbjGu/0WiMpPHUxplXvBOmvJ4n40U02dYdyNrCgPgG7ER8A25g67nbCG8HEN9oFIV4q0w0dnJ0l3meCvFWlSLuXiXD9BuwE9NvwB3Et5sIb0cQ32gEpWiTZJaOypKD281PRHwDdiK+ATcw/XYP4e0Qtp4j7DzfX3jafYyIKdVlPWHH9BuwE9NvwB3EtzsIbwcR3wireH5CMv7CDzBGkVJe0SLfw8civgE7Ed+AG5h+u4HwdhTTb4RRxPhqnhpZeLu556l1ckjcXOtkTL8BOxHfgDuIb7sR3o4jvhE2LVNDap6eje/jXny1jg8okRsPeomhRnwD9mHrOeAOpt/2cvdoYMwpx/fY9kTQSwHkSWqdHFTz9LByiZR8L6qoX1Q8N67IYtvQMSfVZzTey74AwDaJ/rhyPfmglwGgDvr6u9TbMxj0MlBFTLwxh+k3wiTil9Q8ParWqSNKZseI7mVi6zlgJ6bfgDuYfNslNOF9//33661vfas2bdokz/P0jW98I+glOYn4BuxCfAN2Ir4BN7D13B6hCe/JyUmdd955uvXWW4NeivM4eA2wC9NvwE5MvwF3EN+NLzTXeF9zzTW65pprgl4GjpHeneO6b8AiXPsN2IlrvwE3lOOba78bU2jCe7lyuZxyuaNT2UwmE+h6bMXBa4BdypNvAhywS3nyTYAD9uPgtcYUmq3my3XLLbconU7PvfT09AS9JKux9RywC1vPATux9RxwA9d+N56GDe+bb75ZY2Njcy/9/f1BL8l6XPsN2IVrvwE7Ed+AO4jvxtGwW80TiYQSCbY/B4FrvwG7cO03YB+2ngPu4NrvxtCwE28Ei+k3YBcm34CdmH4D7mD6HW6hmXhPTEzopZdemnv9lVde0ZNPPqk1a9Zo69atga4NC2P6DdiDg9cAOzH9BtzB9Du8QjPxfvTRR3XBBRfoggsukCTddNNNuuCCC/SRj3wk6KVhCUy+Absw/QbsxPQbcAfT7/AJzcT7yiuvlDE82WtU3HYMsAvTb8BOTL8Bd3DbsXAJzcQbdmD6DdiF6TdgJ6bfgBu47Vh4EN6oOg5eA+zCbccAOyX64wQ44AjiO3iEN2qG+AbsQnwDdiK+ATcw/Q4W4Y2aYvoN2IX4BuxEfAPuIL6DQXijLohvwB5sPQfsxNZzwB1Mv+uP8EbdMP0G7EJ8A3YivgF3EN/1Q3ij7ohvwB5MvwE7Mf0G3MH0uz4IbwSC+AbsQnwDdiK+AXcQ37VFeCMwbD0H7ML0G7AT02/AHcR37RDeCBzxDdiF+AbsRHwDbmDreW0Q3ggFpt+AXZh+A3Zi+g24g/iuLsIboUJ8A3YhvgE7Ed+AG5h+Vw/hjdBh+g3YhfgG7ER8A+4gvleP8EZoEd+APdh6DtiJreeAO5h+rw7hjVAjvgG7EN+AnYhvwB3E98oQ3gg9tp4DdmH6DdiJ6TfgDqbfy0d4o2EQ34BdiG/ATsQ34A7iu3KENxoK02/ALky/ATsx/QbcwfS7MoQ3GhLx7S4jT9lEuyba1muibb1yiZTItsZHfAN2Ir4BdxDfi4sFvQBgpcrxPbY9EfRSUCeFWFKZ9GaZSEwyM6GWbe5QpFRQ+9g+xUr5oJeIVSjH93ivF/RSAFRROb5zPfwbDdiur79LvT2DQS8jlJh4o+Ex/XZDKRJVJr1FxovOvMHzZl4k+ZGYxjp65Hv8k2YDpt+AnZh+A25g6/n8eJYKK3Dtt/2yyQ4ZLzIX28fxPBkvqmwyHcTSUAPEN2An4htwB/F9PMIbViG+7ZVLtM8f3cfIJ1J1Ww9qj4PXADtx8BrgDqbfRxHesA7xbaklontm6s0/aTYivgE7Ed+AO4hvwhuWYuu5faLF3NyBavMyZuYxsBLTb8BOTL8Bd7g+/Sa8YTXi2x7N2dHFp96eN/MYWI34BuxEfAPucDW+CW9Yj+m3HZryk0pMz4b1sZPv2T8np4bVVJgOaHWoJ6bfgJ2YfgPucHH6TXjDGcR3Y/MktU0cUtv4gKLH3K87WsqrLXNQrZPcM9I1xDdgJ+IbcIdL8R0LegFAPZXje2x7IuilYAU8ScnsmBLZsbmD1Dzja4lj12CxVJ/ReC/fAYBtyvGd68kv+VgAja0c3709dg9RmHjDSUy/G5snKWJ8RYhusPUcsBrTb8Adtk+/CW84i2u/AbsQ34CdiG/AHTbHN+EN5xHfgD2YfgN24uA1wB22HrxGeAPEN2Ad4huwE/ENuMO2+Ca8gVlsPQfswvQbsBPTb8AdNk2/CW/gBMQ3YBfiG7AT8Q24w4b4JryBeTD9BuzC9BuwE9NvwB2NPv0mvIFFEN+AXYhvwE7EN+CORo1vwhtYAtNvwC7EN2Anpt+AOxpx+k14AxUivgF7sPUcsBfxDbijkeKb8AaWgek3YBfiG7AT8Q24o1Gm37GgFwA0ovTunMa2J4JehrVKkSZNN3cql0zJeBFFSwUlp0eVzI7KC3pxsE45vsd7+e4CbFKO71xPPuilAKiDvv4u9fYMBr2MBTHxBlaIyXdtFGJJjXT2KtvcIROJSV5EpWhck23dGkv3yJDeqBGm34CdmH4D7gjz5JvwBlaBrefVZSSNt2+SPG/mpWz29WJTs6Za1ga5RFiOa78BO3HwGuCOsG49J7yBKiC+qyMfb5MfbTo+uo/leTOT8HovDM4hvgE7Ed+AO8IW34Q3UCVMv1ev2JSUzOLBYyLRmTgHaozpN2Anpt+AO8I0/Sa8gSojvldhieg++rhaLwQ4ivgG7ER8A+4IQ3wT3kANMP1emXh+cuFt5poJ80gpr4hfqOeyAOIbsBTTb8AdQU+/CW+ghojv5YkVs4oVpheefHueWqaGOdccgWDrOWAv4htwR1DxTXgDNUZ8V86T1J7Zr2hp9p6r5QCf/b/NU8NKZMcCXCHA9BuwFfENuCOI6Xesrl8NcFQ5vse2J4JeSuhF/JI6RvqUT6SUS6RkvIiipbyS02OKlfglBsKhHN/jvey/AGxSju9cTz7opQCog77+LvX2DNblaxHeQB2ld+eI7wp4khK5cSVy40EvBVhUqs8Q34CFEv1x4htwRHnyXesAZ6s5UGccvAbYhWu/ATtx8BrgllpvPXc+vP1oRGPda3XgzF7t37FdQz0bVUjwjyxqj/gG7EJ8A3YivgF31DK+nd5qnmtO6sBZ2+XHojNv8Dxl21s1tnGd1vXtV/rwcNBLbHhG0lRHSpNr0vKjUTVN59Q+OKymHNu3xLXfgHXYeg7YiWu/AXfUauu5sxNvP+Lp4I5TZqLb847eO3j2z0OnbNF0e2vQy2xopVhU+845TQNnnqLxtZ2a7GzX6KYu7T3vTI1sDP4m9mHC9BuwB1vPAXsx/QbcUe3pt7PhPbG2Q6Wm2NHgPpExGt1AHK6UkTRw+jblW5tn3hDxjv6Cw/M0vHWjxtd2BL3MUOHab8AuxDdgJ679BtxRzduOORveU+nU4g/wPE11pMTTppXJtTYr29626C82RjZ18fc7D+IbsAfTb8BexDfgjmrEt7PhvWAQoiqmOtsls8iTTc9ToaVZpXhTPZfVMIhvwC7EN2An4htwx2qn386Gd2JiavEHGKP45LTI85Uxnrd4eB/7OMyLreeAXZh+A3Zi6znglpXGt7PhnRoclmfMwnHoeeoYGKr3sqwRn8pKkcW/vSLFkmL5Qt3W1KiIb8AuxDdgJ+IbcMdKpt/OhnesWFL3S3tnXjk2vmf/nDp8RG1HRgNaXeNrGx5TpFBc+Bcbxqj98JGZX35gSUy/Absw/QbsxPQbcMtyAtzZ8JaktpGMtjzzotqGRhQpFuWVfCXHp7T+xT3qemU/28xXwTNG61/aMxPe/gm/2DBGiclpde4/FOQSGxLxDdiF+AbsRHwDOFEs6AUELTGV1frd+4JehpVaMpPa8syLGt3Ypcm1HTKRiGL5gtoPHVH60JAiPk84V6Ic32PbE0EvBUAVpPqMxnv5VS9gm3J853ryQS8FQAg4H96orcR0Tut375OZ/eUGTy2rJ707R3wDlihPvglwwD6J/jjxDcDtreaoH4/orgmu/QbswtZzwE5c+w2A8AYsQHwD9uDgNcBexDfgLsIbsATxDdiF+AbsRHwDbiK8AYuw9RywC9NvwE5sPQfcQ3ijoRRjUWXbWpRvToinogsjvgG7EN+AnYhvwB2cao6GUIg36ci2jZrsTEvezDFtTdNZrdl3SG3DY0EvL5S47RhgF04+B+zEbccANzDxRugV403af+5px0W3JBWSCR06fZvGutcEur6wY/oN2IXpN2Anpt+A3QhvhN6RLetVisWOi25Jc68f2bZJpSjfyovh2m/ALsQ3YCeu/QbsRa0g1PxIRBNrO06O7mMYz9PE2s66rqtREd+APTh4DbAX8Q3Yh/BGqBXjMSmyxLepMSok+QFVKeIbsAvxDdiJ6TdgF8IboRYplpZ+kOcpWizWYznWYOs5YBem34C9iG/ADoQ3Qi1WLCk5Ni6ZxZ9Qth3hZPOVIL4BuxDfgJ2Ib6DxEd4IvTX7Ds38Yb74NkapwWE15bgFx0ox/QbswvQbsBNbz4HGRngj9JonprTh+b6j286NmXtpP3xEXX37g16iFYhvwC7EN2An4htoTLGgFwBUonVsXL1PPKfJjnYVkglFSr5aR8YUK3BtdzWV43tseyLopQCognJ8j/cufGcIAI2nHN+5Hnb8AY2CiTcahmektpGMOg8OKn34CNFdQ0y/Absw/QbsxPQbaByEN4B5ce03YBfiG7AT134DjYHwBrAo4huwBwevAfYivoFwI7wBLIn4BuxCfAN2YvoNhBfhDaAibD0H7ML0G7AX8Q2ED+ENYFmIb8AuxDdgJ6bfQLgQ3gCWjek3YBem34C9iG8gHAhvACtGfAN2Ib4BOxHfQPAIbwCrwvQbsAvTb8BObD0HgkV4A6gK4huwC/EN2In4BoJBeAOoGqbfgF2Ib8BOTL+B+iO8AVQd8Q3Yg63ngL2Ib6B+CG8ANUF8A3YhvgE7Mf0G6oPwBlAzbD1HPZSiTZpu7tRUyxrl460iD2uH6TdgL+IbqK1Y0AsAYL/07pzGtieCXgYsY+RpPLVR+WRKMrMx6HmKlApKZQ6oqZgNeonWSvUZjfd6QS8DQJWV4zvXkw96KYB1mHgDqAum36gmIymT3qx8om3mDZ438yLJj8Q01tGjYpTpTS0x/QbsxfQbqD7CG3WXbW3WYO9mHTizV4dO7dFUuo2toQ4hvlENxaZmFeKtc7F9HM+T5Gm6ZU0QS3MO8Q3YifgGqout5qgbI2mwd7PG16+VfCNFPMk3mljXqWRmQhuf71PE94NeJuqgHN9sP8dK5RLtM9vL5wtvzcR3LpFS2/iA2BBde+X4Zvs5YBe2ngPVw8QbdTO6qUvj3bMTqIh33P/Nplp1ePuWAFeHIDD9xkr5XgU/vryIRHbXFdNvwE5Mv4HVI7xRF8bzNLqha9Hp1OSatAqJpnovDQHj2m+sRNQvLPkYzy/O7rVBPRHfgJ247RiwOoQ36iLX2iy/aekrG6bSqbqsB+FDfGM5ktNjC/8iT5KMUXJ6jHl3QDh4DbAX8Q2sDOGNujCLPUFeweNgJ+IblYr6BTVPDs28Yk4IPGMULeXVPD0cyNpwFPEN2InpN7B8hDfqIj6dnTlQbTGep8TkdL2WhJBi6zkq1TJ1RK3jA4r4xaNvNL4S2TGlR/cqYjisMQyYfgP2Ir6BynGqOeoiWiyp7ciIJtZ1zr891Bg1TWeVnJgKYnkIofTunPOnnvuRqEqRJkX8UkXXNLvGk9ScHVMyO6ZSNC7jRRQt5QnukEr1GU49ByzEyedAZawL7/gLB+SfvT3oZWAe6/YcVK61RYXm2ZgqB7gxihRL2vDSXq7HxHFcve1YMRrXZGvXcfepjhayap0cVLzAL6dO5EmKlXjC1wi47Rhgr0R/nPgGFmHlVvP4rn1BLwHziJZK2vLcS1qzb0CxfGEmuAtFpQeG1PPMi4pPu7292EjKJ+PKJxMyPCc9jktbz4vRuMY6th4X3ZJUiiWUSW9RLt4W6PqAamDrOWAnrv0GFmbdxLusHN/5HdwbOkwiJV+dBwbVeWAw6KWEhpE0tmGdRjd2qRSfuZ1apFBUx8CQOg4elsfzU8mh6fdkW7eMFzn5kgzPk4zRRGq94kcm2B2Chsf0G7AX02/gZFZOvI/F9HtlCom4plOtyjcnuAtuDRlJh7dv0ZGtG1U65nZrflNMw1vWa+C0bfz9n8Dm6XcpEjtp0n0cz5OJxJRn6g2LMP0G7MTkGzietRPvYzH9rly2tVlHtm5Str117m3xqWmt3XtQLWMTNfmaRtJ0uk3T7TMxkRyfVMvouBMTvel0mya61sz/Ts/T1Jq0Jtek1TY8Vu+lhZqtB6/50aalH2SMSpU8DmggHLwG2ImD14CjnAjvsviufcT3IrKtzTpw9qkn3Us735zUwTNP0YYX96h1JFPVr1lIxHXwzF4VmpNHbze2qVuxbF4bXnhFCcuv+850r5m5B/FCE05jNNa9hvCeh41bzz2/VNHjOLUbNmLrOWAvtp4DDmw1PxFbzxc21LtpJrrnu7ZU0mDv5qpuey5FI9p/9nYVkrPhFPFmXiQVE006cNapKsaiVfyK4ZNvTi4c3Zr5uy80J+u5pIZj09bzaCmvaDE388uYRcRz43VbE1BvbD0H7MTBa3Cdc+Gt2fgmwI+XTyaUa1v82tJSvElT6VTVvub4uk6Vmprm/5qeJz8W1Xj32qp9vTCKFEuLR5YxipQqm4K6LL07Z0WAe5JaJofmDlI7iTFqnh5m4g3rpfoMAQ5YiviGq5wM7zLi+6hiorJrS4uJ6v1jObG2Y8nHjK9b+jGNLHVkdOnHDC39GMywIb4T+Qm1ZQ5Kxp+J72NemqeHZ8IccATxDdiJ6Tdc5NQ13vPh4LUZkWIFU1XPU7RYrNrX9KPRJbdZ+1G7t5qnBkc0Ur6N2Il/F8YoUiyp/fCRoJbXkGy49juZyyiRG1cukZIfjcnzfSVy44oYdj/APVz7DdiLa7/hEqcn3sdyffqdmJxWLLv4taVeqaSW0eodrhafzh49UG0+xsw8xmIR39fmH7989H+nb+b+TmK5vDY/97KilfxSBCdp9Om3J6NkLqOWqWE1Z0eJbjiP6TdgJ6bfcIXzE+9juTz99iSt3XtQh87oXfCU7TX7DimyWCgvU/vhYU0utt3c89R+yP5pb1OuoC1Pv6hse6umU22SN3NLteaxCSduqVZLNky/ARzF9BuwF9Nv2I6J9zxcnX63jWTU/dLeo4d5zU6/vZKvNXsPKj1Q3WtLmzMTSh0ePnoNa9ns661HRqt++7Kw8iQ1Zya1Zv8hrdl3SC1Ed1U1+vQbwPGYfgN2YvINmzHxXoCr0+/UkVG1Do9pqrNdxXiTosWiWkcyipSqf4qyJ6nrlX2KT01rbGPX3MFt0UJR6YEhdRwcJD5RNendOSbfgEVSfYbJN2Chcnwz/YZtCO8lxHftcy6+I8aobXisLl/Lk9Rx6IjSh47MnqzuKZbLE9whZyRNdbZrrHuNCsmEIsWSUkdGlRocVrQGv6SpFraeA3Zh6zlgL7aewzZsNa+Aq1vP68mbvda5iegOPSPp0OlbNXBGr6bTKRWTCeVbm3Vk60b1v+oMFSq5NV3A2HoO2IWt54CdOHgNNiG8KxTftY8ABySNbOrWZGd65pXyIXyeJ3meSvEmDZzeq0Z4CpzenSPAAYuk+gwBDliK+IYNCO9lIr7hMuN5GtuwbuH7r3ue8q3NyqZa6r20FSO+AbsQ34CdmH6j0RHeK8D0G67KJ+Pym5Y4GsIYZVNt9VpSVTD9BuzC9BuwF/GNRkV4rwLxDffYfQU+8Q3YhfgG7MT0G40oVOF96623qre3V8lkUpdccokefvjhoJe0JKbfcEk8m1OkUFz8QZ6n5PhkvZZUdUy/AbsQ34C9iG80ktCE91e+8hXddNNN+uhHP6rHH39c5513nt785jfr8OHDQS+tIsQ3XOAZo/ShIcks8ETWN4pPTTd0eJcR34A92HoO2IvpNxpFaML7L//yL/X+979f73vf+3T22Wfr7/7u79TS0qJ/+Id/CHppFSO+4YLOA4fVMpKZeaUc4MZIxihaKGjDC3us2ZBOfAN2Ib4BexHfCLslTkmqj3w+r8cee0w333zz3NsikYiuuuoq/fCHP5z3Y3K5nHK5o0+KM5lMXda6lHJ853dsCXopQE14Rtrw4h5NdrYr071WhWRCkVJRqaFRpQaHFS35QS+xqsrxPbY9EfRSAFRBOb7He235FSGAskR/XLmefNDLAOYVion30NCQSqWS1q9ff9zb169fr4GBgXk/5pZbblE6nZ576enpqdNqK8P0GzbzJLWNZLTp+Ve07ald6nnmJXUMDFkX3cdi+g3Yhek3YCe2niOsQhHeK3HzzTdrbGxs7qW/vz/oJZ2Eg9eAhRnP00Rnu0Y2dmmse42KsVBswFkUB68BduHab8BexDfCJhTPdNetW6doNKpDhw4d9/ZDhw5pw4YN835MIpFQItEYWz/ju/ax9Rw4xmRHSoe398zcE3z2OvGh3s1qHxjSur0HQ3+NeHp3jq3ngEVSfYat54CFyvHN9nOEQSgm3vF4XBdddJHuueeeubf5vq977rlHl112WaBrqxam38CM6VSrBs7olR+LzrzB8+ZeMhvWaWjbpqCXWBGm34BdmH4D9mL6jTAIRXhL0k033aTPfOYz+sIXvqAf//jH+sAHPqDJyUm9733vC3ppVUV8w3XDW2Z3sXjzTJc8T5n1a1WMN9V9XStFfAN2Ib4BO3HtN4IWiq3mknTddddpcHBQH/nIRzQwMKDzzz9f//7v/37SgWs24ORzuKrYFFO2vXXJx02sSatjYKgua6oGTj4H7MLJ54C9OPkcQfGMMVb8ajeTySidTuuq7v+mWKRxfptFfMMlueaE9u08c/EH+b46Dg5p7b7572gQdsQ3YBfiG7AXAY5q6Xvv7y75mNBsNXcVW8/hkli+OHeY2oI8T025xv1ByNZzwC5sPQfsxdZz1FNotpq7jK3ntVWIN2l8XadK8ZiihaJSQyNqyhWCXpaToqWSWofHNLkmPf813sbI843ahkeDWF7VsPUcsAtbzwF7cfI56oWJd4gw/a4uI2moZ6P2nr9DI1vWK9O1RiOb12vveTs0uHWjmGEEY23/gCLF0smTb2Mkz9O6PQcUKflBLa+qmH4DdmH6DdiL6TdqjfAOGW47Vj2jm7o0tqnr6O2qIpHjbls1srk76CU6qSmX15ZnX1LLaOa4+G7K5rT+xT1qHxwOdH3Vxm3HALtw2zHAXsQ3aomt5iEV37WPreer4Ec8jWxcJKw9T6Mbu9RxcFARnydQ9daUy2vjC3tUbIqpmIjLK5UUn87J5k2c6d05tp4DFkn1GbaeAxZi6zlqhYl3iDH9XrnpVJtMLLroY0w0qul0qm5rwslihaKSE1NKWB7dZUy/Absw/QbsxfQb1UZ4NwDie/lMtLJvbT/CfwKoP+IbsAvxDdgp0R8nwFE1VEeDYPq9PE3T2YoeF6/wcUC1Ed+AXZh+A/YivlENhHeDIb4rk5jOKTExufA9o41RfGJKiSnCG8Fh6zlgH+IbsBPTb6wW4d2AiO/KdO3eN3NbqhPj2zfyfF/dr/D3iHAgvgG7EN+AvYhvrBSnmjeocnxz8vnCEtM5bX7mRY1sXq+JtR1SxJN8o7bhUXXuP6x4ltjBwopNMY13rVG+JSnP99U6klHLSKZmh8CV45uTzwE7lOObk88B+3DyOVaC8G5w3HZscfFcXut396urb5/8WEyRYpHbh2FJmXWdGtx+zH9XRhrvWqOmqaw2Pf+KYvlCzb42tx0D7MJtxwB7JfrjxDcqxlZzC3Dw2tIivlEsXyC6saSp9taj0e15My+RmSfNheaEDpx5imr9XcS134BdOHgNsBfXfqNShLdFiG9g9UY3ds/8wZtnQuV5KrQkNdVRn/u/E9+AXYhvwF7EN5ZCeFuG6TewcsbzNJ1umz+6y3yjqY72uq2J6TdgF6bfgL2IbyyG8LYU8Q0snylvLV+MJ/mR+l+vSXwDdiG+ATux9RwLIbwtxvQbWB7P9xXN5Re+//usoO7/TnwDdmH6DdiL+MaJCG8HEN9AZTxJ6UNHFn6AMfKMUWpopJ7LOs5iW8+NPOXjrcolUirGEjU/BA5AdRDfgJ2YfuNYhLcjiG+gMh0DQ2oem5iZeh87+Z49Eb/75X5Fi6XgFjjr2Pg2kqaaOzW89lRl0ls03r5Jo529Gu3YpmKMW5MBjYD4BuxFfEOEt1vYeg4szTNGG1/o09q9BxXLzd6b0xi1jGa0+bmX1TY8FvQS55Sn31MtazXV1i0TiR73/lIsodGOrSpG+YEPNAK2ngP2YvqNWNALQP3Fd+1TfseWoJcRStnWZo2tX6t8S7MipZJah8eUGhpRtOQHvTTUkWeMOgaG1DEwJN/z5Bmj+h+nVpliU0zTLWvnf6fnSUaaal2n9syBei8NwAql+ozGe8P6rw6A1Uj0x5XryQe9DASA8HZUefJNgM8wkoZ7Nmh0U/fMluKIJxmjbKpVo5u6tenHuxXPcrCViyJLHLQWtIm1HYs/wPOUj7fJ9yKKGH6BBDSK8uSbAAfsU558E+BuYau549h6PmNibcdMdEsz0a3ZaaHnqdQU08Edp3BQFUKp1BRb8hR2eZ78CL9nBRoRW88Be7H13C08E4Pz028jaXRj10y8zHcPZ89TMRHXZGe72kYyQSwRWFC0UFz63uPGKOIX67KeYrRJ2eZO5eOtkjzFClNqnh5VUzGYW7ABNmD6DdiL6bc7mHhjjqvTbz8aVb61efF48Y2m0231XBaWyUia7GzX4VO26NCpPRrdsE6lWLSCj2xsbUdGF3+AMYrnJ+qyzTwXb9No5ynKJjvkR+Pyo03KJ9o11rlN082dNf/6gO2YfgP2YvptP8Ibx3EyvisaIJhKH4gAFOJN6t95hgbO6NX4uk5NrO3Qka0bteeCszSxJh308moqViiqc//h+d9pjDzfqGVyqObrKEViGm/fNPPKsb/Emv3zZFu3Ck3NNV8HYDtOPgfsRXzbjfDGSVy77VikWFIsm1v8OtlIRMmJyXouCxUynnRwx3YVkrP3q454c9fnG8/TodO2KtvWEvQya6pz/yGt3XNAkRPuLx6fymrzcy9r7Yvjx933uxayydlD3hbaOWIMU2+giohvwE7cdsxeXOONBbly2zFPUsfAkIa2bZr/AcYoUiyp9Uh47t+MoyY70yo0J+Z/p+dJvtHoxnXa8OLeei+tbsrfw+2Hjmi6vU1+NKJ4NqfE1PHXVad35zS2fYG/q1UqxFsWv1zD81RosvsXIEC9cdsxwF7cdsw+hDcW5crBa+2Hjijb2qKJrs7jD1kzRp7va+MLfaG/rZSrJjvaFz4YTzMT8MnOtBMXC0SMUevY+KKPKU++qx/glfz3wX9DQLVx8BpgLw5eswtbzVER27eee5K6d/dr/Qt9SmYmFCkUFcvl1XFwUD0/ekHJiamgl4gFmEgFTzY9z/7qXqZqbz1vyk8tfrmGMTOPAVATbD0H7MXWczsw8UbFbJ9+e5LaRjLcMqzBJKaymlzsADVj1JTNy+M56UmqOf1OZkc13bJm9hzC+X/L0Tw9suqvA2BhTL8BezH9bnxMvLFstk+/0VhSg8Mzf1hk2tp+qPanejeyaky/o35J7ZkDM9vJj/3/hZl5vXXiEPfyBuqE6TdgL6bfjYvwxoq4dvI5witWKKpr9+z3on9C8Glm+jq2fq0mOtuDWWCDSO/OrTrA4/lJdQ6/oubpYUWLWUWLOSWzY+oY2aPmLIcTAvXEbccAe3HyeWMivLEqxDfCoH1oRJt27Z655dsxwV1WTCZ06IxeZbq4ndVSVhvfUb+o1skhdY7sUedIn9omDilWqu2tzAAsjPgG7EV8NxbCG6tGfCMMmjOTiuaL87/T8yRjNLRts/wI/+wtpdb3/AZQX0y/AXsx/W4cPANFVbD1HEErRaOaXJte+LZinicT8TSxtqPeS2tI1dh6DiBciG/AXsR3+BHeqCriG0EpxmMLR3eZMSok+MG0HMQ3YBfiG7AX8R1uhDeqjuk3ghAtlpZ+kOcpWlxgOzoWxPQbsAtbzwF7sfU8vAhv1AzxjXqKFYpKjE8uelsxSWob5nTtlSK+AbsQ34C9iO/wIbxRU0y/UU9r9w3M/GG++DZG7YePKJYv1H1dNmH6DdiF6TdgL6bf4UJ4oy6Ib9RDc2ZSG17co0h527lvZiLcGLUfOqJ1fQeCXqI1iG/ALsQ3YC/iOxxiQS8A7ijHd37Hlrp9zUIirql0m+R5SkxMKTE5rSWO30KDax3JqHf0x5rsbFchEVekVFLrSEaxAtd2V1t6d05j2xNBLwNAlZTje7yXn5SAbcrxnevJB70UZxHeqLv4rn01j+9SNKLD23s0tSZ9dNux5yk+MaUNL+1VU45/dGzmGcO13HVSnnwT4IA9Un2G+AYsleiPE98BYas5AlHLredG0sEd2zXV2T7zBs+bu81UvrVZ+88+VcVYtGZfH3ARW88Bu3DtN2Avrv0OBuGNwNTq4LXJznbl2lrmv6ez56nUFFNm/bqqf13AdRy8BtiH+AbsRXzXF+GNwFU7vsfXdS5+SynP03hXZ1W/JoCjiG/ALsQ3YC+m3/VDeCMUqjn99mOx+afdxyix1RyoKabfgF3Yeg7YjfiuPcIboVKN+I7l8otPvI3hXs5AnRDfgF2Ib8BexHdtEd4IndVOv9sHh5eceLcfOrLizw9geZh+A3Zh+g3Yi63ntUN4I7RWGt/J8Um1DY3MP/U2RvGp7EycA6gr4huwC/EN2Iv4rj7CG6G2kvj2JHW/3K/O/YflFUtH3+H7Sg2OaNOPX1bE58kCEATiG7AL02/AXky/qysW9AKApZTjO79jS8Uf40las/+QOg4cVq61WfI8xaeyipZKFXw0gFoqx/fY9kTQSwFQJak+o/HexS/zAtCYEv1x5XryQS+j4THxRsNYyfQ7YoyaJ6bUPD5JdAMhw/QbsAvTb8BeTL9Xj/BGQ6nmbccABI+D1wD7EN+AvYjvlSO80ZCIb8Autsd3MRrXdHOHpps7VYglRZbAdsQ3YC+m3yvDNd5oWCu59htAeNl47bfvRTSe2qhCou3onRY8T9FiVu2ZA4qWCkEvEaiZcnxz7TdgJ679Xh4m3mh4jT79LsSbdKRng/buPEN7zjtTh7ZvUba1OehlAYGxZfptJI2le1SIt868wfNmXiSVogmNdmyV70WDXSRQB0y/AXsx/a4cE29YoVGn31PpNg2c0StzzBPyiXhcE11rtGbvQXUeHAx6iUAgbJh+5+NtKjUl53+n58koqunmDrVOHan30oC6Y/oN2I3p99KYeMMqjTT9LsaiGjj9+OiWJEVm/jy8daOm2tuCWyAQAo08/c4m249uL5+P5ymXTNdzSUDgmH4D9mL6vTjCG9ZplPge714jEzkhuo9ljMY2rKv3soDQadT4NpHYwv99z/IjbDWHe7jtGGA34nt+hDes1Ai3HZtOLTHN9jxNt7fWazlAqDXibccipfziE29jOFwNTiO+AXsR3ycjvGG1sMc3gOVppPhuzo4tOfFOTo/WbT1AGDH9BuzF1vPjEd6wXlin383jE4s/wBg1ZybrtRygYTTK9DtWmFY8Ozb/1NsYRYtZJbNjQSwNCB3iG7AX8T2D8IYzwhbfqcPD8nyz8FZUz1N6YKjeywIaRtjj25OUGh9Qy9QReX7p6DuMr2R2VOmxfnkiNoAypt+AvZh+czsxOCZMtx2LFUva8GLfzO3EpKNbUn0jRTyt2XtQLZklpuKA48J+2zFPUsvUETVPDasYm1ljtJRXxPhBLw0IrVSf4bZjgKVcvu0YE284KSzT75axCfU89bw6Dg6qaTqrWDantiMj2vzMi9zDG1iG8E+/jZqKWTUVs0Q3UAEm34C9XJ1+M/GGs8Iy/W7KF7S2f0Br+wcCXQfQ6NK7c6GdfANYvnJ8M/0G7OTa9JuJN5wXluk3gNVrlIPXAFSO6TdgL5em34Q3QHwD1iG+Abtw8BpgNxfim/AGZoX1tmMAVobpN2Af4huwl+3Tb8IbOAHxDdiF+AbswvQbsJut8U14A/Ng+g3Yhek3YB/iG7CXjfFNeAOLIL4BuxDfgF2YfgP2sm3rObcTA5YQltuOob6MpGyqVRNr0jLRiJqmc0oNjShWKAa9NKxSOb659Rhgj1Sf4bZjgKVsue0Y4Q1UKL5rH/HtiFI0qoEzepVtb5V8I80+lxvu2aB1ffuVPjwc9BJRBdz3G7AL8Q3Yqzz5buQAZ6s5sAxsPbefkTRw+jZlUy0zb4h4knf0ZeiULZrsaA96magStp4DdmHrOWC3Rt56TngDy8TBa3bLtTYrm26bCe35GKORzd31XhZqiIPXAPsQ34C9GvXab8IbWCHi206Tne0z28sX4nnKtbWoGONKHdsQ34BdmH4Ddmu0+Ca8gVVg+m0fE4nMbjhf6nFcR2gjpt+AfYhvwF6NNP0mvIEqIL7tEZ/OLrzNfJZXLHG6ueWIb8AuTL8BuzVCfBPeQJUw/bZD25FReb4vmQWeoBmj9OEj8hZ6P6zB9BuwD/EN2Cvs02/CG6gy4ruxRXyj9S/tnXnlxGu9jVF8KqvO/YcDWRuCQXwDdmH6DdgtrPFNeAM1wPS7sbWOjmvzsy+pZTQzN/mOFIrq3H9Ym597WRHfD3qJqDOm34B9iG/AXmGcfnMsL1BD8V37lN+xJehlYAWSk9Pa+OIeGc+TH/EUKfniODWkd+c0tj0R9DIAVEmqz2i8l3/dAVsl+uPK9eSDXobExBuoPSbfjc0zRlGiG8dg8g3Yha3ngN3CMvkmvIE6YOs5YBe2ngP2Ib4Be4Vh6znhDdQR8Q3YhfgG7ML0G7BbkPFNeAN1xvQbsAvTb8A+xDdgr6Cm34Q3EBDiG7AL8Q3Yhek3YLd6xzfhDQSI6TdgF6bfgH2Ib8Be9Zx+E95ACBDfgF2Ib8AuTL8Bu9UjvglvICSIb8AuTL8B+xDfgL1qPf0mvIEQYes5YB/iG7AL02/AbrWKb8IbCCHiG7AL8Q3Yh/gG7FWL6TfhDYQU02/ALmw9B+xDfAN2q2Z8E95AyBHfgF2Ib8AubD0H7Fat6TfhDTQApt+AXZh+A/YhvgG7rTa+CW+ggRDfgF2Ib8AuTL8Bu60mvglvoMEw/QbswvQbsA/xDdhrpVvPCW+gQRHfgF2Ib8AuTL8Buy03vglvoIER33BFIRHXyMYuDW9er4k1aRnPC3pJNcH0G7AP8Q3YaznT71jNVwOgpsrxnd+xJeilAFXne54Gt2/RxLpOyZiZl0hEkUJR61/eq5axiaCXWBPp3TmNbU8EvQwAVVKO7/FeO39pCGBpTLwBSzD9ho0On7ZVE2s7Zl7xPCky82PLj0V18IxTlG1tDnaBNcTkG7AP02/AXYQ3YBEOXoNNci1JTa5JzwT3iTxP8qSRzeuDWFrdsPUcsA/xDbiJ8AYsRHzDBhNrO2a2li/E8zTVkZIfsf9HGfEN2IWD1wD32P9sBXAU0280Oj8aXTy8NRPfftSNH2VMvwH7EN+AOzhcDbBcfNe+qh68ZjxP4+s6NNa9VsVkXJFiSamhUbUfPqJYoVi1rwM0ZXPzbzM/hlcqKVos1W1NYcDBa4BdOHgNcIMbYwLAcdWafPuepwM7TtHgKVuUb22WH4upmExoZHO3+l91hvJJYgDV0zY0Ii02DDJG7YMj8paailuI6TdgH6bfgN0Ib8AR1dh6PrJlvbKp1tmDrY75zbznyY9FNXDGtkU7CViOWLGkdXsPzLxyYlwbo1iuoM79hwJZW1gQ34BduPYbsBfhDThmpfHte57GutcuvPXX81RoTirb3rq6BQLHSB86ovUv7lHT9DGB6ftqGxzR5mdfcm6b+XyIb8A+xDdgH67xBhxUju/lXPtdaE7IxKKLP8gYZdta1ZyZXO0SgTltw2NqHR5TMRGXH40olssrWvKDXlaolOOba78Be3DtN2AXJt6Aw5Y1/a70l+8OXm+L2vMkNeXySkxlie5FMP0G7MP0G7AD4Q04rtJrv+PTWUULhcUf5HlqzkxUb3EAlo2D1wD7cO030PgIbwBSBdNvT1L64NDCE21jlBifVHJyujYLBLAsxDdgH+IbaFyEN4A5S02/Ow4Oqm1wZOaVcoDP/t+mbE4bXtxTl3UCqAzTb8A+xDfQmDhcDcBJ4rv2zXvwmiep+5V9ah8aUaZ7jQrJhCLFklJHRtR6ZEwRru8GQim9O8fBa4BFOHgNaDyEN4B5LRbfzeOTah7n5HKgkXDyOWCfVJ8hvoEGwVZzAAuq9OA1AI2DreeAXTh4DWgMhDeAJRHfgF2Ib8A+xDcQboQ3gIow/QbswsFrgH2YfgPhRXgDWBbiG7AL8Q3Yh/gGwofwBrBsTL8BuzD9BuzD9BsIF8IbwIoR34BdiG/APsQ3EA7W3E7MzN4/uOjng14K4JTIc7uVP2NT0MsAUCWtL2QlSZlebjsG2KLlBWl8K7cdA2olk8kolUrJ8xb+78wz5WJtcPv27VNPT0/QywAAAAAAOGZsbEzt7e0Lvt+a8PZ9XwcOHFjyNw0uymQy6unpUX9//6LfDEA98X2JMOL7EmHF9ybCiO9LhFFQ35dLdag1W80jkYi2bNkS9DJCrb29nX8UETp8XyKM+L5EWPG9iTDi+xJhFLbvSw5XAwAAAACghghvAAAAAABqiPB2QCKR0Ec/+lElEpxQi/Dg+xJhxPclworvTYQR35cIo7B+X1pzuBoAAAAAAGHExBsAAAAAgBoivAEAAAAAqCHCGwAAAACAGiK8AQAAAACoIcIbAAAAAIAaIrwd9LGPfUyvfe1r1dLSoo6OjqCXA0fdeuut6u3tVTKZ1CWXXKKHH3446CXBcffff7/e+ta3atOmTfI8T9/4xjeCXhIcd8stt+jiiy9WKpVSd3e33vGOd+j5558Pellw3G233aadO3eqvb1d7e3tuuyyy/Sd73wn6GUBx/n4xz8uz/N04403Br2UOYS3g/L5vN797nfrAx/4QNBLgaO+8pWv6KabbtJHP/pRPf744zrvvPP05je/WYcPHw56aXDY5OSkzjvvPN16661BLwWQJN133326/vrr9eCDD+ruu+9WoVDQm970Jk1OTga9NDhsy5Yt+vjHP67HHntMjz76qN7whjfo7W9/u5599tmglwZIkh555BF9+tOf1s6dO4NeynG4j7fDPv/5z+vGG2/U6Oho0EuBYy655BJdfPHF+pu/+RtJku/76unp0Qc/+EH93u/9XtDLA+R5nu644w694x3vCHopwJzBwUF1d3frvvvu0xVXXBH0coA5a9as0Z//+Z/rV3/1V4NeChw3MTGhCy+8UH/7t3+rP/mTP9H555+vT33qU0EvS2LiDaDe8vm8HnvsMV111VVzb4tEIrrqqqv0wx/+MNC1AUCYjY2NSbORA4RBqVTS7bffrsnJSV122WVBLwfQ9ddfr5/+6Z8+7nlmWMSCXgAAtwwNDalUKmn9+vXHvX39+vXatWtXYOsCgDDzfV833nijLr/8cp177rlBLweOe/rpp3XZZZcpm82qra1Nd9xxh84+++yglwXH3X777Xr88cf1yCOPBL2UeTHxtsTv/d7vyfO8RV+IGgAAGtP111+vZ555RrfffnvQSwF05pln6sknn9RDDz2kD3zgA3rPe96j5557LuhlwWH9/f36rd/6LX3pS19SMpkMejnzYuJtid/+7d/We9/73kUfs3379rqtB1jIunXrFI1GdejQoePefujQIW3YsCGwdQFAWN1www268847df/992vLli1BLwdQPB7XaaedJkm66KKL9Mgjj+iv/uqv9OlPfzropcFRjz32mA4fPqwLL7xw7m2lUkn333+//uZv/ka5XE7RaDTQNRLelujq6lJXV1fQywCWFI/HddFFF+mee+6ZO7jK933dc889uuGGG4JeHgCEhjFGH/zgB3XHHXfo3nvv1SmnnBL0koB5+b6vXC4X9DLgsDe+8Y16+umnj3vb+973Pu3YsUO/+7u/G3h0i/B20969ezU8PKy9e/eqVCrpySeflCSddtppamtrC3p5cMBNN92k97znPXr1q1+t17zmNfrUpz6lyclJve997wt6aXDYxMSEXnrppbnXX3nlFT355JNas2aNtm7dGuja4Kbrr79eX/7yl/XNb35TqVRKAwMDkqR0Oq3m5uaglwdH3Xzzzbrmmmu0detWjY+P68tf/rLuvfde3XXXXUEvDQ5LpVInnX/R2tqqtWvXhuZcDMLbQR/5yEf0hS98Ye71Cy64QJL0ve99T1deeWWAK4MrrrvuOg0ODuojH/mIBgYGdP755+vf//3fTzpwDainRx99VK9//evnXr/pppskSe95z3v0+c9/PsCVwVW33XabJJ30s/kf//Efl7y8DKiVw4cP65d/+Zd18OBBpdNp7dy5U3fddZeuvvrqoJcGhBr38QYAAAAAoIY41RwAAAAAgBoivAEAAAAAqCHCGwAAAACAGiK8AQAAAACoIcIbAAAAAIAaIrwBAAAAAKghwhsAAAAAgBoivAEAAAAAqCHCGwAAAACAGiK8AQBwhO/72rFjhz784Q8f9/Zvfetbisfj+vrXvx7Y2gAAsBnhDQCAIyKRiG6++WbdeuutGhsbkyQ9/vjjuu666/SJT3xC73rXu4JeIgAAVvKMMSboRQAAgPooFos644wz9Ku/+qv6pV/6JV166aX62Z/9Wf2f//N/gl4aAADWIrwBAHDMpz/9af3+7/++1q9fr1NPPVV33HGHIhE2wQEAUCv8lAUAwDG/8Au/oImJCXmep3/+538+KbrvvPNOnXnmmTr99NP12c9+NrB1AgBgi1jQCwAAAPV1ww03SJKGhoZOiu5isaibbrpJ3/ve95ROp3XRRRfpne98p9auXRvQagEAaHxMvAEAcMgf/MEf6Fvf+pYefPBBFYtFfe5znzvu/Q8//LDOOeccbd68WW1tbbrmmmv0H//xH4GtFwAAGxDeAAA44jOf+Yw++clP6t/+7d903nnn6cYbb9Sf/dmfqVAozD3mwIED2rx589zrmzdv1v79+wNaMQAAdiC8AQBwwLe//W3dcMMN+tKXvqRLL71Umt1yPjY2pn/6p38KenkAAFiN8AYAwHKPPfaYrr32Wv3Zn/2Z3vnOd869PZ1O6zd/8zf18Y9/XKVSSZK0adOm4ybc+/fv16ZNmwJZNwAAtuB2YgAAYE6xWNRZZ52le++9d+5wtQceeIDD1QAAWAVONQcAAHNisZg++clP6vWvf71839fv/M7vEN0AAKwSE28AAAAAAGqIa7wBAAAAAKghwhsAAAAAgBoivAEAAAAAqCHCGwAAAACAGiK8AQAAAACoIcIbAAAAAIAaIrwBAAAAAKghwhsAAAAAgBoivAEAAAAAqCHCGwAAAACAGiK8AQAAAACoof8ftEmBFsZ3j/AAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Z_mcmc = posterior_predictive_plot(chains)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "040ca9fc-694d-4eee-b5f2-be03bfc32c5b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[0.4520933 , 0.4540293 , 0.45596862, ..., 0.53816384, 0.54008245,\n", + " 0.5419968 ],\n", + " [0.4537641 , 0.45570213, 0.45764345, ..., 0.5398365 , 0.5417531 ,\n", + " 0.5436653 ],\n", + " [0.4554368 , 0.45737684, 0.45931998, ..., 0.5415082 , 0.5434227 ,\n", + " 0.5453327 ],\n", + " ...,\n", + " [0.5430625 , 0.5450165 , 0.5469687 , ..., 0.6252578 , 0.6269905 ,\n", + " 0.6287157 ],\n", + " [0.5447219 , 0.54667443, 0.54862505, ..., 0.62677556, 0.62850374,\n", + " 0.6302244 ],\n", + " [0.54637897, 0.54832995, 0.55027884, ..., 0.62828875, 0.63001245,\n", + " 0.6317284 ]], dtype=float32)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Z_mcmc" + ] + }, + { + "cell_type": "markdown", + "id": "f211fa23-d779-4829-9666-2802e81f500e", + "metadata": {}, + "source": [ + "It seems that MH as is implemented in the example assigns to all points probabilities around 45-65. Very close to 50%" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "0aa89f5a", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62464/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "Z_mcmc_2 = posterior_predictive_plot(particles)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "68218051-5ee0-41e0-91ae-4cbe94d21e23", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Array(0.0003122, dtype=float32), Array(0.99975044, dtype=float32))" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(Z_mcmc_2), np.max(Z_mcmc_2)" + ] + }, + { + "cell_type": "markdown", + "id": "0a9dba30", + "metadata": {}, + "source": [ + "# Waste-Free SMC" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "647d1be6", + "metadata": {}, + "outputs": [], + "source": [ + "import importlib\n", + "importlib.reload(blackjax)\n", + "from blackjax.smc.waste_free import waste_free_smc\n", + "\n", + "waste_free_smc_kernel = inner_kernel_tuning(\n", + " logprior_fn=logprior,\n", + " loglikelihood_fn=loglikelihood,\n", + " mcmc_step_fn=step_fn,\n", + " mcmc_init_fn=blackjax.rmh.init,\n", + " resampling_fn=resampling.systematic,\n", + " smc_algorithm=adaptive_tempered_smc,\n", + " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", + " initial_parameter_value=initial_parameter_value,\n", + " target_ess=0.5,\n", + " num_mcmc_steps=None,\n", + " update_strategy=waste_free_smc(n_particles,10)\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "4e3d2364", + "metadata": {}, + "outputs": [], + "source": [ + "total_steps_waste_free, final_state_waste_free, normalizing_constant_waste_free = loop(waste_free_smc_kernel.step, iterations_key, waste_free_smc_kernel.init(initial_particles))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "2895b1a2-889f-4e6e-a72a-5670617e4e13", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(0., dtype=float32)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum(normalizing_constant_waste_free[:total_steps_waste_free]) #log scale" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "f9f75aa2-9deb-4188-b11a-1757ae2f9a91", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62464/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Array([[2.8918695e-04, 3.4526619e-04, 4.1533765e-04, ..., 4.1969481e-01,\n", + " 4.3220809e-01, 4.4416195e-01],\n", + " [3.1954193e-04, 3.7984748e-04, 4.5493516e-04, ..., 4.3008462e-01,\n", + " 4.4261801e-01, 4.5457524e-01],\n", + " [3.5531164e-04, 4.2049473e-04, 5.0137856e-04, ..., 4.4092900e-01,\n", + " 4.5347723e-01, 4.6544501e-01],\n", + " ...,\n", + " [5.7525760e-01, 5.8810079e-01, 6.0128236e-01, ..., 9.9963707e-01,\n", + " 9.9969530e-01, 9.9974197e-01],\n", + " [5.8583021e-01, 5.9841263e-01, 6.1136401e-01, ..., 9.9966609e-01,\n", + " 9.9972129e-01, 9.9976534e-01],\n", + " [5.9574318e-01, 6.0810667e-01, 6.2087506e-01, ..., 9.9969071e-01,\n", + " 9.9974334e-01, 9.9978501e-01]], dtype=float32)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "posterior_predictive_plot(final_state_waste_free.sampler_state.particles)" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "630b6a13", + "metadata": {}, + "outputs": [], + "source": [ + "particles_waste_free = final_state_waste_free.sampler_state.particles" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "c1997aa9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62464/4095671798.py:9: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "for i, axi in enumerate(ax):\n", + " axi.hist(chains[:,i], label=\"MH\")\n", + " axi.hist(particles[:, i], label=\"SMC\")\n", + " axi.hist(particles_waste_free[:, i],label=\"WF\")\n", + " \n", + "\n", + " axi.set_title(f\"$w_{i}$\")\n", + " plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "966c65d4-1699-4cb5-b3c2-d1eac1a4dd88", + "metadata": {}, + "source": [ + "There's a big difference in posteriors for SMC vs SMC-WasteFree" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "9c90387f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Array(-0.01791389, dtype=float32),\n", + " Array(-5.750385, dtype=float32),\n", + " Array(-6.4010663, dtype=float32))" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(chains[:,0]), np.mean(particles[:,0]), np.mean(particles_waste_free[:,0]), " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "df47baa9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "StateWithParameterOverride(sampler_state=TemperedSMCState(particles=Array([[-6.385606 , 2.3500376, 2.6450486],\n", + " [-6.878158 , 2.0022292, 4.137133 ],\n", + " [-9.559358 , 3.3078794, 2.0108054],\n", + " ...,\n", + " [-3.7246413, 3.2796614, 0.6937783],\n", + " [-3.7246413, 3.2796614, 0.6937783],\n", + " [-3.7246413, 3.2796614, 0.6937783]], dtype=float32), weights=Array([6.1977698e-05, 6.3779000e-05, 3.8251215e-05, ..., 4.2606887e-05,\n", + " 4.2606887e-05, 4.2606887e-05], dtype=float32), lmbda=Array(1., dtype=float32, weak_type=True)), parameter_override={'cov': Array([[[ 8.731909 , -2.2317386, -1.6413733],\n", + " [-2.2317386, 3.0842333, -1.7759979],\n", + " [-1.6413733, -1.7759979, 2.8467197]]], dtype=float32)})" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_state_waste_free" + ] + }, + { + "cell_type": "markdown", + "id": "9c6d5d22-4bf2-48df-a0a3-b4beac70ae61", + "metadata": {}, + "source": [ + "Note that to achieve similar results, SMC will take" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "b2088325", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(1500000, dtype=int32, weak_type=True)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_steps * 5 * n_particles" + ] + }, + { + "cell_type": "markdown", + "id": "c0d8c6cb-f1a9-4783-89ff-b86eaf73d404", + "metadata": {}, + "source": [ + "inner MCMC steps (with their corresponding density evaluations), whereas Waste-Free is going to take" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "415e3148-5093-4841-84b7-a2c3993b6629", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(252000., dtype=float32, weak_type=True)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_steps_waste_free * n_particles/10 * 9 " + ] + }, + { + "cell_type": "markdown", + "id": "d584f684-6748-4538-adf2-4c1be0b1f224", + "metadata": {}, + "source": [ + "inner MCMC steps." + ] + }, + { + "cell_type": "markdown", + "id": "4655f049-96c2-4c12-9650-dd20d51ec298", + "metadata": {}, + "source": [ + "Confusion matrix in sample for waste free" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "de1497e2-ee8b-4a7e-877c-f788274ed843", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[27, 0],\n", + " [ 0, 23]])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pred3=(predict(Phi,np.mean(particles_waste_free, axis=0))>0.5).astype(int)\n", + "sklearn.metrics.confusion_matrix(y, pred3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4970b81-20d7-47dd-bbf0-907c77195718", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f02b8e09-e0b9-4bd0-9cff-24905e39ed97", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "jupytext": { + "formats": "md:myst,ipynb" + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/logistic_regression.ipynb b/logistic_regression.ipynb index 07ba642aa..610a3f19d 100644 --- a/logistic_regression.ipynb +++ b/logistic_regression.ipynb @@ -7,12 +7,12 @@ "source": [ "# Waste Free SMC comparison\n", "\n", - "In this notebook we demonstrate the use of the random walk Rosenbluth-Metropolis-Hasting algorithm on a simple logistic regression." + "In this notebook we take again a Logistic Regression model, and compare MH, SMC and Waste-Free SMC" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "de1922dd", "metadata": {}, "outputs": [], @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "e7dba964", "metadata": { "tags": [ @@ -57,7 +57,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "7ec4566a", "metadata": {}, "outputs": [], @@ -71,14 +71,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "40210fca", "metadata": { "tags": [ "hide-input" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "colors = [\"tab:red\" if el else \"tab:blue\" for el in rows[0]]\n", "plt.scatter(*X.T, edgecolors=colors, c=\"none\")\n", @@ -114,9 +125,17 @@ "And $\\Phi$ is the matrix that contains the data, so each row $\\Phi_{i,:}$ is the vector $\\left[1, X_0^i, X_1^i\\right]$" ] }, + { + "cell_type": "markdown", + "id": "9af4ac0f-a441-4c2f-a22a-3b5112599c3d", + "metadata": {}, + "source": [ + "Note that X is not normalized" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "f3c7dd2f", "metadata": { "tags": [ @@ -136,24 +155,61 @@ "def log_sigmoid(z):\n", " return z - jnp.log(1 + jnp.exp(z))\n", "\n", - "def logprior(w, alpha=1.0):\n", + "def logprior(w, alpha=1.):\n", " prior_term = alpha * w @ w / 2\n", " return -prior_term\n", " \n", - "def loglikelihood(w, alpha=1.0):\n", + "def loglikelihood(w):\n", " \"\"\"The log-probability density function of the posterior distribution of the model.\"\"\"\n", " log_an = log_sigmoid(Phi @ w)\n", " an = Phi @ w\n", " log_likelihood_term = y * log_an + (1 - y) * jnp.log(1 - sigmoid(an))\n", " return log_likelihood_term.sum()\n", " \n", - "def logdensity_fn(w, alpha=1.0):\n", - " return logprior(w,alpha) + loglikelihood(w,alpha)" + "def logdensity_fn(w, alpha=1.):\n", + " return logprior(w,alpha) + loglikelihood(w)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "id": "a5e8505c-aabb-4da5-ad73-cac475cfece9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Prior')" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "w = jnp.linspace(0, 10).reshape(-1,1)\n", + "for alpha in [0.1, 0.5, 1, 2]:\n", + " plt.plot(w, jax.vmap(lambda x:jnp.exp(logprior(x, alpha)))(w), label=alpha)\n", + "\n", + "plt.legend()\n", + "plt.xlabel(\"Squared norm of w\")\n", + "plt.title(\"Prior\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "id": "043aff76", "metadata": {}, "outputs": [], @@ -173,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "9889d938", "metadata": {}, "outputs": [], @@ -209,14 +265,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "69816b03", "metadata": { "tags": [ "hide-input" ] }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "burnin = 300\n", "\n", @@ -230,7 +297,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "1f1306a6", "metadata": {}, "outputs": [], @@ -250,7 +317,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "263a7714", "metadata": {}, "outputs": [], @@ -284,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "88ccaf4c", "metadata": {}, "outputs": [], @@ -297,7 +364,7 @@ "\n", "\n", "def mcmc_parameter_update_fn(state: TemperedSMCState, info):\n", - " sigma_particles = particles_covariance_matrix(state.particles) * 0.75\n", + " sigma_particles = particles_covariance_matrix(state.particles) * 2.38 / np.sqrt(n_predictors) \n", " return extend_params({\"cov\":sigma_particles})\n", "\n", "def step_fn(key, state, logdensity, cov):\n", @@ -344,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "c0ccdccc", "metadata": {}, "outputs": [], @@ -354,40 +421,81 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "6a672bcc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Array(0., dtype=float32)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "np.exp(normalizing_constant[:total_steps])" + "np.sum(normalizing_constant[:total_steps]) #" ] }, { "cell_type": "code", - "execution_count": null, - "id": "81dae2ae", + "execution_count": 15, + "id": "50955c99-a2fd-46f8-8b4d-cad4ed0bbd48", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "np.float32(1.0)" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "particles = final_state.sampler_state.particles" + "np.exp(np.sum(normalizing_constant[:total_steps]))" + ] + }, + { + "cell_type": "markdown", + "id": "105399cb-61bc-4283-a65b-8b2cc517dde9", + "metadata": {}, + "source": [ + "Why the log normalizing constant is always 0? Is it because of the prior shape?" ] }, { "cell_type": "code", - "execution_count": null, - "id": "6e10f1f1", + "execution_count": 16, + "id": "81dae2ae", "metadata": {}, "outputs": [], "source": [ - "final_state.sampler_state.weights" + "particles = final_state.sampler_state.particles" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "id": "85dd9f86", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+sAAADbCAYAAAAVkgB5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+t0lEQVR4nO3deVRV9f7/8ReCDA4HUmMw0UhLJDFTC0kzU75QUWl5b1kOlKZZaDlcNe41c6g0zbTMoXLA+0szvSvNnHHsmmhGUo7kgGHZwW4mRxxAZP/+uLGvJ3EAOQPwfKy11+J89vvs83mzz/kc3uzh42EYhiEAAAAAAOA2qri6AwAAAAAAwB7FOgAAAAAAboZiHQAAAAAAN0OxDgAAAACAm6FYBwAAAADAzVCsAwAAAADgZijWAQAAAABwMxTrAAAAAAC4GYp1AAAAAADcDMU6AAAAAABuhmIdAAAAAAA3Q7EOAAAAAICboVhHpTVw4EAFBQXZtQ0bNkweHh6aNm2a2Wa1WlW1alV9+OGHLuglALgGYyQAFI/xEc5CsY5KKyAgQLm5uebjs2fPavbs2fLy8tLJkyfN9jlz5qh69erq1q2bi3oKAM7HGAkAxWN8hLNQrKPSCggI0NmzZ1VYWChJWrBggby8vNSxY0dzoC0sLNRHH32khIQEVa9e3cU9BgDnYYwEgOIxPsJZKNZRaQUEBMgwDJ0+fVqS9P7776tPnz6qU6eOOdCuXbtWR44c0QsvvODi3gKAczFGAkDxGB/hLBTrqLQCAgIkSbm5udqyZYt27dql559/XhaLxRxoP/jgA3Xo0EHh4eGSpF9//VXx8fGqXr26GjdurPXr17s0BwBwlNKMkTNmzFCLFi1UtWpVjRo1yqX9BwBHKen4mJeXp169eql+/fqyWCxq3bq1UlNTXZwFygOKdVRaFw+077//vh599FGFhoaaA+2xY8e0fPlyJSYmms9JTExUcHCwfv31V02cOFFPPPGETpw44cIsAMAxSjNGhoSEaNSoUerSpYsLew4AjlXS8bGgoEA333yztmzZopMnT2rgwIF65JFH7K57B4pDsY5Kq2igPXDggD777DP1799fksyBdvbs2QoKCtKjjz4q/TEgL126VKNHj1a1atX06KOPKjIyUp9//rlL8wAARyjpGClJnTt31qOPPmo+FwAqopKOj9WrV9fIkSNVv359ValSRV27dpW3t7cyMjJcmgfcH8U6Kq2igfbtt99Wo0aN1KFDB+mPgfbEiROaNWuWnn/+eXl5eUl/DMg1atRQvXr1zG1ERkZqz549LsoAABynpGMkAFQW1zs+HjhwQCdOnFCjRo2c2m+UP3zDotIqGmg3btyoqVOnmu0Wi0WHDx9W1apV1adPH7M9NzdXFovFbhsWi0W//fabE3sNAM5R0jESACqL6xkfz549q+7duyspKUn+/v5O6zPKJ4p1VFoWi0UeHh6qXr26evbsabYXDZyPPfaYgoODzfYaNWrIZrPZbcNms6lGjRpO7DUAOEdJx0gAqCxKOz6eP39ef/3rX9WoUSONHDnSqX1G+USxjkqrSpUq5vyYF+vUqZMMw7ik/dZbb1Vubq5+/vln3XTTTZKk3bt32w3SAFBRlHSMBIDKojTjY2FhoXr06CEPDw/NmzdPHh4eTugpyjuuWQeuUY0aNdSpUye99tprOnv2rJYvX67vv/9enTp1cnXXAMAtFBQU6Ny5c7pw4YLdzwBQ2T3//PP65ZdftHjxYu71gWvmYfDvceCa/frrr0pISNCmTZtUr149TZ8+XTExMa7uFgC4hVGjRmn06NF2bXPnztUzzzzjsj4BgKv9+OOPuvnmm+Xr6ytPT0+zfdWqVbr33ntd2je4N4p1AAAAAADcDKfBAwAAAADgZkpcrH/55Zd65JFHVLduXXl4eGjp0qV26w3D0MiRIxUSEiI/Pz/FxMTowIEDdjEnTpxQt27dZLFYFBAQoN69eys3N9cu5vvvv9e9994rX19fhYaGasKECZf0ZfHixQoPD5evr68iIyO1cuXKkqYDAAAAAIDbKXGxfvr0ad1xxx2aNm1asesnTJig9957TzNnztT27dtVvXp1xcXF6dy5c2ZMt27dtGfPHqWkpGj58uX68ssv1bdvX3O9zWZTbGysGjRooLS0NE2cOFGjRo3Shx9+aMZs3bpVTz31lHr37q2dO3eqc+fO6ty5s3bv3l3y3wIAAAAAAG7kuq5Z9/Dw0JIlS9S5c2fpj6PqdevW1ZAhQ/S3v/1NkpSTk6OgoCAlJyera9eu2rdvnyIiIrRjxw61atVKkrR69Wo99NBD+umnn1S3bl3NmDFD//jHP2S1WuXt7S1JeuWVV7R06VLt379fkvTkk0/q9OnTWr58udmf1q1bq3nz5po5c+Y19d8wDJ06dUo1a9Zk+gQAuAjjIwAUj/ERgLOU6TXrmZmZslqtdnfH9vf3V1RUlFJTUyVJqampCggIMAt1SYqJiVGVKlW0fft2M6Zdu3ZmoS5JcXFxysjI0O+//27G/Pku3HFxcebrFCcvL082m81cfv75Z/n7++vUqVNl+FsAgPLv1KlTjI8AUAzGRwDOUqbFutVqlSQFBQXZtQcFBZnrrFarAgMD7dZ7eXmpVq1adjHFbePi17hcTNH64owbN07+/v7mEhoaeh3ZAgAAAADgGJXqbvBJSUnKyckxl6NHj7q6SwAAAAAAXKJMi/Xg4GBJUnZ2tl17dna2uS44OFjHjx+3W19QUKATJ07YxRS3jYtf43IxReuL4+PjI4vFYrcAAAAAAOBuyrRYDwsLU3BwsNavX2+22Ww2bd++XdHR0ZKk6OhonTx5UmlpaWbMhg0bVFhYqKioKDPmyy+/1Pnz582YlJQUNW7cWDfccIMZc/HrFMUUvQ4AAADKj59//lndu3dX7dq15efnp8jISH3zzTfmemdODwwA7qDExXpubq7S09OVnp4u/XFTufT0dGVlZcnDw0MDBw7U66+/rmXLlmnXrl3q2bOn6tata94xvkmTJnrggQfUp08fff311/rqq6/Uv39/de3aVXXr1pUkPf300/L29lbv3r21Z88effrpp3r33Xc1ePBgsx8vv/yyVq9erUmTJmn//v0aNWqUvvnmG/Xv37/sfjsAAABwuN9//11t2rRR1apVtWrVKu3du1eTJk0yD9LIidMDA4DbMEpo48aNhqRLloSEBMMwDKOwsNB49dVXjaCgIMPHx8fo2LGjkZGRYbeN3377zXjqqaeMGjVqGBaLxXj22WeNU6dO2cV89913Rtu2bQ0fHx/jpptuMsaPH39JXxYtWmTcdttthre3t3H77bcbK1asKFEuOTk5hiQjJyenpL8GAKjQGB8BONPw4cONtm3bXnZ9YWGhERwcbEycONFsO3nypOHj42N88sknhmEYxt69ew1Jxo4dO8yYVatWGR4eHsbPP/9sGIZhTJ8+3bjhhhuMvLw8u9du3LjxNfeV8RGAs1zXPOvlnc1mk7+/v3Jycrh+HQAuwvgIwJkiIiIUFxenn376SZs3b9ZNN92kF198UX369JEkHT58WA0bNtTOnTvVvHlz83n33XefmjdvrnfffVdz5szRkCFDzGl+9cd9kXx9fbV48WI99thj6tmzp2w2m5YuXWrGbNy4UR06dNCJEyfsjuRfDuMjAGfxcnUH4AKj/B28/RzHbh8AUH448juH75sK4/Dhw5oxY4YGDx6sv//979qxY4deeukleXt7KyEhoUynBw4LC7tkG0XriivW8/LylJeXZz622WxlljdQ6Tm6LlH5/q6gWAcAAIBLFRYWqlWrVnrzzTclSXfeead2796tmTNnKiEhwaV9GzdunEaPHu3SPgConCrVPOsA4EoXLlzQq6++qrCwMPn5+alhw4YaO3asLr4aibsdA6iMQkJCFBERYdfWpEkTZWVlSU6eHvjPkpKSlJOTYy5Hjx69zmwB4NpQrAOAk7z11luaMWOG3n//fe3bt09vvfWWJkyYoKlTp5ox3O0YQGXUpk0bZWRk2LX98MMPatCggeTk6YH/zMfHRxaLxW4BAGegWAcAJ9m6das6deqk+Ph43XzzzfrLX/6i2NhYff3119IfR9WnTJmiESNGqFOnTmrWrJn++c9/6tixY+bNkPbt26fVq1dr1qxZioqKUtu2bTV16lQtXLhQx44dkyTNnz9f+fn5mjNnjm6//XZ17dpVL730kt555x2X5g8AlzNo0CBt27ZNb775pg4ePKgFCxboww8/VGJioiQ5dXpgAHAXFOsA4CT33HOP1q9frx9++EGS9N1332nLli168MEHJUmZmZmyWq2KiYkxn+Pv76+oqCilpqZKklJTUxUQEKBWrVqZMTExMapSpYq2b99uxrRr107e3t5mTFxcnDIyMuzukgwA7uKuu+7SkiVL9Mknn6hp06YaO3aspkyZom7dupkxw4YN04ABA9S3b1/dddddys3N1erVq+Xr62vGzJ8/X+Hh4erYsaMeeughtW3b1u6sIn9/f61du1aZmZlq2bKlhgwZopEjR9qdnQQA7oIbzAGAk7zyyiuy2WwKDw+Xp6enLly4oDfeeMP8Y5S7HQOozB5++GE9/PDDl13v4eGhMWPGaMyYMZeNqVWrlhYsWHDF12nWrJn+/e9/X1dfAcAZOLIOAE6yaNEizZ8/XwsWLNC3336refPm6e2339a8efNc3TWNGzdO/v7+5hIaGurqLgEAAFRqFOsA4CRDhw7VK6+8oq5duyoyMlI9evTQoEGDNG7cOIm7HQMAAOAiFOsA4CRnzpxRlSr2w66np6cKCwsl7nYMAACAi1CsA4CTPPLII3rjjTe0YsUKHTlyREuWLNE777yjxx57TOJuxwAAALgIN5gDACeZOnWqXn31Vb344os6fvy46tatq+eff14jR440Y4YNG6bTp0+rb9++OnnypNq2bVvs3Y779++vjh07qkqVKurSpYvee+89c33R3Y4TExPVsmVL1alTh7sdAwAAlDMehmEYru6Eq9hsNvn7+ysnJ6dynfI5yt/B289x7PYBOFylHR9R9hz5ncP3DVyA8REoQ46uS1S+vys4DR4AAAAAADdDsQ4AAAAAgJuhWAcAAAAAwM1QrAMAAAAA4GYo1gEAAAAAcDMU6wAAAAAAuBmKdQAAAAAA3AzFOgAAAAAAboZiHQAAAAAAN0OxDgAAAACAm6FYBwAAAADAzVCsAwAAAADgZijWAQAAAABwMxTrAAAAAAC4mTIv1m+++WZ5eHhcsiQmJkqS2rdvf8m6fv362W0jKytL8fHxqlatmgIDAzV06FAVFBTYxWzatEktWrSQj4+PGjVqpOTk5LJOBQAAAAAAl/Aq6w3u2LFDFy5cMB/v3r1b//d//6e//vWvZlufPn00ZswY83G1atXMny9cuKD4+HgFBwdr69at+uWXX9SzZ09VrVpVb775piQpMzNT8fHx6tevn+bPn6/169frueeeU0hIiOLi4so6JQAAAAAAnKrMi/Ubb7zR7vH48ePVsGFD3XfffWZbtWrVFBwcXOzz165dq71792rdunUKCgpS8+bNNXbsWA0fPlyjRo2St7e3Zs6cqbCwME2aNEmS1KRJE23ZskWTJ0+mWAcAAAAAlHsOvWY9Pz9fH3/8sXr16iUPDw+zff78+apTp46aNm2qpKQknTlzxlyXmpqqyMhIBQUFmW1xcXGy2Wzas2ePGRMTE2P3WnFxcUpNTXVkOgAAAAAAOEWZH1m/2NKlS3Xy5Ek988wzZtvTTz+tBg0aqG7duvr+++81fPhwZWRk6LPPPpMkWa1Wu0JdkvnYarVeMcZms+ns2bPy8/Mrtj95eXnKy8szH9tstjLMFgAAAACAsuHQYn327Nl68MEHVbduXbOtb9++5s+RkZEKCQlRx44ddejQITVs2NCR3dG4ceM0evRoh74GAAAAAADXy2Gnwf/4449at26dnnvuuSvGRUVFSZIOHjwoSQoODlZ2drZdTNHjouvcLxdjsVgue1RdkpKSkpSTk2MuR48eLWV2AAAAAAA4jsOK9blz5yowMFDx8fFXjEtPT5ckhYSESJKio6O1a9cuHT9+3IxJSUmRxWJRRESEGbN+/Xq77aSkpCg6OvqKr+Xj4yOLxWK3AAAAAADgbhxSrBcWFmru3LlKSEiQl9f/zrQ/dOiQxo4dq7S0NB05ckTLli1Tz5491a5dOzVr1kySFBsbq4iICPXo0UPfffed1qxZoxEjRigxMVE+Pj6SpH79+unw4cMaNmyY9u/fr+nTp2vRokUaNGiQI9IBAAAAAMCpHFKsr1u3TllZWerVq5ddu7e3t9atW6fY2FiFh4dryJAh6tKli7744gszxtPTU8uXL5enp6eio6PVvXt39ezZ025e9rCwMK1YsUIpKSm64447NGnSJM2aNYtp2wAAAAAAFYJDivXY2FgZhqHbbrvNrj00NFSbN2/Wb7/9pnPnzunAgQOaMGHCJaejN2jQQCtXrtSZM2f066+/6u2337Y7Qi9J7du3186dO5WXl6dDhw7Z3XEeANzVzz//rO7du6t27dry8/NTZGSkvvnmG3O9YRgaOXKkQkJC5Ofnp5iYGB04cMBuGydOnFC3bt1ksVgUEBCg3r17Kzc31y7m+++/17333itfX1+FhoZqwoQJTssRAAAA18+h86wDAP7n999/V5s2bVS1alWtWrVKe/fu1aRJk3TDDTeYMRMmTNB7772nmTNnavv27apevbri4uJ07tw5M6Zbt27as2ePUlJStHz5cn355Zd2M23YbDbFxsaqQYMGSktL08SJEzVq1Ch9+OGHTs8ZAAAApePQqdsAAP/z1ltvKTQ0VHPnzjXbwsLCzJ8Nw9CUKVM0YsQIderUSZL0z3/+U0FBQVq6dKm6du2qffv2afXq1dqxY4datWolSZo6daoeeughvf3226pbt67mz5+v/Px8zZkzR97e3rr99tuVnp6ud955x66oBwAAgPviyDoAOMmyZcvUqlUr/fWvf1VgYKDuvPNOffTRR+b6zMxMWa1WxcTEmG3+/v6KiopSamqqJCk1NVUBAQFmoS5JMTExqlKlirZv327GtGvXTt7e3mZMXFycMjIy9PvvvzspWwAAAFwPinUAcJLDhw9rxowZuvXWW7VmzRq98MILeumllzRv3jxJktVqlSQFBQXZPS8oKMhcZ7VaFRgYaLfey8tLtWrVsospbhsXv8af5eXlyWaz2S0AAABwHU6DBwAnKSwsVKtWrfTmm29Kku68807t3r1bM2fOVEJCgkv7Nm7cOI0ePdqlfQAAAMD/cGQdAJwkJCREERERdm1NmjRRVlaWJCk4OFiSlJ2dbReTnZ1trgsODtbx48ft1hcUFOjEiRN2McVt4+LX+LOkpCTl5OSYy9GjR68zWwAAAFwPinUAcJI2bdooIyPDru2HH35QgwYNpD9uNhccHKz169eb6202m7Zv367o6GhJUnR0tE6ePKm0tDQzZsOGDSosLFRUVJQZ8+WXX+r8+fNmTEpKiho3bmx35/mL+fj4yGKx2C0AAABwHYp1AHCSQYMGadu2bXrzzTd18OBBLViwQB9++KESExMlSR4eHho4cKBef/11LVu2TLt27VLPnj1Vt25dde7cWfrjSPwDDzygPn366Ouvv9ZXX32l/v37q2vXrqpbt64k6emnn5a3t7d69+6tPXv26NNPP9W7776rwYMHuzR/ALhW48ePN8fEIufOnVNiYqJq166tGjVqqEuXLpecRZSVlaX4+HhVq1ZNgYGBGjp0qAoKCuxiNm3apBYtWsjHx0eNGjVScnKy0/ICgJKgWAcAJ7nrrru0ZMkSffLJJ2ratKnGjh2rKVOmqFu3bmbMsGHDNGDAAPXt21d33XWXcnNztXr1avn6+pox8+fPV3h4uDp27KiHHnpIbdu2tZtD3d/fX2vXrlVmZqZatmypIUOGaOTIkUzbBqBc2LFjhz744AM1a9bMrn3QoEH64osvtHjxYm3evFnHjh3T448/bq6/cOGC4uPjlZ+fr61bt2revHlKTk7WyJEjzZjMzEzFx8fr/vvvV3p6ugYOHKjnnntOa9ascWqOAHAtPAzDMFzdCVex2Wzy9/dXTk5O5Trlc5S/g7ef49jtA3C4Sjs+ouw58juH75sKJzc3Vy1atND06dP1+uuvq3nz5poyZYpycnJ04403asGCBfrLX/4iSdq/f7+aNGmi1NRUtW7dWqtWrdLDDz+sY8eOmTNgzJw5U8OHD9evv/4qb29vDR8+XCtWrNDu3bvN1+zatatOnjyp1atXX1MfGR+BMuToukTl+7uCI+sAAABwC4mJiYqPj1dMTIxde1pams6fP2/XHh4ervr16ys1NVWSlJqaqsjISLupK+Pi4mSz2bRnzx4z5s/bjouLM7dRHKa2BOAqTN0GAAAAl1u4cKG+/fZb7dix45J1VqtV3t7eCggIsGsPCgqS1Wo1Yy4u1IvWF627UozNZtPZs2fl5+d3yWsztSUAV+HIOgAAAFzq6NGjevnllzV//ny7e3S4A6a2BOAqFOsAAABwqbS0NB0/flwtWrSQl5eXvLy8tHnzZr333nvy8vJSUFCQ8vPzdfLkSbvnZWdnKzg4WJIUHBx8yd3hix5fLcZisRR7VF1MbQnAhSjWAQAA4FIdO3bUrl27lJ6ebi6tWrVSt27dzJ+rVq2q9evXm8/JyMhQVlaWoqOjJUnR0dHatWuXjh8/bsakpKTIYrEoIiLCjLl4G0UxRdsAAHfCNesAAABwqZo1a6pp06Z2bdWrV1ft2rXN9t69e2vw4MGqVauWLBaLBgwYoOjoaLVu3VqSFBsbq4iICPXo0UMTJkyQ1WrViBEjlJiYKB8fH0lSv3799P7772vYsGHq1auXNmzYoEWLFmnFihUuyBoAroxiHQAAAG5v8uTJqlKlirp06aK8vDzFxcVp+vTp5npPT08tX75cL7zwgqKjo1W9enUlJCRozJgxZkxYWJhWrFihQYMG6d1331W9evU0a9YsxcXFuSgrALg85lmvjPNkMs86gKuotOMjyh7zrKOCYXwEyhDzrF8R16wDAAAAAOBmKNYBAAAAAHAzFOsAAAAAALgZinUAAAAAANwMxToAAAAAAG6GqdsAAAAAoCxxl3OUAY6sAwAAAADgZijWAQAAAABwMxTrAAAAAAC4mTIv1keNGiUPDw+7JTw83Fx/7tw5JSYmqnbt2qpRo4a6dOmi7Oxsu21kZWUpPj5e1apVU2BgoIYOHaqCggK7mE2bNqlFixby8fFRo0aNlJycXNapAAAAAADgEg45sn777bfrl19+MZctW7aY6wYNGqQvvvhCixcv1ubNm3Xs2DE9/vjj5voLFy4oPj5e+fn52rp1q+bNm6fk5GSNHDnSjMnMzFR8fLzuv/9+paena+DAgXruuee0Zs0aR6QDAAAAAIBTOeRu8F5eXgoODr6kPScnR7Nnz9aCBQvUoUMHSdLcuXPVpEkTbdu2Ta1bt9batWu1d+9erVu3TkFBQWrevLnGjh2r4cOHa9SoUfL29tbMmTMVFhamSZMmSZKaNGmiLVu2aPLkyYqLi3NESgAAAAAAOI1DivUDBw6obt268vX1VXR0tMaNG6f69esrLS1N58+fV0xMjBkbHh6u+vXrKzU1Va1bt1ZqaqoiIyMVFBRkxsTFxemFF17Qnj17dOeddyo1NdVuG0UxAwcOdEQ6AAAAAIDyqBxPo1fmxXpUVJSSk5PVuHFj/fLLLxo9erTuvfde7d69W1arVd7e3goICLB7TlBQkKxWqyTJarXaFepF64vWXSnGZrPp7Nmz8vPzK7ZveXl5ysvLMx/bbLYyyhoAAAAAgLJT5sX6gw8+aP7crFkzRUVFqUGDBlq0aNFli2hnGTdunEaPHu3SPgAAAAAAcDUOn7otICBAt912mw4ePKjg4GDl5+fr5MmTdjHZ2dnmNe7BwcGX3B2+6PHVYiwWyxX/IZCUlKScnBxzOXr0aJnlCQAAAABAWXF4sZ6bm6tDhw4pJCRELVu2VNWqVbV+/XpzfUZGhrKyshQdHS1Jio6O1q5du3T8+HEzJiUlRRaLRREREWbMxdsoiinaxuX4+PjIYrHYLQDgKuPHj5eHh4fd/TaY3hIAAAByRLH+t7/9TZs3b9aRI0e0detWPfbYY/L09NRTTz0lf39/9e7dW4MHD9bGjRuVlpamZ599VtHR0WrdurUkKTY2VhEREerRo4e+++47rVmzRiNGjFBiYqJ8fHwkSf369dPhw4c1bNgw7d+/X9OnT9eiRYs0aNCgsk4HABxix44d+uCDD9SsWTO7dqa3BAAAgBxRrP/000966qmn1LhxYz3xxBOqXbu2tm3bphtvvFGSNHnyZD388MPq0qWL2rVrp+DgYH322Wfm8z09PbV8+XJ5enoqOjpa3bt3V8+ePTVmzBgzJiwsTCtWrFBKSoruuOMOTZo0SbNmzWLaNgDlQm5urrp166aPPvpIN9xwg9leNL3lO++8ow4dOqhly5aaO3eutm7dqm3btkmSOb3lxx9/rObNm+vBBx/U2LFjNW3aNOXn50uS3fSWTZo0Uf/+/fWXv/xFkydPdlnOAAAAKJkyv8HcwoULr7je19dX06ZN07Rp0y4b06BBA61cufKK22nfvr127txZ6n4CgKskJiYqPj5eMTExev311812V05vyWwZAAAA7sUh86wDAIq3cOFCffvtt9qxY8cl61w5vSWzZQAAALgXh99gDgDwX0ePHtXLL7+s+fPny9fX19XdscNsGQAAAO6FYh0AnCQtLU3Hjx9XixYt5OXlJS8vL23evFnvvfeevLy8FBQU5LLpLZktAwAAwL1QrAOAk3Ts2FG7du1Senq6ubRq1UrdunUzf3bl9JYAAABwH1yzDgBOUrNmTTVt2tSurXr16qpdu7bZXjS9Za1atWSxWDRgwIDLTm85YcIEWa3WYqe3fP/99zVs2DD16tVLGzZs0KJFi7RixQoXZA0AAIDSoFgHADcyefJkValSRV26dFFeXp7i4uI0ffp0c33R9JYvvPCCoqOjVb16dSUkJBQ7veWgQYP07rvvql69ekxvCQAAUM5QrAOAC23atMnuMdNbAgAAQFyzDgAAAACA+6FYBwAAAADAzXAaPAAAAAD3MMrfCa+R4/jXAMoAR9YBAAAAAHAzFOsAAAAAALgZToMHAKC8cNTpoZwSCgCA2+HIOgAAAAAAboZiHQAAAAAAN8Np8Ch73MUTAAAAAK4LR9YBAAAAAHAzFOsAAABwqXHjxumuu+5SzZo1FRgYqM6dOysjI8Mu5ty5c0pMTFTt2rVVo0YNdenSRdnZ2XYxWVlZio+PV7Vq1RQYGKihQ4eqoKDALmbTpk1q0aKFfHx81KhRIyUnJzslRwAoKYp1AAAAuNTmzZuVmJiobdu2KSUlRefPn1dsbKxOnz5txgwaNEhffPGFFi9erM2bN+vYsWN6/PHHzfUXLlxQfHy88vPztXXrVs2bN0/JyckaOXKkGZOZman4+Hjdf//9Sk9P18CBA/Xcc89pzZo1Ts8ZAK6Ga9YBAADgUqtXr7Z7nJycrMDAQKWlpaldu3bKycnR7NmztWDBAnXo0EGSNHfuXDVp0kTbtm1T69attXbtWu3du1fr1q1TUFCQmjdvrrFjx2r48OEaNWqUvL29NXPmTIWFhWnSpEmSpCZNmmjLli2aPHmy4uLiXJI7AFwOR9YBAADgVnJy/nsj2Vq1akmS0tLSdP78ecXExJgx4eHhql+/vlJTUyVJqampioyMVFBQkBkTFxcnm82mPXv2mDEXb6MopmgbAOBOOLIOAAAAt1FYWKiBAweqTZs2atq0qSTJarXK29tbAQEBdrFBQUGyWq1mzMWFetH6onVXirHZbDp79qz8/Pwu6U9eXp7y8vLMxzabrcxyBYAroVgHAACA20hMTNTu3bu1ZcsWV3dF+uPmd6NHj3Z1N1CWnDHNMFAGKNYBAED55Mg/uEflOG7buKz+/ftr+fLl+vLLL1WvXj2zPTg4WPn5+Tp58qTd0fXs7GwFBwebMV9//bXd9oruFn9xzJ/vIJ+dnS2LxVLsUXVJSkpK0uDBg83HNptNoaGhZZIvAFwJ16wDAADApQzDUP/+/bVkyRJt2LBBYWFhdutbtmypqlWrav369WZbRkaGsrKyFB0dLUmKjo7Wrl27dPz4cTMmJSVFFotFERERZszF2yiKKdpGcXx8fGSxWOwWAHAGjqwDAADApRITE7VgwQJ9/vnnqlmzpnmNub+/v/z8/OTv76/evXtr8ODBqlWrliwWiwYMGKDo6Gi1bt1akhQbG6uIiAj16NFDEyZMkNVq1YgRI5SYmCgfHx9JUr9+/fT+++9r2LBh6tWrlzZs2KBFixZpxYoVLs0fAIpDsQ4AAOBMnL5/iRkzZkiS2rdvb9c+d+5cPfPMM5KkyZMnq0qVKurSpYvy8vIUFxen6dOnm7Genp5avny5XnjhBUVHR6t69epKSEjQmDFjzJiwsDCtWLFCgwYN0rvvvqt69epp1qxZTNsGwC1RrAMAAMClDMO4aoyvr6+mTZumadOmXTamQYMGWrly5RW30759e+3cubNU/QQAZyrza9bHjRunu+66SzVr1lRgYKA6d+6sjIwMu5j27dvLw8PDbunXr59dTFZWluLj41WtWjUFBgZq6NChKigosIvZtGmTWrRoIR8fHzVq1EjJycllnQ4AAAAAAE5X5sX65s2blZiYqG3btiklJUXnz59XbGysTp8+bRfXp08f/fLLL+YyYcIEc92FCxcUHx+v/Px8bd26VfPmzVNycrJGjhxpxmRmZio+Pl7333+/0tPTNXDgQD333HNas2ZNWacEAAAAAIBTlflp8KtXr7Z7nJycrMDAQKWlpaldu3Zme7Vq1cxpNP5s7dq12rt3r9atW6egoCA1b95cY8eO1fDhwzVq1Ch5e3tr5syZCgsL06RJkyRJTZo00ZYtWzR58mSuO8L1c8b8m+X0ukIAAAAAjufwqdtycv5bkNSqVcuuff78+apTp46aNm2qpKQknTlzxlyXmpqqyMhIBQUFmW1xcXGy2Wzas2ePGRMTE2O3zbi4OKWmpl62L3l5ebLZbHYLADjLtVwmdO7cOSUmJqp27dqqUaOGunTpcsmcwFwmBAAAUPE5tFgvLCzUwIED1aZNGzVt2tRsf/rpp/Xxxx9r48aNSkpK0v/7f/9P3bt3N9dbrVa7Ql2S+bhoKo/LxdhsNp09e7bY/owbN07+/v7mEhoaWqb5AsCVXMtlQoMGDdIXX3yhxYsXa/PmzTp27Jgef/xxcz2XCQEAAFQODr0bfGJionbv3q0tW7bYtfft29f8OTIyUiEhIerYsaMOHTqkhg0bOqw/SUlJGjx4sPnYZrNRsANwmqtdJpSTk6PZs2drwYIF6tChg/THtEVNmjTRtm3b1Lp1ay4TAgAAqCQcdmS9f//+Wr58uTZu3Kh69epdMTYqKkqSdPDgQUlScHDwJad9Fj0uus79cjEWi0V+fn7Fvo6Pj48sFovdAgCu8ufLhNLS0nT+/Hm7S3zCw8NVv3598xIfLhMCAACoHMr8yLphGBowYICWLFmiTZs2KSws7KrPSU9PlySFhIRIkqKjo/XGG2/o+PHjCgwMlCSlpKTIYrEoIiLCjPnzPJopKSmKjo4u65QAoMwVd5mQ1WqVt7e3AgIC7GKDgoKuegmQSnCZUHH/0Bw3bpxGjx5dxlkCAIByzRk3XcZllfmR9cTERH388cdasGCBatasKavVKqvVal5HfujQIY0dO1ZpaWk6cuSIli1bpp49e6pdu3Zq1qyZJCk2NlYRERHq0aOHvvvuO61Zs0YjRoxQYmKifHx8JEn9+vXT4cOHNWzYMO3fv1/Tp0/XokWLNGjQoLJOCQDKXNFlQgsXLnR1V6Q/LhPKyckxl6NHj7q6SwAAAJVamRfrM2bMUE5Ojtq3b6+QkBBz+fTTTyVJ3t7eWrdunWJjYxUeHq4hQ4aoS5cu+uKLL8xteHp6avny5fL09FR0dLS6d++unj17asyYMWZMWFiYVqxYoZSUFN1xxx2aNGmSZs2axfWYANze5S4TCg4OVn5+vk6ePGkXn52dfdVLgMRlQgAAABWKQ06Dv5LQ0FBt3rz5qttp0KDBJae5/1n79u21c+fOEvcRAFzhapcJtWzZUlWrVtX69evVpUsXSVJGRoaysrLMS3y4TAgAAKBycOjd4AEA/5OYmKgFCxbo888/Ny8TkiR/f3/5+fnJ399fvXv31uDBg1WrVi1ZLBYNGDBA0dHRat26tfSny4QmTJggq9Va7GVC77//voYNG6ZevXppw4YNWrRokVasWOHS/AEAAHDtHDrPOgDgf652mZAkTZ48WQ8//LC6dOmidu3aKTg4WJ999pm5nsuEAAAAKgeOrAOAk1ztMiFJ8vX11bRp0zRt2rTLxnCZEAAAQMXHkXUAAAAAANwMxToAAAAAAG6G0+ABACiBm1+5+o36joyPd0pfAABAxUWxXlKj/B28/RzHbh8AAAC4Bpf75yT/kAScg2IdAICLXMuRcwAAAEejWAcAAAAqMf5JCbgnbjAHAAAAAICb4cg6AACVnaPvxwIAAEqMYh0AAODP+AcGAMDFOA0eAAAAAAA3w5F1AAAAAA51pZvYMRVcKXEGUIVHsQ6gTPAlDAAAAJQdinUALnO5Ap/iHgCAssX0bED5Q7EOuIqjT10alePY7QMAAABwGIp1AAAAANeMS98A56BYR/nEDTUAlBKnggIAgPKAYh2A2+FadgAAAFR2zLMOAAAAAICb4cg6AIfjtGMAAACgZCjWAZQbnB4PAACAyoJiHQBQYXAWB4DKjnEQqDgo1oGKinncAZc44vu0NMrVvQAAAOUdN5gDAAAAAMDNUKwDAAAAAOBmyv1p8NOmTdPEiRNltVp1xx13aOrUqbr77rtd3S0ATsSN54rH+AgAxauQ4+Mfl78d8XXcS9x8bsHVY7hmHigz5bpY//TTTzV48GDNnDlTUVFRmjJliuLi4pSRkaHAwEBXdw8AXIbxEQCK57Lx0dH3knGCI75PO2bD3OcDKFa5Ltbfeecd9enTR88++6wkaebMmVqxYoXmzJmjV155xdXdAwCXqajjI0dsAFyvijo+Aqh4ym2xnp+fr7S0NCUlJZltVapUUUxMjFJTU4t9Tl5envLy8szHOTn/vZu1zWa79hfOM66n21dXkr6UlqNzQOWQZLF7+L1H2b9E03Ozr+v59Qctvuy63aPjrmvbF6tZs6Y8PBzwCygll42PZW1cvUuaHPE+K2u2vGsIAhzlT2Nz2W77pxI/hfHx4g3x9xdQYZXy76WrjZHltlj/z3/+owsXLigoKMiuPSgoSPv37y/2OePGjdPo0aMvaQ8NDXVYP0tsfPk/RQooO084bMv+U8puWzk5ObJYHPgHcglV2PERgGuV4m8UxkcAlUIpa7irjZHltlgvjaSkJA0ePNh8XFhYqBMnTqh27dql+q+vzWZTaGiojh496lZfRNeLvMqPipiTymFeNWvWdHUXrltZj4/uoLy9j66EXNwTuVwd46PrVaT3aZGKllNFy0cVMCdXjZHltlivU6eOPD09lZ2dbdeenZ2t4ODgYp/j4+MjHx8fu7aAgIDr7ovFYqkQb8I/I6/yoyLmpAqcl6O50/joDirS+4hc3BO5lB+VeXysiPu2ouVU0fJRBczJ2fmU23nWvb291bJlS61fv95sKyws1Pr16xUdHe3SvgGAKzE+AkDxGB8BlCfl9si6JA0ePFgJCQlq1aqV7r77bk2ZMkWnT5827+4JAJUV4yMAFI/xEUB5Ua6L9SeffFK//vqrRo4cKavVqubNm2v16tWX3DTEUXx8fPTaa69dcmpUeUde5UdFzEkVOC9ncvX46A4q0vuIXNwTuZRPlW18rIj7tqLlVNHyUQXMyVX5eBiGwTwSAAAAAAC4kXJ7zToAAAAAABUVxToAAAAAAG6GYh0AAAAAADdDsQ4AAAAAgJuhWL+CN954Q/fcc4+qVaumgICAa3qOYRgaOXKkQkJC5Ofnp5iYGB04cMAu5sSJE+rWrZssFosCAgLUu3dv5ebmOiiLS5X09Y8cOSIPD49il8WLF5txxa1fuHChk7Iq3e+1ffv2l/S5X79+djFZWVmKj49XtWrVFBgYqKFDh6qgoMDB2fxPSfM6ceKEBgwYoMaNG8vPz0/169fXSy+9pJycHLs4Z++vadOm6eabb5avr6+ioqL09ddfXzF+8eLFCg8Pl6+vryIjI7Vy5Uq79dfyWUPFV9bvK1cqSS4fffSR7r33Xt1www264YYbFBMTc9Xcnamk+6XIwoUL5eHhoc6dOzu8j9eqpLmcPHlSiYmJCgkJkY+Pj2677Ta3eJ+VNI8pU6aY3yOhoaEaNGiQzp0757T+4vIq4vdpWY9/zzzzzCV/4zzwwANOyOR/SpJTcnLyJf319fW1i3H1fipJPsX9fe3h4aH4+HgzxtX76Msvv9QjjzyiunXrysPDQ0uXLr3qczZt2qQWLVrIx8dHjRo1UnJy8iUxpf3+uywDlzVy5EjjnXfeMQYPHmz4+/tf03PGjx9v+Pv7G0uXLjW+++4749FHHzXCwsKMs2fPmjEPPPCAcccddxjbtm0z/v3vfxuNGjUynnrqKQdmYq+kr19QUGD88ssvdsvo0aONGjVqGKdOnTLjJBlz5861i7s4b0crze/1vvvuM/r06WPX55ycHHN9QUGB0bRpUyMmJsbYuXOnsXLlSqNOnTpGUlKSEzL6r5LmtWvXLuPxxx83li1bZhw8eNBYv369ceuttxpdunSxi3Pm/lq4cKHh7e1tzJkzx9izZ4/Rp08fIyAgwMjOzi42/quvvjI8PT2NCRMmGHv37jVGjBhhVK1a1di1a5cZcy2fNVRsjnhfuUpJc3n66aeNadOmGTt37jT27dtnPPPMM4a/v7/x008/Ob3vf1bSXIpkZmYaN910k3HvvfcanTp1clp/r6SkueTl5RmtWrUyHnroIWPLli1GZmamsWnTJiM9Pd3pfb9YSfOYP3++4ePjY8yfP9/IzMw01qxZY4SEhBiDBg1yet9hryJ+nzpi/EtISDAeeOABu79xTpw44ZR8SpPT3LlzDYvFYtdfq9VqF+PK/VTSfH777Te7XHbv3m14enoac+fONWNcvY9Wrlxp/OMf/zA+++wzQ5KxZMmSK8YfPnzYqFatmjF48GBj7969xtSpUw1PT09j9erVZkxpv/+uhGL9GsydO/eaivXCwkIjODjYmDhxotl28uRJw8fHx/jkk08MwzCMvXv3GpKMHTt2mDGrVq0yPDw8jJ9//tlBGfxPWb1+8+bNjV69etm1Xcsb3VFKm9d9991nvPzyy5ddv3LlSqNKlSp2A+aMGTMMi8Vi5OXllWEGxSur/bVo0SLD29vbOH/+vNnmzP119913G4mJiebjCxcuGHXr1jXGjRtXbPwTTzxhxMfH27VFRUUZzz//vGFc42cNFV9Zv69cqaS5/FlBQYFRs2ZNY968eQ7s5bUpTS4FBQXGPffcY8yaNctISEhwm2K9pLnMmDHDuOWWW4z8/Hwn9vLqSppHYmKi0aFDB7u2wYMHG23atHF4X3FlFfH71BHjn6vHkZLmdLVaw9X76Xr30eTJk42aNWsaubm5Zpur99HFruVv4mHDhhm33367XduTTz5pxMXFmY+v9/dUHE6DL0OZmZmyWq2KiYkx2/z9/RUVFaXU1FRJUmpqqgICAtSqVSszJiYmRlWqVNH27dsd3seyeP20tDSlp6erd+/el6xLTExUnTp1dPfdd2vOnDn67/vf8a4nr/nz56tOnTpq2rSpkpKSdObMGbvtRkZGKigoyGyLi4uTzWbTnj17HJTN/5TV+yUnJ0cWi0VeXl527c7YX/n5+UpLS7P7XFSpUkUxMTHm5+LPUlNT7eL1x++9KP5aPmuo2BzxvnKV0uTyZ2fOnNH58+dVq1YtB/b06kqby5gxYxQYGFjs94qrlCaXZcuWKTo6WomJiQoKClLTpk315ptv6sKFC07sub3S5HHPPfcoLS3NPH3z8OHDWrlypR566CGn9RuXqojfp44c/zZt2qTAwEA1btxYL7zwgn777bcy739xSptTbm6uGjRooNDQUHXq1Mnu70xX7qey2EezZ89W165dVb16dbt2V+2j0rjaZ6ksfk/F8bqGGFwjq9UqSXaFXdHjonVWq1WBgYF26728vFSrVi0zxtF9vN7Xnz17tpo0aaJ77rnHrn3MmDHq0KGDqlWrprVr1+rFF19Ubm6uXnrppTLNoTilzevpp59WgwYNVLduXX3//fcaPny4MjIy9Nlnn5nbLW5/6qL97Uhlsb/+85//aOzYserbt69du7P213/+8x9duHCh2N/j/v37i33O5X7vF3+OdJXPGio2R7yvXKU0ufzZ8OHDVbdu3Uv+kHC20uSyZcsWzZ49W+np6U7q5bUpTS6HDx/Whg0b1K1bN61cuVIHDx7Uiy++qPPnz+u1115zUs/tlSaPp59+Wv/5z3/Utm1bGYahgoIC9evXT3//+9+d1GsUpyJ+nzpq/HvggQf0+OOPKywsTIcOHdLf//53Pfjgg0pNTZWnp2eZ53Gx0uTUuHFjzZkzR82aNVNOTo7efvtt3XPPPdqzZ4/q1avn0v10vfvo66+/1u7duzV79my7dlfuo9K43GfJZrPp7Nmz+v3336/7vVycSlesv/LKK3rrrbeuGLNv3z6Fh4c7rU9l4Vrzul5nz57VggUL9Oqrr16y7uK2O++8U6dPn9bEiROvq/hzdF4XF7CRkZEKCQlRx44ddejQITVs2LDU270aZ+0vm82m+Ph4RUREaNSoUXbrHLG/ADjf+PHjtXDhQm3atOmSGxK5u1OnTqlHjx766KOPVKdOHVd357oVFhYqMDBQH374oTw9PdWyZUv9/PPPmjhxosuK9dLYtGmT3nzzTU2fPl1RUVE6ePCgXn75ZY0dO7bY73/AVS43/nXt2tX8OTIyUs2aNVPDhg21adMmdezY0UW9vbzo6GhFR0ebj++55x41adJEH3zwgcaOHevSvl2v2bNnKzIyUnfffbdde3nbR65S6Yr1IUOG6JlnnrlizC233FKqbQcHB0uSsrOzFRISYrZnZ2erefPmZszx48ftnldQUKATJ06Yzy+Na83rel//X//6l86cOaOePXteNTYqKkpjx45VXl6efHx8riGLSzkrr4v7LEkHDx5Uw4YNFRwcfMldHLOzs6WL9ndpOCOvU6dO6YEHHlDNmjW1ZMkSVa1a9YrxZbG/ilOnTh15enqav7ci2dnZl80hODj4ivHX8llDxeaI95WrlCaXIm+//bbGjx+vdevWqVmzZg7u6dWVNJdDhw7pyJEjeuSRR8y2wsJC6Y+ziDIyMhz6j9MrKc1+CQkJUdWqVe2OCjVp0kRWq1X5+fny9vZ2eL//rDR5vPrqq+rRo4eee+456Y8/pE+fPq2+ffvqH//4h6pU4SpKV6iI36fOGv9uueUW1alTRwcPHnR4IXg9ORWpWrWq7rzzTh08eFBy8X66nnxOnz6thQsXasyYMVd9HWfuo9K43GfJYrHIz89Pnp6e173fi1PpRtsbb7xR4eHhV1xK+2UaFham4OBgrV+/3myz2Wzavn27+d+y6OhonTx5UmlpaWbMhg0bVFhYaBaKjszrel9/9uzZevTRR3XjjTdeNTY9PV033HDDdRV+zsrr4j7rjz+49Mf+2rVrl13BnJKSIovFooiICLfNy2azKTY2Vt7e3lq2bNk1HW0ri/1VHG9vb7Vs2dLuc1FYWKj169fb/Rf5YtHR0Xbx+uP3XhR/LZ81VGyOeF+5SmlykaQJEyZo7NixWr16td19LVyppLmEh4dr165dSk9PN5dHH31U999/v9LT0xUaGurkDP6nNPulTZs2OnjwoPkPB0n64YcfFBIS4pJCXaXM48yZM5cU5EX/gHDWvWhwqYr4feqs8e+nn37Sb7/9ZlfoOkppc7rYhQsXtGvXLrO/rtxP15PP4sWLlZeXp+7du1/1dZy5j0rjap+lstjvxSr1rekqgR9//NHYuXOnOU3Zzp07jZ07d9pNV9a4cWPjs88+Mx+PHz/eCAgIMD7//HPj+++/Nzp16lTs1G133nmnsX37dmPLli3Grbfe6vSp2670+j/99JPRuHFjY/v27XbPO3DggOHh4WGsWrXqkm0uW7bM+Oijj4xdu3YZBw4cMKZPn25Uq1bNGDlypFNyMkqR18GDB40xY8YY33zzjZGZmWl8/vnnxi233GK0a9fOfE7R1G2xsbFGenq6sXr1auPGG290+tRtJckrJyfHiIqKMiIjI42DBw/aTYlRUFBgGC7YXwsXLjR8fHyM5ORkY+/evUbfvn2NgIAA8y77PXr0MF555RUz/quvvjK8vLyMt99+29i3b5/x2muvFTvVzNU+a6jYHPG+cpWS5jJ+/HjD29vb+Ne//mX3Gb/4+8lVSprLn7nTHYJLmktWVpZRs2ZNo3///kZGRoaxfPlyIzAw0Hj99dddmEXJ83jttdeMmjVrGp988olx+PBhY+3atUbDhg2NJ554woVZwKig36dlPf6dOnXK+Nvf/makpqYamZmZxrp164wWLVoYt956q3Hu3Dm3zGn06NHGmjVrjEOHDhlpaWlG165dDV9fX2PPnj12ebtqP5V2XG/btq3x5JNPXtLuDvvo1KlTZm0nyXjnnXeMnTt3Gj/++KNhGIbxyiuvGD169DDji6ZuGzp0qLFv3z5j2rRpxU7ddqXfU2lQrF9BQkKCIemSZePGjWZM0VzVRQoLC41XX33VCAoKMnx8fIyOHTsaGRkZdtv97bffjKeeesqoUaOGYbFYjGeffdapf2Bd7fUzMzMvydMwDCMpKckIDQ01Lly4cMk2V61aZTRv3tyoUaOGUb16deOOO+4wZs6cWWyso5Q0r6ysLKNdu3ZGrVq1DB8fH6NRo0bG0KFD7eZZNwzDOHLkiPHggw8afn5+Rp06dYwhQ4bYTYHmbnlt3Lix2PetJCMzM9MwXLS/pk6datSvX9/w9vY27r77bmPbtm3muvvuu89ISEiwi1+0aJFx2223Gd7e3sbtt99urFixwm79tXzWUPGV9fvKlUqSS4MGDYr9jL/22msu6r29ku6Xi7lTsW6UIpetW7caUVFRho+Pj3HLLbcYb7zxhvmPUlcqSR7nz583Ro0aZTRs2NDw9fU1QkNDjRdffNH4/fffXdR7XKwifp+W5fh35swZIzY21rjxxhuNqlWrGg0aNDD69OlzXQWTo3MaOHCgGRsUFGQ89NBDxrfffmu3PVfvp5K+7/bv329IMtauXXvJttxhH13u7+WiPBISEoz77rvvkuc0b97c8Pb2Nm655Ra7GrDIlX5PpeFhcD4TAAAAAABupdJdsw4AAAAAgLujWAcAAAAAwM1QrAMAAAAA4GYo1gEAAAAAcDMU6wAAAAAAuBmKdQAAAAAA3AzFOgAAAAAAboZiHQAAAAAAN0OxDgAAAACAm6FYBwAAAADAzVCsAwAAAADgZijWAQAAAABwM/8ft3TtMmtqfKsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "burnin = 300\n", "\n", @@ -401,10 +509,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "id": "191ea71c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+sAAADbCAYAAAAVkgB5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA+VElEQVR4nO3deVhV5fr/8Q+CbHDYkBpTopGWSGKmFpJmpnyhotLynLIcKE2z0HI4TueUOVSaZlrmUDng+aWZnivNnHHsa6IZSTmSA4ZlGyuTLQ4gsn5/fGMdd+IAsgfx/bqufV3sZ917refei/1sbtbweBmGYQgAAAAAAHiMSu7uAAAAAAAAcESxDgAAAACAh6FYBwAAAADAw1CsAwAAAADgYSjWAQAAAADwMBTrAAAAAAB4GIp1AAAAAAA8DMU6AAAAAAAehmIdAAAAAAAPQ7EOAAAAAICHoVgHAAAAAMDDUKwDAAAAAOBhKNZx3erXr5+Cg4Md2gYPHiwvLy9NmTLFbLPZbKpcubI+/PBDN/QSANyDMRIASsb4CFehWMd1KzAwUHl5eebz06dPa+bMmfLx8dHx48fN9lmzZqlq1arq3Lmzm3oKAK7HGAkAJWN8hKtQrOO6FRgYqNOnT6uoqEiSNG/ePPn4+Khdu3bmQFtUVKSPPvpISUlJqlq1qpt7DACuwxgJACVjfISrUKzjuhUYGCjDMHTy5ElJ0vvvv6+ePXuqVq1a5kC7evVqHTp0SC+88IKbewsArsUYCQAlY3yEq1Cs47oVGBgoScrLy9OmTZu0Y8cOPf/887JareZA+8EHH6ht27aKjIyUJP36669KTExU1apV1aBBA61du9atOQCAs5RljJw2bZqaNm2qypUra8SIEW7tPwA4S2nHx/z8fHXv3l116tSR1WpVixYtlJaW5uYscC2gWMd16/yB9v3339ejjz6q8PBwc6A9cuSIli5dquTkZPM1ycnJCgkJ0a+//qrx48friSee0LFjx9yYBQA4R1nGyNDQUI0YMUIdO3Z0Y88BwLlKOz4WFhbq5ptv1qZNm3T8+HH169dPjzzyiMN170BJKNZx3SoeaPft26fPPvtMffr0kSRzoJ05c6aCg4P16KOPSn8OyIsXL9bIkSNVpUoVPfroo4qOjtbnn3/u1jwAwBlKO0ZKUocOHfToo4+arwWAiqi042PVqlU1fPhw1alTR5UqVVKnTp3k6+urzMxMt+YBz0exjutW8UD79ttvq379+mrbtq3050B77NgxzZgxQ88//7x8fHykPwfkatWqqXbt2uY6oqOjtWvXLjdlAADOU9oxEgCuF1c7Pu7bt0/Hjh1T/fr1XdpvXHv4hsV1q3igXb9+vSZPnmy2W61WHTx4UJUrV1bPnj3N9ry8PFmtVod1WK1W/f777y7sNQC4RmnHSAC4XlzN+Hj69Gl16dJFw4YNU0BAgMv6jGsTxTquW1arVV5eXqpataq6detmthcPnI899phCQkLM9mrVqslutzusw263q1q1ai7sNQC4RmnHSAC4XpR1fDx79qz+/ve/q379+ho+fLhL+4xrE8U6rluVKlUy58c8X/v27WUYxgXtt956q/Ly8vTzzz/rpptukiTt3LnTYZAGgIqitGMkAFwvyjI+FhUVqWvXrvLy8tKcOXPk5eXlgp7iWsc168AVqlatmtq3b6/XXntNp0+f1tKlS/X999+rffv27u4aAHiEwsJCnTlzRufOnXP4GQCud88//7x++eUXLVy4kHt94Ip5Gfx7HLhiv/76q5KSkrRhwwbVrl1bU6dOVVxcnLu7BQAeYcSIERo5cqRD2+zZs/XMM8+4rU8A4G4//vijbr75Zvn5+cnb29tsX7Fihe6991639g2ejWIdAAAAAAAPw2nwAAAAAAB4mFIX619++aUeeeQRhYWFycvLS4sXL3ZYbhiGhg8frtDQUPn7+ysuLk779u1ziDl27Jg6d+4sq9WqwMBA9ejRQ3l5eQ4x33//ve699175+fkpPDxc48aNu6AvCxcuVGRkpPz8/BQdHa3ly5eXNh0AAAAAADxOqYv1kydP6o477tCUKVNKXD5u3Di99957mj59urZu3aqqVasqISFBZ86cMWM6d+6sXbt2KTU1VUuXLtWXX36pXr16mcvtdrvi4+NVt25dpaena/z48RoxYoQ+/PBDM2bz5s166qmn1KNHD23fvl0dOnRQhw4dtHPnztK/CwAAAAAAeJCrumbdy8tLixYtUocOHaQ/j6qHhYVp4MCB+sc//iFJys3NVXBwsFJSUtSpUyft2bNHUVFR2rZtm5o3by5JWrlypR566CH99NNPCgsL07Rp0/Svf/1LNptNvr6+kqShQ4dq8eLF2rt3ryTpySef1MmTJ7V06VKzPy1atFCTJk00ffr0K+q/YRg6ceKEqlevzvQJAHAexkcAKBnjIwBXKddr1rOysmSz2Rzujh0QEKCYmBilpaVJktLS0hQYGGgW6pIUFxenSpUqaevWrWZM69atzUJdkhISEpSZmak//vjDjPnrXbgTEhLM7ZQkPz9fdrvdfPz8888KCAjQiRMnyvFdAIBr34kTJxgfAaAEjI8AXKVci3WbzSZJCg4OdmgPDg42l9lsNgUFBTks9/HxUY0aNRxiSlrH+du4WEzx8pKMGTNGAQEB5iM8PPwqsgUAAAAAwDmuq7vBDxs2TLm5uebj8OHD7u4SAAAAAAAXKNdiPSQkRJKUk5Pj0J6Tk2MuCwkJ0dGjRx2WFxYW6tixYw4xJa3j/G1cLKZ4eUksFousVqvDAwAAAAAAT1OuxXpERIRCQkK0du1as81ut2vr1q2KjY2VJMXGxur48eNKT083Y9atW6eioiLFxMSYMV9++aXOnj1rxqSmpqpBgwa64YYbzJjzt1McU7wdAAAAXDt+/vlndenSRTVr1pS/v7+io6P1zTffmMtdOT0wAHiCUhfreXl5ysjIUEZGhvTnTeUyMjKUnZ0tLy8v9evXT6+//rqWLFmiHTt2qFu3bgoLCzPvGN+wYUM98MAD6tmzp77++mt99dVX6tOnjzp16qSwsDBJ0tNPPy1fX1/16NFDu3bt0qeffqp3331XAwYMMPvx8ssva+XKlZowYYL27t2rESNG6JtvvlGfPn3K790BAACA0/3xxx9q2bKlKleurBUrVmj37t2aMGGCeZBGLpweGAA8hlFK69evNyRd8EhKSjIMwzCKioqMV1991QgODjYsFovRrl07IzMz02Edv//+u/HUU08Z1apVM6xWq/Hss88aJ06ccIj57rvvjFatWhkWi8W46aabjLFjx17QlwULFhi33Xab4evra9x+++3GsmXLSpVLbm6uIcnIzc0t7dsAABUa4yMAVxoyZIjRqlWriy4vKioyQkJCjPHjx5ttx48fNywWi/HJJ58YhmEYu3fvNiQZ27ZtM2NWrFhheHl5GT///LNhGIYxdepU44YbbjDy8/Mdtt2gQYMr7ivjIwBXuap51q91drtdAQEBys3N5fp1ADgP4yMAV4qKilJCQoJ++uknbdy4UTfddJNefPFF9ezZU5J08OBB1atXT9u3b1eTJk3M1913331q0qSJ3n33Xc2aNUsDBw40p/nVn/dF8vPz08KFC/XYY4+pW7dustvtWrx4sRmzfv16tW3bVseOHXM4kn8xjI8AXMXH3R2Ae9w8dJnTt3FobKLTtwEAcB9nf5fwPXL9OHjwoKZNm6YBAwbon//8p7Zt26aXXnpJvr6+SkpKKtfpgSMiIi5YR/Gykor1/Px85efnm8/tdnu55Q1c76hJLo1iHQAAAG5VVFSk5s2b680335Qk3Xnnndq5c6emT5+upKQkt/ZtzJgxGjlypFv7AOD6dF3Nsw4A7nTu3Dm9+uqrioiIkL+/v+rVq6fRo0fr/KuRuNsxgOtRaGiooqKiHNoaNmyo7OxsycXTA//VsGHDlJubaz4OHz58ldkCwJWhWAcAF3nrrbc0bdo0vf/++9qzZ4/eeustjRs3TpMnTzZjuNsxgOtRy5YtlZmZ6dD2ww8/qG7dupKLpwf+K4vFIqvV6vAAAFegWAcAF9m8ebPat2+vxMRE3Xzzzfrb3/6m+Ph4ff3119KfR9UnTZqkV155Re3bt1fjxo3173//W0eOHDFvhrRnzx6tXLlSM2bMUExMjFq1aqXJkydr/vz5OnLkiCRp7ty5Kigo0KxZs3T77berU6dOeumll/TOO++4NX8AuJj+/ftry5YtevPNN7V//37NmzdPH374oZKTkyXJpdMDA4CnoFgHABe55557tHbtWv3www+SpO+++06bNm3Sgw8+KEnKysqSzWZTXFyc+ZqAgADFxMQoLS1NkpSWlqbAwEA1b97cjImLi1OlSpW0detWM6Z169by9fU1YxISEpSZmelwl2QA8BR33XWXFi1apE8++USNGjXS6NGjNWnSJHXu3NmMGTx4sPr27atevXrprrvuUl5enlauXCk/Pz8zZu7cuYqMjFS7du300EMPqVWrVg5nFQUEBGj16tXKyspSs2bNNHDgQA0fPtzh7CQA8BTcYA4AXGTo0KGy2+2KjIyUt7e3zp07pzfeeMP8Y5S7HQO4nj388MN6+OGHL7rcy8tLo0aN0qhRoy4aU6NGDc2bN++S22ncuLH+93//96r6CgCuwJF1AHCRBQsWaO7cuZo3b56+/fZbzZkzR2+//bbmzJnj7q5pzJgxCggIMB/h4eHu7hIAAMB1jWIdAFxk0KBBGjp0qDp16qTo6Gh17dpV/fv315gxYyTudgwAAIDzUKwDgIucOnVKlSo5Drve3t4qKiqSuNsxAAAAzkOxDgAu8sgjj+iNN97QsmXLdOjQIS1atEjvvPOOHnvsMYm7HQMAAOA83GAOAFxk8uTJevXVV/Xiiy/q6NGjCgsL0/PPP6/hw4ebMYMHD9bJkyfVq1cvHT9+XK1atSrxbsd9+vRRu3btVKlSJXXs2FHvvfeeubz4bsfJyclq1qyZatWqxd2OAQAArjFehmEY7u6Eu9jtdgUEBCg3N/e6O+Xz5qHLnL6NQ2MTnb4NAM5xPY+PuHLO/i7hewSeiPERKD/UJJfGafAAAAAAAHgYinUAAAAAADwMxToAAAAAAB6GYh0AAAAAAA9DsQ4AAAAAgIehWAcAAAAAwMNQrAMAAAAA4GEo1gEAAAAA8DAU6wAAAAAAeBiKdQAAAAAAPAzFOgAAAAAAHoZiHQAAAAAAD0OxDgAAAACAh6FYBwAAAADAw5R7sX7zzTfLy8vrgkdycrIkqU2bNhcs6927t8M6srOzlZiYqCpVqigoKEiDBg1SYWGhQ8yGDRvUtGlTWSwW1a9fXykpKeWdCgAAAAAAbuFT3ivctm2bzp07Zz7fuXOn/ud//kd///vfzbaePXtq1KhR5vMqVaqYP587d06JiYkKCQnR5s2b9csvv6hbt26qXLmy3nzzTUlSVlaWEhMT1bt3b82dO1dr167Vc889p9DQUCUkJJR3SgAAAAAAuFS5F+s33nijw/OxY8eqXr16uu+++8y2KlWqKCQkpMTXr169Wrt379aaNWsUHBysJk2aaPTo0RoyZIhGjBghX19fTZ8+XREREZowYYIkqWHDhtq0aZMmTpxIsQ4AAAAAuOY59Zr1goICffzxx+revbu8vLzM9rlz56pWrVpq1KiRhg0bplOnTpnL0tLSFB0dreDgYLMtISFBdrtdu3btMmPi4uIctpWQkKC0tDRnpgMAAAAAgEuU+5H18y1evFjHjx/XM888Y7Y9/fTTqlu3rsLCwvT9999ryJAhyszM1GeffSZJstlsDoW6JPO5zWa7ZIzdbtfp06fl7+9fYn/y8/OVn59vPrfb7eWYLQAAAAAA5cOpxfrMmTP14IMPKiwszGzr1auX+XN0dLRCQ0PVrl07HThwQPXq1XNmdzRmzBiNHDnSqdsAAAAAAOBqOe00+B9//FFr1qzRc889d8m4mJgYSdL+/fslSSEhIcrJyXGIKX5efJ37xWKsVutFj6pL0rBhw5Sbm2s+Dh8+XMbsAAAAAABwHqcV67Nnz1ZQUJASExMvGZeRkSFJCg0NlSTFxsZqx44dOnr0qBmTmpoqq9WqqKgoM2bt2rUO60lNTVVsbOwlt2WxWGS1Wh0eAAAAAAB4GqcU60VFRZo9e7aSkpLk4/PfM+0PHDig0aNHKz09XYcOHdKSJUvUrVs3tW7dWo0bN5YkxcfHKyoqSl27dtV3332nVatW6ZVXXlFycrIsFoskqXfv3jp48KAGDx6svXv3aurUqVqwYIH69+/vjHQAAAAAAHAppxTra9asUXZ2trp37+7Q7uvrqzVr1ig+Pl6RkZEaOHCgOnbsqC+++MKM8fb21tKlS+Xt7a3Y2Fh16dJF3bp1c5iXPSIiQsuWLVNqaqruuOMOTZgwQTNmzGDaNgAAAABAheCUYj0+Pl6GYei2225zaA8PD9fGjRv1+++/68yZM9q3b5/GjRt3wenodevW1fLly3Xq1Cn9+uuvevvttx2O0EtSmzZttH37duXn5+vAgQMOd5wHAE/1888/q0uXLqpZs6b8/f0VHR2tb775xlxuGIaGDx+u0NBQ+fv7Ky4uTvv27XNYx7Fjx9S5c2dZrVYFBgaqR48eysvLc4j5/vvvde+998rPz0/h4eEaN26cy3IEAADA1XPqPOsAgP/6448/1LJlS1WuXFkrVqzQ7t27NWHCBN1www1mzLhx4/Tee+9p+vTp2rp1q6pWraqEhASdOXPGjOncubN27dql1NRULV26VF9++aXDTBt2u13x8fGqW7eu0tPTNX78eI0YMUIffvihy3MGAABA2Th16jYAwH+99dZbCg8P1+zZs822iIgI82fDMDRp0iS98sorat++vSTp3//+t4KDg7V48WJ16tRJe/bs0cqVK7Vt2zY1b95ckjR58mQ99NBDevvttxUWFqa5c+eqoKBAs2bNkq+vr26//XZlZGTonXfecSjqAQAA4Lk4sg4ALrJkyRI1b95cf//73xUUFKQ777xTH330kbk8KytLNptNcXFxZltAQIBiYmKUlpYmSUpLS1NgYKBZqEtSXFycKlWqpK1bt5oxrVu3lq+vrxmTkJCgzMxM/fHHHy7KFgAAAFeDYh0AXOTgwYOaNm2abr31Vq1atUovvPCCXnrpJc2ZM0eSZLPZJEnBwcEOrwsODjaX2Ww2BQUFOSz38fFRjRo1HGJKWsf52/ir/Px82e12hwcAAADch9PgAcBFioqK1Lx5c7355puSpDvvvFM7d+7U9OnTlZSU5Na+jRkzRiNHjnRrHwAAAPBfHFkHABcJDQ1VVFSUQ1vDhg2VnZ0tSQoJCZEk5eTkOMTk5OSYy0JCQnT06FGH5YWFhTp27JhDTEnrOH8bfzVs2DDl5uaaj8OHD19ltgAAALgaFOsA4CItW7ZUZmamQ9sPP/ygunXrSn/ebC4kJERr1641l9vtdm3dulWxsbGSpNjYWB0/flzp6elmzLp161RUVKSYmBgz5ssvv9TZs2fNmNTUVDVo0MDhzvPns1gsslqtDg8AAAC4D8U6ALhI//79tWXLFr355pvav3+/5s2bpw8//FDJycmSJC8vL/Xr10+vv/66lixZoh07dqhbt24KCwtThw4dpD+PxD/wwAPq2bOnvv76a3311Vfq06ePOnXqpLCwMEnS008/LV9fX/Xo0UO7du3Sp59+qnfffVcDBgxwa/4AcKXGjh1rjonFzpw5o+TkZNWsWVPVqlVTx44dLziLKDs7W4mJiapSpYqCgoI0aNAgFRYWOsRs2LBBTZs2lcViUf369ZWSkuKyvACgNCjWAcBF7rrrLi1atEiffPKJGjVqpNGjR2vSpEnq3LmzGTN48GD17dtXvXr10l133aW8vDytXLlSfn5+ZszcuXMVGRmpdu3a6aGHHlKrVq0c5lAPCAjQ6tWrlZWVpWbNmmngwIEaPnw407YBuCZs27ZNH3zwgRo3buzQ3r9/f33xxRdauHChNm7cqCNHjujxxx83l587d06JiYkqKCjQ5s2bNWfOHKWkpGj48OFmTFZWlhITE3X//fcrIyND/fr103PPPadVq1a5NEcAuBJehmEY7u6Eu9jtdgUEBCg3N/e6O+Xz5qHLnL6NQ2MTnb4NAM5xPY+PuHLO/i7he+T6k5eXp6ZNm2rq1Kl6/fXX1aRJE02aNEm5ubm68cYbNW/ePP3tb3+TJO3du1cNGzZUWlqaWrRooRUrVujhhx/WkSNHzBkwpk+friFDhujXX3+Vr6+vhgwZomXLlmnnzp3mNjt16qTjx49r5cqVV9RHxkeg/FCTXBpH1gEAAOARkpOTlZiYqLi4OIf29PR0nT171qE9MjJSderUUVpamiQpLS1N0dHRDlNXJiQkyG63a9euXWbMX9edkJBgrqMkTG0JwF2Yug0AAABuN3/+fH377bfatm3bBctsNpt8fX0VGBjo0B4cHCybzWbGnF+oFy8vXnapGLvdrtOnT8vf3/+CbTO1JQB34cg6AAAA3Orw4cN6+eWXNXfuXId7dHgCprYE4C4U6wAAAHCr9PR0HT16VE2bNpWPj498fHy0ceNGvffee/Lx8VFwcLAKCgp0/Phxh9fl5OQoJCREkhQSEnLB3eGLn18uxmq1lnhUXUxtCcCNKNYBAADgVu3atdOOHTuUkZFhPpo3b67OnTubP1euXFlr1641X5OZmans7GzFxsZKkmJjY7Vjxw4dPXrUjElNTZXValVUVJQZc/46imOK1wEAnoRr1gEAAOBW1atXV6NGjRzaqlatqpo1a5rtPXr00IABA1SjRg1ZrVb17dtXsbGxatGihSQpPj5eUVFR6tq1q8aNGyebzaZXXnlFycnJslgskqTevXvr/fff1+DBg9W9e3etW7dOCxYs0LJlzr8jNQCUFsU6AAAAPN7EiRNVqVIldezYUfn5+UpISNDUqVPN5d7e3lq6dKleeOEFxcbGqmrVqkpKStKoUaPMmIiICC1btkz9+/fXu+++q9q1a2vGjBlKSEhwU1YAcHEU6wAAAPA4GzZscHju5+enKVOmaMqUKRd9Td26dbV8+fJLrrdNmzbavn17ufUTAJyFa9YBAAAAAPAwFOsAAAAAAHgYinUAAAAAADwMxToAAAAAAB6GYh0AAAAAAA/D3eABAAAAoBzdPHSZ07dxaGyi07cB9+LIOgAAAAAAHoZiHQAAAAAAD0OxDgAAAACAhyn3Yn3EiBHy8vJyeERGRprLz5w5o+TkZNWsWVPVqlVTx44dlZOT47CO7OxsJSYmqkqVKgoKCtKgQYNUWFjoELNhwwY1bdpUFotF9evXV0pKSnmnAgAAAACAWzjlyPrtt9+uX375xXxs2rTJXNa/f3998cUXWrhwoTZu3KgjR47o8ccfN5efO3dOiYmJKigo0ObNmzVnzhylpKRo+PDhZkxWVpYSExN1//33KyMjQ/369dNzzz2nVatWOSMdAAAAAABcyil3g/fx8VFISMgF7bm5uZo5c6bmzZuntm3bSpJmz56thg0basuWLWrRooVWr16t3bt3a82aNQoODlaTJk00evRoDRkyRCNGjJCvr6+mT5+uiIgITZgwQZLUsGFDbdq0SRMnTlRCQoIzUgIAAAAAwGWcUqzv27dPYWFh8vPzU2xsrMaMGaM6deooPT1dZ8+eVVxcnBkbGRmpOnXqKC0tTS1atFBaWpqio6MVHBxsxiQkJOiFF17Qrl27dOeddyotLc1hHcUx/fr1c0Y6AAAAAIBr0LU8jV65F+sxMTFKSUlRgwYN9Msvv2jkyJG69957tXPnTtlsNvn6+iowMNDhNcHBwbLZbJIkm83mUKgXLy9edqkYu92u06dPy9/fv8S+5efnKz8/33xut9vLKWsAAAAAAMpPuRfrDz74oPlz48aNFRMTo7p162rBggUXLaJdZcyYMRo5cqRb+wAAAAAAwOU4feq2wMBA3Xbbbdq/f79CQkJUUFCg48ePO8Tk5OSY17iHhIRccHf44ueXi7FarZf8h8CwYcOUm5trPg4fPlxueQIAAAAAUF6cXqzn5eXpwIEDCg0NVbNmzVS5cmWtXbvWXJ6Zmans7GzFxsZKkmJjY7Vjxw4dPXrUjElNTZXValVUVJQZc/46imOK13ExFotFVqvV4QEA7jJ27Fh5eXk53G+D6S0BAAAgZxTr//jHP7Rx40YdOnRImzdv1mOPPSZvb2899dRTCggIUI8ePTRgwACtX79e6enpevbZZxUbG6sWLVpIkuLj4xUVFaWuXbvqu+++06pVq/TKK68oOTlZFotFktS7d28dPHhQgwcP1t69ezV16lQtWLBA/fv3L+90AMAptm3bpg8++ECNGzd2aGd6SwAAAMgZxfpPP/2kp556Sg0aNNATTzyhmjVrasuWLbrxxhslSRMnTtTDDz+sjh07qnXr1goJCdFnn31mvt7b21tLly6Vt7e3YmNj1aVLF3Xr1k2jRo0yYyIiIrRs2TKlpqbqjjvu0IQJEzRjxgymbQNwTcjLy1Pnzp310Ucf6YYbbjDbi6e3fOedd9S2bVs1a9ZMs2fP1ubNm7VlyxZJMqe3/Pjjj9WkSRM9+OCDGj16tKZMmaKCggJJcpjesmHDhurTp4/+9re/aeLEiW7LGQAAAKVT7jeYmz9//iWX+/n5acqUKZoyZcpFY+rWravly5dfcj1t2rTR9u3by9xPAHCX5ORkJSYmKi4uTq+//rrZ7s7pLZktAwAAwLM4ZZ51AEDJ5s+fr2+//Vbbtm27YJk7p7dktgwAAADP4vQbzAEA/s/hw4f18ssva+7cufLz83N3dxwwWwYAAIBnoVgHABdJT0/X0aNH1bRpU/n4+MjHx0cbN27Ue++9Jx8fHwUHB7ttektmywAAAPAsFOsA4CLt2rXTjh07lJGRYT6aN2+uzp07mz+7c3pLAAAAeA6uWQcAF6levboaNWrk0Fa1alXVrFnTbC+e3rJGjRqyWq3q27fvRae3HDdunGw2W4nTW77//vsaPHiwunfvrnXr1mnBggVatmyZG7IGAABAWVCsA4AHmThxoipVqqSOHTsqPz9fCQkJmjp1qrm8eHrLF154QbGxsapataqSkpJKnN6yf//+evfdd1W7dm2mtwQAALjGUKwDgBtt2LDB4TnTWwIAAEBcsw4AAAAAgOehWAcAAAAAwMNwGjwAAAAAj3DzUOffDPXQ2ESnbwMoDxxZBwAAAADAw1CsAwAAAADgYTgNHgAAF+M0TwAAcDkcWQcAAAAAwMNQrAMAAAAA4GE4DR5O4+zTPDnFEwAAAEBFxZF1AAAAAAA8DMU6AAAA3GrMmDG66667VL16dQUFBalDhw7KzMx0iDlz5oySk5NVs2ZNVatWTR07dlROTo5DTHZ2thITE1WlShUFBQVp0KBBKiwsdIjZsGGDmjZtKovFovr16yslJcUlOQJAaVGsAwAAwK02btyo5ORkbdmyRampqTp79qzi4+N18uRJM6Z///764osvtHDhQm3cuFFHjhzR448/bi4/d+6cEhMTVVBQoM2bN2vOnDlKSUnR8OHDzZisrCwlJibq/vvvV0ZGhvr166fnnntOq1atcnnOAHA5XLMOAAAAt1q5cqXD85SUFAUFBSk9PV2tW7dWbm6uZs6cqXnz5qlt27aSpNmzZ6thw4basmWLWrRoodWrV2v37t1as2aNgoOD1aRJE40ePVpDhgzRiBEj5Ovrq+nTpysiIkITJkyQJDVs2FCbNm3SxIkTlZCQ4JbcAeBiOLIOAAAAj5KbmytJqlGjhiQpPT1dZ8+eVVxcnBkTGRmpOnXqKC0tTZKUlpam6OhoBQcHmzEJCQmy2+3atWuXGXP+OopjitcBAJ6EI+sAAADwGEVFRerXr59atmypRo0aSZJsNpt8fX0VGBjoEBscHCybzWbGnF+oFy8vXnapGLvdrtOnT8vf3/+C/uTn5ys/P998brfbyy1XALgUinUAAAB4jOTkZO3cuVObNm1yd1ekP29+N3LkSHd3A+XI2dMLA+WFYh0AAHgkV/xBfWhsotO3gSvXp08fLV26VF9++aVq165ttoeEhKigoEDHjx93OLqek5OjkJAQM+brr792WF/x3eLPj/nrHeRzcnJktVpLPKouScOGDdOAAQPM53a7XeHh4eWSLwBcCtesAwAAwK0Mw1CfPn20aNEirVu3ThEREQ7LmzVrpsqVK2vt2rVmW2ZmprKzsxUbGytJio2N1Y4dO3T06FEzJjU1VVarVVFRUWbM+esojileR0ksFousVqvDAwBcgSPrAAAAcKvk5GTNmzdPn3/+uapXr25eYx4QECB/f38FBASoR48eGjBggGrUqCGr1aq+ffsqNjZWLVq0kCTFx8crKipKXbt21bhx42Sz2fTKK68oOTlZFotFktS7d2+9//77Gjx4sLp3765169ZpwYIFWraM06IBeB6KdQAAACfidP7LmzZtmiSpTZs2Du2zZ8/WM888I0maOHGiKlWqpI4dOyo/P18JCQmaOnWqGevt7a2lS5fqhRdeUGxsrKpWraqkpCSNGjXKjImIiNCyZcvUv39/vfvuu6pdu7ZmzJjBtG0APBLFOgAAANzKMIzLxvj5+WnKlCmaMmXKRWPq1q2r5cuXX3I9bdq00fbt28vUTwBwpXK/Zn3MmDG66667VL16dQUFBalDhw7KzMx0iGnTpo28vLwcHr1793aIyc7OVmJioqpUqaKgoCANGjRIhYWFDjEbNmxQ06ZNZbFYVL9+faWkpJR3OgAAAAAAuFy5F+sbN25UcnKytmzZotTUVJ09e1bx8fE6efKkQ1zPnj31yy+/mI9x48aZy86dO6fExEQVFBRo8+bNmjNnjlJSUjR8+HAzJisrS4mJibr//vuVkZGhfv366bnnntOqVavKOyUAAAAAAFyq3E+DX7lypcPzlJQUBQUFKT09Xa1btzbbq1SpYk6j8VerV6/W7t27tWbNGgUHB6tJkyYaPXq0hgwZohEjRsjX11fTp09XRESEJkyYIElq2LChNm3apIkTJ3LdEcoN1xkCAAAAcAenT92Wm5srSapRo4ZD+9y5c1WrVi01atRIw4YN06lTp8xlaWlpio6OVnBwsNmWkJAgu92uXbt2mTFxcXEO60xISFBaWtpF+5Kfny+73e7wAABXuZLLhM6cOaPk5GTVrFlT1apVU8eOHS+YE5jLhAAAACo+pxbrRUVF6tevn1q2bKlGjRqZ7U8//bQ+/vhjrV+/XsOGDdP/+3//T126dDGX22w2h0Jdkvm8eCqPi8XY7XadPn26xP6MGTNGAQEB5iM8PLxc8wWAS7mSy4T69++vL774QgsXLtTGjRt15MgRPf744+ZyLhMCAAC4Pjj1bvDJycnauXOnNm3a5NDeq1cv8+fo6GiFhoaqXbt2OnDggOrVq+e0/gwbNkwDBgwwn9vtdgp2AC5zucuEcnNzNXPmTM2bN09t27aV/py2qGHDhtqyZYtatGjBZUIAAADXCacdWe/Tp4+WLl2q9evXq3bt2peMjYmJkSTt379fkhQSEnLBaZ/Fz4uvc79YjNVqlb+/f4nbsVgsslqtDg8AcJe/XiaUnp6us2fPOlziExkZqTp16piX+HCZEAAAwPWh3I+sG4ahvn37atGiRdqwYYMiIiIu+5qMjAxJUmhoqCQpNjZWb7zxho4ePaqgoCBJUmpqqqxWq6KiosyYv86jmZqaqtjY2PJOCQDKXUmXCdlsNvn6+iowMNAhNjg4+LKXAKkUlwmV9A/NMWPGaOTIkeWcJQAAuJa54mbLuLhyP7KenJysjz/+WPPmzVP16tVls9lks9nM68gPHDig0aNHKz09XYcOHdKSJUvUrVs3tW7dWo0bN5YkxcfHKyoqSl27dtV3332nVatW6ZVXXlFycrIsFoskqXfv3jp48KAGDx6svXv3aurUqVqwYIH69+9f3ikBQLkrvkxo/vz57u6K9OdlQrm5uebj8OHD7u4SAADAda3ci/Vp06YpNzdXbdq0UWhoqPn49NNPJUm+vr5as2aN4uPjFRkZqYEDB6pjx4764osvzHV4e3tr6dKl8vb2VmxsrLp06aJu3bpp1KhRZkxERISWLVum1NRU3XHHHZowYYJmzJjB9ZgAPN7FLhMKCQlRQUGBjh8/7hCfk5Nz2UuAxGVCAAAAFYpTToO/lPDwcG3cuPGy66lbt+4Fp7n/VZs2bbR9+/ZS9xEA3OFylwk1a9ZMlStX1tq1a9WxY0dJUmZmprKzs81LfLhMCAAA4Prg1LvBAwD+Kzk5WfPmzdPnn39uXiYkSQEBAfL391dAQIB69OihAQMGqEaNGrJarerbt69iY2PVokUL6S+XCY0bN042m63Ey4Tef/99DR48WN27d9e6deu0YMECLVvGdWcAAADXCqfOsw4A+K/LXSYkSRMnTtTDDz+sjh07qnXr1goJCdFnn31mLucyIQAAgOsDR9YBwEUud5mQJPn5+WnKlCmaMmXKRWO4TAgAAKDi48g6AAAAAAAehmIdAAAAAAAPQ7EOAAAAAICH4Zr1Urp5qPPvpnxobKLTtwEAAAAA8FwcWQcAAAAAwMNQrAMAAAAA4GEo1gEAAAAA8DBcsw4AQAXkinusAAAA56FYBwAA1y3+qQEA8FScBg8AAAAAgIfhyDoAAAAAXGM4M6ji48g6AAAAAAAehmIdAAAAAAAPw2nwgJu54hSmQ2MTnb4NAAAAAOWHI+sAAAAAAHgYjqzjmsVNNQAAAABUVBxZBwAAAADAw1CsAwAAAADgYSjWAQAAAADwMBTrAAAAAAB4GIp1AAAAAAA8DHeDB64DzOUOXDlmmgAAAJ6AI+sAAAAAAHgYinUAAAAAADzMNX8a/JQpUzR+/HjZbDbdcccdmjx5su6++253dwsA3I7xEQBKVhHHRy55Ayqea7pY//TTTzVgwABNnz5dMTExmjRpkhISEpSZmamgoCB3dw8A3IbxEQBK5q7xsSLcD6Mi5ABcS67p0+Dfeecd9ezZU88++6yioqI0ffp0ValSRbNmzXJ31wDArRgfAaBkjI8ArhXX7JH1goICpaena9iwYWZbpUqVFBcXp7S0tBJfk5+fr/z8fPN5bm6uJMlut1/xdovyT11Vv69EafpTVq7IA9eXOv0XOn0bO0cmOH0bZVG9enV5eXm5uxsmd42PjV5bdVX9BlB2njoGMz7+F397ARVXWeu3y42R12yx/ttvv+ncuXMKDg52aA8ODtbevXtLfM2YMWM0cuTIC9rDw8Od1s+yCJjk7h4AnslTPxu5ubmyWq3u7oapIo+PANynLGMw4yOA60FZ/0a93Bh5zRbrZTFs2DANGDDAfF5UVKRjx46pZs2aZfqvr91uV3h4uA4fPuxRX0TlgdyuPRU1L10DuVWvXt3dXbhq5T0+Xg1P399XoyLnpgqeH7mVDeOj+1XE392KllNFy0cVMCdn5XO5MfKaLdZr1aolb29v5eTkOLTn5OQoJCSkxNdYLBZZLBaHtsDAwKvui9VqrRC/hCUht2tPRc1LFTy38uRJ4+PVqMj7uyLnpgqeH7ld2yrK+FgWFXH/VrScKlo+qoA5uTqfa/YGc76+vmrWrJnWrl1rthUVFWnt2rWKjY11a98AwJ0YHwGgZIyPAK4l1+yRdUkaMGCAkpKS1Lx5c919992aNGmSTp48qWeffdbdXQMAt2J8BICSMT4CuFZc08X6k08+qV9//VXDhw+XzWZTkyZNtHLlygtuGuIsFotFr7322gWnRlUE5Hbtqah5qYLn5izuHh+vRkXe3xU5N1Xw/Mit4riWx8eyqIj7t6LlVNHyUQXMyV35eBmGYbh0iwAAAAAA4JKu2WvWAQAAAACoqCjWAQAAAADwMBTrAAAAAAB4GIp1AAAAAAA8DMX6Jbzxxhu65557VKVKFQUGBl7RawzD0PDhwxUaGip/f3/FxcVp3759DjHHjh1T586dZbVaFRgYqB49eigvL89JWZSstH04dOiQvLy8SnwsXLjQjCtp+fz5812U1f8py/vbpk2bC/rdu3dvh5js7GwlJiaqSpUqCgoK0qBBg1RYWOjkbByVNrdjx46pb9++atCggfz9/VWnTh299NJLys3NdYhzx36bMmWKbr75Zvn5+SkmJkZff/31JeMXLlyoyMhI+fn5KTo6WsuXL3dYfiWfPXiO8t7/nqQ0uX300Ue69957dcMNN+iGG25QXFzcZd8Ldyrtfis2f/58eXl5qUOHDk7v49UobX7Hjx9XcnKyQkNDZbFYdNttt3ns72Zpc5s0aZL53REeHq7+/fvrzJkzLusvLq4ifn+W97j5zDPPXPB3zQMPPOCCTP6rNDmlpKRc0F8/Pz+HGHfvp9LkU9Lf1V5eXkpMTDRj3L2PvvzySz3yyCMKCwuTl5eXFi9efNnXbNiwQU2bNpXFYlH9+vWVkpJyQUxZvycvysBFDR8+3HjnnXeMAQMGGAEBAVf0mrFjxxoBAQHG4sWLje+++8549NFHjYiICOP06dNmzAMPPGDccccdxpYtW4z//d//NerXr2889dRTTszkQqXtQ2FhofHLL784PEaOHGlUq1bNOHHihBknyZg9e7ZD3Pm5u0JZ3t/77rvP6Nmzp0O/c3NzzeWFhYVGo0aNjLi4OGP79u3G8uXLjVq1ahnDhg1zQUb/VdrcduzYYTz++OPGkiVLjP379xtr1641br31VqNjx44Oca7eb/Pnzzd8fX2NWbNmGbt27TJ69uxpBAYGGjk5OSXGf/XVV4a3t7cxbtw4Y/fu3cYrr7xiVK5c2dixY4cZcyWfPXgGZ+x/T1Ha3J5++mljypQpxvbt2409e/YYzzzzjBEQEGD89NNPLu/75ZQ2t2JZWVnGTTfdZNx7771G+/btXdbf0iptfvn5+Ubz5s2Nhx56yNi0aZORlZVlbNiwwcjIyHB53y+ntLnNnTvXsFgsxty5c42srCxj1apVRmhoqNG/f3+X9x2OKuL3pzPGzaSkJOOBBx5w+Lvm2LFjLsmnLDnNnj3bsFqtDv212WwOMe7cT6XN5/fff3fIZefOnYa3t7cxe/ZsM8bd+2j58uXGv/71L+Ozzz4zJBmLFi26ZPzBgweNKlWqGAMGDDB2795tTJ482fD29jZWrlxpxpT1e/JSKNavwOzZs6+oWC8qKjJCQkKM8ePHm23Hjx83LBaL8cknnxiGYRi7d+82JBnbtm0zY1asWGF4eXkZP//8s5MycFRefWjSpInRvXt3h7Yr+WV3prLmdt999xkvv/zyRZcvX77cqFSpksPAOW3aNMNqtRr5+fnlmMHFldd+W7BggeHr62ucPXvWbHP1frv77ruN5ORk8/m5c+eMsLAwY8yYMSXGP/HEE0ZiYqJDW0xMjPH8888bxhV+9uA5ynv/e5LS5vZXhYWFRvXq1Y05c+Y4sZdlU5bcCgsLjXvuuceYMWOGkZSU5NHFemnzmzZtmnHLLbcYBQUFLuxl2ZQ2t+TkZKNt27YObQMGDDBatmzp9L7i0iri96czxk13jzelzelytYa799PV7qOJEyca1atXN/Ly8sw2d++j813J38GDBw82br/9doe2J5980khISDCfX+37VBJOgy9HWVlZstlsiouLM9sCAgIUExOjtLQ0SVJaWpoCAwPVvHlzMyYuLk6VKlXS1q1bXdLP8uhDenq6MjIy1KNHjwuWJScnq1atWrr77rs1a9Ys/d9nwDWuJre5c+eqVq1aatSokYYNG6ZTp045rDc6OlrBwcFmW0JCgux2u3bt2uWkbByV1+9Obm6urFarfHx8HNpdtd8KCgqUnp7u8DmpVKmS4uLizM/JX6WlpTnE68/3vzj+Sj578AzO2P+eoiy5/dWpU6d09uxZ1ahRw4k9Lb2y5jZq1CgFBQWV+F3hScqS35IlSxQbG6vk5GQFBwerUaNGevPNN3Xu3DkX9vzyypLbPffco/T0dPP0zYMHD2r58uV66KGHXNZvXKgifn86c9zcsGGDgoKC1KBBA73wwgv6/fffy73/JSlrTnl5eapbt67Cw8PVvn17h78v3bmfymMfzZw5U506dVLVqlUd2t21j8ricp+l8nifSuJzBTG4QjabTZIcCrri58XLbDabgoKCHJb7+PioRo0aZowr+nm1fZg5c6YaNmyoe+65x6F91KhRatu2rapUqaLVq1frxRdfVF5enl566aVyzeFiyprb008/rbp16yosLEzff/+9hgwZoszMTH322Wfmekvarzpvvztbeey33377TaNHj1avXr0c2l2533777TedO3euxPdz7969Jb7mYu//+Z8rXeazB8/gjP3vKcqS218NGTJEYWFhF/xB4G5lyW3Tpk2aOXOmMjIyXNTLsitLfgcPHtS6devUuXNnLV++XPv379eLL76os2fP6rXXXnNRzy+vLLk9/fTT+u2339SqVSsZhqHCwkL17t1b//znP13Ua5SkIn5/OmvcfOCBB/T4448rIiJCBw4c0D//+U89+OCDSktLk7e3d7nncb6y5NSgQQPNmjVLjRs3Vm5urt5++23dc8892rVrl2rXru3W/XS1++jrr7/Wzp07NXPmTId2d+6jsrjYZ8lut+v06dP6448/rvp3uSTXXbE+dOhQvfXWW5eM2bNnjyIjI13Wp/JypbldrdOnT2vevHl69dVXL1h2ftudd96pkydPavz48Vdd9Dk7t/OL1+joaIWGhqpdu3Y6cOCA6tWrV+b1XglX7Te73a7ExERFRUVpxIgRDsuctd8AXLmxY8dq/vz52rBhwwU3FrrWnDhxQl27dtVHH32kWrVqubs7TlFUVKSgoCB9+OGH8vb2VrNmzfTzzz9r/PjxHlWsl8WGDRv05ptvaurUqYqJidH+/fv18ssva/To0SV+9wPucrFxs1OnTubP0dHRaty4serVq6cNGzaoXbt2burtxcXGxio2NtZ8fs8996hhw4b64IMPNHr0aLf27WrNnDlT0dHRuvvuux3ar7V95C7XXbE+cOBAPfPMM5eMueWWW8q07pCQEElSTk6OQkNDzfacnBw1adLEjDl69KjD6woLC3Xs2DHz9WV1pbldbR/+85//6NSpU+rWrdtlY2NiYjR69Gjl5+fLYrFcQRYlc1Vu5/dbkvbv36969eopJCTkgrs55uTkSOft97JyRW4nTpzQAw88oOrVq2vRokWqXLnyJePLa7+VpFatWvL29jbfv2I5OTkXzSMkJOSS8Vfy2YNncMb+9xRlya3Y22+/rbFjx2rNmjVq3Lixk3taeqXN7cCBAzp06JAeeeQRs62oqEj684ygzMxMp/8jtDTKsu9CQ0NVuXJlhyNADRs2lM1mU0FBgXx9fZ3e7ytRltxeffVVde3aVc8995z05x/SJ0+eVK9evfSvf/1LlSpxFaU7VMTvT1eNm7fccotq1aql/fv3O70QvJqcilWuXFl33nmn9u/fL7l5P11NPidPntT8+fM1atSoy27HlfuoLC72WbJarfL395e3t/dV7/eSXHej7Y033qjIyMhLPsr6BRsREaGQkBCtXbvWbLPb7dq6dav537LY2FgdP35c6enpZsy6detUVFRkFojOzu1q+zBz5kw9+uijuvHGGy8bm5GRoRtuuOGqCz5X5XZ+v/XnH2P6c7/t2LHDoVhOTU2V1WpVVFSUR+dmt9sVHx8vX19fLVmy5IqO2JXXfiuJr6+vmjVr5vA5KSoq0tq1ax3+q3y+2NhYh3j9+f4Xx1/JZw+ewRn731OUJTdJGjdunEaPHq2VK1c63JPCk5Q2t8jISO3YsUMZGRnm49FHH9X999+vjIwMhYeHuziDSyvLvmvZsqX2799v/hNCkn744QeFhoZ6TKGuMuZ26tSpCwry4n9KuPI+NHBUEb8/XTVu/vTTT/r9998dCl1nKWtO5zt37px27Nhh9ted++lq8lm4cKHy8/PVpUuXy27HlfuoLC73WSqP/V6iMt+a7jrw448/Gtu3bzenKNu+fbuxfft2h6nKGjRoYHz22Wfm87FjxxqBgYHG559/bnz//fdG+/btS5y67c477zS2bt1qbNq0ybj11lvdMnXbpfrw008/GQ0aNDC2bt3q8Lp9+/YZXl5exooVKy5Y55IlS4yPPvrI2LFjh7Fv3z5j6tSpRpUqVYzhw4e7JKdipc1t//79xqhRo4xvvvnGyMrKMj7//HPjlltuMVq3bm2+pnjqtvj4eCMjI8NYuXKlceONN7pl6rbS5Jabm2vExMQY0dHRxv79+x2mxygsLDQMN+23+fPnGxaLxUhJSTF2795t9OrVywgMDDTvtt+1a1dj6NChZvxXX31l+Pj4GG+//baxZ88e47XXXitx6pnLffbgGZyx/z1FaXMbO3as4evra/znP/9x+Hye/z3jKUqb21950p1/S1La/LKzs43q1asbffr0MTIzM42lS5caQUFBxuuvv+7GLEpW2txee+01o3r16sYnn3xiHDx40Fi9erVRr14944knnnBjFjAq6PdneY+bJ06cMP7xj38YaWlpRlZWlrFmzRqjadOmxq233mqcOXPGI3MaOXKksWrVKuPAgQNGenq60alTJ8PPz8/YtWuXQ97u2k9lHf9btWplPPnkkxe0e8I+OnHihFnbSTLeeecdY/v27caPP/5oGIZhDB061OjatasZXzx126BBg4w9e/YYU6ZMKXHqtku9T2VBsX4JSUlJhqQLHuvXrzdjiuenLlZUVGS8+uqrRnBwsGGxWIx27doZmZmZDuv9/fffjaeeesqoVq2aYbVajWeffdblf5hdrg9ZWVkX5GoYhjFs2DAjPDzcOHfu3AXrXLFihdGkSROjWrVqRtWqVY077rjDmD59eomxzlTa3LKzs43WrVsbNWrUMCwWi1G/fn1j0KBBDvOsG4ZhHDp0yHjwwQcNf39/o1atWsbAgQMdpj/zxNzWr19f4u+wJCMrK8sw3LjfJk+ebNSpU8fw9fU17r77bmPLli3msvvuu89ISkpyiF+wYIFx2223Gb6+vsbtt99uLFu2zGH5lXz24DnKe/97ktLkVrdu3RI/n6+99pqben9ppd1v5/P0Yt0oQ36bN282YmJiDIvFYtxyyy3GG2+8Yf4j1NOUJrezZ88aI0aMMOrVq2f4+fkZ4eHhxosvvmj88ccfbuo9zlcRvz/Lc9w8deqUER8fb9x4441G5cqVjbp16xo9e/a8qoLJ2Tn169fPjA0ODjYeeugh49tvv3VYn7v3U2l/7/bu3WtIMlavXn3BujxhH13sb+TiPJKSkoz77rvvgtc0adLE8PX1NW655RaHGrDYpd6nsvAyOJ8JAAAAAACPct1dsw4AAAAAgKejWAcAAAAAwMNQrAMAAAAA4GEo1gEAAAAA8DAU6wAAAAAAeBiKdQAAAAAAPAzFOgAAAAAAHoZiHQAAAAAAD0OxDgAAAACAh6FYBwAAAADAw1CsAwAAAADgYSjWAQAAAADwMP8fZDDFoWZ9bpsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", "for i, axi in enumerate(ax):\n", @@ -415,10 +534,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "id": "4032de45", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", "for i, axi in enumerate(ax):\n", @@ -429,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "db7cd2eb", "metadata": {}, "outputs": [], @@ -441,7 +571,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "id": "a58e1879", "metadata": {}, "outputs": [], @@ -451,7 +581,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 22, "id": "2e3a9df9", "metadata": {}, "outputs": [], @@ -461,33 +591,74 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "id": "5a6a5dc6", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[26, 1],\n", + " [ 0, 23]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import sklearn\n", "sklearn.metrics.confusion_matrix(y, pred)" ] }, + { + "cell_type": "markdown", + "id": "3c670f3d-0e3a-42d6-9f62-718397695a74", + "metadata": {}, + "source": [ + "Above: confusion matrix for SMC in sample" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "id": "1bc4fd5c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[19, 8],\n", + " [ 0, 23]])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "sklearn.metrics.confusion_matrix(y, pred2)" ] }, + { + "cell_type": "markdown", + "id": "c40e4753-633a-4a06-8dfd-4d5fa2c62b3b", + "metadata": {}, + "source": [ + "Above: confusion matrix for MH in sample" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 25, "id": "6834a6e5", "metadata": {}, "outputs": [], "source": [ "def posterior_predictive_plot(samples):\n", + " from matplotlib import cm, ticker\n", " xmin, ymin = X.min(axis=0) - 0.1\n", " xmax, ymax = X.max(axis=0) + 0.1\n", " step = 0.1\n", @@ -500,29 +671,132 @@ " Z_mcmc = Z_mcmc.mean(axis=0)\n", " \n", " plt.contourf(*Xspace, Z_mcmc)\n", + " plt.legend()\n", " plt.scatter(*X.T, c=colors)\n", " plt.xlabel(r\"$X_0$\")\n", - " plt.ylabel(r\"$X_1$\");" + " plt.ylabel(r\"$X_1$\")\n", + " plt.show();\n", + " return Z_mcmc" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 26, "id": "c36ad97c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62480/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "posterior_predictive_plot(chains)" + "Z_mcmc = posterior_predictive_plot(chains)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, + "id": "040ca9fc-694d-4eee-b5f2-be03bfc32c5b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array([[0.4520933 , 0.4540293 , 0.45596862, ..., 0.53816384, 0.54008245,\n", + " 0.5419968 ],\n", + " [0.4537641 , 0.45570213, 0.45764345, ..., 0.5398365 , 0.5417531 ,\n", + " 0.5436653 ],\n", + " [0.4554368 , 0.45737684, 0.45931998, ..., 0.5415082 , 0.5434227 ,\n", + " 0.5453327 ],\n", + " ...,\n", + " [0.5430625 , 0.5450165 , 0.5469687 , ..., 0.6252578 , 0.6269905 ,\n", + " 0.6287157 ],\n", + " [0.5447219 , 0.54667443, 0.54862505, ..., 0.62677556, 0.62850374,\n", + " 0.6302244 ],\n", + " [0.54637897, 0.54832995, 0.55027884, ..., 0.62828875, 0.63001245,\n", + " 0.6317284 ]], dtype=float32)" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Z_mcmc" + ] + }, + { + "cell_type": "markdown", + "id": "f211fa23-d779-4829-9666-2802e81f500e", + "metadata": {}, + "source": [ + "It seems that MH as is implemented in the example assigns to all points probabilities around 45-65. Very close to 50%" + ] + }, + { + "cell_type": "code", + "execution_count": 28, "id": "0aa89f5a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62480/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAKpCAYAAABKPfTmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABoYUlEQVR4nO3deZxldX3n//f33K326qred5pGG9HQKBIWMwYVUXSMmkTJJGOM489kHDAh5PdLZIyaRA0uMQ8nIyFOTIJDZHDiiHGJgiECcRDZJApoK01DN713177d5Zzv749bt3q7W1Xde8/3nPN6Ph71kK6+3fUFu6vOqz7f8z3GWmsFAAAAAADawgt7AQAAAAAAxBnhDQAAAABAGxHeAAAAAAC0EeENAAAAAEAbEd4AAAAAALQR4Q0AAAAAQBsR3gAAAAAAtFFswttaq4mJCfFYcgAAAACAS9JhL6BVJicnNTg4qPNu/32lenJhLwdVXLllV9hLAABg2d42dH/YSwAAOGTnln0NXxObiTfcd9feHWEvAQCAZbt19LKwlwAAiBjCGx1FfAMA4oD4BgAsBuGNjrtr7w4CHAAQebeOXkaAAwCaQngjNMQ3ACAOiG8AQCOEN0JFfAMA4oD4BgDUE5tTzRFdlfjm1HMAQJTdOnoZJ54DQMTYoEsKhiWZaj8reSMy3tyyPw7hDWfctXcH8Q0AiLTK5DvRAR5I5tGUvO+lpKKRPcdX8MqS1BP2wgDgBGuN7MwvyxRfJWMyNcPb2qKCzN0yPV+UMXbJH89Ya5f+qx0yMTHBc7xjhAAHAERdIuP7qFH6D7vk7UnJpuYvMX1JXVLpfXOyF/thrxAAJEnB9FuU8t+gVauG1NVtZKp0t7XS3KzVsWOj8lNfldf7D1V/L57jjcji3m8AQNQl7r7vkpR+b7fM3vLlpfFN+U1GykvpP+qSeYpLTwDhs0G3TPFVWrVqSCuGPHV1GeVyZ751dRmtGPK0atWQTPFV5W3pS8RnPziL+AYARF2S4tt8NyVvnyfjnzk2Mrb8Pu8fMiGsDIi42fk3tE4wJGMy6uqutr38TOWJeGb+XvClIbzhNJ75DQCIuqTEt/d/07Je7TsYjW/kfSctxeImR6DNrOTdlVb6N7uVfWOfsm/sU/q/dMv7Nn+HWsNIqr69vOqrzYlfs1SENyKB+AYARNmto5fFPsDNnJGCBq8pGqIBaMRKqU9nlf6zLplnT+Sa2e0pfWOXUn+bDXV5WBrCG5HB9BsAEHVxjm+7Nah7ZWmNld1Y/zUAJPNwSqmvluO6cpvGyf+c+kJW5gn+IkUN/48hcohvAECUxTW+/dcVG06z/V8odmo5QGSlvpKpe9uGTVl5X+G8hKghvBFJxDcAIMpiGd9rrfx3FyTplGiwsuVp9wW+gn9PeAONmN2eTFD7XmLjG5ndZFzUpMNeALBUlfjmmd8AgCiqxHecnvcdvKmo4rpAqduzMk+myu8ctvLfWFTwS0WJIR3QkM3VP8LLykq5Di4oloLyf8kG51JUlF9nJeMv+SMS3oi8u/buIL4BAJF16+hlsYpve4mv0iWz0rSkoqQB9lgCi2H/XUn2f2dqT72NFPy7UqeXFS+powrsqA4f7tfKld3KZEz173ZYqVi0On58VoEdlfGOLflDEt6IBabfAIAoi1t8S5J6w14AEE3+G4ry/jEjm7dnxLf1rNQrBa/lto3lMKYk9f+pZmd+TQcO/oyMUjUeFWZl5ct6P5Dpv63865b6Ma21sXiow8TEhAYHB3Xe7b+vVA97L5KM+AYARFXs4hvAkpgnPaXf3y1NSpq/a8P4RnZFoNKfzsme0+QeadRlrZFsvxT01QxveVOSmZQxtbN555Z9DT8W4Y3YIsABAFFEfAOQJM1J3r1pmcfL5W13+gpeXpJ4jLdzCG8kHvENAIgqAhwAoqGZ8OaoC8Qajx0DAERVLB85BgAJRXgj9u7au4MABwBEEvENAPFAeCMxiG8AQBQR3wAQfYQ3EoXpNwAgim4dvYwAB4AII7yRSMQ3ACCKiG8AiCbCG4lFfAMAooj4BoDoIbyRaGw9BwBEEfENANFCeANMvwEAEcR93wAQHYQ3MI/pNwAgiohvAHAf4Q2chvgGAEQN8Q0AbiO8gSqYfgMAoob4BgB3Ed5AHcQ3ACBKuO8bANxEeAMNEN8AgKghvgHALYQ30AS2ngMAoob4BgB3EN7AIhDfAIAoIb4BwA2EN7BITL8BAFHCfd8AED7CG1gi4hsAECXEd8TkJfOdlLxvpGUeSUl+2AsCsBzpsBcARNlde3foyi27wl4GAABNuXX0Mr1t6P6wl4F6rOR9OaPU57IyM+bEu1cGKl2Xl72YAgeiiIk3sExsPQcARAmTb7d5/yej9M25U6JbkjRilP5AV3n6DSByCG+gRYhvAEBUcN+3o2ak1OeyVX/K2HKIp/5HVrIdXheAZSO8gRZi+g0AiBLi2y3e/WmZvKn588YaeXtS0t7arwHgJsIbaAPiGwAQFcS3Q8aMrNd4nG3GuIQHooa/tUCbMP0GAEQFW88dsdrKBI2n2XZV0JHlAGgdwhtoM+IbABAVxHe4gktKsr1WtsZN3NazCs7zpY3c5A1EDeENdADxDQCICuI7RDnJf3deRuaM+LbGSp7k/1Y+tOUBWDrCG+gQtp4DAKKC+A5PcGVJpRvmpDWnhffZgUqfmJV9AdvMgShKh70AIGnu2rtDV27ZFfYyAACoqxLfbxu6P+ylJE7wipKCny/J/MiTJoy01sqeTXADUcbEGwgB028AQFQw/Q6JJ9kXBrKX+kS3VH52+V5T/mbEWNiLARaP8AZCRHwDAKKA+EaYzHdSSr+rR9n/p1eZ3+lR5ld6lfpQTjrE88wRHYQ3EDKm3wCAKOCRYwiD9420Mn/SLbPvRGSbwMi7P63Me7qlw8Q3ooHwBhxBfAMAooD4RsdMS6mbcrKyMvbUwDa+kaaMUn+XDW15wGIQ3oBDiG8AQBQQ3+gE7560VJCMqk+1jW/k3ZuWpju+NGDRCG/AMWw9BwBEAfGNdjOHvIbPYDK+kY6z3RzuI7wBRxHfAADXcd832sn2WamZA917O7AYYJkIb8BhTL8BAFFAfKMdgpeX6oa39ayCF5WklbaTywKWhPAGIoD4BgC4jvhGy623Cq4qyZozw9oaK1nJf3sxlKUBi9XgrgkArqjE95VbdoW9FAAAqqrE99uG7g97KYgJ/z15KSV5X5/PFm/+vu4+qfT/zsnu9MNeItAUY62Nxd6MiYkJDQ4O6rzbf1+pnlzYywHaivgGALiO+EZLHTPy/m9ampHsxkD2El/iSWJwxM4t+xq+hq3mQARx7zcAwHVsPUdLrbIK3lhU8B+Ksi8nuhE9hDcQYcQ3AMBlnHoOAGWENxBxxDcAwHXEN4CkI7yBGGDrOQDAdcQ3gCQjvIEYIb4BAC5j6zmApCK8gZhh+g0AcF2i4vuIkfeVjLwvZGS+m5J4+hWQSDzHG4ipu/bu4LFjAABn3Tp6WbwfOVaQUp/Oybtz/nLbSCYwskOBSu/Ny76YAgeShIk3EGNMvwEALovz5Dv1yXJ0G2vKb4Ep/8SYUfp9XTK7uAwHkoS/8UACEN8AAFfF8b5v84yn1LczMtac+XPWSIGU+nseRA0kCeENJATTbwCAy+IU3949admUrfnzJjAyD6ak6Y4uC0CICG8gYYhvAICrYhPfk41fYqyRps+ciAOIJ8IbSCDiGwDgqjhsPbfrrBQ0eE3WSitqT8UBxAvhDSQUW88BAC6LcnwHV5TqXmVbzyp4dUniNm8gMQhvIOGIbwCAqyIb30NW/jsLkiSrU6faNmXLP/8fCyEtDkAYeI43gIX45rnfAADXVOI7as/8Dn65qNIKq9StWelg+V5u61kFLyvJ/62CtJJt5kCSEN4AFty1dwfxDQBw0q2jl0Uvvq8oKXhlSeZZT5qV7IZAWhH2qgCEga3mAE7Bvd8AAFdFcuu5J9ltgex5RDeQZIQ3gKqIbwCAi+Jw6jmA5CG8AdTE9BsA4CriG0CUOBHeN998s84//3wNDAxoYGBAl156qb7xjW+EvSwA84hvAICLiG8AUeFEeG/atEkf/ehH9cgjj+jhhx/WK1/5Sr3xjW/UE088EfbSAMxj+g0AcBFbzwFEgbHWOvksg+HhYX3iE5/QO9/5zqZePzExocHBQZ13++8r1ZNr+/qAJOPkcwCAi6J26jmAeNi5ZV/D1zgx8T6Z7/u6/fbbNT09rUsvvbTm6/L5vCYmJk55A9AZTL4BAC5i8g3AVc6E9w9/+EP19fUpl8vpP//n/6w77rhD5513Xs3X33jjjRocHFx427x5c0fXCyQdW88BAC5i6zkAFzmz1bxQKGjv3r0aHx/XF7/4RX32s5/VvffeWzO+8/m88vn8wo8nJia0efNmtpoDIWDrOQDARWw9B9AJzWw1dya8T3fFFVdo+/bt+sxnPtPU67nHGwgfAQ4AcBEBDqCdInmPd0UQBKdMtAG4j63nAAAXsfUcQNjSYS9Akm644QZdddVV2rJliyYnJ3Xbbbfpnnvu0Z133hn20gAsUiW+mX4DAFxy6+hlTL4BhMaJ8D5y5Ih+/dd/XQcPHtTg4KDOP/983XnnnXr1q18d9tIALNFde3cQ3wAAp1Qm3wQ4gE5z9h7vxeIeb8BdBDgAwDXEN4BWifQ93gDig3u/AQCu4b5vAJ1EeAPoCJ77DQBwDc/8BtAphDeAjiK+AQCuIb4BtBvhDaDjmH4DAFxDfANoJ8IbQGiIbwCAS9h6DqBdCG8AoSK+AQCuIb4BtBrhDSB0bD0HALiG6TeAViK8ATiD+AYAuIb4BtAKhDcApzD9BgC4hvgGsFyENwAnEd8AAJew9RzAchDeAJzF9BsA4BriG8BSEN4AnEd8AwBcwvQbwGIR3gAigek3AMA1xDeAZhHeACKF+AYAuIT4BtAMwhtA5DD9BgC4hK3nABohvAFEFvENAHAJ8Q2gFsIbQKQx/QYAuIT4BlAN4Q0gFohvAIAr2HoO4HSEN4DYYPoNAHAJ8Q2ggvAGEDvENwDAFUy/AYjwBhBXTL8BAC4hvoFkI7wBxBrxDQBwBdNvILkIbwCxx/QbAOAS4htIHsIbQGIQ3wAAVxDfQLIQ3gAShek3AMAVbD0HkoPwBpBIxDcAwBXENxB/hDeAxCK+AQCuYPoNxBvhDSDR2HoOAHAJ8Q3EE+ENAEy/AQAOIb6B+CG8AWAe028AgCvYeg7EC+ENAKchvgEAriC+gXggvAGgCqbfAABXMP0Goo/wBoA6iG8AgCuIbyC6CG8AaIDpNwDAFUy/gWgivAGgScQ3AMAVxDcQLYQ3ACwC028AgCuYfgPRQXgDwBIQ3wAAVxDfgPtiF97Tzw5oas9g2MsAkABMvwEAriC+AbfFLrwriG8AnUJ8Ay0UWKUKgWRt2CsBIoet54C70mEvoJ0q8d23bTzspQCIuUp8X7llV9hLASJpcP+czv/KUW3/zphSJavZgZR+/OqVevz1q1XoTYW9vFgxgdWm709q079NyitZHdverd0vW6FSF/+d4+LW0cv0tqH7w14GgJMYa+PxLeWJiQkNDg5q68c+LK+rq+prCHAAnUB8A4uz+ifTuurDTytVtPKCE+8PPGliXU5f+5PtyvfHelbQMX1HCnrNjXu04kBefkoykowvFbs83f17W3Xg/P6wl4gWI8CB9tu5ZV/D18R2q3k1bD8H0Anc+w00zwRWr/zU3jOiW5K8QBo4lNdFnz8Y1vJiJVUIdNWHdmvgUL78Y1/y/HJ8p/OBrvzYM1rx3FzYy3Re/+G8XnrbQb32Q7v16o/u0bl3HVdm1g97WTWx9RxwQ6LCW/PxTYAD6ATiG2hs479Nqu948YzorvAC6Zx/HVN22t2wiYptD4xr4Ej1/9aeLX8T5EVfPxrG0iJjx93H9cu/s0s/89Wj2vj4tDZ/f1KX/c1+veW3f6yhZ2fDXl5N3PsNhC9x4V1BgAPoBKbfQH3Dz8wpaHA1kipZDRzMd2pJsbX1wXEFpvbPe4F01gPcllfLuien9LL/sV+e1cI3L8z8W27K11Uf2aNUvsZ3kBxBfAPhSWx4VxDfADqB+Aaq87NGauK0GT9bpxjRlPRcIK/Bf+t0IRZH/7TFi752VLbGlbMXSF3jJZ19/1inl7VoTL+BcCQ+vMX0G0CHMP0GzrTvxQN1Y9BKmlqZ0eim6genonmjW7rq7i4IjDS2MdfJJUWHtdr02FTNWyIkyRpp8/cnO7mqZSG+gc4ivE9CgAPoBOIbOGFiQ057fnagZhAaSY+9eY3kMfFerl1XDNcNR2OlJ1+7qpNLihQT1N8NYKzk+dHaMcD0G+gcwrsKAhxAuzH9Bk741/+yWQfP65Uk+any5LUS4o+9eY12XTEc7gJjYnxDlx781XXS/HS7ws5Pa/de2K+f/vxQeAt0mTE6vq277j3y1khHz+np5KpahvgG2i9Rz/FeCp79DaDdeO43UN7Ku+5H0zr7/44pN+Vrcm1Wu145rMl1bH1uta0Pjev8fzyqNT+dkSRNrcroideu0hNXrZJNs7Oglu3/OqrLP139Wb1WUpAyuv0vz9XcikzH19ZKPPcbWLxmnuNNeDeJAAfQbgQ4gE7KzPjySlb5/pRkCO6GrNXPfeY57fj2qALvxMnmld0Z3/6dLXrmkhWhLrFViG9gcQjvNiDAAbQT8Q1A8/cTb350onygVynQ0e09evrnVqjYnQp7aclmrbY9MK7zvnFMq56eVZA2evalA3ri9at1fFt32KtrKeIbaB7h3SbEN4B2I8CB5Oo7UtBrP/K0Bg8VFMx3tvGlUpenu393q/Zf0B/2EpEgBDjQWDPhzeFqS8DhawDajYPXgGRKFQK97k92q/9IQZLk+eU3IymVD/TqTzyjob1zYS8TCcLBa0BrEN7LQIADaCdOPgeSZ9t3x9V/tFj1sV+eLW9Bf+HXj4axNCQYjx0Dlo/wbgHiG0A7Ed9Acmx9aLzuI6u8QNr2PW55QziIb2DpCO8WYfoNoJ2YfgPJkM4H8hqcvpMqxuJ4HkQU029gaQjvFiPAAbQT8Q3E2+iWroXHU1UTGGlsI882R/iIb2BxCO82Ib4BtAvTbyC+fnzFSpkq93dXGCs9+dpVnVwSUBPTb6B5hHcbMf0G0E7ENxA/E+tzevA/rpfmp9sVdv5t74X9+unPD4W3QKAK4htoLB32ApKgEt88/xtAq1Xim+d+A/Hx+BtWa2J9Vud/+ajW/nRGkjS1KqMnXrdKT752lWyqzulrQEgq8c1zv4HqjLU2Fid0TExMaHBwUFs/9mF5XV1hL6cuAhxAOxDfQPyk53x5JatCb0oyBDeigfhG0uzcsq/ha9hqHgK2nwNoB+79BuKn1JVSoS9NdCNSuPcbOBPhHRLu/wbQLgQ4AMAFxDdwAuEdMgIcQLsQ3wCAsDH9BsoIb0cQ3wDagek3AMAFxDeSjvB2CNNvAO1CfAMAwsb0G0lGeDuIAAfQDky/AQAuIL6RRIS3w4hvAO1AfAMAwsb0G0lDeDuO6TeAdmD6DQBwAfGNpCC8I4IAB9AOxDcAIGxMv5EEhHfEEN8AWo3pNwDABcQ34ozwjiCm3wDagfgGAISN6TfiKh32ArB0lfju2zYe9lIAxEQlvq/csivspQBAMlirVbtntfLZWfkZT8+d36e5FZmwVxW6Sny/bej+sJcCtAThHQMEOIBWu2vvDuIbmDf8zKzO+ddRdY+XND2c0U9/fkjjG7vCXhZiYMW+OV3+F3u1cu+crCQjKfCkn7xiWN99xwYFGTan3jp6GfGNWDDWWhv2IlphYmJCg4OD2vqxD8vrSu4XQ+IbQKsR4EgqU7L6d3+1T8/71zEFJ/WPF0hPvHalHnj7BskzYS4REdZ3pKA3/cFPlJkL5AWn/lxgpGcvGtC/XL9VMvwZqyDA4aqdW/Y1fA3fRosZ7v8G0Grc+42k+tnPH9A53xmT5mO78iZJ533zuC6440i4C0Sknf+Vo1WjW5I8K217cEKrds+GsTRnce83oozwjikCHEArcfI5kiY3WdIL7hqRqbEv0Ej6ma8eVapQpZqARqzVOfeNVI3uiiAlnXPfaCdXFQkcvoaoIrxjjvgG0ErEN5Ji4w+mlCrVvxsvOxto7Y+nl/T7p+d87bj7uH7ur/bpZf/jOZ31wJhMg4+H+EgVrTL5Bv9/B1L3RKlTS4oc4htRw+FqCcDhawBaiZPPkQTNTrJ7RouL/r3XPz6lV33yGWVnAlmvPD4/9+4RTa7K6M73bdP4huSeVZMUfsYo35tSbtqv/SIjTa/kdPN6OPkcUcLEO0HYfg6gldh+jjgb2dpc/G78wdSift/+Q3ld+dE9yswGMpV7x+fbq3ekqKv++GllZuvEGOLBGO165fAph/adzgukn1w+3MlVRRbTb0QB4Z1AxDeAViK+EUfHz+7R9FBajTZ/b31oXF6x+fu8X/hPx+T5Vl6V39gLpJ6xkrbPH+iGePvhG1ZrZkWmanxbSU9eOayxzex+aBb3fsN1hHdCMf0G0EpMvxFHh8/tbfiaTN6qa7L5CfW2747VPVBLks76HreGJcHcYFpf/fB27XtJv+xJTwzL93h65Oq1+u47Noa5vMgivuEq7vFOOO7/BtBKd+3dwb3fiI2JtVlZTzJ1QtkaqdjdxBwjsHrBt46ru0GkG0npPCelJ8XMyqz++f/bpt5jBQ3tm5Of8XTk+T3ys8zGloN7v+Ei/lZDYgIOoIWYfiMunr5sRf3HPXnS3pf0q9idqv8bWat/91fP6dK/PaBGe9cDTxrZ2r20BSOypldl9dyLB3TwRX1Edwsx/YZL+JuNUxDfAFqF+EbUjW7t1tOXDCowZ/5cYMrT7sd+aW3D32fz9yf1/HtHZeYn2vV4gfTjKzhQC2gV7v2GK9hqjjOw/RxAq/DoMUTdfddsVinr6Xn3jUpGsl75FPL8QFr3XLtZx7b3NPw9zr3ruAJPdafndj7KH756rUbOYuINtBrbzxE2whs1EeAAWoV7vxFVftbTv16zWd9/61pteXhCmblAY5ty2vviAdl0o/l12fDeuYYHqvkZo3ves0XPXszOM6Cdbh29jPhGKAhvNDS1Z5D4BrBsTL8RZVOrs3ryqlVL+rXFrvp39llJo5u7iG6gQ5h+Iwzc442mcPgagFbh3m8kzZ5LV1S9T3yBkfZcwtdYoNNuHblUZo8n8wNPOtLcDhZgqZh4Y1HYfg6gFZh+I0l+/OphnfeNY8rO+mdsOQ88Kd+b0k9eyYFqQCdt/d64Xnr7IWUOlM9psLKyF/oqvTsvbWnw+AFgCZh4Y0mYfgNoBR49hiSYXZHRNz5wtmZXlOcdfqr8Jkkzwxn90we3K9/PLATolHPuHdEVf/6sBg/kF95nZKTvp5X57R5pL9NvtJ6x1sbiWzoTExMaHBzU1o99WF5XV9jLSRSm3wBagek34s6UrLY+PK51P5qWjHTwvD7tvXBANsVFPtAp6blAv/pbTyo9F1R9vF/gSbqopNKH5kJYHaJq55Z9DV/Dt1exbGw/B9AKbD9H3Nm00TOXrNAzl6wIeylAYp314HjN6JbKj/2zD6b1xT0X6Ze3PdTh1SHO2GqOluEANgCtwNZzAEC79B0pyKbqv8ZYqfdYceH0c6AVCG+0HPENYLm49xsAwueVAg3un9PAwbxMEIu7U5XvT8kEzb1O848eI8DRCmw1R1uw/RxAK9y1dwdbzwGgw7xSoJ13HNF53zyurilfkjQ1nNEPf2G1nnzNSsmL7rkEey4e1CW3HJCp8X2EwEjHz+7W5NrcKe+/dfQynvuNZWHijbZi+zmA5WL6DQCdY3yrKz7+jF78f44sRLck9Y4UdektB3TZ3+yXInw289yKjB5//WpV+zewkoykh39lXdVfy/Qby0F4oyOIbwDLRXwDQPtt/86YNv/b1BkT4cqM+wX/PFI+mT/CHvrVdfrBG1fLT5VjO5gvonx/Snf/3lYdOL+/7q8nwLEUbDVHx7D9HMBycfI5ALTXud86rsBIXq2t2J604+4RHTqvr9NLax3P6OFfXa8fvmG1tj40oey0r8m1We17Sb+CdPNzSbafYzEIb3QcAQ5gubj3GwDaY/BAvmZ0a/5xWyv25zu5pLbJ96f1k1cOL+v3qEy+CXA0wlZzhIbt5wCWg3u/AaD1ij318yAwUr6XhDgdW8/RCH9rECoOXwOwXAQ4ALTO7p8bWrjnuRpjpadfNtTJJUUG936jHsIbTiDAASwX8Q0Ay/fka1aq0JOqGt+BJ02uzWr3y1aEsbTIIMBRDeENpxDgAJaD6TcALM/sUEb/9MGzNbUqI0kKUidO/R7Z2qV/+sDZ8nMkRDOIb5zMWBvhB/GdZGJiQoODg9r6sQ/L6+oKezloAQ5fA7AcHL4GAEtnAquN/zaptbtmFHjSgZ/p1+FzeyRjmvjVOB2Hr8Xbzi37Gr6G8IbzCHAAy0GAAwBcQYDHUzPhzT4ROI/t5wCWg63nAABXsP08uQhvRAbxDWCpuPcbAOAKDl9LJsIbkcL0G8ByEOAAAFcQ38lCeCOSCHAAy0F8AwBcwPQ7OQhvRBoBDmCpmH4DAFxBgMcf4Y1YIL4BLBXxDQBwBfEdX4Q3YoPpN4ClYvoNAHAF0+94IrwROwQ4gKUivgEAriC+44XwRmwR3wCWguk3AMAVTL/jg/BGrDH9BrBUBDgAwBUEeAfNShqT5Lf2tyW8kQgEOIClIr4BoL5UIdDAwbx6RophLyX2iO/2Md9PKf37Xcq+sU/Zt/Yp8ys9Sv3PbDnEW/H7W2tta36rcE1MTGhwcFBbP/ZheV1dYS8HjuvbNh72EgBE0JVbdoW9BABwRnba10v+4ZCe/y+jyuQDSdKxbV167JfW6tmLGHi029uG7g97CbHh/XNaqY/nJE8ygVl4v/Ws7PMClT4xK9VJzJ1b9jX+GK1aLBAlTL8BLAXTbwAoy8z4+vcfeEovuPP4QnRL0vAzc7riz57VC+48Fur6koDt5y0yIaX+PCfp1Oiu/Nj81JP3D5llfxjCG4nF9nMAS8G93wAg7fzyEQ0eyMsLTn2/N7+X9pJbDqhrjK3nnUB8L493V0byJSNT9edNYJT6akYKqv508x9neb8ciD4CHMBSEOAAksoEVuf+88gZ0X3Ka6z0/HtHO7msRGP6vXTmWa9hFZsxT5pa3schvIF5xDeApSC+ASRNdtpXbrr+kc/WkwYO5ju2JpQR4EvQ1eSRZ9nlfRjCGzgJ028AS8H0G0CSlHKebPVduacodqc6sRxUQXw3L7jMl/Fr/4G2nlXwklLdw9Wa4UR433jjjbrooovU39+vNWvW6E1vepN27eLkWISHAAewFMQ3gCTws572vbhfQZ2S8HxpzyVcS4WJ6Xdz7AW+gnN9We/MybeVlazk/2ph2R/HifC+9957dc011+iBBx7Qt771LRWLRV155ZWanp4Oe2lIOOIbwGIx/QaQBI/94lpJUrVNuoEnHXhhr448v6fj68KZCPAGjFT60Kzs88uHFtiULb8ZK2Uk/w/ysucv82Q1V5/jffToUa1Zs0b33nuvXv7ylzf1a3iON9qNZ38DWCye+w1gMYb2zqn3eEGzg2kd39YtmSb2c4do8yMTuvzTe5WdCeSnjIy18gJp3wX9+vbvbFGxh63mruHZ33VYyfwgJe/+lDRnZM8KFFxRlPob/9JmnuOdbs0qW2t8vBw4w8PDNV+Tz+eVz584sGFiYqIja0NyVabfBDiAZlUm3wQ4gHrW/nhal/zdfq16Zm7hfePrsnrwbeu196Xu7r7bd+GAbvvMedr23XEN7ZtTKWf07EWDGjmrO+yloYbK5JsAr8JIdqcvf2f9gwOX/Nu7NvEOgkC/8Au/oLGxMX3nO9+p+bo/+qM/0h//8R+f8X4m3ugUAhzAYhHgAE639sfTuupPnpYJrE6+xbTyj/9y/VY9c7G78Y1oI8Bbo5mJtxP3eJ/smmuu0eOPP67bb7+97utuuOEGjY+PL7zt29f4XxZoJe7/BrBY3PsN4BTW6tK/3X9GdKs8fJMkXfo3+2V8p+ZkiBHu/e4cp7aaX3vttfra176m++67T5s2bar72lwup1wu17G1AdWw/RzAYrH9HHCbCaw2fX9SZ31vXJm5QGMbc/rJK4c1tXqZD/GtYmjvnFY+O1fz542knvGSNv5gUs+9eKDlH7/VuiZKWv/ElLyS1bGzuzW+kV2oUcD2885wIryttXrPe96jO+64Q/fcc4+2bdsW9pKARSHAASzWXXt3EN+AY7rGinrtR/Zo5d45BZ5krGSNdMEdR/S9t63XE69f3dKP13e82PA1VlLvscavC1OqEOjiWw5oxz0j8k66PfbAeb2675rNml7V+m9aoPUI8PZyYqv5Nddco7//+7/Xbbfdpv7+fh06dEiHDh3S7Oxs2EsDFoXnfwNYDB49BjjEWr36489o6LnyBNoLyuFd+d9L/udBbX2wtd9gnx1oPAMzkuaaeF1orNUr//xZnfsvp0a3JK378bTe8P6n1DVRCmt1WAK2n7eHE+F98803a3x8XJdffrnWr1+/8PaFL3wh7KUBS0J8A1gMAhwI37ofTWvN7ll5NR7XGxhp55ePtPRjHtverYm12arPwq4odHt67sVNPM8oJOufmNaW70/KVPmX8AKpe6yk8755LIylYRl49nfrORHe1tqqb7/xG78R9tKAJWP6DWCxiG8gPJsfnVBQ57HTnpVW755VrpXTW2P04NvWSyedYn66h//DOvlZJy7ZqzrnvlEFdZbnBdLz/2Wkk0tCCxHgrePu32IgJghwAIvB9BsIR6po606eT7yuxkh8iZ69aFDfvm6L5gbK1V9ZQ6Hb0/3/aYN+9JpVLf14rdYzWqy5S6Cie5yt5lFHfC+fwzeMAPEytWeQw9cANI3D14DOOn5W9xn3KJ9urj+l2RWZln/sPZeu0DMXDWrTv02q93hRc4Np7Xtxv9OT7oqZ4YwCT3Xje6YN/83QeRy+tjzu/20GYoTpN4DFYPoNdM7Tl61QsduTNdV/PjDSk1eulE3VeMEy2bTRvgsH9OMrV+qZiwcjEd2S9NOfH6ob3YEn7XrVcCeXhDZj+/nSRONvNBAzBDiAxSDAgfbzc57+5bqtCjydcs+yVfmRYkee36MfvGlNmEt00qEX9GrPxYNVv2EReNL0yoyefO3KMJaGNiPAF4fwBkJEfANYDOIbaK/9F/TrK3/6PO25dFD+/GR7anVGD/7aen3zD8+OzBS6o4zRPb+9WU+8bpVKmRP1bSU9t7NfX/3QOSr0cXdrnBHfzTHW2mbOkXDexMSEBgcHtfVjH5bX1RX2coBF4/5vAIvB/d9Am1krE6htW8vjKDPja92PpuWVrI5v69bUmmzYS0KHJfX+751b9jV8Dd9+AhxRmX4T4ACaweFrQJsZI1vn8WI4U7EnpX0XDoS9DISIA9hqY78M4Bju/wbQLO79BgC4iO3nZyK8AUcR3wCaRYDHjylZeS1+XjQAdBKHr52KreaAw9h+DmAx2H4efVseGtf5XzmqtT+ZkSQd39qlx1+/Wk+9fIVkuNcYQPSw/byMw9WACCHAATSLAI+eC/7PYV34vw8r8LTwXOTASJ6VnrxyWN/9TxuJbwCRF8cAb+ZwNbaaAxHC/d8AmsX282hZ+fSMLvzfhyWdiG6pHN2SdN5dI9r86GRIqwOA1knq9nPCG4gg4htAs4jvaHjBt44rqHOCduBJL7jzWCeXBABtk8T7vwlvIKKYfgNoFtNv9616elaeX/vnvUBatWeuk0sCgLZLUoAT3kDEEeAAmkV8u6uU9dTo0B0/y/3dAOIpCQFOeAMxQXwDaAbTbzc9e9GAVKerA0965mI+zwOItzjHN+ENxAjTbwDNIsDd8pNXDCvfk1JQ5cosMFKQMnryNSvDWBoAdFRcp9+ENxBDBDiAZhHfbsj3p/XN95+tfH9amp9wB55kJZVynu567zZNrs2FvUwA6Ji4BTjP8QYSgOd/A2gGz/4OX6oQ6Oz7x7T+8SkZKx15fo+eevmQit11jjwHgJhz/dnfzTzHm/AGEoL4BtAsAhwA4CJXA7yZ8GarOZAQbD8H0Cy2nwMAXBTl7eeEN5AwBDiAZnD4GgDAVVEMcMIbSCjiG0AziG8AgKuiFOCEN5BgTL8BNIPpNwDAZVGIb8IbAAEOoCkEOADAVa5PvwlvAAsIcADNIL4BAK5yNcAJbwBnIL4BNML0GwDgMtcCnPAGUBXTbwDNIMABAC5zJb4JbwB1EeAAmkF8AwBc5cL0m/AG0BQCHEAjTL8BAC4LM8AJbwCLQnwDaIQABwC4LIwAJ7wBLBrTbwDNIL4BAC7rZHwT3gCWjAAH0AjTbwCAyzo1/Sa8ASwb8Q2gEQIcAOCydgc44Q2gJZh+A2gG8Q0AcFm7ApzwBtBSBDiARph+AwBc1+oAJ7wBtAUBDqARAhwA4LpWBTjhDaCtiG8AjRDfAADXLTe+CW8Abcf0G0AjTL8BAK5bzvSb8AbQMQQ4gEaIbwCA65YS4Om2rQYAaqjEd9+28bCXAsBBlfi+csuusJcCAEBNlfjeuaXxa5l4AwgN028A9bD9HAAQF4Q3gFCx/RxAI8Q3ACDqCG8ATiDAAdTD9BsAEGWxC+++pz31747dvxaQGMQ3gHoIcABAFMW2UPt3E+BAVDH9BtAI8Q0AiJLYlykBDkQXAQ6gHqbfAICoSEyREt9AdBHgAOohwAEArktUjTL9BqKN+AZQD/ENAHBVIiuUAAeii+k3gHqYfgMAXJTo+iTAgegiwAHUQ4ADAFxCdRLgQKQR4ADqIb4BAC6gNk9CgAPRRXwDqIXpNwAgbFRmFQQ4EE1MvwHUQ4ADAMJCXdZBgAPRRIADqIf4BgB0GlXZBOIbiCbiG0AtTL8BAJ1EUTaJ6TcQTUy/AdRDgAMAOoGSXCQCHIgmAhxAPcQ3AKCdKMglIsCBaCLAAdTC9BsA0C6U4zIR4EA0Ed8AaiHAAQCtRjG2CAEORA/TbwD1EOAAgFahFFuMAAeihwAHUA/xDQBYLgqxTQhwIHoIcAC1MP0GACwHZdhmxDcQPcQ3gFoIcADAUlCFHcD0G4gept8A6iG+AQCLQQ12EAEORA8BDqAWpt8AgGZRgSEgwIHoIcAB1EKAAwAaof5CRIAD0UN8A6iF+AYA1EL1OYAAB6KF6TeAWph+AwCqofYcQoAD0UKAA6iFAAcAnIzKcxDxDUQLAQ6gFtcC3ARWa34yrU3fn9Dg/rmwlwMAiZEOewGorhLfk9uDsJcCoElTewbVt2087GUAcNBde3foyi27Ql3D9n8d1UtvO6S+keLC+448r0f3v3Ojjm/rDnVtABB3jFYdx/ZzIFqYfgOoJczp945vHdfln96n3pOiW5JW7Z7Rv//AUxp+ZjaUdQFAUlB0EUGAA9FCgAOopdMBnpn1dfGtByRJ5rSf8wLJK1ld9PmDHVsPACQRJRcxBDgQLQQ4gFo6Fd9bHxxXOm9r/rwXSJt+MKWe06bhAIDWoeAiigAHooX4BlBNJ6bffceKsqnGryO8AaB9KLeII8CB6GD6DaCWdgb47EBapomzWucGOHMXANqFYosJAhyIDgIcQC3tCPBnLhlUkDr97u4TAiMdfl6PptZkW/pxAQAntKXUvve977Xjt0UTiG8gOghwALW0Mr7z/Wk99uY1VX8uMOUT1x7+1XUt+3gAgDO1pdLe8pa3tOO3RZOYfgPRQnwDqKaV0+/HfmmNHvqVdSrmypPvylFrM0MZ3fUH23TovL6WfBwAQHVLvpnnrW99a9X3W2s1MjKynDWhRSrxPbm9iRu7AISqEt9928bDXgoAx1Ti+8otu5b+mxijH7x5jZ68aqU2f39S2Slfk2uzOviiPlmv9jZ0AEBrLDm8//mf/1m33nqr+vpO/Q6ptVb33XdfK9aGFiHAgeggwAHUctfeHcuLb0mlrpT2XLqiZWsCADRnyeF9+eWXq7+/Xy9/+cvP+Lnzzz9/uetCGxDgQHQQ4ACqacn0GwDQccZaa5t4nfMmJiY0ODioF/7WnyqV6wp7OZFAgAPRQHwDqIUAB4Dw/dnOLzR8TdMncH35y19e7nrgGA5hA6KB088B1NLO538DAFqn6eq6+uqr9Rd/8Rd1XxOT4XniEN9ANBDgAGohvgHAbU0X15e+9CW9733v03XXXXfGz/m+r1tuuUUveMELWr0+dAjTbyA6iG8A1TD9BgB3NV1ar3/963XvvffqH/7hH/SLv/iLmpubU6FQ0M0336xzzjlHv/u7v6urr766vatF2xHgQDQw/QZQCwEOAO5Z9OFq+/bt0+te9zp5nqdjx46pWCzquuuu07XXXquBgYH2rbQBDldrDw5gA6KBA9gA1MIBbADQXs0crraox4lNTk7q7//+73X48GFNTU3JGKMHHnhAP/MzP7OcdcJhPIIMiAYePwagllY8/xsAsDxN7yl+//vfr61bt+qzn/2sPvKRj+jo0aN6y1veoiuuuEIPPfRQe1eJ0LEFHYgGtqADqIbt5wAQrqZL6otf/KI+9alP6Sc/+Yne9a53qbe3V7fccot+8zd/U694xSv0la98pb0rhRMIcCAaiG8A1RDgABCOpreaP/nkkzLGnPH+D33oQ9qyZYve+ta36s/+7M907bXXtnqNcFD/bo/t54Dj2H4OoJZKfLMFHQA6o+nRZbXornjXu96lL33pS/qv//W/tmpdiACm30A0sP0cQC1MvwGgM1pWTa973et0zz33tOq3Q4QQ4EA0EOAAqmH7OQC0X0tr6SUveUkrfztEDAEORAPxDaAaAhwA2odKQssR4ID7mH4DqIX4BoDWo47QNgQ44D4CHEA1TL8BoLWoIrQdAQ64jwAHUA0BDgCtQQ2hYwhwwH3EN4BqCHAAWB4qCB1HfANuY/oNoBbiGwCWhgJCKJh+A+4jwAFUw/QbABaP8kGoCHDAfQQ4gGoIcABoHsUDJxDggPuIbwDVEOAA0BilA6cQ4IDbmH4DqIUAB4DaKBw4iQAH3EaAA6iF+AaAM1E2cBoBDriNAAdQDdNvADgVRYNIIL4BtxHfAKohwAGgjJpBZDD9BtzG9BtALQQ4gKSjYhA5BDjgNgIcQC3EN4Ckol4QWQQ44DYCHEA1TL8BJBHVgsgjwOPL+mnZYk7WT4W9FCwD8Q2gGgIcQJKkw14A0CqV+J7cHoS9FCyTzXfLTqyWij2V98jmpmQGj8qkCyGvDktRie++beNhLwWAYyrxfeWWXWEvBQDahjEhYofpd7TZuV7Z41ukYvdJ7zVSvk/26FbZYjbE1WG52H4OoBam3wDijEJBLLH9PJqslezYuvkfmdN+1kjWkx1fG8LK0GoEOIBq2H4OIK4oE8QaAR4x+V4pyFSJ7gojFXplS5kOLwztQnwDqIYABxA3FAkSgQCPiFJWkm38Op/wjhOm3wBqIcABxAUlgkQhwB3n+XWm3ScxfidWgw4jwAHUQoADiDoKBIlEgDuqa0pSvVPprZQqSJl8BxeFTiPAAdRCfAOIKsoDiUaAu8V4gdQ3Ume7uZHpPyrTxFAc0UeAA6iG6TeAKKI4AB5B5hTTf0zqrcT3yW+BzOAhmZ7JsJeIDiO+AVRDgAOIknTYCwBcUYnvye31tjqj3YyRzOBR2b4RaXZANkjJpIpS92R5Io5EqsR337bxsJcCwDGV+L5yy66wlwIANTHmA07D9nM3mJQv0zcqb+CYTO840Q2J7ecA6mD6DcBlztTFfffdpze84Q3asGGDjDH68pe/HPaSkHAEOOAuAhxANWw/B+AqZ6pienpaO3fu1E033RT2UoBTEOCAu4hvANUQ4ABc48w93ldddZWuuuqqsJcB1MQ94ICbuP8bQC3c/w3AFc6E92Ll83nl8yee5TsxMRHqepAcBDjgJgIcQC0EOICwRXb/7I033qjBwcGFt82bN4e9JCQM288BN3H/N4Ba2H4OICyRLYcbbrhB4+PjC2/79u0Le0lIIO7/BtxFfAOohvu/AYQhslvNc7mccrlc2MsAJLafA85i+zmAWth+DqCTGNUBLcQEHHAT288B1MIEHEAnODPxnpqa0lNPPbXw4z179uixxx7T8PCwtmzZEuragMViAg64iQk4gFqYgANoJ2fC++GHH9YrXvGKhR9ff/31kqS3v/3tuuWWW0JcGbB0BDjgJgIcQC0EOIB2cCa8L7/8cllrw14G0Bb9uz3iG3DQ1J5B4htAVXft3UF8A2gZbkYFOoT7vwE3cf83gFq4/xtAq1ABQIcR4ICbCHAAtRDgAJaLq38gJAQ44CYCHEAtBDiApeKqHwgZAQ64ifgGUAsBDmCxuNoHHEGAA+5h+g2gHuIbQLO4ygccQ3wD7iHAAdTC9BtAM7jCBxzE9BtwEwEOoBYCHEA9XNkDDiPAATcR3wBqIcABVMMVPRABBDjgHqbfAOohwAGcjCt5IEIIcMA9BDiAeghwACK8gWgiwAH3EOAA6iG+gWTjyh2IMAIccA8BDqAWpt9AcnHFDsQA8Q24h/gGUAsBDiQPV+tATDD9BtzD9BtAPQQ4kBxcpQMxQ4AD7iHAAdRDgAPxx9U5EFMEOOAeAhxAPQQ4EF9clQMxR4AD7iG+AdRDfAPxw9U4kBAEOOAWpt8A6mH6DcRLOuwFAOis/t2eJrcHYS9jyaw10my/bKFbkmRyM1LXpIwJe2XA0lTiu2/beNhLAeCgSnxfuWVX2EsBsAyEN5BAlcl31ALcFrpkRzZJQVqSLb9vZkjyitLK52Qy+bCXCCwZAQ6gHgIciDb2nQIJFqXt59ZPyx7fLAWp+feY+TdJQVr22GbZIBr/LkA9bEEHUA9b0IFo4ioVQCQC3E6vkKx3IrZPYSSbkmZWhLAyoD2IbwD1EOBAtLh9pQ2go5wO8Nn+GtF9gp3t79hygE5g+g2gEeIbiAZHr7ABhMnJALeN1mOaeA0QTQQ4gHqYfgPu4yoVQE1OxXcmv3CgWnVWSs91cEFA5xHgAOohwAF3OXRVDcBFrky/Te9og63mRqZ3rIMrAsJDgAOohwAH3BP+1TSASAg9wHPTUnclrE+efM//c++ITG42jJUBoSG+AdRDgAPu4DneABYlrGeAGyNpxSEpOys7NSz5ufJPpAsyfcel7omOrgdwBc//BtAIzwAHwkd4A1iSMALcGEm941LP+ImD1ExQfj+QcAQ4gEYIcCA8bDUHsCxhbEE3RjJeUH4juoFTcP83gEbYfg50HuENoCVcOIANwAkEOIB6uP8b6CyulAG0TOgHsAE4A/ENoB4CHOgMrpABtBwBDriF6TeARghwoL24MgbQNgQ44BYCHEAjBDjQHlwRA2g7AhxwCwEOoBECHGgtroQBdAwBDriF+AbQCAEOtAZXwAA6jvgG3MH0G0AzCHBgebj6BRAKpt+AWwhwAM0gvoGl4aoXQKgIcMAtBDiARph+A4vH1S4AJxDggFsIcACNEOBA89JhLwAATta/21Ng0ppcuUKaHZACT0oXZHrHpJ4xGRP2CoFkmdozqL5t42EvA4DDKvF95ZZdYS8FcBbhDcApJdOl6dwmacpoobJLOdnxtdJsv7TyORljw14mkCiVyTcBDqAeAhyojX2dAJxhJc3kNkg6Kbql8o9lpEKP7OTKEFcIJBvbzwE0gy3owJkIbwDOKHl9siat2vvJjTQ9JMvAGwgVAQ6gGQQ4cALhDcAZvpdTw6q2KcnPdGpJAOogwAE0gwAHYhjeK54qaGhXIexlAGijvr2GE9ABhxDfAJpBfCPJYnvlOrSLAAeiJh1M19lmLslaeUFBxpYkHkEGOIXpN4BmMP1GUsX+ipUAB6IjFcwp5c/W3m5ujHKlUZ2e5sQ34A4CHEAzCHAkTWKuVglwwH1GUk/hgDw7/3e1EuDz/5stjijjV3+cEdNvwC0EOIBmEOBIisQ9x7sS36M7smEvBUAVnnz15Z9VMdWvYqpPVimlbEHZ0rhSNt/w11fie3J70IHVAmiEZ4ADaAbPAEfcJS68KwhwwF1GUtafVNafXPLvQYADbpnaM0h8A2iIAEdcJX5fJlvQgXhjCzrgDrafA2gWW9ARN4mdeFcEnqepoRXKF/tljZHtKijrjytli2EvDUALMQEH3MH2cwDNYgKOuEh0eBe6cjq0fZuCdKr8DmMka1VID6mreES5Goc4oXlWUsnrLd+razylgoKy/oQ8vrGBkPTv9ohvwBEEOIBmEeCIusSGd2CMDm0/qxzdJz83eP6f57JrNfjUjOY2EohLFcjTdG6TAq9r4VTqkifl08PKlY6pqzQa9hKRUEy/AbcQ4ACaRYAjqhJ74+P00KCCdPrU6D6ZtZpYvYp7wJfISprJblBgcuV3GHPKWz6zWoVUf9jLRMJx/zfgFu7/BtAs7gFH1CT2inO2v0H0GaPZgT7NP0WYAF8k33TJT/XU/cZGPj288N8XCBMBDriDA9gALAbxjahI7pVmjR5shABvTinVu7C9vCpjFHg52eTe7QAHEeCAOwhwAM1i+o0oSOwVZm5mtv4LrFV2dq5mnxPg9dkmv7Nha03EgRAR34A7CHAAzSLA4bLEXl32jYyWJ7K1prLGaODosYa/D/FdXcrma28zr7C+PFvq1JKARWH6DbiFAAfQLAIcLkrsVWWq5Gv1s/vKPzg5vuf/ue/4iHpHmztdlen3mTL+lIz1a39jw1plS+My3OUNxxHggFuIbwDNIsDhkkTfYNs7PqnMrt0aX71Ss4MDssYoOzurgaPH1TM+sejbwCvxPboj25b1RomRVU/hgKazG8tHnFem3/Mhngrm1FU6Hu4igUXgEWSAO3j8GIDF4BFkcEGiw1uSsnNzWr1vv7Rvf8t+TwK8LB3Mqi+/V/n0kIqpfsl4MraknD+mbGmMaTciiQAH3EGAA1gMAhxhSnx4txMBLqVsQT3Fw7LFw9LSD5MHnEOAA+4gwAEsBgGOMHDjYgdwD3g5uIluxBH3fwPu4AA2AIvBPeDoJK4YO4gAB+KJA9gAtxDgABaDAEcncKUYAgIciCcCHHAL8Q1gMQhwtBNXiCEiwIF4IsABdzD9BrBYBDjagcPVHMAhbM0LlFJgMjIK5NkC943DaRzABriDA9gALBaHsKGVGMk4hAl4bYFJazq7XpNdZ2u6a4umus7SVO4sFVJ9YS8NaIjpN+AOJuAAFovpN1qBq0EHEeCnCkxaU7ktKnl9kjEnvT+j2ewG5VNcQMF9bD8H3EKAA1gMtp9jubgKdBgBXjaXXimr1CnRLWnhx3OZ1bL8UUZEEOCAW4hvAItBgGOpuPqLgCTHt5VRMTVwZnSfwqiQ6u/gqoDlI8ABdzD9BrBYBDgWi6u+iEjq9Dsw6QbRXXldpiPrAVqNAAfcQYADWCwCHM3iai9ikhbgxjZ3GrQRp0Yj2ohvwB0EOIDFIsDRCFd6EZWUAPfkK+XPSNbWfV3Wn+zYmoB2YfoNuIUAB7BYBDhq4Qov4pIQ4F2lY+V/qBbf1irjT8izxY6vC2gXAhxwC/ENYLEIcJyOK7uYiHOAp4M59RQOyMgvv8PahbeMP67u4uGwlwi0BQEOuIPpN4ClIMBRkQ57AWitSnyP7siGvZSWygTTSs89rZLXJ9/LyNhAGX9KXiXGgRirxPfkds4yAMJWie++beNhLwVAhFTi+8otu8JeCkJCeMdUHAPcSMoEU8rQHkio/t0e8Q04ggAHsBQEeHKxhzHm4rwFHUgitp8DbmELOoClYAt68nD1lhAEOBAvBDjgFgIcwFIQ4MnBVVvCEN9AvBDggFuIbwBLQYDHH1drCcT0G4gfAhxwB9NvAEtFgMcXV2kJRoAD8UOAA+4gwAEsFQEeP1ydgQAHYoj4BtxBgANYKgI8PrgywwICHIgXpt+AWwhwAEtFgEcfV2Q4AwEOxAsBDriFAAewVAR4dHElhpoIcCBeCHDALcQ3gKUiwKOHKzA0RIAD8UKAA+5g+g1gOQjw6ODKC00jwIF4Ib4BdxDgAJaDAHcfV11YNOIbiA+m34BbCHAAy0GAuysd9gIQTZX4Ht2RDXspAFqgEt+T24Owl7JotpSR5vok60mZOSk3LWPCXhWwPJX47ts2HvZSAERQJb6v3LIr7KVgHmMOLAvbz4F4idIE3AZGwcgG2SPbZSfWyE6ukh3ZLHt4u2yhK+zlAS3B9BvAcjD9dkc0rq7gPAIciBfXA9xayY5skub6599j5t8kBWnZ41tki+zIQTyw/RzAcrD93A3uXlUhkpoJ8JLJaTazRtPZjZrJrFPR65Ht2AoBLIaz8V3olgq9J2L7FEayRnZqOISFAe1DgANYDgI8XNzjjbaodg+4lTSbWaNiekV5XGWMZK2K6QGl/Bn1FvbLkOCAc1y8/9vODsx/Vql1M7eRZgdkVxzifm/EDvd/A1gO7v8Oh6OjDMTFyRPwfHpIxdT8d+orV8Lz/+t73ZrJrAttnQAac2r7eZBq4kWeZKluxBcTcADLwQS8sxy5gkLcrfhJUUUzpJqjJ2NUSvUpMGzCAFznRICnmzhTwitJhl00iD8CHMByEOCdQXijI/LdXQrSjaO66PV2ZD0Ali/MADc943W2mau8Db1njG3mSBTiG8ByEODtRXijM5q++uUqGYiaMOLbpItS37H5H50+1bZSqiDTN9LxdQFhY/oNYLkI8PZgXy86IjOXP3GgWi3GKGXnOrksAC0SxgFspv+YlCrJTq6Ugsz8ewOpe0Jm8IiM585hcECncQAbgOXiELbWIrzRESnfV+/omKaHVlSPb2vl2YJSAeENVARKKTAZGflK2WLYy2lKJwPcGEm9Y1LPmFTKlQ9SSxcIbuAkBDiA5SLAW4PwRscM7z+kQk+3irlc+R2VALdWnu9r3VN7lZ0rnPIIMiCJfJPRXGa1Sl7vwt8TL5hTV/GYMsFM2MtrSscDPJNv+8cBoowAB7BcBPjyEN7omJTva/1PntbEqpWaXDUkP5OR5/vqGxnTwNFjShdLUo1ngCeBlRSY8nZZzxa52z2hfJPVVG5z+QiOk3aHBCanmexG9RQOKhNMhbrGxXDxGeBAkhHgAJaLAF8awhsd5QWBVhw5qhVHjjZ8bVIC3EoqpIeUTw/Jzj9OzdiSsqUx5UojBHjCzGZWnxHd0vxY11rNZtcqPTcVuT8X/bs94htwyNSeQeIbwLIQ4IvDqeaoqpjNaravV4Wu3BnnBXdaJcDjyEqazazVXHqVrFIn3m/SyqdXaia7PvT//uicwKTlp3rrPu/empRKXl+nl9YSTjz/G8ACTkAH0Aqcgt4cJt44Rb67SyMb1yvfd+J52pnZOQ0dOKSeyfZsb7WS5vr7NNfXKyupa3pG3ROTp0z04jr9Lnk9KqZrXPQYo1KqX8XUpLJ+dLYWY+kqtxrUZa0CLyNFeHjM9nPALWw/B9AKTMDrI7yxIN/drUPP2yZ72rSt2JXTkbO3as2eveqZmGzpxyxmszp89laVunLlx41ZaWKtUTpf0Jo9zyo7d+qBSXEL8EJ6sP5j1qxVIbWC8E4IY/2Wvs51BDjgFgIcQCsQ4NWx5w8Ljm9aX47uaveWSjq2eUNLtz0HnqdD52xTKZc98XG88scqZTM6dM42+elU1V87tKsQiy3ogck2fLZ54MXjmwxozLMFeUGh/M2YOtIx+0YMW9ABt7AFHUArsAX9VFzpQJJUyOVU6O2pe29pkMlotr9195ZODa+Qn0lX/5jGKEilNLlyuO7vEfUANzaoH1nWxma6icaMpK7isYWD1M5grXKlEXlR3mdeB/ENuIUAB9AKBHgZVzmQ5ifMDVmrUrZ109fpoRVNvKa5L/hRDfCM33jrfjOvQXxkgil1Fw5Kmv+mzElvudKocqXjYS+xrZh+A+4hvgG0QtIDnHu8IUlKlZqYqhqjlF9q2ccMvCqPTDrt4wWp6lvNa4naPeBZf7z8GDFVmfxbKyNf2RL32iVN1p9Uxp9SMdWnwGRkrK+MPyVPydn9wP3fgFu4/xtAqyT1HnDGCpAkZWdnlc7Xv7fU+L66W3i4WmYu33Cbdea0w9WaFZXpt5FVX2GfPDu/3sp0U5Jni+rNP5eo2MIJRlZZf1JdpRHl/PHE/jlgAg64he3nAFolaRNwrmYgzd9bOnTgUO17SyWtOHREXtC649X6j480nHj3HxtZ8u8fle3nni2pL/+sevP7lCuNKFcaUU/+OfXln1HKur9+oBOIb8AtBDiAVklKgHMlgwW94xNa9ew+ef781s75ADdBoKEDhzRwtLX3lnZNTavv+MgpU96Fj2utekbH1TM+seyPE4UAN5LSway6SsfVVTquTDCjOt+SABKJ6TfgHgIcQKvEPcC5xxun6BsdV8/YhGYH+lXKZpQq+eoZn5AXtP4+SyNp5b4Dys7OaXzNKvnzB7elSiUNHD2ugSPHWhqfUbv/G0B13P8NuId7wAG0SlzvASe8cQbPWvW2YNLcDCNp4NiI+o+NLJysni4U2zrtJcCXz0oqeb0qpFfINxkZBcqWJpT1J2Ri+qgruIcAB9xDgANolZOn33GIcPbswQlGUqZQVKbN0X2yKGxBd5GVNJNdr5ncRpW8Hlkvq8DkNJdZrcncVgWG7+ehs9iCDriH7ecAWikO29C5UkHiEeCLk08Pq+T1lX9QORzPGMkYWZPWdHaDWncEH9A84htwC/d/A2i1KAc4VynAPOK7MSupkB6qfRq9MQq8Lvled6eXBkhMvwEnEeAAWi2KAc7VCXASpt/1BSYra1L1X2StSoQ3QkaAA+4hwAG0WpQCnKsSoAoCHIgHAhxwDwEOoNWiEOBOXY3cdNNNOuuss9TV1aWLL75YDz74YNhLQsIR4KfybEHG+vVfZIzSwWynlgQ0hQAH3EOAA2g1lwPcmauQL3zhC7r++uv1wQ9+UI8++qh27typ17zmNTpy5EjYSwMI8HlGUrY0Ktkax6dZKy/IK0V4w1HEN+Ae4htAq7kY4M5cgfz5n/+53vWud+kd73iHzjvvPP3VX/2Venp69Ld/+7dhLw1YQIBLudKI0sFU+QeVALdWslbGltRbONCxR8IBS8H0G3AP028A7eBSgDtx5VEoFPTII4/oiiuuWHif53m64oor9N3vfrfqr8nn85qYmDjlDeiUJMe3kdRTOKie/AGlgxmZoCDP5tVVOqr+/LPybDHsJQJNIcAB9xDgANrBhQB34orj2LFj8n1fa9euPeX9a9eu1aFDh6r+mhtvvFGDg4MLb5s3b+7QaoGyJE+/jaRMMKXewn4N5J9Rf36vcqUxGQVhLw1YNAIccA8BDqAdwgzwyF5p3HDDDRofH19427dvX9hLQkIlOcCXw0oqen3Kp4eUTw0qUIPHlAFtRoAD7iHAAbRDGAGe7uhHq2HVqlVKpVI6fPjwKe8/fPiw1q1bV/XX5HI55XK5Dq0QaKwS36M7smEvxXlFr1ez2bWyJr1wn/hcZo2y/pi6ike5Rxyh6t/taXI7uzcAl1Tiu2/beNhLARAjlfi+csuutn8sJ761n81mdeGFF+ruu+9eeF8QBLr77rt16aWXhro2YLGYgNdX8ro1k90gW5lwG7PwVkit0GxmddhLBJh+A45iAg6gHToxAXfmquL666/XX//1X+tzn/ucfvSjH+nd7363pqen9Y53vCPspQFLQnxXN5deWf4HU2WubYyKqRUKjBObcQACHHAU8Q2gHdoZ4M5c3V599dU6evSoPvCBD+jQoUO64IIL9M1vfvOMA9eAKGH7+akCpeSnehq+rpjqV6402pE1Ac2oxDdb0AF3sP0cQLu0Ywu6sbbyIN5om5iY0ODgoF72qj9SOt0V9nKAqpIe4L7JaqrrrPovsla50oi6Ssc7tSxgUYhvwE0EOIB2aRTgf7bzCw1/D/bPAR2U9Pu/PVtaOEyt4esAR7H9HHAT938DaJdWbEF3Zqs50C7FbEbTQyvkZ9JKFUvqHR1TplAMdU1J3YJuFCjtT6qU6q9+j7e1kqwy/mQYywMWhe3ngJvYgg6gXZazBZ3wRmxZSaMb1mpi9aoT7zDS2Lo16j96XMMHDoX+2KokBnh36bimUr2y1js1vq2VjFF34YiMCBlEBwEOuIkAB9AuSwlwwhuxNb5mtSbWnPRoqpMab3L1SqV8XysOHw1lbacb2lVITHx7tqje/F7NZVar5PUuxLdni+oqHFMmmAp7icCSEOCAmwhwAO2ysP18Z+PXEt6IpcAYja9dVfsFxmh8zWoNHD0mL3DjfMEkTb9TtqjewgEFSinwMjI2kGcLoe9AAFqhf7dHfAMOmtozSHwDCA2nwyCW5vp6ZVOpuq+xKU9zfX0dW1OzknQAmydf6WBOKaIbMcMBbICbOIANQFi4KkAsWa+5P9pByt2/AkkKcCCuCHDATQQ4gE7jagCxlMnnm3vdXHOvCxMBDkQfAQ64iQAH0ClcBSCWsnN5Zadnaj8z2lplZ2aVm53r9NKWjPgGoo8AB9xEgANoN776I7ZW7dsvEwRnxre1MkGgVXv3h7W0JWP6DcQD8Q24iQAH0C6cao7Yys7ltWHXbo2tW63poRXlx1ZZq97Rca04fESZfHQDNkknoIclUEqF9KACk5VklfGnlA6mOQQOLcPjxwB38QgyAK1GeCPWMoWCVu/dr5X7DihIp+SVfHm1tp9HEAHeHoXUgGYza095XzE9KC/Iqze/X55Koa0N8UOAA+7iEWQAWoW9bkgEz1qli6VYRffJ2ILeOiWv+0R0G3PiTVJgsprObVQ8/xQhbNz/DbiJ7ecAWoGv8ECMEODLN5ceLv+DqbKp3BgFXk4lr7fj60JyEN+AmwhwAMvBV3cghojvpbEy8r2e6tG98CKrUorwRnsx/QbcRYADWAq+qgMxxfR7iepF9zzLEWvoEAIccBcBDmAx+GoOxBwBvhhWJijWfv77vJTNd2xFgAhwwGkEOIBm8FUcSAgCvDEjKeeP1X6BteVHi5UmOrmsplkZFb1eFVL98k2OQ+BiiAAH3EWAA6iHx4kBCcMjyOrLlkZV9HrK93rrpK3n81Pw7uIheXLrsU9WUiE9VD4YzqQW3u8Fc+opHGZCH0P9uz0ePwY4ikeQAaiGb5sDCcX0uzojqbewX13FozK2WH6ntUoH0+ot7FPWnwp7iWfIp1dqLrP6lOiWpMDkNJXbLN/wTZY4YvoNuIvpN4DTMfEGTpLv6dbEymEVu7tkgkC9YxPqGxmVF8RzssT0u7rKlvOcPzZ/kJq7x6kFSilfeQTa6YyRrDSXWanewsFOLw0dUolvJuCAeyrxzQQcAOENzG/VHVu/VuNrV5e3FBsjWat8b4/G1q7SuqeeUTYf3+26BHhtxvE7pYup/vovMEYlr0+BPOe2yKO1CHDAXQQ4APaoAZKmhwbL0a2T7uk1RjJGQTqtw2dvdTy/WoMD2KInME18/9QY2dO2oSO+2H4OuIst6EBy8dUZiWclja9ZVfsRUsbIz2U1MzjQ6aWFhviODs+WGr/IWhnrd2I58k1Gs5nVmsidpYncNs1k1qlkujrysXEC938DbiPAgeRhqzkSL0h5KnZ313+RtZrr61XvuJuPkWqHqG0/t5JKXq+KqT5JRimbV6Y0Hvvt1Rl/snywWi3WKh1MdeS/Q9Hr00x2ffkH8ztHiiatYnpAXcUjypXqPKoNbcH2c8BtbEEHkoNvhwPNHJtlJWtcPV6rvaKw/TwwaU3lztJMbqOKqQEVU/2aS6/SZNfZKqT6wl5eW3nylSuNVP/J+eeOdxWPt30dgUmfEd0n//NcZo1KXoNvcKFtmIADbmP6DcQfX4WReJ7vK53P195qLkmeUdf0TCeX5RxXA9xKms5uUmAy5XfM35tfDj6j2cz62G91zpWOq6t4VDptO7ln8+rL71PKtv//t0Jq/qKx1jeorFU+vaLt60B9BDjgLrafA/HGVnMknpE0cPS4Rjaur/4Ca+X5vnrG2AYmB7egl7w+BV6NtVROp88MKR3jx2kZSbnSqLKlMZW8HlnjKRUUlLKdO4m/5PXUjm7Nn5Xg9XRsPaivf7fH9nPAUWw/B+KJb3sDkvqPjah3dP7+05Mn39bKBIHWPP2svHoT8QRyZfpdTPXV360w/zitJPy/Z2SVCaaV9Sc7Gt1lzfwXTsL/C9HB9BtwGxNwIF6YeAPzE8NVe/erZ3xSk6uGVejqkgkC9Y6Na+DYiNLFYthLdJIL0++m7r1P6P35nZQOZuV73XW3mqf8ZN+u4SoOYAPcxgQciAfCG5hnJPWOTyTq5PJWCTPAU0FeJa/OAWrWyrPFZo7QwzJkS2PKp4fKQ+0a8c2p5m4jwAG3EeBAtLHHDEDLhHEAW7Y0fwFSZ7t5luBrO0++egoH5x8BcOrtGrJWXcUjStu5MJeIJrH9HHAbW9CBaOKrK4CW62R8e/LVXTxc/sHpwafy9DWfHlSx3lQcLZEJptWff0bZ0qi8IC8vyCvrj6sv/6xyPhOaKOH+b8B9BDgQLWw1B9AWndx+nvUn5Nmi5tIrT9xnfNJ2Z2uymsltUHfhkLI+txK0k2dL6i4dk0rHwl4KWoDt54D7pvYMsv0ciAC+nQ2grTq1/TwdzMrYUvWfnH+s2GxmjSx3ewOLxgQccBvTb8B9fBUF0BHtDnArT6VUf+1TtY2RZFRM9bdtDUDcEd+A2whwwF18BQXQUe0K8MCkm3psWGAyLf/YQJIw/QbcR4AD7uErJ4BQtDq+jW3uHlQj7lUFWoEAB9xHgAPu4CsmgNC0cvrtqaSUP1v3sWKSlPEnW/LxAJQR4ID7CHAgfHylBBC6VgV4V+Uk7Wrxba0y/ri8WgewAVgWAhxwHwEOhIevkACcsdwATwez6ikcOLGd3NqFt6w/pu7ikdYtFkBVxDfgPgIc6Dye441YK2azmu3vlYxRbnpW2dlZHiYVAUO7Ckt+/ncmmFZ6brdKXp98LyNjA2X8KXnyW75OANXx/G8gGngGONA5hDdiyU95OrZ5k2ZXDJzYdmyMsjOzWv3MPmUK7X+uNJanMvleSoAbSZlgShmu+YFQEeCA+yqTbwIcaC/2gyF2rKTDZ5+l2cH55zUbs/CYqUJ3lw4+b5v8dCrcRaJp7X7+N4D24/5vwH1sPwfai6+CiJ2ZwQEVenuqP9PZGAXptCZWrQxjaVgGAhyIPuIbcB8BDrQHXwERO9NDg/UfKWWMpoZXdHJJaCHiG4g2pt9ANBDgQGvxlQ+x46fT1afdJwlSHG8QZUy/gegjwIFoIMCB1uArHmInXSjUn3hbq3SRaIsDAhyIPgIciAYCHFgevtIhdvpGxhpOvPuPjXZsPWg/AhyIPuIbiAYCHFgavsohdrqmptUzMlZ96m2tMrNz6js+EsbS0GbENxBtTL+B6CC+gcXhRlfEjpG0eu9zGisUNLF6pWxq/tFhQaC+0TEN7z8kr95WdETacp7/DcANPP8biAaeAQ40j/BGLBlJQ4eOaPDwURV6umWNUXZ2TinfD3tp6BACHIg+AhyIBgIcaIzwRqx51qpreibsZSBEBDgQfQQ4EA0EOFAbN1IBSATu/waij/u/gWjgADbgTEy8ASQG02+ExTdZlbweyUipYE6pYE71n72AWph+A9HBBBw4gfAGkDgEODolkKfZ7HqVUr0nnrRgjLxgTj2Fg0rZYthLjCwCHIgOAhwgvIHQFbMZTa4c1uxgv6wxyk3PaODYiHIzs2EvLfYIcLSTlTSd26TA5MrvMCdm3IHJaTq3WX1zz8oThz4uBwEORAcBjiTjZikgRLP9fdp/7vM0sWaVil1dKuVymh5aoYPP367xNavCXl5icP832qHk9Snwuk4J7gXGyCqlQnpFGEuLJe7/BqKDe8CRRHyVAkLip1M6sm1L+aL85Avz+X8e3bBOs3294S0wYYZ2FQhwtFQhPXBie3k1xqiQGujkkmKvf7dHgAMRQnwjSfjqBIRkcnhI9vToPpm1mli9stPLSjwCHK1ilar997vyGpPq2HqShAAHooPpN5KCr0pASOYaTbON0VxfX6eWg9MQ4FguzxbrT7ytLb8GbUOAA9FBgCPu+GoEAHUQ31iqrD/ecOKdLXHAUCcQ30B0EOCIK74SASHpmpqu/wJr1TU11anloA6m31iKVDCrTGmi+tTbWqVsvhzn6Aim30C0EOCIG74CASHpHxmVsbb2VlRjNHD0eKeXhToIcCyGkdRdPKRc6biMPemRYTZQ1h9Xb36fjOpsRUdbEOBAtBDgiAue4w2EJFXytWbPXh3etqX8jsqWVGslYzR04JC6G03FEYqhXQWe/Y2mGEldpRHlSqPyTU4yUiooyIhnToeN538D0cIzwBF1hDcQou7JKW388U81uXJYs4P9ssYoNz2jgWMjys3Mhr081FGZfBPgaIaRVdrOiQG3e/p3e8Q3ECEEOKKK8AZClikUNXzwsHTwcNhLwRIQ4ED0Mf0GoocAR9RwkxMAtAD3fwPRx/3fQPRw/zeigq8uANBCxDcQfQQ4EC0cwIYo4KsKALQY028gHohvIFoIcLiMrygA0CYEOBB9TL+B6CHA4SK+kgBAmxHgQPQR4ED0EOBwCV9BAKBDiG8g+ghwIHoIcLiAx4kBQBVW0lxfr2YGBxSkPGXm8uobGVO6VFrW78vjx4B44PnfQPTwCDKEifAGgNP4KU9Htm1Vvq9Xsnbh/WPr12r4uYMaOD6y7I9BgAPRx/O/gWgiwBEG9koBwEmspKNnbVG+t6f8DmNOeRvZvEEzA/0t+3hsPweij+3nQDSxBR2dxFcJADhJoadbc/195dCuxlqNrVvd0o/J4WtAPBDgQDQR3+gEvjoAwElmBvpP2V5+BmNU6OmRn061/GMT4EA8EN9A9DD9RrvxlQEATmI9r354zwu89n36JMCB6GP6DUQTAY524SsCAJwkMzdXe5v5POP7SheXd7p5M4hvIPoIcCCaCHC0Gl8JAOAkvWPjMkFQe+ptrfqPjcg0MRVvBabfQDwQ4EA0EeBoFb4CAMBJvMBq9bPPlX9welxbq8zsnFYcPtrxdRHgQDwQ4EA0EeBYLj7zA8BpeiYmtf6nT6t7fHIhvr1SSYOHj2r9U3vkBeE9s5f4BuKB+AaiiQDHUqXDXgAAuCg3M6u1z+yVNUaBZ+T5gerf+d05lfge3ZENeykAlqES35Pbw/tmHoClqcR337bxsJeCiCC8AaAOY61Sfmfu514sAhyIBwIciC4CHM1inxMARBz3fwPxwP3fQHSxBR2N8NkdAGKC+AbigfgGoov4Ri18ZgeAGGH6DcQD028guph+oxo+owNADBHgQDwQ4EB0EeA4GZ/JASDGiG8gHghwILoIcIjwBoD4Y/oNxAfxDUQXAZ5sfPYGgIQgwIF4YPoNRBsBnkx81gaAhCG+gXggwIFoI8CThc/WAJBATL+B+CDAgWgjwJMhdp+lu588GPYSACAyCHAgPohvINoI8HiL5Wfo7sf3q/vx/WEvAwAigwAH4oHpNxB9BHg8xfozMwEOAItDfAPxQIAD0UeAx0siPiMT4ADQPKbfQHwQ4ED0Ed/xkKjPxMQ3ADSPAAfig/gGoo3pd/Ql7rMw028AWBziG4gHpt9A9BHg0ZUOewFhqcT37Is2hr0UAHBeJb5Hd2RD+fi+yaiU6pOVJ8/mlfGnZEJZCRB9lfie3B6EvRQAS1SJ775t42EvBU1KbHhXEOAA0LxOB7iV0UxmrUrpAcna8juN0Zz11V04qEww05F1AHFEgAPRR4BHB/uN5rH9HACa16nt5zPZdSql+ss/MKb8JsnK00x2o0qmqyPrAOKM7edA9LEF3X18pj0J938DQPPaffiab3Ll6DZVNpXPvy+fGW7bxweShPu/gXggwN3FZ9gqCHAAaF67AryY6j+xvbwaY1TyemW52xtoGQIciAcC3D18Zq2DAAeA5rU6vq1p4kuUMbJ8KQNajgAH4oEAd0fiD1drRvfj+zl8DZhnjdHU0ApNrhpWKZuV8X31jY6p/9iI0qVS2MtDyFp5+Jpni41fZAMZ+cv+WACq69/tcfgaEAMcwhY+wrtJnH4OSIExOnz2VuX7esvvMEZKpzS+drUmVw1r3U/3KJvPh71MOKAVAZ4pTWguvar2C6xV1h9noznQZpx+DsQHAR4e9hAtEtvPkWRj69aUo/uk06WlcoAHqZSObNuiOnfkIoGWs/3ck6+u4tHyD06/19taGVtSrjiyzBUCaBbbz4H4YPt55/HZc4kIcCRNYIwmVw1XP2Fa8wdddeU0V5mGA/OWc/hazh9Td+GAPHvSr7dWGX9Cffm98thmDnQcAQ7EA/d/dxZbzZeJLehIimJXTjaVqv8ia5Xv7VH31HSnloUIWer286w/pYw/pcBkJHnybFFGbHkFwsb930A8sP28M/h2ZYsw/UbcmXqPdTpZs69DYi1l+m0kpWxRKZsnugGHMP0G4oMJeHvxmbKF2H6OOMvM5eUVG5xaboy6J6c6tSREWLue/Q0gHAQ4EB8EeHvwGbINCHDEkZE0ePRY7Ym2tcpNTSs3O9fppSHCCHAgXghwID4I8NbiM2MbEd+Im4Ejx9Q7Mlb+QSXA5/83k89r9TP7Qlwdooz4BuKF+AbigwBvDQ5XazMOX0OcGEmr9u1X/8ioJlcOq5jLyvN99Y2Oq2dsXB73d2MZWvHsbwDu4PnfQLxwCNvyEN4dQoAjLoykrukZdU3PhL0UxBQBDsQLAQ7ECwG+NOwD6jDu/waA5rD9HIgXtp8D8cIW9MXhM2BIiG8AaIzD14B44fA1IH4I8ObwmS9ETL8BoDkEOBAvBDgQPwR4fXzGcwABDgDNIb6BeCHAgfghvqvjM51DiG8AaIzpNxA/xDcQL0y/z8RnOccw/QaA5hDgQLww/QbihwA/ITaPE7Pzzw8uBfG4CMv8YI8kafa89WEvBQCc1v/EnMbO4dFjQFz0PFn+36mzefwYEBcTP8pJknq3ToS9lLaYmJhQf3+/jDE1X2NspVgj7rnnntPmzZvDXgYAAAAAIGHGx8c1MDBQ8+djE95BEOjAgQMNv9OQRBMTE9q8ebP27dtX9w8D0En8uYSL+HMJV/FnEy7izyVcFNafy0YdGput5p7nadOmTWEvw2kDAwN8UoRz+HMJF/HnEq7izyZcxJ9LuMi1P5ecYAEAAAAAQBsR3gAAAAAAtBHhnQC5XE4f/OAHlcvlwl4KsIA/l3ARfy7hKv5swkX8uYSLXP1zGZvD1QAAAAAAcBETbwAAAAAA2ojwBgAAAACgjQhvAAAAAADaiPAGAAAAAKCNCG8AAAAAANqI8E6gj3zkI7rsssvU09OjFStWhL0cJNRNN92ks846S11dXbr44ov14IMPhr0kJNx9992nN7zhDdqwYYOMMfryl78c9pKQcDfeeKMuuugi9ff3a82aNXrTm96kXbt2hb0sJNzNN9+s888/XwMDAxoYGNCll16qb3zjG2EvCzjFRz/6URljdN1114W9lAWEdwIVCgW95S1v0bvf/e6wl4KE+sIXvqDrr79eH/zgB/Xoo49q586des1rXqMjR46EvTQk2PT0tHbu3Kmbbrop7KUAkqR7771X11xzjR544AF961vfUrFY1JVXXqnp6emwl4YE27Rpkz760Y/qkUce0cMPP6xXvvKVeuMb36gnnngi7KUBkqSHHnpIn/nMZ3T++eeHvZRT8BzvBLvlllt03XXXaWxsLOylIGEuvvhiXXTRRfr0pz8tSQqCQJs3b9Z73vMevfe97w17eYCMMbrjjjv0pje9KeylAAuOHj2qNWvW6N5779XLX/7ysJcDLBgeHtYnPvEJvfOd7wx7KUi4qakpveQlL9Ff/uVf6sMf/rAuuOACfepTnwp7WRITbwCdVigU9Mgjj+iKK65YeJ/nebriiiv03e9+N9S1AYDLxsfHpfnIAVzg+75uv/12TU9P69JLLw17OYCuueYavf71rz/lOtMV6bAXACBZjh07Jt/3tXbt2lPev3btWv34xz8ObV0A4LIgCHTdddfpZS97mV70oheFvRwk3A9/+ENdeumlmpubU19fn+644w6dd955YS8LCXf77bfr0Ucf1UMPPRT2Uqpi4h0T733ve2WMqftG1AAAEE3XXHONHn/8cd1+++1hLwXQjh079Nhjj+l73/ue3v3ud+vtb3+7nnzyybCXhQTbt2+ffud3fkef//zn1dXVFfZyqmLiHRO/93u/p9/4jd+o+5qzzz67Y+sBalm1apVSqZQOHz58yvsPHz6sdevWhbYuAHDVtddeq6997Wu67777tGnTprCXAyibzeqcc86RJF144YV66KGH9N/+23/TZz7zmbCXhoR65JFHdOTIEb3kJS9ZeJ/v+7rvvvv06U9/Wvl8XqlUKtQ1Et4xsXr1aq1evTrsZQANZbNZXXjhhbr77rsXDq4KgkB33323rr322rCXBwDOsNbqPe95j+644w7dc8892rZtW9hLAqoKgkD5fD7sZSDBXvWqV+mHP/zhKe97xzveoXPPPVd/8Ad/EHp0i/BOpr1792pkZER79+6V7/t67LHHJEnnnHOO+vr6wl4eEuD666/X29/+dr30pS/Vz/7sz+pTn/qUpqen9Y53vCPspSHBpqam9NRTTy38eM+ePXrsscc0PDysLVu2hLo2JNM111yj2267Tf/4j/+o/v5+HTp0SJI0ODio7u7usJeHhLrhhht01VVXacuWLZqcnNRtt92me+65R3feeWfYS0OC9ff3n3H+RW9vr1auXOnMuRiEdwJ94AMf0Oc+97mFH7/4xS+WJH3729/W5ZdfHuLKkBRXX321jh49qg984AM6dOiQLrjgAn3zm98848A1oJMefvhhveIVr1j48fXXXy9Jevvb365bbrklxJUhqW6++WZJOuNr89/93d81vL0MaJcjR47o13/913Xw4EENDg7q/PPP15133qlXv/rVYS8NcBrP8QYAAAAAoI041RwAAAAAgDYivAEAAAAAaCPCGwAAAACANiK8AQAAAABoI8IbAAAAAIA2IrwBAAAAAGgjwhsAAAAAgDYivAEAAAAAaCPCGwAAAACANiK8AQBIiCAIdO655+p973vfKe//+te/rmw2qy996UuhrQ0AgDgjvAEASAjP83TDDTfopptu0vj4uCTp0Ucf1dVXX62Pfexj+sVf/MWwlwgAQCwZa60NexEAAKAzSqWSnv/85+ud73yn3va2t+mSSy7RL/3SL+m///f/HvbSAACILcIbAICE+cxnPqM//MM/1Nq1a7V9+3bdcccd8jw2wQEA0C58lQUAIGF+7dd+TVNTUzLG6H/9r/91RnR/7Wtf044dO/S85z1Pn/3sZ0NbJwAAcZEOewEAAKCzrr32WknSsWPHzojuUqmk66+/Xt/+9rc1ODioCy+8UG9+85u1cuXKkFYLAED0MfEGACBB3v/+9+vrX/+6HnjgAZVKJf3N3/zNKT//4IMP6oUvfKE2btyovr4+XXXVVbrrrrtCWy8AAHFAeAMAkBB//dd/rU9+8pP66le/qp07d+q6667Txz/+cRWLxYXXHDhwQBs3blz48caNG7V///6QVgwAQDwQ3gAAJMA//dM/6dprr9XnP/95XXLJJdL8lvPx8XHdeuutYS8PAIBYI7wBAIi5Rx55RG9961v18Y9/XG9+85sX3j84OKjf/u3f1kc/+lH5vi9J2rBhwykT7v3792vDhg2hrBsAgLjgcWIAAGBBqVTSC17wAt1zzz0Lh6vdf//9HK4GAMAycKo5AABYkE6n9clPflKveMUrFASBfv/3f5/oBgBgmZh4AwAAAADQRtzjDQAAAABAGxHeAAAAAAC0EeENAAAAAEAbEd4AAAAAALQR4Q0AAAAAQBsR3gAAAAAAtBHhDQAAAABAGxHeAAAAAAC0EeENAAAAAEAbEd4AAAAAALQR4Q0AAAAAQBv9/4BaS6xKlXHoAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "posterior_predictive_plot(particles)" + "Z_mcmc_2 = posterior_predictive_plot(particles)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "68218051-5ee0-41e0-91ae-4cbe94d21e23", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(Array(0.13222471, dtype=float32), Array(0.9617157, dtype=float32))" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.min(Z_mcmc_2), np.max(Z_mcmc_2)" ] }, { @@ -535,7 +809,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "647d1be6", "metadata": {}, "outputs": [], @@ -561,7 +835,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "id": "4e3d2364", "metadata": {}, "outputs": [], @@ -571,17 +845,79 @@ }, { "cell_type": "code", - "execution_count": null, - "id": "a2adf9e7", + "execution_count": 32, + "id": "2895b1a2-889f-4e6e-a72a-5670617e4e13", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "Array(0., dtype=float32)" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.sum(normalizing_constant_waste_free[:total_steps_waste_free]) #log scale" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "f9f75aa2-9deb-4188-b11a-1757ae2f9a91", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62480/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Array([[0.02926168, 0.03162239, 0.0342155 , ..., 0.6721513 , 0.68868244,\n", + " 0.7042139 ],\n", + " [0.03172185, 0.03427563, 0.03707994, ..., 0.68726957, 0.70317787,\n", + " 0.7181016 ],\n", + " [0.03439488, 0.03715712, 0.04018922, ..., 0.7021 , 0.71738654,\n", + " 0.73170614],\n", + " ...,\n", + " [0.6933465 , 0.715117 , 0.7361818 , ..., 0.99362504, 0.9940435 ,\n", + " 0.99442685],\n", + " [0.7091236 , 0.7303853 , 0.75086385, ..., 0.9940827 , 0.9944701 ,\n", + " 0.99482614],\n", + " [0.7244788 , 0.7451816 , 0.7650328 , ..., 0.99450475, 0.9948642 ,\n", + " 0.9951936 ]], dtype=float32)" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "posterior_predictive_plot(final_state_waste_free.sampler_state.particles)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "630b6a13", "metadata": {}, "outputs": [], @@ -591,53 +927,220 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "c1997aa9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_62480/4095671798.py:9: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "\n", "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", "for i, axi in enumerate(ax):\n", - " axi.hist(chains[:,i])\n", - " axi.hist(particles[:, i])\n", - " axi.hist(particles_waste_free[:, i])\n", + " axi.hist(chains[:,i], label=\"MH\")\n", + " axi.hist(particles[:, i], label=\"SMC\")\n", + " axi.hist(particles_waste_free[:, i],label=\"WF\")\n", + " \n", + "\n", " axi.set_title(f\"$w_{i}$\")\n", + " plt.legend()\n", "plt.show()" ] }, + { + "cell_type": "markdown", + "id": "966c65d4-1699-4cb5-b3c2-d1eac1a4dd88", + "metadata": {}, + "source": [ + "There's a big difference in posteriors for SMC vs SMC-WasteFree" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "9c90387f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(Array(-0.01791389, dtype=float32),\n", + " Array(-0.64235276, dtype=float32),\n", + " Array(-1.4553034, dtype=float32))" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - " final_state_waste_free.sampler_state" + "np.mean(chains[:,0]), np.mean(particles[:,0]), np.mean(particles_waste_free[:,0]), " ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "id": "df47baa9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "StateWithParameterOverride(sampler_state=TemperedSMCState(particles=Array([[-1.7003354 , 0.8432715 , 1.2795514 ],\n", + " [-1.0450116 , 1.0331315 , 0.48102152],\n", + " [-1.7003354 , 0.8432715 , 1.2795514 ],\n", + " ...,\n", + " [-1.0532204 , 0.11202506, 0.9025311 ],\n", + " [-1.0532204 , 0.11202506, 0.9025311 ],\n", + " [-1.0532204 , 0.11202506, 0.9025311 ]], dtype=float32), weights=Array([5.2097013e-05, 4.6736131e-05, 5.2097013e-05, ..., 4.2692016e-05,\n", + " 4.2692016e-05, 4.2692016e-05], dtype=float32), lmbda=Array(1., dtype=float32, weak_type=True)), parameter_override={'cov': Array([[[ 0.17416753, 0.01399391, -0.1476322 ],\n", + " [ 0.01399391, 0.0592518 , -0.03197484],\n", + " [-0.1476322 , -0.03197484, 0.16884296]]], dtype=float32)})" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "final_state_waste_free" ] }, + { + "cell_type": "markdown", + "id": "9c6d5d22-4bf2-48df-a0a3-b4beac70ae61", + "metadata": {}, + "source": [ + "Note that to achieve similar results, SMC will take" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "id": "b2088325", "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(700000, dtype=int32, weak_type=True)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_steps * 5 * n_particles" + ] + }, + { + "cell_type": "markdown", + "id": "c0d8c6cb-f1a9-4783-89ff-b86eaf73d404", + "metadata": {}, + "source": [ + "inner MCMC steps (with their corresponding density evaluations), whereas Waste-Free is going to take" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "415e3148-5093-4841-84b7-a2c3993b6629", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Array(234000., dtype=float32, weak_type=True)" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "total_steps_waste_free * n_particles/10 * 9 " + ] + }, + { + "cell_type": "markdown", + "id": "d584f684-6748-4538-adf2-4c1be0b1f224", + "metadata": {}, + "source": [ + "inner MCMC steps." + ] + }, + { + "cell_type": "markdown", + "id": "4655f049-96c2-4c12-9650-dd20d51ec298", + "metadata": {}, + "source": [ + "Confusion matrix in sample for waste free" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "de1497e2-ee8b-4a7e-877c-f788274ed843", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[27, 0],\n", + " [ 0, 23]])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pred3=(predict(Phi,np.mean(particles_waste_free, axis=0))>0.5).astype(int)\n", + "sklearn.metrics.confusion_matrix(y, pred3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e4970b81-20d7-47dd-bbf0-907c77195718", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f02b8e09-e0b9-4bd0-9cff-24905e39ed97", + "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "jupytext": { - "formats": "md,ipynb" + "formats": "md:myst,ipynb" }, "kernelspec": { "display_name": "Python 3 (ipykernel)", diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index 4f74f719a..d0fa94fa0 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -16,8 +16,8 @@ from blackjax.smc.waste_free import update_waste_free, waste_free_smc from tests.smc import SMCLinearRegressionTestCase -#jax.config.update("jax_disable_jit", True) # for easier debugging -class TemperedSMCTest(SMCLinearRegressionTestCase): + +class WasteFreeSMCTest(SMCLinearRegressionTestCase): """Test posterior mean estimate.""" def setUp(self): @@ -67,14 +67,7 @@ def body_fn(carry, lmbda): self.assert_linear_regression_test_case(result) -#class UpdateWasteFreeTest(chex.TestCase): -# update_waste_free(mcmc_init_fn, -# logposterior_fn, -# mcmc_step_fn, -# n_particles: int, -# p: int, -# num_resampled, -# num_mcmc_steps): + if __name__ == "__main__": From f0ce4baecd07b9d6186e1295a09ee3a184d99a87 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Thu, 15 Aug 2024 16:23:23 -0300 Subject: [PATCH 07/29] tests in place --- blackjax/__init__.py | 5 -- blackjax/smc/adaptive_tempered.py | 4 +- blackjax/smc/tempered.py | 34 ++++++----- blackjax/smc/waste_free.py | 40 ++++++++----- tests/smc/test_smc.py | 94 ++++++++++++++----------------- tests/smc/test_waste_free_smc.py | 42 ++++++++++++-- 6 files changed, 126 insertions(+), 93 deletions(-) diff --git a/blackjax/__init__.py b/blackjax/__init__.py index 6c85e2afc..a66e51c76 100644 --- a/blackjax/__init__.py +++ b/blackjax/__init__.py @@ -3,7 +3,6 @@ from blackjax._version import __version__ - from .base import SamplingAlgorithm, VIAlgorithm from .diagnostics import effective_sample_size as ess from .diagnostics import potential_scale_reduction as rhat @@ -24,12 +23,10 @@ normal_random_walk, rmh_as_top_level_api, ) - from .smc import adaptive_tempered from .smc import inner_kernel_tuning as _inner_kernel_tuning from .smc import tempered - """ The above three classes exist as a backwards compatible way of exposing both the high level, differentiable factory and the low level components, which may not be differentiable. Moreover, this design allows for the lower @@ -61,7 +58,6 @@ def __call__(self, *args, **kwargs) -> VIAlgorithm: return self.differentiable(*args, **kwargs) - def generate_top_level_api_from(module): return GenerateSamplingAPI( module.as_top_level_api, module.init, module.build_kernel @@ -105,7 +101,6 @@ def generate_top_level_api_from(module): __all__ = [ "__version__", - "ess", # diagnostics "rhat", ] diff --git a/blackjax/smc/adaptive_tempered.py b/blackjax/smc/adaptive_tempered.py index 7cbf3ff08..9e773e9b6 100644 --- a/blackjax/smc/adaptive_tempered.py +++ b/blackjax/smc/adaptive_tempered.py @@ -34,7 +34,7 @@ def build_kernel( resampling_fn: Callable, target_ess: float, root_solver: Callable = solver.dichotomy, - **extra_parameters + **extra_parameters, ) -> Callable: r"""Build a Tempered SMC step using an adaptive schedule. @@ -89,7 +89,7 @@ def compute_delta(state: tempered.TemperedSMCState) -> float: mcmc_step_fn, mcmc_init_fn, resampling_fn, - **extra_parameters + **extra_parameters, ) def kernel( diff --git a/blackjax/smc/tempered.py b/blackjax/smc/tempered.py index 04990796d..19de8afb7 100644 --- a/blackjax/smc/tempered.py +++ b/blackjax/smc/tempered.py @@ -48,16 +48,19 @@ def init(particles: ArrayLikeTree): return TemperedSMCState(particles, weights, 0.0) -def update_and_take_last(mcmc_init_fn, - tempered_logposterior_fn, - shared_mcmc_step_fn, - num_mcmc_steps, - n_particles): +def update_and_take_last( + mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + num_mcmc_steps, + n_particles, +): """ Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and returns the last values, waisting the previous num_mcmc_steps-1 samples per chain. """ + def mcmc_kernel(rng_key, position, step_parameters): state = mcmc_init_fn(position, tempered_logposterior_fn) @@ -80,7 +83,7 @@ def build_kernel( mcmc_step_fn: Callable, mcmc_init_fn: Callable, resampling_fn: Callable, - update_strategy: Callable = update_and_take_last + update_strategy: Callable = update_and_take_last, ) -> Callable: """Build the base Tempered SMC kernel. @@ -168,11 +171,13 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: shared_mcmc_step_fn = partial(mcmc_step_fn, **shared_mcmc_parameters) - update_fn, num_resampled = update_strategy(mcmc_init_fn, - tempered_logposterior_fn, - shared_mcmc_step_fn, - n_particles=state.weights.shape[0], - num_mcmc_steps=num_mcmc_steps) + update_fn, num_resampled = update_strategy( + mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + n_particles=state.weights.shape[0], + num_mcmc_steps=num_mcmc_steps, + ) smc_state, info = smc.base.step( rng_key, @@ -180,7 +185,7 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: update_fn, jax.vmap(log_weights_fn), resampling_fn, - num_resampled + num_resampled, ) tempered_state = TemperedSMCState( @@ -200,7 +205,7 @@ def as_top_level_api( mcmc_parameters: dict, resampling_fn: Callable, num_mcmc_steps: Optional[int] = 10, - update_strategy = update_and_take_last + update_strategy=update_and_take_last, ) -> SamplingAlgorithm: """Implements the (basic) user interface for the Adaptive Tempered SMC kernel. @@ -228,14 +233,13 @@ def as_top_level_api( """ - kernel = build_kernel( logprior_fn, loglikelihood_fn, mcmc_step_fn, mcmc_init_fn, resampling_fn, - update_strategy + update_strategy, ) def init_fn(position: ArrayLikeTree, rng_key=None): diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py index eca6472c6..2f0ced582 100644 --- a/blackjax/smc/waste_free.py +++ b/blackjax/smc/waste_free.py @@ -1,16 +1,19 @@ -import jax.lax +import functools + import jax +import jax.lax import jax.numpy as jnp -import functools -def update_waste_free(mcmc_init_fn, - logposterior_fn, - mcmc_step_fn, - n_particles: int, - p: int, - num_resampled, - num_mcmc_steps): +def update_waste_free( + mcmc_init_fn, + logposterior_fn, + mcmc_step_fn, + n_particles: int, + p: int, + num_resampled, + num_mcmc_steps=None, +): """ Given M particles, mutates them using p-1 steps. Returns M*P-1 particles, consistent of the initial plus all the intermediate steps, thus implementing a @@ -18,9 +21,11 @@ def update_waste_free(mcmc_init_fn, See Algorithm 2: https://arxiv.org/abs/2011.02328 """ if num_mcmc_steps is not None: - raise ValueError("Can't use waste free SMC with a num_mcmc_steps parameter, set num_mcmc_steps = None") + raise ValueError( + "Can't use waste free SMC with a num_mcmc_steps parameter, set num_mcmc_steps = None" + ) - num_mcmc_steps = p-1 + num_mcmc_steps = p - 1 def mcmc_kernel(rng_key, position, step_parameters): state = mcmc_init_fn(position, logposterior_fn) @@ -31,7 +36,9 @@ def body_fn(state, rng_key): ) return new_state, (new_state, info) - _, (states, infos) = jax.lax.scan(body_fn, state, jax.random.split(rng_key, num_mcmc_steps)) + _, (states, infos) = jax.lax.scan( + body_fn, state, jax.random.split(rng_key, num_mcmc_steps) + ) return states, infos def update(rng_key, position, step_parameters): @@ -41,18 +48,23 @@ def update(rng_key, position, step_parameters): at each step of each chain. """ states, infos = jax.vmap(mcmc_kernel)(rng_key, position, step_parameters) + # step particles is num_resmapled, num_mcmc_steps, dimension_of_variable # want to transformed into num_resampled * num_mcmc_steps, dimension of variable def reshape_step_particles(x): if len(x.shape) > 2: - return x.reshape((x.shape[0]*x.shape[1], -1)) + return x.reshape((x.shape[0] * x.shape[1], -1)) else: return x.flatten() step_particles = jax.tree.map(reshape_step_particles, states.position) - new_particles = jax.tree.map(lambda x,y: jnp.concatenate([x,y]), position, step_particles) + new_particles = jax.tree.map( + lambda x, y: jnp.concatenate([x, y]), position, step_particles + ) return new_particles, infos + return update, num_resampled + def waste_free_smc(n_particles, p): return functools.partial(update_waste_free, num_resampled=int(n_particles / p), p=p) diff --git a/tests/smc/test_smc.py b/tests/smc/test_smc.py index 6366182a8..b0e86e0b0 100644 --- a/tests/smc/test_smc.py +++ b/tests/smc/test_smc.py @@ -1,4 +1,6 @@ """Test the generic SMC sampler""" +import functools + import chex import jax import jax.numpy as jnp @@ -9,6 +11,8 @@ import blackjax import blackjax.smc.resampling as resampling from blackjax.smc.base import extend_params, init, step +from blackjax.smc.tempered import update_and_take_last +from blackjax.smc.waste_free import update_waste_free def logdensity_fn(position): @@ -29,82 +33,66 @@ def setUp(self): @chex.variants(with_jit=True) def test_smc(self): num_mcmc_steps = 20 - num_particles = 1000 - - def update_fn(rng_key, position, update_params): - hmc = blackjax.hmc(logdensity_fn, **update_params) - state = hmc.init(position) - - def body_fn(state, rng_key): - new_state, info = hmc.step(rng_key, state) - return new_state, info - - keys = jax.random.split(rng_key, num_mcmc_steps) - last_state, info = jax.lax.scan(body_fn, state, keys) - return last_state.position, info - - init_key, sample_key = jax.random.split(self.key) + num_particles = 5000 - # Initialize the state of the SMC sampler - init_particles = 0.25 + jax.random.normal(init_key, shape=(num_particles,)) same_for_all_params = dict( step_size=1e-2, inverse_mass_matrix=jnp.eye(1), num_integration_steps=50 ) + hmc_kernel = functools.partial( + blackjax.hmc.build_kernel(), **same_for_all_params + ) + hmc_init = blackjax.hmc.init - state = init( - init_particles, - same_for_all_params, + update_fn, _ = update_and_take_last( + hmc_init, logdensity_fn, hmc_kernel, num_mcmc_steps, num_particles ) + init_key, sample_key = jax.random.split(self.key) + # Initialize the state of the SMC sampler + init_particles = 0.25 + jax.random.normal(init_key, shape=(num_particles,)) + state = init(init_particles, {}) # Run the SMC sampler once new_state, info = self.variant(step, static_argnums=(2, 3, 4))( sample_key, state, - jax.vmap(update_fn, in_axes=(0, 0, None)), + update_fn, jax.vmap(logdensity_fn), resampling.systematic, ) + assert new_state.particles.shape == (num_particles,) mean, std = _weighted_avg_and_std(new_state.particles, state.weights) - np.testing.assert_allclose(0.0, mean, atol=1e-1) - np.testing.assert_allclose(1.0, std, atol=1e-1) + np.testing.assert_allclose(mean, 0.0, atol=1e-1) + np.testing.assert_allclose(std, 1.0, atol=1e-1) @chex.variants(with_jit=True) def test_smc_waste_free(self): - num_mcmc_steps = 10 + p = 500 num_particles = 1000 - num_resampled = num_particles // num_mcmc_steps - - def waste_free_update_fn(keys, particles, update_params): - def one_particle_fn(rng_key, position, particle_update_params): - hmc = blackjax.hmc(logdensity_fn, **particle_update_params) - state = hmc.init(position) - - def body_fn(state, rng_key): - new_state, info = hmc.step(rng_key, state) - return new_state, (state, info) - - keys = jax.random.split(rng_key, num_mcmc_steps) - _, (states, info) = jax.lax.scan(body_fn, state, keys) - return states.position, info - - particles, info = jax.vmap(one_particle_fn, in_axes=(0, 0, None))( - keys, particles, update_params - ) - particles = particles.reshape((num_particles,)) - return particles, info - + num_resampled = num_particles // p init_key, sample_key = jax.random.split(self.key) # Initialize the state of the SMC sampler init_particles = 0.25 + jax.random.normal(init_key, shape=(num_particles,)) state = init( init_particles, - dict( - step_size=1e-2, - inverse_mass_matrix=jnp.eye(1), - num_integration_steps=100, - ), + {}, + ) + same_for_all_params = dict( + step_size=1e-2, inverse_mass_matrix=jnp.eye(1), num_integration_steps=50 + ) + hmc_kernel = functools.partial( + blackjax.hmc.build_kernel(), **same_for_all_params + ) + hmc_init = blackjax.hmc.init + + waste_free_update_fn, _ = update_waste_free( + hmc_init, + logdensity_fn, + hmc_kernel, + num_particles, + p=p, + num_resampled=num_resampled, ) # Run the SMC sampler once @@ -116,10 +104,10 @@ def body_fn(state, rng_key): resampling.systematic, num_resampled, ) - + assert new_state.particles.shape == (num_particles,) mean, std = _weighted_avg_and_std(new_state.particles, state.weights) - np.testing.assert_allclose(0.0, mean, atol=1e-1) - np.testing.assert_allclose(1.0, std, atol=1e-1) + np.testing.assert_allclose(mean, 0.0, atol=1e-1) + np.testing.assert_allclose(std, 1.0, atol=1e-1) class ExtendParamsTest(chex.TestCase): diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index d0fa94fa0..3d99b3c92 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -4,17 +4,16 @@ import chex import jax import jax.numpy as jnp -import jax.scipy.stats as stats import numpy as np from absl.testing import absltest import blackjax import blackjax.smc.resampling as resampling -import blackjax.smc.solver as solver from blackjax import adaptive_tempered_smc, tempered_smc from blackjax.smc import extend_params -from blackjax.smc.waste_free import update_waste_free, waste_free_smc +from blackjax.smc.waste_free import waste_free_smc from tests.smc import SMCLinearRegressionTestCase +from tests.smc.test_tempered_smc import inference_loop class WasteFreeSMCTest(SMCLinearRegressionTestCase): @@ -23,6 +22,7 @@ class WasteFreeSMCTest(SMCLinearRegressionTestCase): def setUp(self): super().setUp() self.key = jax.random.key(42) + @chex.variants(with_jit=True) def test_fixed_schedule_tempered_smc(self): ( @@ -52,7 +52,7 @@ def test_fixed_schedule_tempered_smc(self): hmc_parameters, resampling.systematic, None, - waste_free_smc(100,4) + waste_free_smc(100, 4), ) init_state = tempering.init(init_particles) smc_kernel = self.variant(tempering.step) @@ -66,8 +66,42 @@ def body_fn(carry, lmbda): (_, result), _ = jax.lax.scan(body_fn, (0, init_state), lambda_schedule) self.assert_linear_regression_test_case(result) + @chex.variants(with_jit=True) + def test_adaptive_tempered_smc(self): + ( + init_particles, + logprior_fn, + loglikelihood_fn, + ) = self.particles_prior_loglikelihood() + hmc_init = blackjax.hmc.init + hmc_kernel = blackjax.hmc.build_kernel() + hmc_parameters = extend_params( + { + "step_size": 10e-2, + "inverse_mass_matrix": jnp.eye(2), + "num_integration_steps": 50, + }, + ) + tempering = adaptive_tempered_smc( + logprior_fn, + loglikelihood_fn, + hmc_kernel, + hmc_init, + hmc_parameters, + resampling.systematic, + 0.5, + update_strategy=waste_free_smc(100, 4), + num_mcmc_steps=None, + ) + init_state = tempering.init(init_particles) + + n_iter, result, log_likelihood = self.variant( + functools.partial(inference_loop, tempering.step) + )(self.key, init_state) + + self.assert_linear_regression_test_case(result) if __name__ == "__main__": From 35766901c52a2c7796ac3a161ec5b44091f18cb0 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Thu, 15 Aug 2024 16:29:02 -0300 Subject: [PATCH 08/29] rolling back changes --- blackjax/__init__.py | 57 + logistic_regression-different-prior.ipynb | 1165 --------------------- logistic_regression.ipynb | 1165 --------------------- 3 files changed, 57 insertions(+), 2330 deletions(-) delete mode 100644 logistic_regression-different-prior.ipynb delete mode 100644 logistic_regression.ipynb diff --git a/blackjax/__init__.py b/blackjax/__init__.py index a66e51c76..dfdcfc545 100644 --- a/blackjax/__init__.py +++ b/blackjax/__init__.py @@ -3,6 +3,11 @@ from blackjax._version import __version__ +from .adaptation.chees_adaptation import chees_adaptation +from .adaptation.mclmc_adaptation import mclmc_find_L_and_step_size +from .adaptation.meads_adaptation import meads_adaptation +from .adaptation.pathfinder_adaptation import pathfinder_adaptation +from .adaptation.window_adaptation import window_adaptation from .base import SamplingAlgorithm, VIAlgorithm from .diagnostics import effective_sample_size as ess from .diagnostics import potential_scale_reduction as rhat @@ -23,9 +28,19 @@ normal_random_walk, rmh_as_top_level_api, ) +from .optimizers import dual_averaging, lbfgs +from .sgmcmc import csgld as _csgld +from .sgmcmc import sghmc as _sghmc +from .sgmcmc import sgld as _sgld +from .sgmcmc import sgnht as _sgnht from .smc import adaptive_tempered from .smc import inner_kernel_tuning as _inner_kernel_tuning from .smc import tempered +from .vi import meanfield_vi as _meanfield_vi +from .vi import pathfinder as _pathfinder +from .vi import schrodinger_follmer as _schrodinger_follmer +from .vi import svgd as _svgd +from .vi.pathfinder import PathFinderAlgorithm """ The above three classes exist as a backwards compatible way of exposing both the high level, differentiable @@ -58,6 +73,16 @@ def __call__(self, *args, **kwargs) -> VIAlgorithm: return self.differentiable(*args, **kwargs) +@dataclasses.dataclass +class GeneratePathfinderAPI: + differentiable: Callable + approximate: Callable + sample: Callable + + def __call__(self, *args, **kwargs) -> PathFinderAlgorithm: + return self.differentiable(*args, **kwargs) + + def generate_top_level_api_from(module): return GenerateSamplingAPI( module.as_top_level_api, module.init, module.build_kernel @@ -98,9 +123,41 @@ def generate_top_level_api_from(module): smc_family = [tempered_smc, adaptive_tempered_smc] "Step_fn returning state has a .particles attribute" +# stochastic gradient mcmc +sgld = generate_top_level_api_from(_sgld) +sghmc = generate_top_level_api_from(_sghmc) +sgnht = generate_top_level_api_from(_sgnht) +csgld = generate_top_level_api_from(_csgld) +svgd = generate_top_level_api_from(_svgd) + +# variational inference +meanfield_vi = GenerateVariationalAPI( + _meanfield_vi.as_top_level_api, + _meanfield_vi.init, + _meanfield_vi.step, + _meanfield_vi.sample, +) +schrodinger_follmer = GenerateVariationalAPI( + _schrodinger_follmer.as_top_level_api, + _schrodinger_follmer.init, + _schrodinger_follmer.step, + _schrodinger_follmer.sample, +) + +pathfinder = GeneratePathfinderAPI( + _pathfinder.as_top_level_api, _pathfinder.approximate, _pathfinder.sample +) + __all__ = [ "__version__", + "dual_averaging", # optimizers + "lbfgs", + "window_adaptation", # mcmc adaptation + "meads_adaptation", + "chees_adaptation", + "pathfinder_adaptation", + "mclmc_find_L_and_step_size", # mclmc adaptation "ess", # diagnostics "rhat", ] diff --git a/logistic_regression-different-prior.ipynb b/logistic_regression-different-prior.ipynb deleted file mode 100644 index 770bfb808..000000000 --- a/logistic_regression-different-prior.ipynb +++ /dev/null @@ -1,1165 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "3cdc536d", - "metadata": {}, - "source": [ - "# Waste Free SMC comparison\n", - "\n", - "In this notebook we take again a Logistic Regression model, and compare MH, SMC and Waste-Free SMC" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "de1922dd", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e7dba964", - "metadata": { - "tags": [ - "hide-cell" - ] - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import sklearn\n", - "\n", - "plt.rcParams[\"axes.spines.right\"] = False\n", - "plt.rcParams[\"axes.spines.top\"] = False\n", - "plt.rcParams[\"figure.figsize\"] = (12, 8)\n", - "import jax\n", - "\n", - "from datetime import date\n", - "rng_key = jax.random.key(int(date.today().strftime(\"%Y%m%d\")))\n", - "import jax.numpy as jnp\n", - "from sklearn.datasets import make_biclusters\n", - "import blackjax" - ] - }, - { - "cell_type": "markdown", - "id": "ee12f75d", - "metadata": {}, - "source": [ - "## The Data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7ec4566a", - "metadata": {}, - "outputs": [], - "source": [ - "num_points = 50\n", - "X, rows, cols = make_biclusters(\n", - " (num_points, 2), 2, noise=0.6, random_state=314, minval=-3, maxval=3\n", - ")\n", - "y = rows[0] * 1.0 # y[i] = whether point i belongs to cluster 1" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "40210fca", - "metadata": { - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "colors = [\"tab:red\" if el else \"tab:blue\" for el in rows[0]]\n", - "plt.scatter(*X.T, edgecolors=colors, c=\"none\")\n", - "plt.xlabel(r\"$X_0$\")\n", - "plt.ylabel(r\"$X_1$\");" - ] - }, - { - "cell_type": "markdown", - "id": "49f196c9", - "metadata": {}, - "source": [ - "## The Model\n", - "\n", - "We use a simple logistic regression model to infer to which cluster each of the points belongs. We note $y$ a binary variable that indicates whether a point belongs to the first cluster :\n", - "\n", - "$$\n", - "y \\sim \\operatorname{Bernoulli}(p)\n", - "$$\n", - "\n", - "The probability $p$ to belong to the first cluster commes from a logistic regression:\n", - "\n", - "$$\n", - "p = \\operatorname{logistic}(\\Phi\\,\\boldsymbol{w})\n", - "$$\n", - "\n", - "where $w$ is a vector of weights whose priors are a normal prior centered on 0:\n", - "\n", - "$$\n", - "\\boldsymbol{w} \\sim \\operatorname{Normal}(0, \\sigma)\n", - "$$\n", - "\n", - "And $\\Phi$ is the matrix that contains the data, so each row $\\Phi_{i,:}$ is the vector $\\left[1, X_0^i, X_1^i\\right]$" - ] - }, - { - "cell_type": "markdown", - "id": "9af4ac0f-a441-4c2f-a22a-3b5112599c3d", - "metadata": {}, - "source": [ - "Note that X is not normalized" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f3c7dd2f", - "metadata": { - "tags": [ - "hide-stderr" - ] - }, - "outputs": [], - "source": [ - "Phi = jnp.c_[jnp.ones(num_points)[:, None], X]\n", - "N, M = Phi.shape\n", - "\n", - "\n", - "def sigmoid(z):\n", - " return jnp.exp(z) / (1 + jnp.exp(z))\n", - "\n", - "\n", - "def log_sigmoid(z):\n", - " return z - jnp.log(1 + jnp.exp(z))\n", - "\n", - "def logprior(w, alpha=0.01):\n", - " prior_term = alpha * w @ w / 2\n", - " return -prior_term\n", - " \n", - "def loglikelihood(w):\n", - " \"\"\"The log-probability density function of the posterior distribution of the model.\"\"\"\n", - " log_an = log_sigmoid(Phi @ w)\n", - " an = Phi @ w\n", - " log_likelihood_term = y * log_an + (1 - y) * jnp.log(1 - sigmoid(an))\n", - " return log_likelihood_term.sum()\n", - " \n", - "def logdensity_fn(w, alpha=0.01):\n", - " return logprior(w,alpha) + loglikelihood(w)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "a5e8505c-aabb-4da5-ad73-cac475cfece9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Prior')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "w = jnp.linspace(0, 10).reshape(-1,1)\n", - "for alpha in [0.1, 0.5, 1, 2]:\n", - " plt.plot(w, jax.vmap(lambda x:jnp.exp(logprior(x, alpha)))(w), label=alpha)\n", - "\n", - "plt.legend()\n", - "plt.xlabel(\"Squared norm of w\")\n", - "plt.title(\"Prior\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "043aff76", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.linear_model import LogisticRegression" - ] - }, - { - "cell_type": "markdown", - "id": "93778681", - "metadata": {}, - "source": [ - "## Posterior Sampling\n", - "\n", - "We use `blackjax`'s Random Walk RMH kernel to sample from the posterior distribution." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "9889d938", - "metadata": {}, - "outputs": [], - "source": [ - "rng_key, init_key = jax.random.split(rng_key)\n", - "\n", - "w0 = jax.random.multivariate_normal(init_key, 0.1 + jnp.zeros(M), jnp.eye(M))\n", - "rmh = blackjax.rmh(logdensity_fn, blackjax.mcmc.random_walk.normal(jnp.ones(M) * 0.05))\n", - "initial_state = rmh.init(w0)\n", - "\n", - "def inference_loop(rng_key, kernel, initial_state, num_samples):\n", - " @jax.jit\n", - " def one_step(state, rng_key):\n", - " state, _ = kernel(rng_key, state)\n", - " return state, state\n", - "\n", - " keys = jax.random.split(rng_key, num_samples)\n", - " _, states = jax.lax.scan(one_step, initial_state, keys)\n", - "\n", - " return states\n", - "\n", - "rng_key, sample_key = jax.random.split(rng_key)\n", - "states = inference_loop(sample_key, rmh.step, initial_state, 5_000)" - ] - }, - { - "cell_type": "markdown", - "id": "3301e09c", - "metadata": {}, - "source": [ - "Trace display:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "69816b03", - "metadata": { - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "burnin = 300\n", - "\n", - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.plot(states.position[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - " axi.axvline(x=burnin, c=\"tab:red\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "1f1306a6", - "metadata": {}, - "outputs": [], - "source": [ - "burnin = 300\n", - "chains = states.position[burnin:, :]\n", - "nsamp, _ = chains.shape" - ] - }, - { - "cell_type": "markdown", - "id": "daa2e425", - "metadata": {}, - "source": [ - "# Classic SMC" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "263a7714", - "metadata": {}, - "outputs": [], - "source": [ - "import jax.numpy as jnp\n", - "import numpy as np\n", - "\n", - "from blackjax import adaptive_tempered_smc\n", - "from blackjax.smc import resampling, extend_params\n", - "from blackjax.smc.inner_kernel_tuning import StateWithParameterOverride\n", - "from blackjax.smc.tempered import TemperedSMCState\n", - "import jax\n", - "from jax import numpy as jnp\n", - "from datetime import date\n", - "import numpy as np\n", - "import pandas as pd\n", - "import functools\n", - "from jax.scipy.stats import multivariate_normal\n", - "from blackjax import additive_step_random_walk, inner_kernel_tuning\n", - "from blackjax.mcmc.random_walk import normal\n", - "from blackjax.smc.tuning.from_particles import (\n", - " particles_covariance_matrix\n", - ")\n", - "\n", - "n_predictors = 3\n", - "def initial_particles_multivariate_normal(key, n_samples):\n", - " return jax.random.multivariate_normal(\n", - " key, jnp.zeros(n_predictors) + 0.1, jnp.eye(n_predictors), (n_samples,)\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "88ccaf4c", - "metadata": {}, - "outputs": [], - "source": [ - "n_particles = 20000\n", - "key = jax.random.PRNGKey(10)\n", - "key, initial_particles_key, iterations_key = jax.random.split(key, 3)\n", - "initial_particles = initial_particles_multivariate_normal(initial_particles_key, n_particles)\n", - "initial_parameter_value = extend_params({\"cov\": particles_covariance_matrix(initial_particles)})\n", - "\n", - "\n", - "def mcmc_parameter_update_fn(state: TemperedSMCState, info):\n", - " sigma_particles = particles_covariance_matrix(state.particles) * 2.38 / np.sqrt(n_predictors) \n", - " return extend_params({\"cov\":sigma_particles})\n", - "\n", - "def step_fn(key, state, logdensity, cov):\n", - " return blackjax.rmh(logdensity, normal(cov)).step(key, state)\n", - "\n", - "\n", - "kernel_tuned_proposal = inner_kernel_tuning(\n", - " logprior_fn=logprior,\n", - " loglikelihood_fn=loglikelihood,\n", - " mcmc_step_fn=step_fn,\n", - " mcmc_init_fn=blackjax.rmh.init,\n", - " resampling_fn=resampling.systematic,\n", - " smc_algorithm=adaptive_tempered_smc,\n", - " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", - " initial_parameter_value=initial_parameter_value,\n", - " target_ess=0.5,\n", - " num_mcmc_steps=5,\n", - ")\n", - "\n", - "from blackjax.smc.base import SMCInfo\n", - "def loop(kernel, rng_key, initial_state):\n", - " normalizing_constant = jnp.zeros((1000))\n", - "\n", - " def cond(carry):\n", - " _, state, _ = carry\n", - " return state.sampler_state.lmbda < 1\n", - "\n", - " def body(carry):\n", - " i, state, op_key = carry\n", - " op_key, subkey = jax.random.split(op_key, 2)\n", - " state, info = kernel(subkey, state)\n", - " normalizing_constant.at[i].set(info.log_likelihood_increment)\n", - " return i + 1, state, op_key\n", - "\n", - " def f(initial_state, key):\n", - " total_iter, final_state, _ = jax.lax.while_loop(\n", - " cond, body, (0, initial_state, key)\n", - " )\n", - " return total_iter, final_state\n", - "\n", - " total_iter, final_state = f(initial_state, rng_key)\n", - " return total_iter, final_state, normalizing_constant" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "c0ccdccc", - "metadata": {}, - "outputs": [], - "source": [ - "total_steps, final_state, normalizing_constant = loop(kernel_tuned_proposal.step, iterations_key, kernel_tuned_proposal.init(initial_particles))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "6a672bcc", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(0., dtype=float32)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.sum(normalizing_constant[:total_steps]) #" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "50955c99-a2fd-46f8-8b4d-cad4ed0bbd48", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float32(1.0)" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.exp(np.sum(normalizing_constant[:total_steps]))" - ] - }, - { - "cell_type": "markdown", - "id": "105399cb-61bc-4283-a65b-8b2cc517dde9", - "metadata": {}, - "source": [ - "Why the log normalizing constant is always 0? Is it because of the prior shape?" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "81dae2ae", - "metadata": {}, - "outputs": [], - "source": [ - "particles = final_state.sampler_state.particles" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "85dd9f86", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+IAAADbCAYAAADphyuzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxJ0lEQVR4nO3dfXRU1b3/8U+eE0JmIsEkUAKmF5eQgkoAYaT1J5LF1MYqNdrLakAUhEInaJIWMC1FxEoQRVBAImqBuwoLYV0fiTzkBglVwkNjaXko0V6x4YKT0IuZKRQSSOb3R+VcBoIYyJwzk7xfa521yD57znz3yeQbvtnnnB3m8/l8AgAAAAAApgi3OgAAAAAAADoSCnEAAAAAAExEIQ4AAAAAgIkoxAEAAAAAMBGFOAAAAAAAJqIQBwAAAADARBTiAAAAAACYiEIcAAAAAAATUYgDAAAAAGAiCnEAAAAAAExEIQ4AAAAAgIkoxAEAAAAAMBGFONqt/Px8paSk+LVNnz5dYWFhWrp0qdHmdrsVFRWl5cuXWxAlAJiP/AgALSM/wiwU4mi3EhMTdfLkSePr06dP6/XXX1dkZKTq6+uN9t/+9reKj49Xbm6uRZECgLnIjwDQMvIjzEIhjnYrMTFRp0+fVnNzsyRpzZo1ioyM1IgRI4xE2tzcrFdffVXjxo1TfHy8xREDgDnIjwDQMvIjzEIhjnYrMTFRPp9Pp06dkiQtWbJEEydOVNeuXY1EumXLFn3++eeaMmWKxdECgHnIjwDQMvIjzEIhjnYrMTFRknTy5El9+OGH2rdvn37605/KZrMZifSVV17RXXfdpT59+kiSjh8/ruzsbMXHx+umm25SeXm5pWMAgEC4mvy4bNkyZWZmKioqSrNnz7Y0fgAIlNbmx4aGBo0fP149e/aUzWbT0KFDVVlZafEoEAooxNFuXZhIlyxZonvvvVdpaWlGIj127Jg2bNggl8tlvMblcik1NVXHjx/Xc889px//+Mc6ceKEhaMAgLZ3NfmxW7dumj17tnJyciyMHAACq7X58dy5c7rhhhv04Ycfqr6+Xvn5+frhD3/od5850BIKcbRb5xPpp59+qjfffFN5eXmSZCTS119/XSkpKbr33nulrxLu22+/raeeekqdOnXSvffeq/79++udd96xdBwA0NZamx8ladSoUbr33nuN1wJAe9Ta/BgfH69Zs2apZ8+eCg8P1+jRoxUdHa3q6mpLx4HgRyGOdut8In3++efVu3dv3XXXXdJXifTEiRN67bXX9NOf/lSRkZHSVwm3c+fO6tGjh3GM/v3768CBAxaNAAACo7X5EQA6imvNj59++qlOnDih3r17mxo3Qg+/YdFunU+kH3zwgRYvXmy022w2ffbZZ4qKitLEiRON9pMnT8pms/kdw2az6X//939NjBoAAq+1+REAOopryY+nT5/WmDFjVFRUJLvdblrMCE0U4mi3bDabwsLCFB8fr4ceeshoP58Yf/SjHyk1NdVo79y5s7xer98xvF6vOnfubGLUABB4rc2PANBRXG1+PHv2rB588EH17t1bs2bNMjVmhCYKcbRb4eHhxhqQF7rvvvvk8/kuab/xxht18uRJHT16VN/61rckSfv37/dLwgDQHrQ2PwJAR3E1+bG5uVljx45VWFiYVq1apbCwMBMiRajjHnHgK507d9Z9992nJ598UqdPn9aGDRv05z//Wffdd5/VoQGA5c6dO6czZ86oqanJ798A0NH99Kc/1RdffKH169fzbA18Y2E+/vQNGI4fP65x48Zp27Zt6tGjh15++WVlZWVZHRYAWG727Nl66qmn/NpWrFihhx9+2LKYAMBqf/vb33TDDTcoNjZWERERRvvGjRv1ve99z9LYENwoxAEAAAAAMBGXpgMAAAAAYCIKcQAAAAAATEQhDgAAAACAidptIe7z+eT1elmGBQAuQn4EgJaRHwGYpd0W4v/4xz9kt9v1j3/8w+pQACCokB8BoGXkRwBmabeFOAAAAAAAwYhCHAAAAAAAE1GIAwAAAABgIgpxAAAAAABMRCEOAACAgDp69KjGjBmjpKQkxcXFqX///vrDH/5g7Pf5fJo1a5a6deumuLg4ZWVl6dNPP/U7xokTJ5SbmyubzabExERNmDBBJ0+e9Ovz5z//Wd/73vcUGxurtLQ0zZ8/37QxAkBrUIgDAAAgYL788ksNGzZMUVFR2rhxow4ePKgFCxbouuuuM/rMnz9fL730kkpKSrRr1y7Fx8fL6XTqzJkzRp/c3FwdOHBAZWVl2rBhg7Zv365JkyYZ+71er0aOHKlevXqpqqpKzz33nGbPnq3ly5ebPmYAuJIwXztdKNHr9cput8vj8chms1kdDgAEDfIjADM98cQT+uijj/T73/++xf0+n0/du3fXz3/+c/3iF7+QJHk8HqWkpGjlypUaPXq0/vKXvygjI0N79uzRoEGDJEmbNm3SD37wA/3P//yPunfvrmXLlulXv/qV3G63oqOjjfd+++23dejQoW8UK/kRgFkirQ4AwEVm2wN4bE/gjg3APIHME8Z7kC/QNt599105nU49+OCDqqio0Le+9S397Gc/08SJEyVJhw8fltvtVlZWlvEau92uIUOGqLKyUqNHj1ZlZaUSExONIlySsrKyFB4erl27dulHP/qRKisrdccddxhFuCQ5nU49++yz+vLLL/1m4M9raGhQQ0OD8bXX6w3gmQC5C/g/XJoOAACAgPnss8+0bNky3Xjjjdq8ebOmTJmixx57TKtWrZIkud1uSVJKSorf61JSUox9brdbycnJfvsjIyPVpUsXvz4tHePC97hYcXGx7Ha7saWlpbXZuAHg61CIAwAAIGCam5uVmZmpuXPnasCAAZo0aZImTpyokpISq0NTUVGRPB6PsR05csTqkAB0EBTiAAAACJhu3bopIyPDr61v376qqamRJKWmpkqSamtr/frU1tYa+1JTU1VXV+e3/9y5czpx4oRfn5aOceF7XCwmJkY2m81vAwAzUIgDAAAgYIYNG6bq6mq/tk8++US9evWSJKWnpys1NVXl5eXGfq/Xq127dsnhcEiSHA6H6uvrVVVVZfTZunWrmpubNWTIEKPP9u3bdfbsWaNPWVmZbrrpphbvDwcAK1GIAwAAIGAKCgq0c+dOzZ07V3/961+1Zs0aLV++XC6XS5IUFham/Px8/eY3v9G7776rffv26aGHHlL37t01atQo6asZ9O9///uaOHGidu/erY8++kh5eXkaPXq0unfvLkn6yU9+oujoaE2YMEEHDhzQG2+8oRdffFGFhYWWjh8AWsJT0wEAABAwgwcP1ltvvaWioiLNmTNH6enpWrRokXJzc40+06dP16lTpzRp0iTV19fru9/9rjZt2qTY2Fijz+rVq5WXl6cRI0YoPDxcOTk5eumll4z9drtdW7Zskcvl0sCBA9W1a1fNmjXLb61xAAgWrCMOBBuWL0OAkR/bAZYAAgKC/Bhg5C7AwKXpAAAAAACYiEIcAAAAAAATUYgDAAAAAGAiCnEAAAAAAExEIQ4AAAAAgIkoxAEAAAAAMBGFOAAAAAAAJqIQBwAAAADARBTiAAAAAACYKNLqAAAAQBCabTfhPTyBfw8AAIIQM+IAAAAAAJiIQhwAAAAAABNxaToAAG3JjEu6AQBASGNGHAAAAAAAE1GIAwAAAABgolYX4kePHtWYMWOUlJSkuLg49e/fX3/4wx+M/T6fT7NmzVK3bt0UFxenrKwsffrpp37HOHHihHJzc2Wz2ZSYmKgJEybo5MmTfn3+/Oc/63vf+55iY2OVlpam+fPnX8s4AQAAAAAICq0qxL/88ksNGzZMUVFR2rhxow4ePKgFCxbouuuuM/rMnz9fL730kkpKSrRr1y7Fx8fL6XTqzJkzRp/c3FwdOHBAZWVl2rBhg7Zv365JkyYZ+71er0aOHKlevXqpqqpKzz33nGbPnq3ly5e31bgBAAAAALBEqx7W9uyzzyotLU0rVqww2tLT041/+3w+LVq0SDNnztR9990nSfqP//gPpaSk6O2339bo0aP1l7/8RZs2bdKePXs0aNAgSdLixYv1gx/8QM8//7y6d++u1atXq7GxUb/97W8VHR2t73znO9q7d69eeOEFv4IdAAAAAIBQ06oZ8XfffVeDBg3Sgw8+qOTkZA0YMECvvvqqsf/w4cNyu93Kysoy2ux2u4YMGaLKykpJUmVlpRITE40iXJKysrIUHh6uXbt2GX3uuOMORUdHG32cTqeqq6v15ZdfthhbQ0ODvF6v3wYAVpk3b57CwsKUn59vtJ05c0Yul0tJSUnq3LmzcnJyVFtb6/e6mpoaZWdnq1OnTkpOTta0adN07tw5vz7btm1TZmamYmJi1Lt3b61cudK0cQEAAODataoQ/+yzz7Rs2TLdeOON2rx5s6ZMmaLHHntMq1atkiS53W5JUkpKit/rUlJSjH1ut1vJycl++yMjI9WlSxe/Pi0d48L3uFhxcbHsdruxpaWltWZoANBm9uzZo1deeUU333yzX3tBQYHee+89rV+/XhUVFTp27Jjuv/9+Y39TU5Oys7PV2NioHTt2aNWqVVq5cqVmzZpl9Dl8+LCys7M1fPhw7d27V/n5+Xr00Ue1efNmU8cIAACAq9eqQry5uVmZmZmaO3euBgwYoEmTJmnixIkqKSkJXITfUFFRkTwej7EdOXLE6pAAdEAnT55Ubm6uXn31Vb/nZ3g8Hr3++ut64YUXdNddd2ngwIFasWKFduzYoZ07d0qStmzZooMHD+p3v/udbr31Vt199916+umntXTpUjU2NkqSSkpKlJ6ergULFqhv377Ky8vTAw88oIULF1o2ZgAAALROqwrxbt26KSMjw6+tb9++qqmpkSSlpqZK0iWXWtbW1hr7UlNTVVdX57f/3LlzOnHihF+flo5x4XtcLCYmRjabzW8DALO5XC5lZ2f73aIjSVVVVTp79qxfe58+fdSzZ0+/W3f69+/vd0WQ0+mU1+vVgQMHjD4XH9vpdBrHaAm37gAAAASXVhXiw4YNU3V1tV/bJ598ol69eklfPbgtNTVV5eXlxn6v16tdu3bJ4XBIkhwOh+rr61VVVWX02bp1q5qbmzVkyBCjz/bt23X27FmjT1lZmW666Sa/GSYACCZr167Vxx9/rOLi4kv2ud1uRUdHKzEx0a/94lt3rnRbzuX6eL1enT59usW4uHUHAAAguLSqEC8oKNDOnTs1d+5c/fWvf9WaNWu0fPlyuVwuSTIeTPSb3/xG7777rvbt26eHHnpI3bt316hRo6SvZtC///3va+LEidq9e7c++ugj5eXlafTo0erevbsk6Sc/+Ymio6M1YcIEHThwQG+88YZefPFFFRYWBuIcAMA1O3LkiB5//HGtXr1asbGxVofjh1t3AAAAgkurli8bPHiw3nrrLRUVFWnOnDlKT0/XokWLlJuba/SZPn26Tp06pUmTJqm+vl7f/e53tWnTJr//mK5evVp5eXkaMWKEwsPDlZOTo5deesnYb7fbtWXLFrlcLg0cOFBdu3bVrFmzWLoMQNCqqqpSXV2dMjMzjbampiZt375dS5Ys0ebNm9XY2Kj6+nq/WfGLb93ZvXu333Evvi3ncrfu2Gw2xcXFtRhbTEyMYmJi2nC0AAAAuBatKsQl6Z577tE999xz2f1hYWGaM2eO5syZc9k+Xbp00Zo1a772fW6++Wb9/ve/b214AGCJESNGaN++fX5tjzzyiPr06aMZM2YoLS1NUVFRKi8vV05OjiSpurpaNTU1frfuPPPMM6qrqzNWlygrK5PNZjOez+FwOPT+++/7vU9ZWZlxDAAAAAS/VhfiAELYbHuAj+8J7PGDWEJCgvr16+fXFh8fr6SkJKN9woQJKiwsVJcuXWSz2TR16lQ5HA4NHTpUkjRy5EhlZGRo7Nixmj9/vtxut2bOnCmXy2XMaE+ePFlLlizR9OnTNX78eG3dulXr1q1TaWmpBaMGAADA1aAQBwCTLFy40Lgdp6GhQU6nUy+//LKxPyIiQhs2bNCUKVPkcDgUHx+vcePG+V1hlJ6ertLSUhUUFOjFF19Ujx499Nprr8npdFo0KgAAALRWmM/n81kdRCB4vV7Z7XZ5PB6WMkNoCfSsdSB14BnxUEJ+DLBQ/hk2GzkDQYb8GGBm5EfyCkJEq56aDgAAAAAArg2XpgMAAABoH5h1R4hgRhwAAAAAABNRiAMAAAAAYCIKcQAAAAAATEQhDgAAAACAiSjEAQAAAAAwEYU4AAAAAAAmohAHAACAaebNm6ewsDDl5+cbbWfOnJHL5VJSUpI6d+6snJwc1dbW+r2upqZG2dnZ6tSpk5KTkzVt2jSdO3fOr8+2bduUmZmpmJgY9e7dWytXrjRtXADQGhTiAAAAMMWePXv0yiuv6Oabb/ZrLygo0Hvvvaf169eroqJCx44d0/3332/sb2pqUnZ2thobG7Vjxw6tWrVKK1eu1KxZs4w+hw8fVnZ2toYPH669e/cqPz9fjz76qDZv3mzqGAHgm4i0OgAAAAC0fydPnlRubq5effVV/eY3vzHaPR6PXn/9da1Zs0Z33XWXJGnFihXq27evdu7cqaFDh2rLli06ePCg/uu//kspKSm69dZb9fTTT2vGjBmaPXu2oqOjVVJSovT0dC1YsECS1LdvX3344YdauHChnE6nZeMOGbPtVkcAdCjMiAMAACDgXC6XsrOzlZWV5ddeVVWls2fP+rX36dNHPXv2VGVlpSSpsrJS/fv3V0pKitHH6XTK6/XqwIEDRp+Lj+10Oo1jAEAwYUYcAAAAAbV27Vp9/PHH2rNnzyX73G63oqOjlZiY6NeekpIit9tt9LmwCD+///y+r+vj9Xp1+vRpxcXFXfLeDQ0NamhoML72er3XNE4A+KaYEQcAAEDAHDlyRI8//rhWr16t2NhYq8PxU1xcLLvdbmxpaWlWhwSgg6AQBwAAQMBUVVWprq5OmZmZioyMVGRkpCoqKvTSSy8pMjJSKSkpamxsVH19vd/ramtrlZqaKklKTU295Cnq57++Uh+bzdbibLgkFRUVyePxGNuRI0fadOwAcDkU4gAAAAiYESNGaN++fdq7d6+xDRo0SLm5uca/o6KiVF5ebrymurpaNTU1cjgckiSHw6F9+/aprq7O6FNWViabzaaMjAyjz4XHON/n/DFaEhMTI5vN5rcBgBm4RxwAAAABk5CQoH79+vm1xcfHKykpyWifMGGCCgsL1aVLF9lsNk2dOlUOh0NDhw6VJI0cOVIZGRkaO3as5s+fL7fbrZkzZ8rlcikmJkaSNHnyZC1ZskTTp0/X+PHjtXXrVq1bt06lpaUWjBoAvh6FOAAAACy1cOFChYeHKycnRw0NDXI6nXr55ZeN/REREdqwYYOmTJkih8Oh+Ph4jRs3TnPmzDH6pKenq7S0VAUFBXrxxRfVo0cPvfbaayxdBiAohfl8Pp/VQQSC1+uV3W6Xx+PhMiOEllBex3O2x+oI8A2QHwMslH+GzUbOQJDp0PmR3PXNkbvQBrhHHAAAAAAAE1GIAwAAAABgIgpxAAAAAABMRCEOAAAAAICJKMQBAAAAADARhTgAAAAAACaiEAcAAAAAwETXVIjPmzdPYWFhys/PN9rOnDkjl8ulpKQkde7cWTk5OaqtrfV7XU1NjbKzs9WpUyclJydr2rRpOnfunF+fbdu2KTMzUzExMerdu7dWrlx5LaECAAAAABAUrroQ37Nnj1555RXdfPPNfu0FBQV67733tH79elVUVOjYsWO6//77jf1NTU3Kzs5WY2OjduzYoVWrVmnlypWaNWuW0efw4cPKzs7W8OHDtXfvXuXn5+vRRx/V5s2brzZcAAAAAACCwlUV4idPnlRubq5effVVXXfddUa7x+PR66+/rhdeeEF33XWXBg4cqBUrVmjHjh3auXOnJGnLli06ePCgfve73+nWW2/V3XffraefflpLly5VY2OjJKmkpETp6elasGCB+vbtq7y8PD3wwANauHBhW40bAAAAAABLXFUh7nK5lJ2draysLL/2qqoqnT171q+9T58+6tmzpyorKyVJlZWV6t+/v1JSUow+TqdTXq9XBw4cMPpcfGyn02kcoyUNDQ3yer1+GwAAAAAAwSaytS9Yu3atPv74Y+3Zs+eSfW63W9HR0UpMTPRrT0lJkdvtNvpcWISf339+39f18Xq9On36tOLi4i557+LiYj311FOtHQ4AAAAAAKZq1Yz4kSNH9Pjjj2v16tWKjY0NXFRXoaioSB6Px9iOHDlidUgAAAAAAFyiVYV4VVWV6urqlJmZqcjISEVGRqqiokIvvfSSIiMjlZKSosbGRtXX1/u9rra2VqmpqZKk1NTUS56ifv7rK/Wx2WwtzoZLUkxMjGw2m98GAAAAAECwaVUhPmLECO3bt0979+41tkGDBik3N9f4d1RUlMrLy43XVFdXq6amRg6HQ5LkcDi0b98+1dXVGX3Kyspks9mUkZFh9LnwGOf7nD8GAAAAAAChqlX3iCckJKhfv35+bfHx8UpKSjLaJ0yYoMLCQnXp0kU2m01Tp06Vw+HQ0KFDJUkjR45URkaGxo4dq/nz58vtdmvmzJlyuVyKiYmRJE2ePFlLlizR9OnTNX78eG3dulXr1q1TaWlp240cAAAAAAALtPphbVeycOFChYeHKycnRw0NDXI6nXr55ZeN/REREdqwYYOmTJkih8Oh+Ph4jRs3TnPmzDH6pKenq7S0VAUFBXrxxRfVo0cPvfbaa3I6nW0dLnB1ZtutjgAAAABAiArz+Xw+q4MIBK/XK7vdLo/Hw/3iaHsU4i2b7bE6AnwD5McAIz98c+QMBJkOnR/JXd8cuQtt4KrWEQcAAAAAAFeHQhwAAAAAABNRiAMAAAAAYCIKcQAAAAAATEQhDgAAAACAiSjEAQAAAAAwEYU4AAAAAAAmohAHAAAAAMBEkVYHAAAAAAAhY7bdhPfwBP49YClmxAEAAAAAMBGFOAC0geLiYg0ePFgJCQlKTk7WqFGjVF1d7dfnzJkzcrlcSkpKUufOnZWTk6Pa2lq/PjU1NcrOzlanTp2UnJysadOm6dy5c359tm3bpszMTMXExKh3795auXKlKWMEAABA2+DSdABoAxUVFXK5XBo8eLDOnTunX/7ylxo5cqQOHjyo+Ph4SVJBQYFKS0u1fv162e125eXl6f7779dHH30kSWpqalJ2drZSU1O1Y8cOffHFF3rooYcUFRWluXPnSpIOHz6s7OxsTZ48WatXr1Z5ebkeffRRdevWTU6n09JzEBLMuJwQAADgCsJ8Pp/P6iACwev1ym63y+PxyGazWR0O2hv+M98y7mcyHD9+XMnJyaqoqNAdd9whj8ej66+/XmvWrNEDDzwgSTp06JD69u2ryspKDR06VBs3btQ999yjY8eOKSUlRZJUUlKiGTNm6Pjx44qOjtaMGTNUWlqq/fv3G+81evRo1dfXa9OmTd8otg6dH/nZ7XjIS2gF8iOCBrmr3ePSdAAIAI/nX79Au3TpIkmqqqrS2bNnlZWVZfTp06ePevbsqcrKSklSZWWl+vfvbxThkuR0OuX1enXgwAGjz4XHON/n/DFa0tDQIK/X67cBAADAOhTiANDGmpublZ+fr2HDhqlfv36SJLfbrejoaCUmJvr1TUlJkdvtNvpcWISf339+39f18Xq9On36dIvxFBcXy263G1taWlobjhYAAACtRSEOAG3M5XJp//79Wrt2rdWhSJKKiork8XiM7ciRI1aHBAAA0KHxsDYAaEN5eXnasGGDtm/frh49ehjtqampamxsVH19vd+seG1trVJTU40+u3fv9jve+aeqX9jn4iet19bWymazKS4ursWYYmJiFBMT04ajBAAAwLVgRhwA2oDP51NeXp7eeustbd26Venp6X77Bw4cqKioKJWXlxtt1dXVqqmpkcPhkCQ5HA7t27dPdXV1Rp+ysjLZbDZlZGQYfS48xvk+548BAACA4MeMOAC0AZfLpTVr1uidd95RQkKCcU+33W5XXFyc7Ha7JkyYoMLCQnXp0kU2m01Tp06Vw+HQ0KFDJUkjR45URkaGxo4dq/nz58vtdmvmzJlyuVzGjPbkyZO1ZMkSTZ8+XePHj9fWrVu1bt06lZaWWjp+AAAAfHPMiANAG1i2bJk8Ho/uvPNOdevWzdjeeOMNo8/ChQt1zz33KCcnR3fccYdSU1P15ptvGvsjIiK0YcMGRUREyOFwaMyYMXrooYc0Z84co096erpKS0tVVlamW265RQsWLNBrr73GGuIAAAAhhEIcANqAz+drcXv44YeNPrGxsVq6dKlOnDihU6dO6c033zTu/T6vV69eev/99/XPf/5Tx48f1/PPP6/ISP+Ll+6880798Y9/VENDg/77v//b7z0AIBgVFxdr8ODBSkhIUHJyskaNGqXq6mq/PmfOnJHL5VJSUpI6d+6snJycS56JUVNTo+zsbHXq1EnJycmaNm2azp0759dn27ZtyszMVExMjHr37q2VK1eaMkYAaA0KcQAAAARURUWFXC6Xdu7cqbKyMp09e1YjR47UqVOnjD4FBQV67733tH79elVUVOjYsWO6//77jf1NTU3Kzs5WY2OjduzYoVWrVmnlypWaNWuW0efw4cPKzs7W8OHDtXfvXuXn5+vRRx/V5s2bTR8zAHydMJ/P57M6iEDwer2y2+3yeDyy2WxWh4P2Zrbd6giC02yP1RHgG+jQ+ZGf3Y6HvBSUjh8/ruTkZFVUVOiOO+6Qx+PR9ddfrzVr1uiBBx6QJB06dEh9+/ZVZWWlhg4dqo0bN+qee+7RsWPHlJKSIkkqKSnRjBkzdPz4cUVHR2vGjBkqLS3V/v37jfcaPXq06uvrtWnTpivGRX5E0CB3tXvMiAMAAMBUHs+/iowuXbpIkqqqqnT27FllZWUZffr06aOePXuqsrJSklRZWan+/fsbRbgkOZ1Oeb1eHThwwOhz4THO9zl/jIs1NDTI6/X6bQBgBgpxAAAAmKa5uVn5+fkaNmyY+vXrJ0lyu92Kjo5WYmKiX9+UlBRjFQq32+1XhJ/ff37f1/Xxer06ffr0JbEUFxfLbrcbW1paWhuPFgBaRiEOAAAA07hcLu3fv19r1661OhQVFRXJ4/EY25EjR6wOCUAHwTriAAAAMEVeXp42bNig7du3q0ePHkZ7amqqGhsbVV9f7zcrXltba6wukZqaqt27d/sd7/xT1S/sc/GT1mtra2Wz2RQXF3dJPDExMYqJiWnjUQLAlTEjDgAAgIDy+XzKy8vTW2+9pa1btyo9Pd1v/8CBAxUVFaXy8nKjrbq6WjU1NXI4HJIkh8Ohffv2qa6uzuhTVlYmm82mjIwMo8+Fxzjf5/wxACBYtKoQZw1IAAAAtJbL5dLvfvc7rVmzRgkJCXK73XK73cZ923a7XRMmTFBhYaE++OADVVVV6ZFHHpHD4dDQoUMlSSNHjlRGRobGjh2rP/3pT9q8ebNmzpwpl8tlzGpPnjxZn332maZPn65Dhw7p5Zdf1rp161RQUGDp+AHgYq0qxFkDEgAAAK21bNkyeTwe3XnnnerWrZuxvfHGG0afhQsX6p577lFOTo7uuOMOpaam6s033zT2R0REaMOGDYqIiJDD4dCYMWP00EMPac6cOUaf9PR0lZaWqqysTLfccosWLFig1157TU6n0/QxA8DXuaZ1xIN1DUh19HUgEXistdky1rwMCR06P/Kz2/GQl9AK5EcEDXJXu3dN94gHyxqQAAAAAACEiqt+arqVa0C29NTLhoYGNTQ0GF97vd6rHRoAAAAAAAFz1TPiwbQGpL56kJzdbje2tLQ0q0MCAAAAAOASV1WIn18D8oMPPrjsGpAXungNyJbWd9Q1rAEpSUVFRfJ4PMZ25MiRqxkaAAAAAAAB1apCPJjXgIyJiZHNZvPbAAAAAAAINq26R9zlcmnNmjV65513jDUg9dXaj3FxcX5rQHbp0kU2m01Tp0697BqQ8+fPl9vtbnENyCVLlmj69OkaP368tm7dqnXr1qm0tDQQ5wAAAAAAANO0akacNSABAAAAALg2rZoR/yZLjsfGxmrp0qVaunTpZfv06tVL77///tce584779Qf//jH1oQHAAAAAEDQu6Z1xAEAAAAAQOtQiAMAAAAAYCIKcQAAAAAATNSqe8SBkDLbbnUEAAAAAHAJCnEAANB+BfqPsrM9gT0+AKBdohAHAAAAgh1X+gHtCveIAwAAAABgIgpxAAAAAABMRCEOAAAAAICJuEccAAAAAIKJGc8E4GGTlmJGHAAAAAAAE1GIAwAAAABgIgpxAAAAAABMRCEOAAAAAICJKMQBAAAAADARhTgAAAAAACaiEAcAAAAAwEQU4gAAAAAAmIhCHAAAAAAAE0VaHQCAdmS2PYDH9gTu2AAAAICJmBEH0K7d8ESp1SEAAAAAfijEAQAAAAAwEZemw1qBvJQZ+MoNT5Tq83nZVocBoD0y4/cYt+YAQLtDIQ4ACA78YQ4AAHQQXJoOAAAAAICJKMQBAAAAADARl6YDAAAAQEfDMy4sxYw4AAAAAAAmYkYcV8YDlAAAAACgzQR1Ib506VI999xzcrvduuWWW7R48WLddtttVocFAJYjPwIdCJePtho5EkCwC9pC/I033lBhYaFKSko0ZMgQLVq0SE6nU9XV1UpOTrY6PACwDPkRAC7PkhzJ1YMAWinM5/P5rA6iJUOGDNHgwYO1ZMkSSVJzc7PS0tI0depUPfHEE1d8vdfrld1ul8fjkc1mMyHidoxfLggGVzlbc8MTpZKkz+dlt3FA1mm3+ZFcA1inHc2IX0uOvOr8SP4CrBOi+SsoZ8QbGxtVVVWloqIioy08PFxZWVmqrKxs8TUNDQ1qaGgwvvZ4/vUN8Xq9JkQcBIp7WB0BEFhX+bPc3PBPSVLPgvXa/5Sz1a9PSEhQWFjYVb13IFiaH8kzQPt1lTk21HNkm+XHhqCc1wI6hiCt966UH4OyEP/73/+upqYmpaSk+LWnpKTo0KFDLb6muLhYTz311CXtaWlpAYsTgInmXftsg31R618TbLPG5EcAAXGVOTbUcyT5EWgH2uD/iIFwpfwYlIX41SgqKlJhYaHxdXNzs06cOKGkpKSg+kttIHi9XqWlpenIkSNB9cvQCpyLf+E8/J9rPRcJCQkBictMbZkfO8JnizG2Hx1hnFaPMdRz5OXyY1RUlHr27Bmynx2rPxfXivitE8qxK8jiv1J+DMpCvGvXroqIiFBtba1fe21trVJTU1t8TUxMjGJiYvzaEhMTAxpnsLHZbJZ/4IIF5+JfOA//p72ci2DJj+3lfH4dxth+dIRxdoQxfhOtzZGXy4/nL00P9fNK/NYK5fhDOXaFSPzhVgfQkujoaA0cOFDl5eVGW3Nzs8rLy+VwOCyNDQCsRH4EgMsjRwIIFUE5Iy5JhYWFGjdunAYNGqTbbrtNixYt0qlTp/TII49YHRoAWIr8CACXR44EEAqCthD/93//dx0/flyzZs2S2+3Wrbfeqk2bNl3y8A3867KqJ5988pJLqzoizsW/cB7+T3s8F1bmx/Z4Pi/GGNuPjjDOjjDG1mqLHBnq55X4rRXK8Ydy7Aqx+IN2HXEAAAAAANqjoLxHHAAAAACA9opCHAAAAAAAE1GIAwAAAABgIgpxAAAAAABMRCEe4p555hndfvvt6tSpkxITE1vsExYWdsm2du1a02MNpG9yHmpqapSdna1OnTopOTlZ06ZN07lz50yP1Qo33HDDJZ+BefPmWR2WKZYuXaobbrhBsbGxGjJkiHbv3m11SO3C559/rgkTJig9PV1xcXH6t3/7Nz355JNqbGy0OrRr0t4/L8XFxRo8eLASEhKUnJysUaNGqbq62uqwAmrevHkKCwtTfn6+1aG0uaNHj2rMmDFKSkpSXFyc+vfvrz/84Q9Wh9XuhGK+C8Vc1t7yUyjmnlDOKU1NTfr1r3/t93P69NNPK5ifS04hHuIaGxv14IMPasqUKV/bb8WKFfriiy+MbdSoUabFaIYrnYempiZlZ2ersbFRO3bs0KpVq7Ry5UrNmjXL9FitMmfOHL/PwNSpU60OKeDeeOMNFRYW6sknn9THH3+sW265RU6nU3V1dVaHFvIOHTqk5uZmvfLKKzpw4IAWLlyokpIS/fKXv7Q6tKvWET4vFRUVcrlc2rlzp8rKynT27FmNHDlSp06dsjq0gNizZ49eeeUV3XzzzVaH0ua+/PJLDRs2TFFRUdq4caMOHjyoBQsW6LrrrrM6tHYn1PJdqOay9pSfQjH3hHpOefbZZ7Vs2TItWbJEf/nLX/Tss89q/vz5Wrx4sdWhXZ4P7cKKFSt8dru9xX2SfG+99ZbpMVnhcufh/fff94WHh/vcbrfRtmzZMp/NZvM1NDSYHKX5evXq5Vu4cKHVYZjutttu87lcLuPrpqYmX/fu3X3FxcWWxtVezZ8/35eenm51GFetI35e6urqfJJ8FRUVVofS5v7xj3/4brzxRl9ZWZnv//2//+d7/PHHrQ6pTc2YMcP33e9+1+owOqxgznftJZeFan4K1dwT6jklOzvbN378eL+2+++/35ebm2tZTFfCjHgH4XK51LVrV91222367W9/G9SXaQRCZWWl+vfvr5SUFKPN6XTK6/XqwIEDlsZmlnnz5ikpKUkDBgzQc8891+4vy29sbFRVVZWysrKMtvDwcGVlZamystLS2Norj8ejLl26WB3GVemonxePxyNJIft9+zoul0vZ2dl+39P25N1339WgQYP04IMPKjk5WQMGDNCrr75qdVgdRrDmu/aUy0I1P4Vq7gn1nHL77bervLxcn3zyiSTpT3/6kz788EPdfffdVod2WZFWB4DAmzNnju666y516tRJW7Zs0c9+9jOdPHlSjz32mNWhmcbtdvsV4ZKMr91ut0VRmeexxx5TZmamunTpoh07dqioqEhffPGFXnjhBatDC5i///3vampqavH7fujQIcviaq/++te/avHixXr++eetDuWqdMTPS3Nzs/Lz8zVs2DD169fP6nDa1Nq1a/Xxxx9rz549VocSMJ999pmWLVumwsJC/fKXv9SePXv02GOPKTo6WuPGjbM6vHYtmPNde8lloZqfQjn3hHpOeeKJJ+T1etWnTx9FRESoqalJzzzzjHJzc60O7bKYEQ9CTzzxRIsPWLtwa00y/fWvf61hw4ZpwIABmjFjhqZPn67nnnsuoGNoC219Htqb1pyfwsJC3Xnnnbr55ps1efJkLViwQIsXL1ZDQ4PVw0CQuZqfu6NHj+r73/++HnzwQU2cONGy2NE6LpdL+/fvb3cP7zxy5Igef/xxrV69WrGxsVaHEzDNzc3KzMzU3LlzNWDAAE2aNEkTJ05USUmJ1aGFDPJd8ArF/BTquSfUc8q6deu0evVqrVmzRh9//LFWrVql559/XqtWrbI6tMtiRjwI/fznP9fDDz/8tX2+/e1vX/XxhwwZoqeffloNDQ2KiYm56uMEWlueh9TU1EueGFpbW2vsC0XXcn6GDBmic+fO6fPPP9dNN90UoAit1bVrV0VERBjf5/Nqa2tD9ntuhtZ+ro4dO6bhw4fr9ttv1/Lly02IMDA62uclLy9PGzZs0Pbt29WjRw+rw2lTVVVVqqurU2ZmptHW1NSk7du3a8mSJWpoaFBERISlMbaFbt26KSMjw6+tb9+++s///E/LYgo17THftYdcFqr5KdRzT6jnlGnTpumJJ57Q6NGjJUn9+/fX3/72NxUXFwftjD6FeBC6/vrrdf311wfs+Hv37tV1110X1EW42vg8OBwOPfPMM6qrq1NycrIkqaysTDab7ZKkEyqu5fzs3btX4eHhxrloj6KjozVw4ECVl5cbqwQ0NzervLxceXl5VocXtFrzuTp69KiGDx+ugQMHasWKFQoPD92LrDrK58Xn82nq1Kl66623tG3bNqWnp1sdUpsbMWKE9u3b59f2yCOPqE+fPpoxY0ZQ/0e4NYYNG3bJ0k6ffPKJevXqZVlMoaY95rtQzmWhnp9CPfeEek755z//ecnPZUREhJqbmy2L6UooxENcTU2NTpw4oZqaGjU1NWnv3r2SpN69e6tz58567733VFtbq6FDhyo2NlZlZWWaO3eufvGLX1gdepu60nkYOXKkMjIyNHbsWM2fP19ut1szZ86Uy+UK+j9IXKvKykrt2rVLw4cPV0JCgiorK1VQUKAxY8aEzJIUV6uwsFDjxo3ToEGDdNttt2nRokU6deqUHnnkEatDC3lHjx7VnXfeqV69eun555/X8ePHjX2hMutysY7weXG5XFqzZo3eeecdJSQkGM/IsNvtiouLszq8NpGQkHDJPaXx8fFKSkoKqXtNr6SgoEC333675s6dqx//+MfavXu3li9fHrQztaEs1PJdqOayUM9PoZ57Qj2n/PCHP9Qzzzyjnj176jvf+Y7++Mc/6oUXXtD48eOtDu3yrH5sO67NuHHjfJIu2T744AOfz+fzbdy40Xfrrbf6Onfu7IuPj/fdcsstvpKSEl9TU5PVobepK50Hn8/n+/zzz3133323Ly4uzte1a1ffz3/+c9/Zs2ctjdsMVVVVviFDhvjsdrsvNjbW17dvX9/cuXN9Z86csTo0UyxevNjXs2dPX3R0tO+2227z7dy50+qQ2oUVK1a0+DMX6r9W2vvn5XLfsxUrVlgdWkCF0hJCrfHee+/5+vXr54uJifH16dPHt3z5cqtDapdCMd+FYi5rj/kp1HJPKOcUr9fre/zxx309e/b0xcbG+r797W/7fvWrXwX1MsVhvo62jhUAAAAAABYKzhtcAAAAAABopyjEAQAAAAAwEYU4AAAAAAAmohAHAAAAAMBEFOIAAAAAAJiIQhwAAAAAABNRiAMAAAAAYCIKcQAAAAAATEQhDgAAAACAiSjEAQAAAAAwEYU4AAAAAAAmohAHAAAAAMBE/x+k0JTPqZjXbQAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "burnin = 300\n", - "\n", - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(states.position[burnin:, i])\n", - " axi.hist(particles[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "191ea71c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(particles[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "4032de45", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+IAAADbCAYAAADphyuzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAmXklEQVR4nO3dfXRUdX7H8U9CIIHAJIKbCSwBUuEssIAszymu5SGHWTdW0ajLKWp4EJVOWJNYgbQuj+2GZcWAEAgCm9Aii7JVWUCBFCTWEpRGqTwsqVYwFHYCu5gMICQhmf5DbhkJOgmZeycz79c5cw5z72/ufH8hfJjv3Du/CfN4PB4BAAAAAABThFtdAAAAAAAAoYRGHAAAAAAAE9GIAwAAAABgIhpxAAAAAABMRCMOAAAAAICJaMQBAAAAADARjTgAAAAAACaiEQcAAAAAwEQ04gAAAAAAmIhGHAAAAAAAE9GIAwAAAABgIhpxAAAAAABMRCOOoJWRkSG73e61bfbs2QoLC1NeXp6xzeVyqW3btnr11VctqBIAzEc+AkDjyEeYhUYcQSs2NlaXLl0y7l+5ckUbNmxQRESEKisrje2/+c1vFB0drcmTJ1tUKQCYi3wEgMaRjzALjTiCVmxsrK5cuaL6+npJ0ubNmxUREaHx48cbQVpfX69169YpLS1N0dHRFlcMAOYgHwGgceQjzEIjjqAVGxsrj8ejy5cvS5JWrVqlGTNm6M477zSCdM+ePTp16pRmzpxpcbUAYB7yEQAaRz7CLDTiCFqxsbGSpEuXLumDDz7QkSNH9Mwzz8hmsxlBunbtWo0bN059+/aVJJ0/f14pKSmKjo7WD37wA+3du9fSOQCAPzQnH9esWaMhQ4aobdu2WrBggaX1A4C/NDUfq6urNW3aNPXo0UM2m02jRo1SSUmJxbNAa0AjjqB1Y5CuWrVKDzzwgBISEowgPXv2rHbs2CGn02k8xul0Kj4+XufPn9evf/1rPfbYY7pw4YKFswCAltecfOzatasWLFig1NRUCysHAP9qaj5eu3ZNvXr10gcffKDKykplZGTor//6r70+Zw40hkYcQashSD/77DO9+eabSk9PlyQjSDds2CC73a4HHnhAuh64b7/9thYuXKgOHTrogQce0MCBA7Vt2zZL5wEALa2p+ShJEydO1AMPPGA8FgCCUVPzMTo6WvPmzVOPHj0UHh6uSZMmqV27diorK7N0Hgh8NOIIWg1B+tJLL6l3794aN26cdD1IL1y4oPXr1+uZZ55RRESEdD1wO3bsqO7duxvHGDhwoI4dO2bRDADAP5qajwAQKm43Hz/77DNduHBBvXv3NrVutD78D4ug1RCk7733nlauXGlst9ls+uKLL9S2bVvNmDHD2H7p0iXZbDavY9hsNv35z382sWoA8L+m5iMAhIrbyccrV67o8ccfV3Z2tmJiYkyrGa0TjTiCls1mU1hYmKKjo/Xkk08a2xuC8aGHHlJ8fLyxvWPHjnK73V7HcLvd6tixo4lVA4D/NTUfASBUNDcfa2tr9eijj6p3796aN2+eqTWjdaIRR9AKDw83vgPyRg8++KA8Hs9N2/v06aNLly7pzJkz+v73vy9JOnr0qFcIA0AwaGo+AkCoaE4+1tfX64knnlBYWJg2btyosLAwEypFa8dnxIHrOnbsqAcffFDz58/XlStXtGPHDn366ad68MEHrS4NACx37do1Xb16VXV1dV5/BoBQ98wzz+iPf/yjtm7dytoa8FmYh7e+AcP58+eVlpam/fv3q3v37lq9erWSk5OtLgsALLdgwQItXLjQa1tBQYGmTJliWU0AYLUvv/xSvXr1UlRUlNq0aWNsf/fdd/XjH//Y0toQ2GjEAQAAAAAwEZemAwAAAABgIhpxAAAAAABMRCMOAAAAAICJgrYR93g8crvdfA0LAHwD+QgAjSMfAZglaBvxixcvKiYmRhcvXrS6FAAIKOQjADSOfARglqBtxAEAAAAACEQ04gAAAAAAmIhGHAAAAH515swZPf744+rSpYvat2+vgQMH6j//8z+N/R6PR/PmzVPXrl3Vvn17JScn67PPPvM6xoULFzR58mTZbDbFxsZq+vTpunTpkteYTz/9VD/+8Y8VFRWlhIQELV261LQ5AkBT0IgDAADAb7766iuNHj1abdu21bvvvqvjx49r2bJluuOOO4wxS5cu1SuvvKL8/Hx9+OGHio6OlsPh0NWrV40xkydP1rFjx1RUVKQdO3bo/fff19NPP23sd7vdmjBhgnr27KnS0lL9+te/1oIFC/Tqq6+aPmcA+C5hniBdFtLtdismJkZVVVWy2WxWlwMAAYN8BGCmuXPn6j/+4z/07//+743u93g86tatm55//nn93d/9nSSpqqpKdrtdhYWFmjRpkv7whz+of//+OnTokIYNGyZJ2rVrl37605/qf//3f9WtWzetWbNG//AP/yCXy6V27doZz/3222/rxIkTPtVKPgIwC2fEAQAA4De///3vNWzYMD366KOKi4vTj370I61bt87Yf/LkSblcLiUnJxvbYmJiNHLkSJWUlEiSSkpKFBsbazThkpScnKzw8HB9+OGHxph7773XaMIlyeFwqKysTF999VWjtVVXV8vtdnvdAMAMNOIAAADwmy+++EJr1qxRnz59tHv3bs2cOVM///nPtXHjRkmSy+WSJNntdq/H2e12Y5/L5VJcXJzX/oiICHXu3NlrTGPHuPE5viknJ0cxMTHGLSEhocXmDQDfJqKpDzhz5ozmzJmjd999V19//bV69+6tgoIC4x1Kj8ej+fPna926daqsrNTo0aON8G1w4cIFzZo1S9u3b1d4eLhSU1O1YsUKdezY0Rjz6aefyul06tChQ/re976nWbNmafbs2S01b0CS1GvuTr8e/9SSFL8eHwD8xd/5KDIyZNTX12vYsGH65S9/KUn60Y9+pKNHjyo/P19paWmW1padna2srCzjvtvtphlv5cgutBZNasQbFtsYO3as3n33XX3ve9/TZ5991uhiGxs3blRiYqJ+8YtfyOFw6Pjx44qKipKuL7bxxz/+UUVFRaqtrdXUqVP19NNPa/PmzdINi20kJycrPz9fR44c0bRp0xQbG+u1KAcAAAACW9euXdW/f3+vbf369dO//uu/SpLi4+MlSRUVFeratasxpqKiQoMHDzbGnDt3zusY165d04ULF4zHx8fHq6KiwmtMw/2GMd8UGRmpyMjIFpglQgnNPlpCky5N/9WvfqWEhAQVFBRoxIgRSkxM1IQJE3TXXXdJ18+GL1++XC+++KIefPBBDRo0SP/8z/+ss2fP6u2335Yk/eEPf9CuXbu0fv16jRw5Uvfcc49WrlypLVu26OzZs5Kk1157TTU1NfrNb36jH/7wh5o0aZJ+/vOf6+WXX/bHzwAAAAB+Mnr0aJWVlXlt++///m/17NlTkpSYmKj4+Hjt3bvX2O92u/Xhhx8qKSlJkpSUlKTKykqVlpYaY/bt26f6+nqNHDnSGPP++++rtrbWGFNUVKQf/OAHXieNACAQNOmM+O9//3s5HA49+uijKi4u1ve//3397d/+rWbMmCH5sNjGpEmTvnOxjYceeuiWi2386le/0ldffdVomFZXV6u6utq4z2IbrZ8Z7zYCAAD/yszM1F/+5V/ql7/8pR577DF99NFHevXVV42vFQsLC1NGRob+8R//UX369DGuqOzWrZsmTpwoXT+D/pOf/EQzZsxQfn6+amtrlZ6erkmTJqlbt26SpL/5m7/RwoULNX36dM2ZM0dHjx7VihUrlJuba+n8AaAxTTojzmIbAAAAaIrhw4frrbfe0m9/+1sNGDBAixcv1vLlyzV58mRjzOzZszVr1iw9/fTTGj58uC5duqRdu3YZH2vU9Ssm+/btq/Hjx+unP/2p7rnnHq/vCI+JidGePXt08uRJDR06VM8//7zmzZvHxxoBBKQmnRFnsQ0AAAA01f3336/777//lvvDwsK0aNEiLVq06JZjOnfubKwndCuDBg265feVA0AgadIZ8VsttlFeXi59Y7GNG1VUVHgtpOGvxTZsNpvXDQAAAACAQNOkRpzFNgAAAAAAuD1NujSdxTYAALAei1kCANC6NakRb1hsIzs7W4sWLVJiYmKji21cvnxZTz/9tCorK3XPPfc0uthGenq6xo8fr/DwcKWmpuqVV14x9jcstuF0OjV06FDdeeedLLYBAAAAAAgKTWrExWIbAAAAAADcliZ9RhwAAAAAANweGnEAAAAAAExEIw4AAAAAgIloxAEAAAAAMBGNOAAAAAAAJqIRBwAAAADARDTiAAAAAACYiEYcAAAAAAAT0YgDAAAAAGAiGnEAAAAAAExEIw4AAAAAgIloxAEAAAAAMBGNOAAAAAAAJqIRBwAAAADARDTiAAAAAACYiEYcAAAAAAAT0YgDAAAAAGAiGnEAAAAAAExEIw4AAAAAgIloxAEAAAAAMBGNOAAAAAAAJqIRBwAAAADARDTiAAAAAACYiEYcAPxgyZIlCgsLU0ZGhrHt6tWrcjqd6tKlizp27KjU1FRVVFR4Pa68vFwpKSnq0KGD4uLi9MILL+jatWteY/bv368hQ4YoMjJSvXv3VmFhoWnzAgAAwO2jEQeAFnbo0CGtXbtWgwYN8tqemZmp7du3a+vWrSouLtbZs2f18MMPG/vr6uqUkpKimpoaHThwQBs3blRhYaHmzZtnjDl58qRSUlI0duxYHT58WBkZGXrqqae0e/duU+cIAACA5qMRB4AWdOnSJU2ePFnr1q3THXfcYWyvqqrShg0b9PLLL2vcuHEaOnSoCgoKdODAAR08eFCStGfPHh0/flybNm3S4MGDdd9992nx4sXKy8tTTU2NJCk/P1+JiYlatmyZ+vXrp/T0dD3yyCPKzc21bM4AAABoGhpxAGhBTqdTKSkpSk5O9tpeWlqq2tpar+19+/ZVjx49VFJSIkkqKSnRwIEDZbfbjTEOh0Nut1vHjh0zxnzz2A6HwzhGY6qrq+V2u71uAAAAsE6E1QUAQLDYsmWLPv74Yx06dOimfS6XS+3atVNsbKzXdrvdLpfLZYy5sQlv2N+w79vGuN1uXblyRe3bt7/puXNycrRw4cIWmCEAAABaAmfEAaAFnD59Ws8995xee+01RUVFWV2Ol+zsbFVVVRm306dPW10SAABASKMRB4AWUFpaqnPnzmnIkCGKiIhQRESEiouL9corrygiIkJ2u101NTWqrKz0elxFRYXi4+MlSfHx8Tetot5w/7vG2Gy2Rs+GS1JkZKRsNpvXDQAAANahEQeAFjB+/HgdOXJEhw8fNm7Dhg3T5MmTjT+3bdtWe/fuNR5TVlam8vJyJSUlSZKSkpJ05MgRnTt3zhhTVFQkm82m/v37G2NuPEbDmIZjAAAAIPDxGXEAaAGdOnXSgAEDvLZFR0erS5cuxvbp06crKytLnTt3ls1m06xZs5SUlKRRo0ZJkiZMmKD+/fvriSee0NKlS+VyufTiiy/K6XQqMjJSkvTss89q1apVmj17tqZNm6Z9+/bpjTfe0M6dOy2YNQAAAJqDRhwATJKbm6vw8HClpqaqurpaDodDq1evNva3adNGO3bs0MyZM5WUlKTo6GilpaVp0aJFxpjExETt3LlTmZmZWrFihbp3767169fL4XBYNCsAAAA0FZemA4Cf7N+/X8uXLzfuR0VFKS8vTxcuXNDly5f15ptvGp/9btCzZ0+98847+vrrr3X+/Hm99NJLiojwfs90zJgx+uSTT1RdXa3/+Z//0ZQpU0ybEwDcriVLligsLEwZGRnGtqtXr8rpdKpLly7q2LGjUlNTb1oPo7y8XCkpKerQoYPi4uL0wgsv6Nq1a15j9u/fryFDhigyMlK9e/dWYWGhafMCgKagEQcAAIApDh06pLVr12rQoEFe2zMzM7V9+3Zt3bpVxcXFOnv2rB5++GFjf11dnVJSUlRTU6MDBw5o48aNKiws1Lx584wxJ0+eVEpKisaOHavDhw8rIyNDTz31lHbv3m3qHAHAFzTiAAAA8LtLly5p8uTJWrdune644w5je1VVlTZs2KCXX35Z48aN09ChQ1VQUKADBw7o4MGDkqQ9e/bo+PHj2rRpkwYPHqz77rtPixcvVl5enmpqaiRJ+fn5SkxM1LJly9SvXz+lp6frkUceUW5urmVzBoBbua1GnEuLAAAA4Aun06mUlBQlJyd7bS8tLVVtba3X9r59+6pHjx4qKSmRJJWUlGjgwIGy2+3GGIfDIbfbrWPHjhljvnlsh8NhHKMx1dXVcrvdXjcAMEOzG3EuLQIAAIAvtmzZoo8//lg5OTk37XO5XGrXrp1iY2O9ttvtdrlcLmPMjU14w/6Gfd82xu1268qVK43WlZOTo5iYGOOWkJBwmzMFAN80qxHn0iIAAAD44vTp03ruuef02muvKSoqyupyvGRnZ6uqqsq4nT592uqSAISIZjXiXFoEAAAAX5SWlurcuXMaMmSIIiIiFBERoeLiYr3yyiuKiIiQ3W5XTU2NKisrvR5XUVFhfLNEfHz8TR91bLj/XWNsNpvat2/faG2RkZGy2WxeNwAwQ5MbcS4tAgAAgK/Gjx+vI0eO6PDhw8Zt2LBhmjx5svHntm3bau/evcZjysrKVF5erqSkJElSUlKSjhw5onPnzhljioqKZLPZ1L9/f2PMjcdoGNNwDAAIJBE+jDE0XFpUVFQUkJcWZWVlGffdbjfNOAAAgMU6deqkAQMGeG2Ljo5Wly5djO3Tp09XVlaWOnfuLJvNplmzZikpKUmjRo2SJE2YMEH9+/fXE088oaVLl8rlcunFF1+U0+lUZGSkJOnZZ5/VqlWrNHv2bE2bNk379u3TG2+8oZ07d1owawD4dk06I86lRQAAAGhpubm5uv/++5Wamqp7771X8fHxevPNN439bdq00Y4dO9SmTRslJSXp8ccf15NPPqlFixYZYxITE7Vz504VFRXp7rvv1rJly7R+/Xo5HA6LZgUAt9akM+INlxbdaOrUqerbt6/mzJmjhIQE49Ki1NRU6RaXFv3TP/2Tzp07p7i4OOkWlxa98847Xs/DpUUAAASXXnP9f6by1JIUvz8Hmm7//v1e96OiopSXl6e8vLxbPqZnz543vT78pjFjxuiTTz5psToBwF+a1IhzaREAAAAAALenSY24L3JzcxUeHq7U1FRVV1fL4XBo9erVxv6GS4tmzpyppKQkRUdHKy0trdFLizIzM7VixQp1796dS4sAAAAAAEHhthtxLi0CAAAAAMB3zfoecQAAAAAA0Dw04gAAAAAAmIhGHAAAAAAAE9GIAwAAAABgIhpxAAAAAABMRCMOAAAAAICJaMQBAAAAADDRbX+POAAA+H+95u60ugQAABDgOCMOAAAAAICJaMQBAAAAADARjTgAAAAAACbiM+IAAAAA/I41NID/xxlxAAAAAABMRCMOAAAAAICJuDQdAAAAAAKIGZfxn1qS4vfnwK1xRhwAAAAAABNxRhzwI97NBAAAAPBNnBEHAAAAAMBEnBFHs/D1EwAAAADQPJwRBwAAAADARDTiAAAAAACYiEYcAAAAAAAT0YgDAAAAAGAiGnEAAAAAAExEIw4AAAAAgIloxAEAAAAAMBGNOAAAAAAAJqIRBwAAAADARDTiAAAAAACYiEYcAAAAAAAT0YgDQAvIycnR8OHD1alTJ8XFxWnixIkqKyvzGnP16lU5nU516dJFHTt2VGpqqioqKrzGlJeXKyUlRR06dFBcXJxeeOEFXbt2zWvM/v37NWTIEEVGRqp3794qLCw0ZY4AAABoGTTiANACiouL5XQ6dfDgQRUVFam2tlYTJkzQ5cuXjTGZmZnavn27tm7dquLiYp09e1YPP/ywsb+urk4pKSmqqanRgQMHtHHjRhUWFmrevHnGmJMnTyolJUVjx47V4cOHlZGRoaeeekq7d+82fc4AAABongirCwCAYLBr1y6v+4WFhYqLi1NpaanuvfdeVVVVacOGDdq8ebPGjRsnSSooKFC/fv108OBBjRo1Snv27NHx48f1b//2b7Lb7Ro8eLAWL16sOXPmaMGCBWrXrp3y8/OVmJioZcuWSZL69eunDz74QLm5uXI4HJbMHQAAAE3DGXEA8IOqqipJUufOnSVJpaWlqq2tVXJysjGmb9++6tGjh0pKSiRJJSUlGjhwoOx2uzHG4XDI7Xbr2LFjxpgbj9EwpuEYjamurpbb7fa6AQAAwDo04gDQwurr65WRkaHRo0drwIABkiSXy6V27dopNjbWa6zdbpfL5TLG3NiEN+xv2PdtY9xut65cudJoPTk5OYqJiTFuCQkJLThbAAAANBWNOAC0MKfTqaNHj2rLli1WlyJJys7OVlVVlXE7ffq01SUBCDEsaAkA3prUiBOiAPDt0tPTtWPHDr333nvq3r27sT0+Pl41NTWqrKz0Gl9RUaH4+HhjzDfzsuH+d42x2Wxq3759ozVFRkbKZrN53QDATCxoCQDemtSIE6IA0DiPx6P09HS99dZb2rdvnxITE732Dx06VG3bttXevXuNbWVlZSovL1dSUpIkKSkpSUeOHNG5c+eMMUVFRbLZbOrfv78x5sZjNIxpOAYABKJdu3ZpypQp+uEPf6i7775bhYWFKi8vV2lpqXR9XY0NGzbo5Zdf1rhx4zR06FAVFBTowIEDOnjwoCQZC1pu2rRJgwcP1n333afFixcrLy9PNTU1kuS1oGW/fv2Unp6uRx55RLm5uZbOHwC+qUmNOCEKAI1zOp3atGmTNm/erE6dOsnlcsnlchmf246JidH06dOVlZWl9957T6WlpZo6daqSkpI0atQoSdKECRPUv39/PfHEE/qv//ov7d69Wy+++KKcTqciIyMlSc8++6y++OILzZ49WydOnNDq1av1xhtvKDMz09L5A0BTBMqClixmCcAqt/UZ8UAJUQCw2po1a1RVVaUxY8aoa9euxu311183xuTm5ur+++9Xamqq7r33XsXHx+vNN9809rdp00Y7duxQmzZtlJSUpMcff1xPPvmkFi1aZIxJTEzUzp07VVRUpLvvvlvLli3T+vXr+eoyAK1GIC1oyWKWAKzS7O8RtzJEG/scZHV1taqrq437vKMJwEwej+c7x0RFRSkvL095eXm3HNOzZ0+9884733qcMWPG6JNPPmlWnQBgtYYFLT/44AOrS1F2draysrKM+263m2YcgCmafUY80FYF5h1NAACAwBZoC1qymCUAqzSrEQ+0EBVfzwMAABCwWNASALw1qREP5BDlHU0AAIDAxIKWAOCtSZ8Rdzqd2rx5s7Zt22aEqK6HZ/v27b1CtHPnzrLZbJo1a9YtQ3Tp0qVyuVyNhuiqVas0e/ZsTZs2Tfv27dMbb7yhnTt3+uNnAAAAAD9as2aNdH2NixsVFBRoypQp0vUFLcPDw5Wamqrq6mo5HA6tXr3aGNuwoOXMmTOVlJSk6OhopaWlNbqgZWZmplasWKHu3buzoCWAgBTm8WWFoYbBYWGNbr8xRK9evarnn39ev/3tb71CtOGyc0n68ssvNXPmTO3fv98I0SVLligi4v/fF9i/f78yMzN1/Phxde/eXb/4xS+M5/CF2+1WTEyMqqqqODvuB73m8qZIoDi1JMXqEtDKkI/+RT4GFjISTUE++hf5GFjIR2s16Yw4qwIDAAAAAHB7but7xAEAAAAAQNPQiAMAAAAAYCIacQAAAAAATEQjDgAAAACAiWjEAQAAAAAwUZNWTQcAAGhN/P11SXz9DwCgOTgjDgAAAACAiWjEAQAAAAAwEY04AAAAAAAmohEHAAAAAMBENOIAAAAAAJiIRhwAAAAAABPRiAMAAAAAYCIacQAAAAAATBRhdQEAAJil19ydVpcAAADAGXEAAAAAAMxEIw4AAAAAgIloxAEAAAAAMBGNOAAAAAAAJqIRBwAAAADARDTiAAAAAACYiK8vAwAAAEIcX+8Yesz4Oz+1JMXvz9Fa0YgDrRwhCgAAALQuXJoOAAAAAICJOCMehLi0CAAAAAACF2fEAQAAAAAwEY04AAAAAAAmohEHAAAAAMBENOIAAAAAAJiIRhwAAAAAABPRiAMAAAAAYCIacQAAAAAATMT3iAMAADRTr7k7/f4cp5ak+P05AADm4ow4AAAAAAAmohEHAAAAAMBEXJoOAAgIZlziCwAAEAg4Iw4AAAAAgIkCuhHPy8tTr169FBUVpZEjR+qjjz6yuiQACAjkIwDcGhkJINAF7KXpr7/+urKyspSfn6+RI0dq+fLlcjgcKisrU1xcnNXlAYBlyEcAuLVgzUg+voPWiG+WuLUwj8fjsbqIxowcOVLDhw/XqlWrJEn19fVKSEjQrFmzNHfu3O98vNvtVkxMjKqqqmSz2Uyo2DeEKNC41hqiViAfgdBCPjbN7WRkoOajyEjgllprRgbkGfGamhqVlpYqOzvb2BYeHq7k5GSVlJQ0+pjq6mpVV1cb96uqqqTrgRpI6qu/troEICAF2r/VBp06dVJYWJjVZRiszMcB83c3u24Azdcjc6vfn+PoQkezHtfaM7K1vH4UryGBWwrEf6/yIR8DshH/05/+pLq6Otntdq/tdrtdJ06caPQxOTk5Wrhw4U3bExIS/FYngJYTs9zqChoXaGdFyEcA/tDcDG7tGUk+Aq1fa30NGZCNeHNkZ2crKyvLuF9fX68LFy6oS5cuzX6n1u12KyEhQadPnw6o/2T8IVTmGirzVAjN1d/z7NSpU4sf02z+yMdgESr/TnzFz+Nm/ExuduPPpLVnZEvlYyj9noTSXMV8rS7H7/w53+/Kx4BsxO+88061adNGFRUVXtsrKioUHx/f6GMiIyMVGRnptS02NrZF6rHZbCHxi6gQmmuozFMhNNdQmWeg5WOwCJXfH1/x87gZP5Ob2Wy2gHszr6kZ2dL5GEq/J6E0VzHfoGfFfAPy68vatWunoUOHau/evca2+vp67d27V0lJSZbWBgBWIh8B4NbISACtRUCeEZekrKwspaWladiwYRoxYoSWL1+uy5cva+rUqVaXBgCWIh8B4NbISACtQcA24j/72c90/vx5zZs3Ty6XS4MHD9auXbtuWnzDnyIjIzV//vybLlkKRqEy11CZp0JorqEyzxsFQj4Gi1D8/fk2/Dxuxs/kZoH+M7EiIwP9Z9KSQmmuYr5Bz8r5Buz3iAMAAAAAEIwC8jPiAAAAAAAEKxpxAAAAAABMRCMOAAAAAICJaMQBAAAAADARjXgzVFdXa/DgwQoLC9Phw4etLqdFnTp1StOnT1diYqLat2+vu+66S/Pnz1dNTY3VpbWIvLw89erVS1FRURo5cqQ++ugjq0tqcTk5ORo+fLg6deqkuLg4TZw4UWVlZVaX5XdLlixRWFiYMjIyrC4FrVCwZ5+vQiEjfRWqWeorMve7BfPrxQahkJ2hkouhnHlW5RmNeDPMnj1b3bp1s7oMvzhx4oTq6+u1du1aHTt2TLm5ucrPz9ff//3fW13abXv99deVlZWl+fPn6+OPP9bdd98th8Ohc+fOWV1aiyouLpbT6dTBgwdVVFSk2tpaTZgwQZcvX7a6NL85dOiQ1q5dq0GDBlldClqpYM4+X4VKRvoqFLPUV2Sub4L59WKDYM/OUMrFUM08S/PMgyZ55513PH379vUcO3bMI8nzySefWF2S3y1dutSTmJhodRm3bcSIER6n02ncr6ur83Tr1s2Tk5NjaV3+du7cOY8kT3FxsdWl+MXFixc9ffr08RQVFXn+6q/+yvPcc89ZXRKCRLBkn69CNSN9FexZ6isy1zeh+HqxQTBlZyjnYihkntV5xhnxJqioqNCMGTP0L//yL+rQoYPV5ZimqqpKnTt3trqM21JTU6PS0lIlJycb28LDw5WcnKySkhJLa/O3qqoqSWr1f4e34nQ6lZKS4vV3C7SEYMg+X4VyRvoq2LPUV2TudwvV14sNgiU7Qz0XQyHzrM6zCEuetRXyeDyaMmWKnn32WQ0bNkynTp2yuiRTfP7551q5cqVeeuklq0u5LX/6059UV1cnu93utd1ut+vEiROW1eVv9fX1ysjI0OjRozVgwACry2lxW7Zs0ccff6xDhw5ZXQqCTLBkn69CNSN9FexZ6isy97uF6uvFBsGUnaGci6GQeYGQZyF/Rnzu3LkKCwv71tuJEye0cuVKXbx4UdnZ2VaX3Cy+zvNGZ86c0U9+8hM9+uijmjFjhmW1o/mcTqeOHj2qLVu2WF1Kizt9+rSee+45vfbaa4qKirK6HAQosg8tIZiz1Fehnrmh8nqxAdkZ2oI98wIlz8I8Ho/HsmcPAOfPn9ef//znbx3zF3/xF3rssce0fft2hYWFGdvr6urUpk0bTZ48WRs3bjSh2ubzdZ7t2rWTJJ09e1ZjxozRqFGjVFhYqPDw1v2eTU1NjTp06KDf/e53mjhxorE9LS1NlZWV2rZtm6X1+UN6erq2bdum999/X4mJiVaX0+LefvttPfTQQ2rTpo2xra6uTmFhYQoPD1d1dbXXPoSmUM8+X4ViRvoq2LPUV6GeuaHyerEB2Rm6uRgKmRcoeRbyjbivysvL5Xa7jftnz56Vw+HQ7373O40cOVLdu3e3tL6WdObMGY0dO1ZDhw7Vpk2bguY/1pEjR2rEiBFauXKldP2ymx49eig9PV1z5861urwW4/F4NGvWLL311lvav3+/+vTpY3VJfnHx4kV9+eWXXtumTp2qvn37as6cOUF7KRX8J1izz1ehkpG+CpUs9RWZ65tQer3YIJizM5RyMZQyL1DyjM+I+6hHjx5e9zt27ChJuuuuu4IqVM+cOaMxY8aoZ8+eeumll3T+/HljX3x8vKW13a6srCylpaVp2LBhGjFihJYvX67Lly9r6tSpVpfWopxOpzZv3qxt27apU6dOcrlckqSYmBi1b9/e6vJaTKdOnW4KyujoaHXp0oUXhGiyYM4+X4VKRvoqVLLUV2Sub0Ll9WKDYM/OUMrFUMq8QMkzGnF4KSoq0ueff67PP//8pv8wWvvFEz/72c90/vx5zZs3Ty6XS4MHD9auXbtuWoSjtVuzZo0kacyYMV7bCwoKNGXKFIuqAgJbMGefr0IlI31FlgLfLdizM5RykcwzH5emAwAAAABgota/kgIAAAAAAK0IjTgAAAAAACaiEQcAAAAAwEQ04gAAAAAAmIhGHAAAAAAAE9GIAwAAAABgIhpxAAAAAABMRCMOAAAAAICJaMQBAAAAADARjTgAAAAAACaiEQcAAAAAwEQ04gAAAAAAmOj/AMwNQs0n3Bh5AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(initial_particles[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "db7cd2eb", - "metadata": {}, - "outputs": [], - "source": [ - "def predict(x, w):\n", - " return sigmoid(x@w)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "a58e1879", - "metadata": {}, - "outputs": [], - "source": [ - "pred=(predict(Phi,np.mean(particles, axis=0))>0.5).astype(int)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "2e3a9df9", - "metadata": {}, - "outputs": [], - "source": [ - "pred2=(predict(Phi,np.mean(states.position, axis=0))>0.5).astype(int)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "5a6a5dc6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[27, 0],\n", - " [ 0, 23]])" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import sklearn\n", - "sklearn.metrics.confusion_matrix(y, pred)" - ] - }, - { - "cell_type": "markdown", - "id": "3c670f3d-0e3a-42d6-9f62-718397695a74", - "metadata": {}, - "source": [ - "Above: confusion matrix for SMC in sample" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "1bc4fd5c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[19, 8],\n", - " [ 0, 23]])" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sklearn.metrics.confusion_matrix(y, pred2)" - ] - }, - { - "cell_type": "markdown", - "id": "c40e4753-633a-4a06-8dfd-4d5fa2c62b3b", - "metadata": {}, - "source": [ - "Above: confusion matrix for MH in sample" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "6834a6e5", - "metadata": {}, - "outputs": [], - "source": [ - "def posterior_predictive_plot(samples):\n", - " from matplotlib import cm, ticker\n", - " xmin, ymin = X.min(axis=0) - 0.1\n", - " xmax, ymax = X.max(axis=0) + 0.1\n", - " step = 0.1\n", - " Xspace = jnp.mgrid[xmin:xmax:step, ymin:ymax:step]\n", - " _, nx, ny = Xspace.shape\n", - " \n", - " # Compute the average probability to belong to the first cluster at each point on the meshgrid\n", - " Phispace = jnp.concatenate([jnp.ones((1, nx, ny)), Xspace])\n", - " Z_mcmc = sigmoid(jnp.einsum(\"mij,sm->sij\", Phispace, samples))\n", - " Z_mcmc = Z_mcmc.mean(axis=0)\n", - " \n", - " plt.contourf(*Xspace, Z_mcmc)\n", - " plt.legend()\n", - " plt.scatter(*X.T, c=colors)\n", - " plt.xlabel(r\"$X_0$\")\n", - " plt.ylabel(r\"$X_1$\")\n", - " plt.show();\n", - " return Z_mcmc" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "c36ad97c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62464/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Z_mcmc = posterior_predictive_plot(chains)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "040ca9fc-694d-4eee-b5f2-be03bfc32c5b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([[0.4520933 , 0.4540293 , 0.45596862, ..., 0.53816384, 0.54008245,\n", - " 0.5419968 ],\n", - " [0.4537641 , 0.45570213, 0.45764345, ..., 0.5398365 , 0.5417531 ,\n", - " 0.5436653 ],\n", - " [0.4554368 , 0.45737684, 0.45931998, ..., 0.5415082 , 0.5434227 ,\n", - " 0.5453327 ],\n", - " ...,\n", - " [0.5430625 , 0.5450165 , 0.5469687 , ..., 0.6252578 , 0.6269905 ,\n", - " 0.6287157 ],\n", - " [0.5447219 , 0.54667443, 0.54862505, ..., 0.62677556, 0.62850374,\n", - " 0.6302244 ],\n", - " [0.54637897, 0.54832995, 0.55027884, ..., 0.62828875, 0.63001245,\n", - " 0.6317284 ]], dtype=float32)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Z_mcmc" - ] - }, - { - "cell_type": "markdown", - "id": "f211fa23-d779-4829-9666-2802e81f500e", - "metadata": {}, - "source": [ - "It seems that MH as is implemented in the example assigns to all points probabilities around 45-65. Very close to 50%" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "0aa89f5a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62464/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Z_mcmc_2 = posterior_predictive_plot(particles)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "68218051-5ee0-41e0-91ae-4cbe94d21e23", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(Array(0.0003122, dtype=float32), Array(0.99975044, dtype=float32))" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.min(Z_mcmc_2), np.max(Z_mcmc_2)" - ] - }, - { - "cell_type": "markdown", - "id": "0a9dba30", - "metadata": {}, - "source": [ - "# Waste-Free SMC" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "647d1be6", - "metadata": {}, - "outputs": [], - "source": [ - "import importlib\n", - "importlib.reload(blackjax)\n", - "from blackjax.smc.waste_free import waste_free_smc\n", - "\n", - "waste_free_smc_kernel = inner_kernel_tuning(\n", - " logprior_fn=logprior,\n", - " loglikelihood_fn=loglikelihood,\n", - " mcmc_step_fn=step_fn,\n", - " mcmc_init_fn=blackjax.rmh.init,\n", - " resampling_fn=resampling.systematic,\n", - " smc_algorithm=adaptive_tempered_smc,\n", - " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", - " initial_parameter_value=initial_parameter_value,\n", - " target_ess=0.5,\n", - " num_mcmc_steps=None,\n", - " update_strategy=waste_free_smc(n_particles,10)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "4e3d2364", - "metadata": {}, - "outputs": [], - "source": [ - "total_steps_waste_free, final_state_waste_free, normalizing_constant_waste_free = loop(waste_free_smc_kernel.step, iterations_key, waste_free_smc_kernel.init(initial_particles))" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "2895b1a2-889f-4e6e-a72a-5670617e4e13", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(0., dtype=float32)" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.sum(normalizing_constant_waste_free[:total_steps_waste_free]) #log scale" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "f9f75aa2-9deb-4188-b11a-1757ae2f9a91", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62464/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Array([[2.8918695e-04, 3.4526619e-04, 4.1533765e-04, ..., 4.1969481e-01,\n", - " 4.3220809e-01, 4.4416195e-01],\n", - " [3.1954193e-04, 3.7984748e-04, 4.5493516e-04, ..., 4.3008462e-01,\n", - " 4.4261801e-01, 4.5457524e-01],\n", - " [3.5531164e-04, 4.2049473e-04, 5.0137856e-04, ..., 4.4092900e-01,\n", - " 4.5347723e-01, 4.6544501e-01],\n", - " ...,\n", - " [5.7525760e-01, 5.8810079e-01, 6.0128236e-01, ..., 9.9963707e-01,\n", - " 9.9969530e-01, 9.9974197e-01],\n", - " [5.8583021e-01, 5.9841263e-01, 6.1136401e-01, ..., 9.9966609e-01,\n", - " 9.9972129e-01, 9.9976534e-01],\n", - " [5.9574318e-01, 6.0810667e-01, 6.2087506e-01, ..., 9.9969071e-01,\n", - " 9.9974334e-01, 9.9978501e-01]], dtype=float32)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "posterior_predictive_plot(final_state_waste_free.sampler_state.particles)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "630b6a13", - "metadata": {}, - "outputs": [], - "source": [ - "particles_waste_free = final_state_waste_free.sampler_state.particles" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "c1997aa9", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62464/4095671798.py:9: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(chains[:,i], label=\"MH\")\n", - " axi.hist(particles[:, i], label=\"SMC\")\n", - " axi.hist(particles_waste_free[:, i],label=\"WF\")\n", - " \n", - "\n", - " axi.set_title(f\"$w_{i}$\")\n", - " plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "966c65d4-1699-4cb5-b3c2-d1eac1a4dd88", - "metadata": {}, - "source": [ - "There's a big difference in posteriors for SMC vs SMC-WasteFree" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "9c90387f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(Array(-0.01791389, dtype=float32),\n", - " Array(-5.750385, dtype=float32),\n", - " Array(-6.4010663, dtype=float32))" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.mean(chains[:,0]), np.mean(particles[:,0]), np.mean(particles_waste_free[:,0]), " - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "df47baa9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "StateWithParameterOverride(sampler_state=TemperedSMCState(particles=Array([[-6.385606 , 2.3500376, 2.6450486],\n", - " [-6.878158 , 2.0022292, 4.137133 ],\n", - " [-9.559358 , 3.3078794, 2.0108054],\n", - " ...,\n", - " [-3.7246413, 3.2796614, 0.6937783],\n", - " [-3.7246413, 3.2796614, 0.6937783],\n", - " [-3.7246413, 3.2796614, 0.6937783]], dtype=float32), weights=Array([6.1977698e-05, 6.3779000e-05, 3.8251215e-05, ..., 4.2606887e-05,\n", - " 4.2606887e-05, 4.2606887e-05], dtype=float32), lmbda=Array(1., dtype=float32, weak_type=True)), parameter_override={'cov': Array([[[ 8.731909 , -2.2317386, -1.6413733],\n", - " [-2.2317386, 3.0842333, -1.7759979],\n", - " [-1.6413733, -1.7759979, 2.8467197]]], dtype=float32)})" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "final_state_waste_free" - ] - }, - { - "cell_type": "markdown", - "id": "9c6d5d22-4bf2-48df-a0a3-b4beac70ae61", - "metadata": {}, - "source": [ - "Note that to achieve similar results, SMC will take" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "b2088325", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(1500000, dtype=int32, weak_type=True)" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "total_steps * 5 * n_particles" - ] - }, - { - "cell_type": "markdown", - "id": "c0d8c6cb-f1a9-4783-89ff-b86eaf73d404", - "metadata": {}, - "source": [ - "inner MCMC steps (with their corresponding density evaluations), whereas Waste-Free is going to take" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "415e3148-5093-4841-84b7-a2c3993b6629", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(252000., dtype=float32, weak_type=True)" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "total_steps_waste_free * n_particles/10 * 9 " - ] - }, - { - "cell_type": "markdown", - "id": "d584f684-6748-4538-adf2-4c1be0b1f224", - "metadata": {}, - "source": [ - "inner MCMC steps." - ] - }, - { - "cell_type": "markdown", - "id": "4655f049-96c2-4c12-9650-dd20d51ec298", - "metadata": {}, - "source": [ - "Confusion matrix in sample for waste free" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "de1497e2-ee8b-4a7e-877c-f788274ed843", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[27, 0],\n", - " [ 0, 23]])" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pred3=(predict(Phi,np.mean(particles_waste_free, axis=0))>0.5).astype(int)\n", - "sklearn.metrics.confusion_matrix(y, pred3)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e4970b81-20d7-47dd-bbf0-907c77195718", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f02b8e09-e0b9-4bd0-9cff-24905e39ed97", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "jupytext": { - "formats": "md:myst,ipynb" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/logistic_regression.ipynb b/logistic_regression.ipynb deleted file mode 100644 index 610a3f19d..000000000 --- a/logistic_regression.ipynb +++ /dev/null @@ -1,1165 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "3cdc536d", - "metadata": {}, - "source": [ - "# Waste Free SMC comparison\n", - "\n", - "In this notebook we take again a Logistic Regression model, and compare MH, SMC and Waste-Free SMC" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "de1922dd", - "metadata": {}, - "outputs": [], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "e7dba964", - "metadata": { - "tags": [ - "hide-cell" - ] - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import sklearn\n", - "\n", - "plt.rcParams[\"axes.spines.right\"] = False\n", - "plt.rcParams[\"axes.spines.top\"] = False\n", - "plt.rcParams[\"figure.figsize\"] = (12, 8)\n", - "import jax\n", - "\n", - "from datetime import date\n", - "rng_key = jax.random.key(int(date.today().strftime(\"%Y%m%d\")))\n", - "import jax.numpy as jnp\n", - "from sklearn.datasets import make_biclusters\n", - "import blackjax" - ] - }, - { - "cell_type": "markdown", - "id": "ee12f75d", - "metadata": {}, - "source": [ - "## The Data" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7ec4566a", - "metadata": {}, - "outputs": [], - "source": [ - "num_points = 50\n", - "X, rows, cols = make_biclusters(\n", - " (num_points, 2), 2, noise=0.6, random_state=314, minval=-3, maxval=3\n", - ")\n", - "y = rows[0] * 1.0 # y[i] = whether point i belongs to cluster 1" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "40210fca", - "metadata": { - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "colors = [\"tab:red\" if el else \"tab:blue\" for el in rows[0]]\n", - "plt.scatter(*X.T, edgecolors=colors, c=\"none\")\n", - "plt.xlabel(r\"$X_0$\")\n", - "plt.ylabel(r\"$X_1$\");" - ] - }, - { - "cell_type": "markdown", - "id": "49f196c9", - "metadata": {}, - "source": [ - "## The Model\n", - "\n", - "We use a simple logistic regression model to infer to which cluster each of the points belongs. We note $y$ a binary variable that indicates whether a point belongs to the first cluster :\n", - "\n", - "$$\n", - "y \\sim \\operatorname{Bernoulli}(p)\n", - "$$\n", - "\n", - "The probability $p$ to belong to the first cluster commes from a logistic regression:\n", - "\n", - "$$\n", - "p = \\operatorname{logistic}(\\Phi\\,\\boldsymbol{w})\n", - "$$\n", - "\n", - "where $w$ is a vector of weights whose priors are a normal prior centered on 0:\n", - "\n", - "$$\n", - "\\boldsymbol{w} \\sim \\operatorname{Normal}(0, \\sigma)\n", - "$$\n", - "\n", - "And $\\Phi$ is the matrix that contains the data, so each row $\\Phi_{i,:}$ is the vector $\\left[1, X_0^i, X_1^i\\right]$" - ] - }, - { - "cell_type": "markdown", - "id": "9af4ac0f-a441-4c2f-a22a-3b5112599c3d", - "metadata": {}, - "source": [ - "Note that X is not normalized" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "f3c7dd2f", - "metadata": { - "tags": [ - "hide-stderr" - ] - }, - "outputs": [], - "source": [ - "Phi = jnp.c_[jnp.ones(num_points)[:, None], X]\n", - "N, M = Phi.shape\n", - "\n", - "\n", - "def sigmoid(z):\n", - " return jnp.exp(z) / (1 + jnp.exp(z))\n", - "\n", - "\n", - "def log_sigmoid(z):\n", - " return z - jnp.log(1 + jnp.exp(z))\n", - "\n", - "def logprior(w, alpha=1.):\n", - " prior_term = alpha * w @ w / 2\n", - " return -prior_term\n", - " \n", - "def loglikelihood(w):\n", - " \"\"\"The log-probability density function of the posterior distribution of the model.\"\"\"\n", - " log_an = log_sigmoid(Phi @ w)\n", - " an = Phi @ w\n", - " log_likelihood_term = y * log_an + (1 - y) * jnp.log(1 - sigmoid(an))\n", - " return log_likelihood_term.sum()\n", - " \n", - "def logdensity_fn(w, alpha=1.):\n", - " return logprior(w,alpha) + loglikelihood(w)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "a5e8505c-aabb-4da5-ad73-cac475cfece9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 1.0, 'Prior')" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "w = jnp.linspace(0, 10).reshape(-1,1)\n", - "for alpha in [0.1, 0.5, 1, 2]:\n", - " plt.plot(w, jax.vmap(lambda x:jnp.exp(logprior(x, alpha)))(w), label=alpha)\n", - "\n", - "plt.legend()\n", - "plt.xlabel(\"Squared norm of w\")\n", - "plt.title(\"Prior\")" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "043aff76", - "metadata": {}, - "outputs": [], - "source": [ - "from sklearn.linear_model import LogisticRegression" - ] - }, - { - "cell_type": "markdown", - "id": "93778681", - "metadata": {}, - "source": [ - "## Posterior Sampling\n", - "\n", - "We use `blackjax`'s Random Walk RMH kernel to sample from the posterior distribution." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "9889d938", - "metadata": {}, - "outputs": [], - "source": [ - "rng_key, init_key = jax.random.split(rng_key)\n", - "\n", - "w0 = jax.random.multivariate_normal(init_key, 0.1 + jnp.zeros(M), jnp.eye(M))\n", - "rmh = blackjax.rmh(logdensity_fn, blackjax.mcmc.random_walk.normal(jnp.ones(M) * 0.05))\n", - "initial_state = rmh.init(w0)\n", - "\n", - "def inference_loop(rng_key, kernel, initial_state, num_samples):\n", - " @jax.jit\n", - " def one_step(state, rng_key):\n", - " state, _ = kernel(rng_key, state)\n", - " return state, state\n", - "\n", - " keys = jax.random.split(rng_key, num_samples)\n", - " _, states = jax.lax.scan(one_step, initial_state, keys)\n", - "\n", - " return states\n", - "\n", - "rng_key, sample_key = jax.random.split(rng_key)\n", - "states = inference_loop(sample_key, rmh.step, initial_state, 5_000)" - ] - }, - { - "cell_type": "markdown", - "id": "3301e09c", - "metadata": {}, - "source": [ - "Trace display:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "69816b03", - "metadata": { - "tags": [ - "hide-input" - ] - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "burnin = 300\n", - "\n", - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.plot(states.position[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - " axi.axvline(x=burnin, c=\"tab:red\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "1f1306a6", - "metadata": {}, - "outputs": [], - "source": [ - "burnin = 300\n", - "chains = states.position[burnin:, :]\n", - "nsamp, _ = chains.shape" - ] - }, - { - "cell_type": "markdown", - "id": "daa2e425", - "metadata": {}, - "source": [ - "# Classic SMC" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "263a7714", - "metadata": {}, - "outputs": [], - "source": [ - "import jax.numpy as jnp\n", - "import numpy as np\n", - "\n", - "from blackjax import adaptive_tempered_smc\n", - "from blackjax.smc import resampling, extend_params\n", - "from blackjax.smc.inner_kernel_tuning import StateWithParameterOverride\n", - "from blackjax.smc.tempered import TemperedSMCState\n", - "import jax\n", - "from jax import numpy as jnp\n", - "from datetime import date\n", - "import numpy as np\n", - "import pandas as pd\n", - "import functools\n", - "from jax.scipy.stats import multivariate_normal\n", - "from blackjax import additive_step_random_walk, inner_kernel_tuning\n", - "from blackjax.mcmc.random_walk import normal\n", - "from blackjax.smc.tuning.from_particles import (\n", - " particles_covariance_matrix\n", - ")\n", - "\n", - "n_predictors = 3\n", - "def initial_particles_multivariate_normal(key, n_samples):\n", - " return jax.random.multivariate_normal(\n", - " key, jnp.zeros(n_predictors) + 0.1, jnp.eye(n_predictors), (n_samples,)\n", - " )" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "88ccaf4c", - "metadata": {}, - "outputs": [], - "source": [ - "n_particles = 20000\n", - "key = jax.random.PRNGKey(10)\n", - "key, initial_particles_key, iterations_key = jax.random.split(key, 3)\n", - "initial_particles = initial_particles_multivariate_normal(initial_particles_key, n_particles)\n", - "initial_parameter_value = extend_params({\"cov\": particles_covariance_matrix(initial_particles)})\n", - "\n", - "\n", - "def mcmc_parameter_update_fn(state: TemperedSMCState, info):\n", - " sigma_particles = particles_covariance_matrix(state.particles) * 2.38 / np.sqrt(n_predictors) \n", - " return extend_params({\"cov\":sigma_particles})\n", - "\n", - "def step_fn(key, state, logdensity, cov):\n", - " return blackjax.rmh(logdensity, normal(cov)).step(key, state)\n", - "\n", - "\n", - "kernel_tuned_proposal = inner_kernel_tuning(\n", - " logprior_fn=logprior,\n", - " loglikelihood_fn=loglikelihood,\n", - " mcmc_step_fn=step_fn,\n", - " mcmc_init_fn=blackjax.rmh.init,\n", - " resampling_fn=resampling.systematic,\n", - " smc_algorithm=adaptive_tempered_smc,\n", - " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", - " initial_parameter_value=initial_parameter_value,\n", - " target_ess=0.5,\n", - " num_mcmc_steps=5,\n", - ")\n", - "\n", - "from blackjax.smc.base import SMCInfo\n", - "def loop(kernel, rng_key, initial_state):\n", - " normalizing_constant = jnp.zeros((1000))\n", - "\n", - " def cond(carry):\n", - " _, state, _ = carry\n", - " return state.sampler_state.lmbda < 1\n", - "\n", - " def body(carry):\n", - " i, state, op_key = carry\n", - " op_key, subkey = jax.random.split(op_key, 2)\n", - " state, info = kernel(subkey, state)\n", - " normalizing_constant.at[i].set(info.log_likelihood_increment)\n", - " return i + 1, state, op_key\n", - "\n", - " def f(initial_state, key):\n", - " total_iter, final_state, _ = jax.lax.while_loop(\n", - " cond, body, (0, initial_state, key)\n", - " )\n", - " return total_iter, final_state\n", - "\n", - " total_iter, final_state = f(initial_state, rng_key)\n", - " return total_iter, final_state, normalizing_constant" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "c0ccdccc", - "metadata": {}, - "outputs": [], - "source": [ - "total_steps, final_state, normalizing_constant = loop(kernel_tuned_proposal.step, iterations_key, kernel_tuned_proposal.init(initial_particles))" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "6a672bcc", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(0., dtype=float32)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.sum(normalizing_constant[:total_steps]) #" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "50955c99-a2fd-46f8-8b4d-cad4ed0bbd48", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "np.float32(1.0)" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.exp(np.sum(normalizing_constant[:total_steps]))" - ] - }, - { - "cell_type": "markdown", - "id": "105399cb-61bc-4283-a65b-8b2cc517dde9", - "metadata": {}, - "source": [ - "Why the log normalizing constant is always 0? Is it because of the prior shape?" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "81dae2ae", - "metadata": {}, - "outputs": [], - "source": [ - "particles = final_state.sampler_state.particles" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "85dd9f86", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "burnin = 300\n", - "\n", - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(states.position[burnin:, i])\n", - " axi.hist(particles[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "191ea71c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(particles[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "4032de45", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(initial_particles[:, i])\n", - " axi.set_title(f\"$w_{i}$\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "db7cd2eb", - "metadata": {}, - "outputs": [], - "source": [ - "def predict(x, w):\n", - " return sigmoid(x@w)\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "a58e1879", - "metadata": {}, - "outputs": [], - "source": [ - "pred=(predict(Phi,np.mean(particles, axis=0))>0.5).astype(int)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "2e3a9df9", - "metadata": {}, - "outputs": [], - "source": [ - "pred2=(predict(Phi,np.mean(states.position, axis=0))>0.5).astype(int)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "5a6a5dc6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[26, 1],\n", - " [ 0, 23]])" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import sklearn\n", - "sklearn.metrics.confusion_matrix(y, pred)" - ] - }, - { - "cell_type": "markdown", - "id": "3c670f3d-0e3a-42d6-9f62-718397695a74", - "metadata": {}, - "source": [ - "Above: confusion matrix for SMC in sample" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "1bc4fd5c", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[19, 8],\n", - " [ 0, 23]])" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sklearn.metrics.confusion_matrix(y, pred2)" - ] - }, - { - "cell_type": "markdown", - "id": "c40e4753-633a-4a06-8dfd-4d5fa2c62b3b", - "metadata": {}, - "source": [ - "Above: confusion matrix for MH in sample" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "6834a6e5", - "metadata": {}, - "outputs": [], - "source": [ - "def posterior_predictive_plot(samples):\n", - " from matplotlib import cm, ticker\n", - " xmin, ymin = X.min(axis=0) - 0.1\n", - " xmax, ymax = X.max(axis=0) + 0.1\n", - " step = 0.1\n", - " Xspace = jnp.mgrid[xmin:xmax:step, ymin:ymax:step]\n", - " _, nx, ny = Xspace.shape\n", - " \n", - " # Compute the average probability to belong to the first cluster at each point on the meshgrid\n", - " Phispace = jnp.concatenate([jnp.ones((1, nx, ny)), Xspace])\n", - " Z_mcmc = sigmoid(jnp.einsum(\"mij,sm->sij\", Phispace, samples))\n", - " Z_mcmc = Z_mcmc.mean(axis=0)\n", - " \n", - " plt.contourf(*Xspace, Z_mcmc)\n", - " plt.legend()\n", - " plt.scatter(*X.T, c=colors)\n", - " plt.xlabel(r\"$X_0$\")\n", - " plt.ylabel(r\"$X_1$\")\n", - " plt.show();\n", - " return Z_mcmc" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "c36ad97c", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62480/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Z_mcmc = posterior_predictive_plot(chains)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "040ca9fc-694d-4eee-b5f2-be03bfc32c5b", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array([[0.4520933 , 0.4540293 , 0.45596862, ..., 0.53816384, 0.54008245,\n", - " 0.5419968 ],\n", - " [0.4537641 , 0.45570213, 0.45764345, ..., 0.5398365 , 0.5417531 ,\n", - " 0.5436653 ],\n", - " [0.4554368 , 0.45737684, 0.45931998, ..., 0.5415082 , 0.5434227 ,\n", - " 0.5453327 ],\n", - " ...,\n", - " [0.5430625 , 0.5450165 , 0.5469687 , ..., 0.6252578 , 0.6269905 ,\n", - " 0.6287157 ],\n", - " [0.5447219 , 0.54667443, 0.54862505, ..., 0.62677556, 0.62850374,\n", - " 0.6302244 ],\n", - " [0.54637897, 0.54832995, 0.55027884, ..., 0.62828875, 0.63001245,\n", - " 0.6317284 ]], dtype=float32)" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Z_mcmc" - ] - }, - { - "cell_type": "markdown", - "id": "f211fa23-d779-4829-9666-2802e81f500e", - "metadata": {}, - "source": [ - "It seems that MH as is implemented in the example assigns to all points probabilities around 45-65. Very close to 50%" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "0aa89f5a", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62480/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "Z_mcmc_2 = posterior_predictive_plot(particles)" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "id": "68218051-5ee0-41e0-91ae-4cbe94d21e23", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(Array(0.13222471, dtype=float32), Array(0.9617157, dtype=float32))" - ] - }, - "execution_count": 29, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.min(Z_mcmc_2), np.max(Z_mcmc_2)" - ] - }, - { - "cell_type": "markdown", - "id": "0a9dba30", - "metadata": {}, - "source": [ - "# Waste-Free SMC" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "647d1be6", - "metadata": {}, - "outputs": [], - "source": [ - "import importlib\n", - "importlib.reload(blackjax)\n", - "from blackjax.smc.waste_free import waste_free_smc\n", - "\n", - "waste_free_smc_kernel = inner_kernel_tuning(\n", - " logprior_fn=logprior,\n", - " loglikelihood_fn=loglikelihood,\n", - " mcmc_step_fn=step_fn,\n", - " mcmc_init_fn=blackjax.rmh.init,\n", - " resampling_fn=resampling.systematic,\n", - " smc_algorithm=adaptive_tempered_smc,\n", - " mcmc_parameter_update_fn=mcmc_parameter_update_fn,\n", - " initial_parameter_value=initial_parameter_value,\n", - " target_ess=0.5,\n", - " num_mcmc_steps=None,\n", - " update_strategy=waste_free_smc(n_particles,10)\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "id": "4e3d2364", - "metadata": {}, - "outputs": [], - "source": [ - "total_steps_waste_free, final_state_waste_free, normalizing_constant_waste_free = loop(waste_free_smc_kernel.step, iterations_key, waste_free_smc_kernel.init(initial_particles))" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "2895b1a2-889f-4e6e-a72a-5670617e4e13", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(0., dtype=float32)" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.sum(normalizing_constant_waste_free[:total_steps_waste_free]) #log scale" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "f9f75aa2-9deb-4188-b11a-1757ae2f9a91", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62480/2150260783.py:15: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Array([[0.02926168, 0.03162239, 0.0342155 , ..., 0.6721513 , 0.68868244,\n", - " 0.7042139 ],\n", - " [0.03172185, 0.03427563, 0.03707994, ..., 0.68726957, 0.70317787,\n", - " 0.7181016 ],\n", - " [0.03439488, 0.03715712, 0.04018922, ..., 0.7021 , 0.71738654,\n", - " 0.73170614],\n", - " ...,\n", - " [0.6933465 , 0.715117 , 0.7361818 , ..., 0.99362504, 0.9940435 ,\n", - " 0.99442685],\n", - " [0.7091236 , 0.7303853 , 0.75086385, ..., 0.9940827 , 0.9944701 ,\n", - " 0.99482614],\n", - " [0.7244788 , 0.7451816 , 0.7650328 , ..., 0.99450475, 0.9948642 ,\n", - " 0.9951936 ]], dtype=float32)" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "posterior_predictive_plot(final_state_waste_free.sampler_state.particles)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "id": "630b6a13", - "metadata": {}, - "outputs": [], - "source": [ - "particles_waste_free = final_state_waste_free.sampler_state.particles" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "id": "c1997aa9", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_62480/4095671798.py:9: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", - " plt.legend()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", - "for i, axi in enumerate(ax):\n", - " axi.hist(chains[:,i], label=\"MH\")\n", - " axi.hist(particles[:, i], label=\"SMC\")\n", - " axi.hist(particles_waste_free[:, i],label=\"WF\")\n", - " \n", - "\n", - " axi.set_title(f\"$w_{i}$\")\n", - " plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "966c65d4-1699-4cb5-b3c2-d1eac1a4dd88", - "metadata": {}, - "source": [ - "There's a big difference in posteriors for SMC vs SMC-WasteFree" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "id": "9c90387f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(Array(-0.01791389, dtype=float32),\n", - " Array(-0.64235276, dtype=float32),\n", - " Array(-1.4553034, dtype=float32))" - ] - }, - "execution_count": 36, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.mean(chains[:,0]), np.mean(particles[:,0]), np.mean(particles_waste_free[:,0]), " - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "id": "df47baa9", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "StateWithParameterOverride(sampler_state=TemperedSMCState(particles=Array([[-1.7003354 , 0.8432715 , 1.2795514 ],\n", - " [-1.0450116 , 1.0331315 , 0.48102152],\n", - " [-1.7003354 , 0.8432715 , 1.2795514 ],\n", - " ...,\n", - " [-1.0532204 , 0.11202506, 0.9025311 ],\n", - " [-1.0532204 , 0.11202506, 0.9025311 ],\n", - " [-1.0532204 , 0.11202506, 0.9025311 ]], dtype=float32), weights=Array([5.2097013e-05, 4.6736131e-05, 5.2097013e-05, ..., 4.2692016e-05,\n", - " 4.2692016e-05, 4.2692016e-05], dtype=float32), lmbda=Array(1., dtype=float32, weak_type=True)), parameter_override={'cov': Array([[[ 0.17416753, 0.01399391, -0.1476322 ],\n", - " [ 0.01399391, 0.0592518 , -0.03197484],\n", - " [-0.1476322 , -0.03197484, 0.16884296]]], dtype=float32)})" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "final_state_waste_free" - ] - }, - { - "cell_type": "markdown", - "id": "9c6d5d22-4bf2-48df-a0a3-b4beac70ae61", - "metadata": {}, - "source": [ - "Note that to achieve similar results, SMC will take" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "id": "b2088325", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(700000, dtype=int32, weak_type=True)" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "total_steps * 5 * n_particles" - ] - }, - { - "cell_type": "markdown", - "id": "c0d8c6cb-f1a9-4783-89ff-b86eaf73d404", - "metadata": {}, - "source": [ - "inner MCMC steps (with their corresponding density evaluations), whereas Waste-Free is going to take" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "415e3148-5093-4841-84b7-a2c3993b6629", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Array(234000., dtype=float32, weak_type=True)" - ] - }, - "execution_count": 39, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "total_steps_waste_free * n_particles/10 * 9 " - ] - }, - { - "cell_type": "markdown", - "id": "d584f684-6748-4538-adf2-4c1be0b1f224", - "metadata": {}, - "source": [ - "inner MCMC steps." - ] - }, - { - "cell_type": "markdown", - "id": "4655f049-96c2-4c12-9650-dd20d51ec298", - "metadata": {}, - "source": [ - "Confusion matrix in sample for waste free" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "de1497e2-ee8b-4a7e-877c-f788274ed843", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[27, 0],\n", - " [ 0, 23]])" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pred3=(predict(Phi,np.mean(particles_waste_free, axis=0))>0.5).astype(int)\n", - "sklearn.metrics.confusion_matrix(y, pred3)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e4970b81-20d7-47dd-bbf0-907c77195718", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "f02b8e09-e0b9-4bd0-9cff-24905e39ed97", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "jupytext": { - "formats": "md:myst,ipynb" - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 5c341770c8db256037f956e4785b048d2de30d27 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Thu, 15 Aug 2024 17:24:27 -0300 Subject: [PATCH 09/29] Adding test for num_mcmc_steps --- tests/smc/test_waste_free_smc.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index 3d99b3c92..279731cb6 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -5,13 +5,14 @@ import jax import jax.numpy as jnp import numpy as np +import pytest from absl.testing import absltest import blackjax import blackjax.smc.resampling as resampling from blackjax import adaptive_tempered_smc, tempered_smc from blackjax.smc import extend_params -from blackjax.smc.waste_free import waste_free_smc +from blackjax.smc.waste_free import waste_free_smc, update_waste_free from tests.smc import SMCLinearRegressionTestCase from tests.smc.test_tempered_smc import inference_loop @@ -104,5 +105,16 @@ def test_adaptive_tempered_smc(self): self.assert_linear_regression_test_case(result) +def test_waste_free_set_num_mcmc_steps(): + with pytest.raises(ValueError) as exc_info: + update_waste_free(lambda x:x, + lambda x:1, + lambda x:1, + 100, + 10, + 3, + num_mcmc_steps=50) + assert str(exc_info.value).startswith("Can't use waste free SMC with a num_mcmc_steps parameter") + if __name__ == "__main__": absltest.main() From 8145cbb3b571c075a4aa863bc38daf90b6387eb0 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Thu, 15 Aug 2024 17:26:55 -0300 Subject: [PATCH 10/29] format --- tests/smc/test_waste_free_smc.py | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index 279731cb6..8b470aceb 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -12,7 +12,7 @@ import blackjax.smc.resampling as resampling from blackjax import adaptive_tempered_smc, tempered_smc from blackjax.smc import extend_params -from blackjax.smc.waste_free import waste_free_smc, update_waste_free +from blackjax.smc.waste_free import update_waste_free, waste_free_smc from tests.smc import SMCLinearRegressionTestCase from tests.smc.test_tempered_smc import inference_loop @@ -107,14 +107,13 @@ def test_adaptive_tempered_smc(self): def test_waste_free_set_num_mcmc_steps(): with pytest.raises(ValueError) as exc_info: - update_waste_free(lambda x:x, - lambda x:1, - lambda x:1, - 100, - 10, - 3, - num_mcmc_steps=50) - assert str(exc_info.value).startswith("Can't use waste free SMC with a num_mcmc_steps parameter") + update_waste_free( + lambda x: x, lambda x: 1, lambda x: 1, 100, 10, 3, num_mcmc_steps=50 + ) + assert str(exc_info.value).startswith( + "Can't use waste free SMC with a num_mcmc_steps parameter" + ) + if __name__ == "__main__": absltest.main() From 9550d5d9c5e2feb90f98c537c82c32f4493ae1e0 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 16 Aug 2024 09:53:59 -0300 Subject: [PATCH 11/29] better test coverage --- blackjax/smc/waste_free.py | 2 ++ tests/smc/test_waste_free_smc.py | 50 +++++++++++++++++++++++++++++++- 2 files changed, 51 insertions(+), 1 deletion(-) diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py index 2f0ced582..9727567e9 100644 --- a/blackjax/smc/waste_free.py +++ b/blackjax/smc/waste_free.py @@ -67,4 +67,6 @@ def reshape_step_particles(x): def waste_free_smc(n_particles, p): + if not n_particles % p ==0: + raise ValueError("p must be a divider of n_particles ") return functools.partial(update_waste_free, num_resampled=int(n_particles / p), p=p) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index 8b470aceb..886d08492 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -1,4 +1,5 @@ """Test the tempered SMC steps and routine""" + import functools import chex @@ -7,11 +8,14 @@ import numpy as np import pytest from absl.testing import absltest +from scipy.stats import stats import blackjax import blackjax.smc.resampling as resampling from blackjax import adaptive_tempered_smc, tempered_smc -from blackjax.smc import extend_params +from blackjax.mcmc.random_walk import build_rmh +from blackjax.smc import extend_params, base +from blackjax.smc.base import SMCState from blackjax.smc.waste_free import update_waste_free, waste_free_smc from tests.smc import SMCLinearRegressionTestCase from tests.smc.test_tempered_smc import inference_loop @@ -105,6 +109,44 @@ def test_adaptive_tempered_smc(self): self.assert_linear_regression_test_case(result) +class Update_waste_free_multivariate_particles(chex.TestCase): + + @chex.variants(with_jit=True) + def test_update_waste_free_multivariate_particles(self): + """ + Given resampled multivariate particles, + when updating with waste free, they are joined + by the result of iterating the MCMC chain to + get a bigger set of particles. + """ + resampled_particles = np.ones((50, 3)) + n_particles = 100 + + def normal_logdensity(x): + return jnp.log( + jax.scipy.stats.multivariate_normal.pdf( + x, mean=np.zeros(3), cov=np.diag(np.ones(3)) + ) + ) + + def rmh_proposal_distribution(rng_key, position): + return position + jax.random.normal(rng_key, (3,)) * 25.0 + + kernel = functools.partial( + blackjax.rmh.build_kernel(), transition_generator=rmh_proposal_distribution + ) + init = blackjax.rmh.init + update, _ = waste_free_smc(n_particles, 2)( + init, normal_logdensity, kernel, n_particles + ) + + updated_particles, infos = self.variant(update)( + jax.random.split(jax.random.PRNGKey(10), 50), resampled_particles, {} + ) + + assert updated_particles.shape == (n_particles, 3) + + def test_waste_free_set_num_mcmc_steps(): with pytest.raises(ValueError) as exc_info: update_waste_free( @@ -115,5 +157,11 @@ def test_waste_free_set_num_mcmc_steps(): ) +def test_waste_free_p_non_divier(): + with pytest.raises(ValueError) as exc_info: + waste_free_smc(100, 3) + assert str(exc_info.value).startswith("p must be a divider") + + if __name__ == "__main__": absltest.main() From c06b6ab41fa92d2e4cb09f103bb21b9ba2ede764 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 16 Aug 2024 10:22:23 -0300 Subject: [PATCH 12/29] linter --- blackjax/smc/waste_free.py | 2 +- tests/smc/test_waste_free_smc.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/blackjax/smc/waste_free.py b/blackjax/smc/waste_free.py index 9727567e9..05395eca7 100644 --- a/blackjax/smc/waste_free.py +++ b/blackjax/smc/waste_free.py @@ -67,6 +67,6 @@ def reshape_step_particles(x): def waste_free_smc(n_particles, p): - if not n_particles % p ==0: + if not n_particles % p == 0: raise ValueError("p must be a divider of n_particles ") return functools.partial(update_waste_free, num_resampled=int(n_particles / p), p=p) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index 886d08492..92a2e1169 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -14,7 +14,7 @@ import blackjax.smc.resampling as resampling from blackjax import adaptive_tempered_smc, tempered_smc from blackjax.mcmc.random_walk import build_rmh -from blackjax.smc import extend_params, base +from blackjax.smc import base, extend_params from blackjax.smc.base import SMCState from blackjax.smc.waste_free import update_waste_free, waste_free_smc from tests.smc import SMCLinearRegressionTestCase From 424599e3b4dd39d67c03c3603bf26a1c95866d04 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 16 Aug 2024 10:25:12 -0300 Subject: [PATCH 13/29] Flake8 --- tests/smc/test_waste_free_smc.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index 92a2e1169..ccb783ea1 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -8,14 +8,11 @@ import numpy as np import pytest from absl.testing import absltest -from scipy.stats import stats import blackjax import blackjax.smc.resampling as resampling from blackjax import adaptive_tempered_smc, tempered_smc -from blackjax.mcmc.random_walk import build_rmh -from blackjax.smc import base, extend_params -from blackjax.smc.base import SMCState +from blackjax.smc import extend_params from blackjax.smc.waste_free import update_waste_free, waste_free_smc from tests.smc import SMCLinearRegressionTestCase from tests.smc.test_tempered_smc import inference_loop From 110b62e28583ecc780059fdb2395a8f3a95ff2b2 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 16 Aug 2024 10:26:41 -0300 Subject: [PATCH 14/29] black --- tests/smc/test_waste_free_smc.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/smc/test_waste_free_smc.py b/tests/smc/test_waste_free_smc.py index ccb783ea1..a5eeef135 100644 --- a/tests/smc/test_waste_free_smc.py +++ b/tests/smc/test_waste_free_smc.py @@ -107,7 +107,6 @@ def test_adaptive_tempered_smc(self): class Update_waste_free_multivariate_particles(chex.TestCase): - @chex.variants(with_jit=True) def test_update_waste_free_multivariate_particles(self): """ From 964ec95b7efabd007bfc19fb5d19886193f8cf7b Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Wed, 21 Aug 2024 16:35:26 -0300 Subject: [PATCH 15/29] implementation[ --- blackjax/smc/base.py | 29 ++++++ blackjax/smc/mcmc_to_update_fn_adapter.py | 70 ++++++++++++++ blackjax/smc/tempered.py | 106 ++++++---------------- tests/smc/test_smc.py | 3 +- 4 files changed, 130 insertions(+), 78 deletions(-) create mode 100644 blackjax/smc/mcmc_to_update_fn_adapter.py diff --git a/blackjax/smc/base.py b/blackjax/smc/base.py index 5093cf06b..76ce650c8 100644 --- a/blackjax/smc/base.py +++ b/blackjax/smc/base.py @@ -156,3 +156,32 @@ def extend_params(params): """ return jax.tree.map(lambda x: jnp.asarray(x)[None, ...], params) + + +def update_and_take_last( + mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + num_mcmc_steps, + n_particles, +): + """ + Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and + returns the last values, waisting the previous num_mcmc_steps-1 + samples per chain. + """ + + def mcmc_kernel(rng_key, position, step_parameters): + state = mcmc_init_fn(position, tempered_logposterior_fn) + + def body_fn(state, rng_key): + new_state, info = shared_mcmc_step_fn( + rng_key, state, tempered_logposterior_fn, **step_parameters + ) + return new_state, info + + keys = jax.random.split(rng_key, num_mcmc_steps) + last_state, info = jax.lax.scan(body_fn, state, keys) + return last_state.position, info + + return jax.vmap(mcmc_kernel), n_particles diff --git a/blackjax/smc/mcmc_to_update_fn_adapter.py b/blackjax/smc/mcmc_to_update_fn_adapter.py new file mode 100644 index 000000000..e8fcbd8e8 --- /dev/null +++ b/blackjax/smc/mcmc_to_update_fn_adapter.py @@ -0,0 +1,70 @@ +from functools import partial +from typing import Callable + +from blackjax.smc.base import SMCState, update_and_take_last +from blackjax.types import PRNGKey +from blackjax import smc +import jax + + +def build_kernel( + mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + resampling_fn, + update_strategy: Callable = update_and_take_last, + ): + """Builds a SMC step that constructs MCMC kernels from the input parameters, + which may change across iterations. Moreover, it defines the way + such kernels are used to update the particles. This layer + adapts an API defined in terms of kernels (mcmc_step_fn and mcmc_init_fn) into an API + that depends on an update function over the set of particles. + ---------- + + update_strategy + + + Returns + ------- + A callable that takes a rng_key and a TemperedSMCState that contains the current state + of the chain and that returns a new state of the chain along with + information about the transition. + + """ + + def step( + rng_key: PRNGKey, + state, + num_mcmc_steps: int, + mcmc_parameters: dict, + logposterior_fn: Callable, + log_weights_fn: Callable, + ) -> tuple[smc.base.SMCState, smc.base.SMCInfo]: + + shared_mcmc_parameters = {} + unshared_mcmc_parameters = {} + for k, v in mcmc_parameters.items(): + if v.shape[0] == 1: + shared_mcmc_parameters[k] = v[0, ...] + else: + unshared_mcmc_parameters[k] = v + + shared_mcmc_step_fn = partial(mcmc_step_fn, **shared_mcmc_parameters) + + update_fn, num_resampled = update_strategy( + mcmc_init_fn, + logposterior_fn, + shared_mcmc_step_fn, + n_particles=state.weights.shape[0], + num_mcmc_steps=num_mcmc_steps, + ) + + return smc.base.step( + rng_key, + SMCState(state.particles, state.weights, unshared_mcmc_parameters), + update_fn, + jax.vmap(log_weights_fn), + resampling_fn, + num_resampled, + ) + + return step diff --git a/blackjax/smc/tempered.py b/blackjax/smc/tempered.py index 19de8afb7..f747c3348 100644 --- a/blackjax/smc/tempered.py +++ b/blackjax/smc/tempered.py @@ -11,7 +11,6 @@ # 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 functools import partial from typing import Callable, NamedTuple, Optional import jax @@ -19,7 +18,9 @@ import blackjax.smc as smc from blackjax.base import SamplingAlgorithm -from blackjax.smc.base import SMCState + +import blackjax.smc.build_inner_kernels as bik +from blackjax.smc.base import update_and_take_last from blackjax.types import Array, ArrayLikeTree, ArrayTree, PRNGKey __all__ = ["TemperedSMCState", "init", "build_kernel", "as_top_level_api"] @@ -48,42 +49,13 @@ def init(particles: ArrayLikeTree): return TemperedSMCState(particles, weights, 0.0) -def update_and_take_last( - mcmc_init_fn, - tempered_logposterior_fn, - shared_mcmc_step_fn, - num_mcmc_steps, - n_particles, -): - """ - Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and - returns the last values, waisting the previous num_mcmc_steps-1 - samples per chain. - """ - - def mcmc_kernel(rng_key, position, step_parameters): - state = mcmc_init_fn(position, tempered_logposterior_fn) - - def body_fn(state, rng_key): - new_state, info = shared_mcmc_step_fn( - rng_key, state, tempered_logposterior_fn, **step_parameters - ) - return new_state, info - - keys = jax.random.split(rng_key, num_mcmc_steps) - last_state, info = jax.lax.scan(body_fn, state, keys) - return last_state.position, info - - return jax.vmap(mcmc_kernel), n_particles - - def build_kernel( - logprior_fn: Callable, - loglikelihood_fn: Callable, - mcmc_step_fn: Callable, - mcmc_init_fn: Callable, - resampling_fn: Callable, - update_strategy: Callable = update_and_take_last, + logprior_fn: Callable, + loglikelihood_fn: Callable, + mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + resampling_fn: Callable, + update_strategy: Callable = update_and_take_last, ) -> Callable: """Build the base Tempered SMC kernel. @@ -121,13 +93,14 @@ def build_kernel( information about the transition. """ + delegate = bik.build_kernel(mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy) def kernel( - rng_key: PRNGKey, - state: TemperedSMCState, - num_mcmc_steps: int, - lmbda: float, - mcmc_parameters: dict, + rng_key: PRNGKey, + state: TemperedSMCState, + num_mcmc_steps: int, + lmbda: float, + mcmc_parameters: dict, ) -> tuple[TemperedSMCState, smc.base.SMCInfo]: """Move the particles one step using the Tempered SMC algorithm. @@ -153,14 +126,6 @@ def kernel( """ delta = lmbda - state.lmbda - shared_mcmc_parameters = {} - unshared_mcmc_parameters = {} - for k, v in mcmc_parameters.items(): - if v.shape[0] == 1: - shared_mcmc_parameters[k] = v[0, ...] - else: - unshared_mcmc_parameters[k] = v - def log_weights_fn(position: ArrayLikeTree) -> float: return delta * loglikelihood_fn(position) @@ -169,24 +134,13 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: tempered_loglikelihood = state.lmbda * loglikelihood_fn(position) return logprior + tempered_loglikelihood - shared_mcmc_step_fn = partial(mcmc_step_fn, **shared_mcmc_parameters) - - update_fn, num_resampled = update_strategy( - mcmc_init_fn, - tempered_logposterior_fn, - shared_mcmc_step_fn, - n_particles=state.weights.shape[0], - num_mcmc_steps=num_mcmc_steps, - ) - - smc_state, info = smc.base.step( - rng_key, - SMCState(state.particles, state.weights, unshared_mcmc_parameters), - update_fn, - jax.vmap(log_weights_fn), - resampling_fn, - num_resampled, - ) + smc_state, info = delegate(rng_key, + state, + num_mcmc_steps, + mcmc_parameters, + tempered_logposterior_fn, + log_weights_fn + ) tempered_state = TemperedSMCState( smc_state.particles, smc_state.weights, state.lmbda + delta @@ -198,14 +152,14 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: def as_top_level_api( - logprior_fn: Callable, - loglikelihood_fn: Callable, - mcmc_step_fn: Callable, - mcmc_init_fn: Callable, - mcmc_parameters: dict, - resampling_fn: Callable, - num_mcmc_steps: Optional[int] = 10, - update_strategy=update_and_take_last, + logprior_fn: Callable, + loglikelihood_fn: Callable, + mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + mcmc_parameters: dict, + resampling_fn: Callable, + num_mcmc_steps: Optional[int] = 10, + update_strategy=update_and_take_last, ) -> SamplingAlgorithm: """Implements the (basic) user interface for the Adaptive Tempered SMC kernel. diff --git a/tests/smc/test_smc.py b/tests/smc/test_smc.py index b0e86e0b0..1443c2de9 100644 --- a/tests/smc/test_smc.py +++ b/tests/smc/test_smc.py @@ -10,8 +10,7 @@ import blackjax import blackjax.smc.resampling as resampling -from blackjax.smc.base import extend_params, init, step -from blackjax.smc.tempered import update_and_take_last +from blackjax.smc.base import extend_params, init, step, update_and_take_last from blackjax.smc.waste_free import update_waste_free From 93205f3f7b9331c42163739459e2eed6039d9808 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 12:33:11 -0300 Subject: [PATCH 16/29] partial posteriors implementation --- blackjax/__init__.py | 139 +++++------------- blackjax/adaptation/chees_adaptation.py | 10 +- ...c_to_update_fn_adapter.py => from_mcmc.py} | 17 +-- blackjax/smc/partial_posteriors_path.py | 80 ++++++++++ blackjax/smc/tempered.py | 14 +- tests/smc/__init__.py | 33 ++++- tests/smc/test_partial_posteriors_smc.py | 71 +++++++++ 7 files changed, 237 insertions(+), 127 deletions(-) rename blackjax/smc/{mcmc_to_update_fn_adapter.py => from_mcmc.py} (78%) create mode 100644 blackjax/smc/partial_posteriors_path.py create mode 100644 tests/smc/test_partial_posteriors_smc.py diff --git a/blackjax/__init__.py b/blackjax/__init__.py index dfdcfc545..81841024c 100644 --- a/blackjax/__init__.py +++ b/blackjax/__init__.py @@ -3,44 +3,44 @@ from blackjax._version import __version__ -from .adaptation.chees_adaptation import chees_adaptation -from .adaptation.mclmc_adaptation import mclmc_find_L_and_step_size -from .adaptation.meads_adaptation import meads_adaptation -from .adaptation.pathfinder_adaptation import pathfinder_adaptation -from .adaptation.window_adaptation import window_adaptation +#from .adaptation.chees_adaptation import chees_adaptation +#from .adaptation.mclmc_adaptation import mclmc_find_L_and_step_size +#from .adaptation.meads_adaptation import meads_adaptation +#from .adaptation.pathfinder_adaptation import pathfinder_adaptation +#from .adaptation.window_adaptation import window_adaptation from .base import SamplingAlgorithm, VIAlgorithm -from .diagnostics import effective_sample_size as ess -from .diagnostics import potential_scale_reduction as rhat -from .mcmc import barker -from .mcmc import dynamic_hmc as _dynamic_hmc -from .mcmc import elliptical_slice as _elliptical_slice -from .mcmc import ghmc as _ghmc +#from .diagnostics import effective_sample_size as ess +#from .diagnostics import potential_scale_reduction as rhat +#from .mcmc import barker +#from .mcmc import dynamic_hmc as _dynamic_hmc +#from .mcmc import elliptical_slice as _elliptical_slice +#from .mcmc import ghmc as _ghmc from .mcmc import hmc as _hmc -from .mcmc import mala as _mala -from .mcmc import marginal_latent_gaussian -from .mcmc import mclmc as _mclmc -from .mcmc import nuts as _nuts -from .mcmc import periodic_orbital, random_walk -from .mcmc import rmhmc as _rmhmc -from .mcmc.random_walk import additive_step_random_walk as _additive_step_random_walk -from .mcmc.random_walk import ( - irmh_as_top_level_api, - normal_random_walk, - rmh_as_top_level_api, -) -from .optimizers import dual_averaging, lbfgs -from .sgmcmc import csgld as _csgld -from .sgmcmc import sghmc as _sghmc -from .sgmcmc import sgld as _sgld -from .sgmcmc import sgnht as _sgnht +#from .mcmc import mala as _mala +#from .mcmc import marginal_latent_gaussian +#from .mcmc import mclmc as _mclmc +#from .mcmc import nuts as _nuts +#from .mcmc import periodic_orbital, random_walk +#from .mcmc import rmhmc as _rmhmc +#from .mcmc.random_walk import additive_step_random_walk as _additive_step_random_walk +#from .mcmc.random_walk import ( +# irmh_as_top_level_api, +# normal_random_walk, +# rmh_as_top_level_api, +#) +#from .optimizers import dual_averaging, lbfgs +#from .sgmcmc import csgld as _csgld +#from .sgmcmc import sghmc as _sghmc +#from .sgmcmc import sgld as _sgld +#from .sgmcmc import sgnht as _sgnht from .smc import adaptive_tempered from .smc import inner_kernel_tuning as _inner_kernel_tuning from .smc import tempered -from .vi import meanfield_vi as _meanfield_vi -from .vi import pathfinder as _pathfinder -from .vi import schrodinger_follmer as _schrodinger_follmer -from .vi import svgd as _svgd -from .vi.pathfinder import PathFinderAlgorithm +#from .vi import meanfield_vi as _meanfield_vi +#from .vi import pathfinder as _pathfinder +#from .vi import schrodinger_follmer as _schrodinger_follmer +#from .vi import svgd as _svgd +#from .vi.pathfinder import PathFinderAlgorithm """ The above three classes exist as a backwards compatible way of exposing both the high level, differentiable @@ -73,14 +73,13 @@ def __call__(self, *args, **kwargs) -> VIAlgorithm: return self.differentiable(*args, **kwargs) -@dataclasses.dataclass -class GeneratePathfinderAPI: - differentiable: Callable - approximate: Callable - sample: Callable +##class GeneratePathfinderAPI: + # differentiable: Callable + ## approximate: Callable + # sample: Callable - def __call__(self, *args, **kwargs) -> PathFinderAlgorithm: - return self.differentiable(*args, **kwargs) + # def __call__(self, *args, **kwargs) -> PathFinderAlgorithm: + #return self.differentiable(*args, **kwargs) def generate_top_level_api_from(module): @@ -91,29 +90,6 @@ def generate_top_level_api_from(module): # MCMC hmc = generate_top_level_api_from(_hmc) -nuts = generate_top_level_api_from(_nuts) -rmh = GenerateSamplingAPI(rmh_as_top_level_api, random_walk.init, random_walk.build_rmh) -irmh = GenerateSamplingAPI( - irmh_as_top_level_api, random_walk.init, random_walk.build_irmh -) -dynamic_hmc = generate_top_level_api_from(_dynamic_hmc) -rmhmc = generate_top_level_api_from(_rmhmc) -mala = generate_top_level_api_from(_mala) -mgrad_gaussian = generate_top_level_api_from(marginal_latent_gaussian) -orbital_hmc = generate_top_level_api_from(periodic_orbital) - -additive_step_random_walk = GenerateSamplingAPI( - _additive_step_random_walk, random_walk.init, random_walk.build_additive_step -) - -additive_step_random_walk.register_factory("normal_random_walk", normal_random_walk) - -mclmc = generate_top_level_api_from(_mclmc) -elliptical_slice = generate_top_level_api_from(_elliptical_slice) -ghmc = generate_top_level_api_from(_ghmc) -barker_proposal = generate_top_level_api_from(barker) - -hmc_family = [hmc, nuts] # SMC adaptive_tempered_smc = generate_top_level_api_from(adaptive_tempered) @@ -123,41 +99,4 @@ def generate_top_level_api_from(module): smc_family = [tempered_smc, adaptive_tempered_smc] "Step_fn returning state has a .particles attribute" -# stochastic gradient mcmc -sgld = generate_top_level_api_from(_sgld) -sghmc = generate_top_level_api_from(_sghmc) -sgnht = generate_top_level_api_from(_sgnht) -csgld = generate_top_level_api_from(_csgld) -svgd = generate_top_level_api_from(_svgd) - # variational inference -meanfield_vi = GenerateVariationalAPI( - _meanfield_vi.as_top_level_api, - _meanfield_vi.init, - _meanfield_vi.step, - _meanfield_vi.sample, -) -schrodinger_follmer = GenerateVariationalAPI( - _schrodinger_follmer.as_top_level_api, - _schrodinger_follmer.init, - _schrodinger_follmer.step, - _schrodinger_follmer.sample, -) - -pathfinder = GeneratePathfinderAPI( - _pathfinder.as_top_level_api, _pathfinder.approximate, _pathfinder.sample -) - - -__all__ = [ - "__version__", - "dual_averaging", # optimizers - "lbfgs", - "window_adaptation", # mcmc adaptation - "meads_adaptation", - "chees_adaptation", - "pathfinder_adaptation", - "mclmc_find_L_and_step_size", # mclmc adaptation - "ess", # diagnostics - "rhat", -] diff --git a/blackjax/adaptation/chees_adaptation.py b/blackjax/adaptation/chees_adaptation.py index 60b3e719f..9048091ee 100644 --- a/blackjax/adaptation/chees_adaptation.py +++ b/blackjax/adaptation/chees_adaptation.py @@ -9,11 +9,11 @@ import optax import blackjax.mcmc.dynamic_hmc as dynamic_hmc -import blackjax.optimizers.dual_averaging as dual_averaging -from blackjax.adaptation.base import AdaptationResults, return_all_adapt_info -from blackjax.base import AdaptationAlgorithm -from blackjax.types import Array, ArrayLikeTree, PRNGKey -from blackjax.util import pytree_size +#import blackjax.optimizers.dual_averaging as dual_averaging +#from blackjax.adaptation.base import AdaptationResults, return_all_adapt_info +##from blackjax.base import AdaptationAlgorithm +f#rom blackjax.types import Array, ArrayLikeTree, PRNGKey +f#rom blackjax.util import pytree_size # optimal tuning for HMC, see https://arxiv.org/abs/1001.4460 OPTIMAL_TARGET_ACCEPTANCE_RATE = 0.651 diff --git a/blackjax/smc/mcmc_to_update_fn_adapter.py b/blackjax/smc/from_mcmc.py similarity index 78% rename from blackjax/smc/mcmc_to_update_fn_adapter.py rename to blackjax/smc/from_mcmc.py index e8fcbd8e8..cd9ce4da4 100644 --- a/blackjax/smc/mcmc_to_update_fn_adapter.py +++ b/blackjax/smc/from_mcmc.py @@ -13,21 +13,15 @@ def build_kernel( resampling_fn, update_strategy: Callable = update_and_take_last, ): - """Builds a SMC step that constructs MCMC kernels from the input parameters, - which may change across iterations. Moreover, it defines the way - such kernels are used to update the particles. This layer + """SMC step from MCMC kernels. + Builds MCMC kernels from the input parameters, which may change across iterations. + Moreover, it defines the way such kernels are used to update the particles. This layer adapts an API defined in terms of kernels (mcmc_step_fn and mcmc_init_fn) into an API that depends on an update function over the set of particles. - ---------- - - update_strategy - - Returns ------- - A callable that takes a rng_key and a TemperedSMCState that contains the current state - of the chain and that returns a new state of the chain along with - information about the transition. + A callable that takes a rng_key and a state with .particles and .weights and returns a base.SMCState + and base.SMCInfo pair. """ @@ -39,7 +33,6 @@ def step( logposterior_fn: Callable, log_weights_fn: Callable, ) -> tuple[smc.base.SMCState, smc.base.SMCInfo]: - shared_mcmc_parameters = {} unshared_mcmc_parameters = {} for k, v in mcmc_parameters.items(): diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py new file mode 100644 index 000000000..a631765c5 --- /dev/null +++ b/blackjax/smc/partial_posteriors_path.py @@ -0,0 +1,80 @@ +from typing import NamedTuple, Callable +import jax +import jax.numpy as jnp +from blackjax.types import ArrayTree, Array +from blackjax.smc.from_mcmc import build_kernel as smc_from_mcmc + + +class PartialPosteriorsSMCState(NamedTuple): + """Current state for the tempered SMC algorithm. + + particles: PyTree + The particles' positions. + weights: for + + """ + + particles: ArrayTree + weights: Array + selector: Array + + +def init(particles, num_datapoints): + num_particles = jax.tree_util.tree_flatten(particles)[0][0].shape[0] + weights = jnp.ones(num_particles) / num_particles + return PartialPosteriorsSMCState(particles, weights, jnp.zeros(num_datapoints)) + + +def partial_posteriors_kernel(mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + resampling_fn: Callable, + num_mcmc_steps: int, + mcmc_parameters: ArrayTree, + partial_logposterior_factory: Callable[[Array], Callable]): + """Build the Partial Posteriors (data tempering) SMC kernel. + The distribution's trajectory includes increasingly adding more + datapoints to the likelihood. + Parameters + ---------- + mcmc_step_fn + A function that computes the log density of the prior distribution + mcmc_init_fn + A function that returns the probability at a given + position. + resampling_fn + A random function that resamples generated particles based of weights + num_mcmc_steps + Number of iterations in the MCMC chain. + mcmc_parameters + A dictionary of parameters to be used by the inner MCMC kernels + partial_logposterior_factory: + A callable that given an array of 0 and 1, returns a function logposterior(x). + The array represents which values to include in the logposterior calculation. The logposterior + must be jax compilable. + + Returns + ------- + A callable that takes a rng_key and PartialPosteriorsSMCState and selectors for + the current and previous posteriors, and takes a data-tempered SMC state. + """ + delegate = smc_from_mcmc(mcmc_step_fn, mcmc_init_fn, resampling_fn) + + def step(key, state: PartialPosteriorsSMCState, selector): + key, lp1, lp2 = jax.random.split(key, 3) + + logposterior_fn = partial_logposterior_factory(selector) + previous_logposterior_fn = partial_logposterior_factory(state.selector) + + def log_weights_fn(x): + return logposterior_fn(x) - previous_logposterior_fn(x) + + state, info = delegate(key, + state, + num_mcmc_steps, + mcmc_parameters, + logposterior_fn, + log_weights_fn) + + return PartialPosteriorsSMCState(state.particles, state.weights, selector), info + + return step diff --git a/blackjax/smc/tempered.py b/blackjax/smc/tempered.py index f747c3348..5a100bdd2 100644 --- a/blackjax/smc/tempered.py +++ b/blackjax/smc/tempered.py @@ -19,7 +19,7 @@ import blackjax.smc as smc from blackjax.base import SamplingAlgorithm -import blackjax.smc.build_inner_kernels as bik +import blackjax.smc.from_mcmc as smc_from_mcmc from blackjax.smc.base import update_and_take_last from blackjax.types import Array, ArrayLikeTree, ArrayTree, PRNGKey @@ -93,7 +93,7 @@ def build_kernel( information about the transition. """ - delegate = bik.build_kernel(mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy) + delegate = smc_from_mcmc.build_kernel(mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy) def kernel( rng_key: PRNGKey, @@ -135,11 +135,11 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: return logprior + tempered_loglikelihood smc_state, info = delegate(rng_key, - state, - num_mcmc_steps, - mcmc_parameters, - tempered_logposterior_fn, - log_weights_fn + state, + num_mcmc_steps, + mcmc_parameters, + tempered_logposterior_fn, + log_weights_fn ) tempered_state = TemperedSMCState( diff --git a/tests/smc/__init__.py b/tests/smc/__init__.py index 7a4e5c029..bcb431fb0 100644 --- a/tests/smc/__init__.py +++ b/tests/smc/__init__.py @@ -5,19 +5,28 @@ class SMCLinearRegressionTestCase(chex.TestCase): - def logdensity_fn(self, log_scale, coefs, preds, x): - """Linear regression""" + + def logdensity_by_observation(self, log_scale, coefs, preds, x): scale = jnp.exp(log_scale) y = jnp.dot(x, coefs) logpdf = stats.norm.logpdf(preds, y, scale) + return logpdf + + def logdensity_fn(self, log_scale, coefs, preds, x): + """Linear regression""" + logpdf = self.logdensity_by_observation(log_scale, coefs, preds, x) return jnp.sum(logpdf) - def particles_prior_loglikelihood(self): + def observations(self): num_particles = 100 x_data = np.random.normal(0, 1, size=(1000, 1)) y_data = 3 * x_data + np.random.normal(size=x_data.shape) observations = {"x": x_data, "preds": y_data} + return observations, num_particles + + def particles_prior_loglikelihood(self): + observations, num_particles = self.observations() logprior_fn = lambda x: stats.norm.logpdf(x["log_scale"]) + stats.norm.logpdf( x["coefs"] @@ -30,6 +39,24 @@ def particles_prior_loglikelihood(self): return init_particles, logprior_fn, loglikelihood_fn + def partial_posterior(self): + num_particles = 100 + + x_data = np.random.normal(0, 1, size=(1000, 1)) + y_data = 3 * x_data + np.random.normal(size=x_data.shape) + observations = {"x": x_data, "preds": y_data} + + logprior_fn = lambda x: stats.norm.logpdf(x["log_scale"]) + stats.norm.logpdf( + x["coefs"] + ) + loglikelihood_fn = lambda x: self.logdensity_fn(**x, **observations) + + log_scale_init = np.random.randn(num_particles) + coeffs_init = np.random.randn(num_particles) + init_particles = {"log_scale": log_scale_init, "coefs": coeffs_init} + + return init_particles, logprior_fn, observations + def assert_linear_regression_test_case(self, result): np.testing.assert_allclose( np.mean(np.exp(result.particles["log_scale"])), 1.0, rtol=1e-1 diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py new file mode 100644 index 000000000..a56f2e589 --- /dev/null +++ b/tests/smc/test_partial_posteriors_smc.py @@ -0,0 +1,71 @@ +import chex +import jax +import jax.numpy as jnp +import numpy as np +from absl.testing import absltest +import blackjax +import blackjax.smc.resampling as resampling +from blackjax.smc import extend_params +from blackjax.smc.partial_posteriors_path import partial_posteriors_kernel, init +from tests.smc import SMCLinearRegressionTestCase + + +class PartialPosteriorSMCTest(SMCLinearRegressionTestCase): + """Test posterior mean estimate.""" + + def setUp(self): + super().setUp() + self.key = jax.random.key(42) + + @chex.variants(with_jit=True) + def test_partial_posteriors(self): + ( + init_particles, + logprior_fn, + observations, + ) = self.partial_posterior() + print("here") + hmc_init = blackjax.hmc.init + hmc_kernel = blackjax.hmc.build_kernel() + hmc_parameters = extend_params( + { + "step_size": 10e-2, + "inverse_mass_matrix": jnp.eye(2), + "num_integration_steps": 50, + }, + ) + dataset_size = 1000 + + def partial_logposterior_factory(selector): + def partial_logposterior(x): + lp = logprior_fn(x) + return lp + jnp.sum(self.logdensity_by_observation(**x, **observations) * selector.reshape(-1, 1)) + + return jax.jit(partial_logposterior) + + kernel = partial_posteriors_kernel(hmc_kernel, hmc_init, + resampling.systematic, + 10, + hmc_parameters, + partial_logposterior_factory=partial_logposterior_factory) + + init_state = init(init_particles, 1000) + smc_kernel = self.variant(kernel) + + selectors = jnp.array([jnp.concat([jnp.ones(selector), jnp.zeros(dataset_size - selector)]) + for selector in np.arange(100, 1100, 100)]) + + def body_fn(carry, selector): + i, state = carry + subkey = jax.random.fold_in(self.key, i) + new_state, info = smc_kernel(subkey, state, selector) + return (i + 1, new_state), (new_state, info) + + (steps, result), _ = jax.lax.scan(body_fn, (0, init_state), selectors) + assert steps == 10 + print(selectors) + self.assert_linear_regression_test_case(result) + + +if __name__ == "__main__": + absltest.main() From c608b6041e81069f8d5db886466c226a2b6e9d80 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 12:35:14 -0300 Subject: [PATCH 17/29] rolling back some changes --- blackjax/__init__.py | 139 +++++++++++++++++------- blackjax/adaptation/chees_adaptation.py | 10 +- 2 files changed, 105 insertions(+), 44 deletions(-) diff --git a/blackjax/__init__.py b/blackjax/__init__.py index 81841024c..dfdcfc545 100644 --- a/blackjax/__init__.py +++ b/blackjax/__init__.py @@ -3,44 +3,44 @@ from blackjax._version import __version__ -#from .adaptation.chees_adaptation import chees_adaptation -#from .adaptation.mclmc_adaptation import mclmc_find_L_and_step_size -#from .adaptation.meads_adaptation import meads_adaptation -#from .adaptation.pathfinder_adaptation import pathfinder_adaptation -#from .adaptation.window_adaptation import window_adaptation +from .adaptation.chees_adaptation import chees_adaptation +from .adaptation.mclmc_adaptation import mclmc_find_L_and_step_size +from .adaptation.meads_adaptation import meads_adaptation +from .adaptation.pathfinder_adaptation import pathfinder_adaptation +from .adaptation.window_adaptation import window_adaptation from .base import SamplingAlgorithm, VIAlgorithm -#from .diagnostics import effective_sample_size as ess -#from .diagnostics import potential_scale_reduction as rhat -#from .mcmc import barker -#from .mcmc import dynamic_hmc as _dynamic_hmc -#from .mcmc import elliptical_slice as _elliptical_slice -#from .mcmc import ghmc as _ghmc +from .diagnostics import effective_sample_size as ess +from .diagnostics import potential_scale_reduction as rhat +from .mcmc import barker +from .mcmc import dynamic_hmc as _dynamic_hmc +from .mcmc import elliptical_slice as _elliptical_slice +from .mcmc import ghmc as _ghmc from .mcmc import hmc as _hmc -#from .mcmc import mala as _mala -#from .mcmc import marginal_latent_gaussian -#from .mcmc import mclmc as _mclmc -#from .mcmc import nuts as _nuts -#from .mcmc import periodic_orbital, random_walk -#from .mcmc import rmhmc as _rmhmc -#from .mcmc.random_walk import additive_step_random_walk as _additive_step_random_walk -#from .mcmc.random_walk import ( -# irmh_as_top_level_api, -# normal_random_walk, -# rmh_as_top_level_api, -#) -#from .optimizers import dual_averaging, lbfgs -#from .sgmcmc import csgld as _csgld -#from .sgmcmc import sghmc as _sghmc -#from .sgmcmc import sgld as _sgld -#from .sgmcmc import sgnht as _sgnht +from .mcmc import mala as _mala +from .mcmc import marginal_latent_gaussian +from .mcmc import mclmc as _mclmc +from .mcmc import nuts as _nuts +from .mcmc import periodic_orbital, random_walk +from .mcmc import rmhmc as _rmhmc +from .mcmc.random_walk import additive_step_random_walk as _additive_step_random_walk +from .mcmc.random_walk import ( + irmh_as_top_level_api, + normal_random_walk, + rmh_as_top_level_api, +) +from .optimizers import dual_averaging, lbfgs +from .sgmcmc import csgld as _csgld +from .sgmcmc import sghmc as _sghmc +from .sgmcmc import sgld as _sgld +from .sgmcmc import sgnht as _sgnht from .smc import adaptive_tempered from .smc import inner_kernel_tuning as _inner_kernel_tuning from .smc import tempered -#from .vi import meanfield_vi as _meanfield_vi -#from .vi import pathfinder as _pathfinder -#from .vi import schrodinger_follmer as _schrodinger_follmer -#from .vi import svgd as _svgd -#from .vi.pathfinder import PathFinderAlgorithm +from .vi import meanfield_vi as _meanfield_vi +from .vi import pathfinder as _pathfinder +from .vi import schrodinger_follmer as _schrodinger_follmer +from .vi import svgd as _svgd +from .vi.pathfinder import PathFinderAlgorithm """ The above three classes exist as a backwards compatible way of exposing both the high level, differentiable @@ -73,13 +73,14 @@ def __call__(self, *args, **kwargs) -> VIAlgorithm: return self.differentiable(*args, **kwargs) -##class GeneratePathfinderAPI: - # differentiable: Callable - ## approximate: Callable - # sample: Callable +@dataclasses.dataclass +class GeneratePathfinderAPI: + differentiable: Callable + approximate: Callable + sample: Callable - # def __call__(self, *args, **kwargs) -> PathFinderAlgorithm: - #return self.differentiable(*args, **kwargs) + def __call__(self, *args, **kwargs) -> PathFinderAlgorithm: + return self.differentiable(*args, **kwargs) def generate_top_level_api_from(module): @@ -90,6 +91,29 @@ def generate_top_level_api_from(module): # MCMC hmc = generate_top_level_api_from(_hmc) +nuts = generate_top_level_api_from(_nuts) +rmh = GenerateSamplingAPI(rmh_as_top_level_api, random_walk.init, random_walk.build_rmh) +irmh = GenerateSamplingAPI( + irmh_as_top_level_api, random_walk.init, random_walk.build_irmh +) +dynamic_hmc = generate_top_level_api_from(_dynamic_hmc) +rmhmc = generate_top_level_api_from(_rmhmc) +mala = generate_top_level_api_from(_mala) +mgrad_gaussian = generate_top_level_api_from(marginal_latent_gaussian) +orbital_hmc = generate_top_level_api_from(periodic_orbital) + +additive_step_random_walk = GenerateSamplingAPI( + _additive_step_random_walk, random_walk.init, random_walk.build_additive_step +) + +additive_step_random_walk.register_factory("normal_random_walk", normal_random_walk) + +mclmc = generate_top_level_api_from(_mclmc) +elliptical_slice = generate_top_level_api_from(_elliptical_slice) +ghmc = generate_top_level_api_from(_ghmc) +barker_proposal = generate_top_level_api_from(barker) + +hmc_family = [hmc, nuts] # SMC adaptive_tempered_smc = generate_top_level_api_from(adaptive_tempered) @@ -99,4 +123,41 @@ def generate_top_level_api_from(module): smc_family = [tempered_smc, adaptive_tempered_smc] "Step_fn returning state has a .particles attribute" +# stochastic gradient mcmc +sgld = generate_top_level_api_from(_sgld) +sghmc = generate_top_level_api_from(_sghmc) +sgnht = generate_top_level_api_from(_sgnht) +csgld = generate_top_level_api_from(_csgld) +svgd = generate_top_level_api_from(_svgd) + # variational inference +meanfield_vi = GenerateVariationalAPI( + _meanfield_vi.as_top_level_api, + _meanfield_vi.init, + _meanfield_vi.step, + _meanfield_vi.sample, +) +schrodinger_follmer = GenerateVariationalAPI( + _schrodinger_follmer.as_top_level_api, + _schrodinger_follmer.init, + _schrodinger_follmer.step, + _schrodinger_follmer.sample, +) + +pathfinder = GeneratePathfinderAPI( + _pathfinder.as_top_level_api, _pathfinder.approximate, _pathfinder.sample +) + + +__all__ = [ + "__version__", + "dual_averaging", # optimizers + "lbfgs", + "window_adaptation", # mcmc adaptation + "meads_adaptation", + "chees_adaptation", + "pathfinder_adaptation", + "mclmc_find_L_and_step_size", # mclmc adaptation + "ess", # diagnostics + "rhat", +] diff --git a/blackjax/adaptation/chees_adaptation.py b/blackjax/adaptation/chees_adaptation.py index 9048091ee..60b3e719f 100644 --- a/blackjax/adaptation/chees_adaptation.py +++ b/blackjax/adaptation/chees_adaptation.py @@ -9,11 +9,11 @@ import optax import blackjax.mcmc.dynamic_hmc as dynamic_hmc -#import blackjax.optimizers.dual_averaging as dual_averaging -#from blackjax.adaptation.base import AdaptationResults, return_all_adapt_info -##from blackjax.base import AdaptationAlgorithm -f#rom blackjax.types import Array, ArrayLikeTree, PRNGKey -f#rom blackjax.util import pytree_size +import blackjax.optimizers.dual_averaging as dual_averaging +from blackjax.adaptation.base import AdaptationResults, return_all_adapt_info +from blackjax.base import AdaptationAlgorithm +from blackjax.types import Array, ArrayLikeTree, PRNGKey +from blackjax.util import pytree_size # optimal tuning for HMC, see https://arxiv.org/abs/1001.4460 OPTIMAL_TARGET_ACCEPTANCE_RATE = 0.651 From 359be7742030981e372f855daf4ef62a0cb62086 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 12:37:37 -0300 Subject: [PATCH 18/29] linter --- blackjax/smc/base.py | 10 ++-- blackjax/smc/from_mcmc.py | 7 +-- blackjax/smc/partial_posteriors_path.py | 31 ++++++------ blackjax/smc/tempered.py | 60 ++++++++++++------------ tests/smc/__init__.py | 4 +- tests/smc/test_partial_posteriors_smc.py | 31 ++++++++---- 6 files changed, 78 insertions(+), 65 deletions(-) diff --git a/blackjax/smc/base.py b/blackjax/smc/base.py index 76ce650c8..4c7e6c76b 100644 --- a/blackjax/smc/base.py +++ b/blackjax/smc/base.py @@ -159,11 +159,11 @@ def extend_params(params): def update_and_take_last( - mcmc_init_fn, - tempered_logposterior_fn, - shared_mcmc_step_fn, - num_mcmc_steps, - n_particles, + mcmc_init_fn, + tempered_logposterior_fn, + shared_mcmc_step_fn, + num_mcmc_steps, + n_particles, ): """ Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and diff --git a/blackjax/smc/from_mcmc.py b/blackjax/smc/from_mcmc.py index cd9ce4da4..0d0352612 100644 --- a/blackjax/smc/from_mcmc.py +++ b/blackjax/smc/from_mcmc.py @@ -1,10 +1,11 @@ from functools import partial from typing import Callable +import jax + +from blackjax import smc from blackjax.smc.base import SMCState, update_and_take_last from blackjax.types import PRNGKey -from blackjax import smc -import jax def build_kernel( @@ -12,7 +13,7 @@ def build_kernel( mcmc_init_fn: Callable, resampling_fn, update_strategy: Callable = update_and_take_last, - ): +): """SMC step from MCMC kernels. Builds MCMC kernels from the input parameters, which may change across iterations. Moreover, it defines the way such kernels are used to update the particles. This layer diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py index a631765c5..5cba1244c 100644 --- a/blackjax/smc/partial_posteriors_path.py +++ b/blackjax/smc/partial_posteriors_path.py @@ -1,8 +1,10 @@ -from typing import NamedTuple, Callable +from typing import Callable, NamedTuple + import jax import jax.numpy as jnp -from blackjax.types import ArrayTree, Array + from blackjax.smc.from_mcmc import build_kernel as smc_from_mcmc +from blackjax.types import Array, ArrayTree class PartialPosteriorsSMCState(NamedTuple): @@ -25,12 +27,14 @@ def init(particles, num_datapoints): return PartialPosteriorsSMCState(particles, weights, jnp.zeros(num_datapoints)) -def partial_posteriors_kernel(mcmc_step_fn: Callable, - mcmc_init_fn: Callable, - resampling_fn: Callable, - num_mcmc_steps: int, - mcmc_parameters: ArrayTree, - partial_logposterior_factory: Callable[[Array], Callable]): +def partial_posteriors_kernel( + mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + resampling_fn: Callable, + num_mcmc_steps: int, + mcmc_parameters: ArrayTree, + partial_logposterior_factory: Callable[[Array], Callable], +): """Build the Partial Posteriors (data tempering) SMC kernel. The distribution's trajectory includes increasingly adding more datapoints to the likelihood. @@ -56,7 +60,7 @@ def partial_posteriors_kernel(mcmc_step_fn: Callable, ------- A callable that takes a rng_key and PartialPosteriorsSMCState and selectors for the current and previous posteriors, and takes a data-tempered SMC state. - """ + """ delegate = smc_from_mcmc(mcmc_step_fn, mcmc_init_fn, resampling_fn) def step(key, state: PartialPosteriorsSMCState, selector): @@ -68,12 +72,9 @@ def step(key, state: PartialPosteriorsSMCState, selector): def log_weights_fn(x): return logposterior_fn(x) - previous_logposterior_fn(x) - state, info = delegate(key, - state, - num_mcmc_steps, - mcmc_parameters, - logposterior_fn, - log_weights_fn) + state, info = delegate( + key, state, num_mcmc_steps, mcmc_parameters, logposterior_fn, log_weights_fn + ) return PartialPosteriorsSMCState(state.particles, state.weights, selector), info diff --git a/blackjax/smc/tempered.py b/blackjax/smc/tempered.py index 5a100bdd2..88539deaa 100644 --- a/blackjax/smc/tempered.py +++ b/blackjax/smc/tempered.py @@ -17,9 +17,8 @@ import jax.numpy as jnp import blackjax.smc as smc -from blackjax.base import SamplingAlgorithm - import blackjax.smc.from_mcmc as smc_from_mcmc +from blackjax.base import SamplingAlgorithm from blackjax.smc.base import update_and_take_last from blackjax.types import Array, ArrayLikeTree, ArrayTree, PRNGKey @@ -50,12 +49,12 @@ def init(particles: ArrayLikeTree): def build_kernel( - logprior_fn: Callable, - loglikelihood_fn: Callable, - mcmc_step_fn: Callable, - mcmc_init_fn: Callable, - resampling_fn: Callable, - update_strategy: Callable = update_and_take_last, + logprior_fn: Callable, + loglikelihood_fn: Callable, + mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + resampling_fn: Callable, + update_strategy: Callable = update_and_take_last, ) -> Callable: """Build the base Tempered SMC kernel. @@ -93,14 +92,16 @@ def build_kernel( information about the transition. """ - delegate = smc_from_mcmc.build_kernel(mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy) + delegate = smc_from_mcmc.build_kernel( + mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy + ) def kernel( - rng_key: PRNGKey, - state: TemperedSMCState, - num_mcmc_steps: int, - lmbda: float, - mcmc_parameters: dict, + rng_key: PRNGKey, + state: TemperedSMCState, + num_mcmc_steps: int, + lmbda: float, + mcmc_parameters: dict, ) -> tuple[TemperedSMCState, smc.base.SMCInfo]: """Move the particles one step using the Tempered SMC algorithm. @@ -134,13 +135,14 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: tempered_loglikelihood = state.lmbda * loglikelihood_fn(position) return logprior + tempered_loglikelihood - smc_state, info = delegate(rng_key, - state, - num_mcmc_steps, - mcmc_parameters, - tempered_logposterior_fn, - log_weights_fn - ) + smc_state, info = delegate( + rng_key, + state, + num_mcmc_steps, + mcmc_parameters, + tempered_logposterior_fn, + log_weights_fn, + ) tempered_state = TemperedSMCState( smc_state.particles, smc_state.weights, state.lmbda + delta @@ -152,14 +154,14 @@ def tempered_logposterior_fn(position: ArrayLikeTree) -> float: def as_top_level_api( - logprior_fn: Callable, - loglikelihood_fn: Callable, - mcmc_step_fn: Callable, - mcmc_init_fn: Callable, - mcmc_parameters: dict, - resampling_fn: Callable, - num_mcmc_steps: Optional[int] = 10, - update_strategy=update_and_take_last, + logprior_fn: Callable, + loglikelihood_fn: Callable, + mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + mcmc_parameters: dict, + resampling_fn: Callable, + num_mcmc_steps: Optional[int] = 10, + update_strategy=update_and_take_last, ) -> SamplingAlgorithm: """Implements the (basic) user interface for the Adaptive Tempered SMC kernel. diff --git a/tests/smc/__init__.py b/tests/smc/__init__.py index bcb431fb0..006d7ba38 100644 --- a/tests/smc/__init__.py +++ b/tests/smc/__init__.py @@ -5,7 +5,6 @@ class SMCLinearRegressionTestCase(chex.TestCase): - def logdensity_by_observation(self, log_scale, coefs, preds, x): scale = jnp.exp(log_scale) y = jnp.dot(x, coefs) @@ -39,7 +38,7 @@ def particles_prior_loglikelihood(self): return init_particles, logprior_fn, loglikelihood_fn - def partial_posterior(self): + def partial_posterior_test_case(self): num_particles = 100 x_data = np.random.normal(0, 1, size=(1000, 1)) @@ -49,7 +48,6 @@ def partial_posterior(self): logprior_fn = lambda x: stats.norm.logpdf(x["log_scale"]) + stats.norm.logpdf( x["coefs"] ) - loglikelihood_fn = lambda x: self.logdensity_fn(**x, **observations) log_scale_init = np.random.randn(num_particles) coeffs_init = np.random.randn(num_particles) diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index a56f2e589..003abd463 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -3,10 +3,11 @@ import jax.numpy as jnp import numpy as np from absl.testing import absltest + import blackjax import blackjax.smc.resampling as resampling from blackjax.smc import extend_params -from blackjax.smc.partial_posteriors_path import partial_posteriors_kernel, init +from blackjax.smc.partial_posteriors_path import init, partial_posteriors_kernel from tests.smc import SMCLinearRegressionTestCase @@ -23,7 +24,7 @@ def test_partial_posteriors(self): init_particles, logprior_fn, observations, - ) = self.partial_posterior() + ) = self.partial_posterior_test_case() print("here") hmc_init = blackjax.hmc.init hmc_kernel = blackjax.hmc.build_kernel() @@ -39,21 +40,31 @@ def test_partial_posteriors(self): def partial_logposterior_factory(selector): def partial_logposterior(x): lp = logprior_fn(x) - return lp + jnp.sum(self.logdensity_by_observation(**x, **observations) * selector.reshape(-1, 1)) + return lp + jnp.sum( + self.logdensity_by_observation(**x, **observations) + * selector.reshape(-1, 1) + ) return jax.jit(partial_logposterior) - kernel = partial_posteriors_kernel(hmc_kernel, hmc_init, - resampling.systematic, - 10, - hmc_parameters, - partial_logposterior_factory=partial_logposterior_factory) + kernel = partial_posteriors_kernel( + hmc_kernel, + hmc_init, + resampling.systematic, + 10, + hmc_parameters, + partial_logposterior_factory=partial_logposterior_factory, + ) init_state = init(init_particles, 1000) smc_kernel = self.variant(kernel) - selectors = jnp.array([jnp.concat([jnp.ones(selector), jnp.zeros(dataset_size - selector)]) - for selector in np.arange(100, 1100, 100)]) + selectors = jnp.array( + [ + jnp.concat([jnp.ones(selector), jnp.zeros(dataset_size - selector)]) + for selector in np.arange(100, 1100, 100) + ] + ) def body_fn(carry, selector): i, state = carry From cef4ef0488c30db74790ac021caa42b3e525d347 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 14:29:30 -0300 Subject: [PATCH 19/29] fixing test --- blackjax/smc/from_mcmc.py | 2 +- blackjax/smc/partial_posteriors_path.py | 68 ++++++++++++++++++++---- tests/smc/test_partial_posteriors_smc.py | 18 ++++--- 3 files changed, 68 insertions(+), 20 deletions(-) diff --git a/blackjax/smc/from_mcmc.py b/blackjax/smc/from_mcmc.py index 0d0352612..41546a308 100644 --- a/blackjax/smc/from_mcmc.py +++ b/blackjax/smc/from_mcmc.py @@ -11,7 +11,7 @@ def build_kernel( mcmc_step_fn: Callable, mcmc_init_fn: Callable, - resampling_fn, + resampling_fn: Callable, update_strategy: Callable = update_and_take_last, ): """SMC step from MCMC kernels. diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py index 5cba1244c..a11d1b556 100644 --- a/blackjax/smc/partial_posteriors_path.py +++ b/blackjax/smc/partial_posteriors_path.py @@ -1,10 +1,12 @@ -from typing import Callable, NamedTuple +from typing import Callable, NamedTuple, Optional, Tuple import jax import jax.numpy as jnp +from blackjax import SamplingAlgorithm, smc +from blackjax.smc.base import update_and_take_last from blackjax.smc.from_mcmc import build_kernel as smc_from_mcmc -from blackjax.types import Array, ArrayTree +from blackjax.types import Array, ArrayLikeTree, ArrayTree, PRNGKey class PartialPosteriorsSMCState(NamedTuple): @@ -12,7 +14,10 @@ class PartialPosteriorsSMCState(NamedTuple): particles: PyTree The particles' positions. - weights: for + weights: + Weights of the particles, so that they represent a probability distribution + selector: + {Datapoints used to calculate the posterior the particles represent """ @@ -21,20 +26,26 @@ class PartialPosteriorsSMCState(NamedTuple): selector: Array -def init(particles, num_datapoints): +def init(particles: ArrayLikeTree, num_datapoints: int) -> PartialPosteriorsSMCState: + """ + num_datapoints are the number of observations that could potentially be + used in a partial posterior. Since the initial selector is all 0s, it + means that no likelihood term will be added (only prior). + """ num_particles = jax.tree_util.tree_flatten(particles)[0][0].shape[0] weights = jnp.ones(num_particles) / num_particles return PartialPosteriorsSMCState(particles, weights, jnp.zeros(num_datapoints)) -def partial_posteriors_kernel( +def build_kernel( mcmc_step_fn: Callable, mcmc_init_fn: Callable, resampling_fn: Callable, - num_mcmc_steps: int, + num_mcmc_steps: Optional[int], mcmc_parameters: ArrayTree, partial_logposterior_factory: Callable[[Array], Callable], -): + update_strategy=update_and_take_last, +) -> Callable: """Build the Partial Posteriors (data tempering) SMC kernel. The distribution's trajectory includes increasingly adding more datapoints to the likelihood. @@ -61,12 +72,13 @@ def partial_posteriors_kernel( A callable that takes a rng_key and PartialPosteriorsSMCState and selectors for the current and previous posteriors, and takes a data-tempered SMC state. """ - delegate = smc_from_mcmc(mcmc_step_fn, mcmc_init_fn, resampling_fn) - - def step(key, state: PartialPosteriorsSMCState, selector): - key, lp1, lp2 = jax.random.split(key, 3) + delegate = smc_from_mcmc(mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy) + def step( + key, state: PartialPosteriorsSMCState, selector: Array + ) -> Tuple[PartialPosteriorsSMCState, smc.base.SMCInfo]: logposterior_fn = partial_logposterior_factory(selector) + previous_logposterior_fn = partial_logposterior_factory(state.selector) def log_weights_fn(x): @@ -79,3 +91,37 @@ def log_weights_fn(x): return PartialPosteriorsSMCState(state.particles, state.weights, selector), info return step + + +def as_top_level_api( + mcmc_step_fn: Callable, + mcmc_init_fn: Callable, + mcmc_parameters: dict, + resampling_fn: Callable, + partial_logposterior_factory: Callable, + num_mcmc_steps: Optional[int] = 10, + update_strategy=update_and_take_last, +) -> SamplingAlgorithm: + """ + A factory that wraps the kernel into a SamplingAlgorithm object. + See build_kernel for full documentation on the parameters. + """ + + kernel = build_kernel( + mcmc_step_fn, + mcmc_init_fn, + resampling_fn, + num_mcmc_steps, + mcmc_parameters, + partial_logposterior_factory, + update_strategy, + ) + + def init_fn(position: ArrayLikeTree, num_observations, rng_key=None): + del rng_key + return init(position, num_observations) + + def step(key: PRNGKey, state: PartialPosteriorsSMCState, selector: Array): + return kernel(key, state, selector) + + return SamplingAlgorithm(init_fn, step) # type: ignore[arg-type] diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index 003abd463..0d341b858 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -7,7 +7,7 @@ import blackjax import blackjax.smc.resampling as resampling from blackjax.smc import extend_params -from blackjax.smc.partial_posteriors_path import init, partial_posteriors_kernel +from blackjax.smc.partial_posteriors_path import build_kernel, init from tests.smc import SMCLinearRegressionTestCase @@ -25,9 +25,10 @@ def test_partial_posteriors(self): logprior_fn, observations, ) = self.partial_posterior_test_case() - print("here") + hmc_init = blackjax.hmc.init hmc_kernel = blackjax.hmc.build_kernel() + hmc_parameters = extend_params( { "step_size": 10e-2, @@ -35,6 +36,7 @@ def test_partial_posteriors(self): "num_integration_steps": 50, }, ) + dataset_size = 1000 def partial_logposterior_factory(selector): @@ -47,11 +49,11 @@ def partial_logposterior(x): return jax.jit(partial_logposterior) - kernel = partial_posteriors_kernel( + kernel = build_kernel( hmc_kernel, hmc_init, resampling.systematic, - 10, + 30, hmc_parameters, partial_logposterior_factory=partial_logposterior_factory, ) @@ -62,7 +64,7 @@ def partial_logposterior(x): selectors = jnp.array( [ jnp.concat([jnp.ones(selector), jnp.zeros(dataset_size - selector)]) - for selector in np.arange(100, 1100, 100) + for selector in np.arange(100, 1001, 50) ] ) @@ -72,9 +74,9 @@ def body_fn(carry, selector): new_state, info = smc_kernel(subkey, state, selector) return (i + 1, new_state), (new_state, info) - (steps, result), _ = jax.lax.scan(body_fn, (0, init_state), selectors) - assert steps == 10 - print(selectors) + (steps, result), it = jax.lax.scan(body_fn, (0, init_state), selectors) + assert steps == 19 + self.assert_linear_regression_test_case(result) From 094208778f018aed8ca54dd377662a0f113f2851 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 14:39:09 -0300 Subject: [PATCH 20/29] adding reference --- blackjax/smc/partial_posteriors_path.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py index a11d1b556..49244b4ae 100644 --- a/blackjax/smc/partial_posteriors_path.py +++ b/blackjax/smc/partial_posteriors_path.py @@ -48,7 +48,7 @@ def build_kernel( ) -> Callable: """Build the Partial Posteriors (data tempering) SMC kernel. The distribution's trajectory includes increasingly adding more - datapoints to the likelihood. + datapoints to the likelihood. See Section 2.2 of https://arxiv.org/pdf/2007.11936 Parameters ---------- mcmc_step_fn From 1304f9fa66acb2dddc2d77fd1f73b93c19c5efbe Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 14:47:00 -0300 Subject: [PATCH 21/29] typo --- tests/smc/test_partial_posteriors_smc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index 0d341b858..4abbb7c92 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -11,7 +11,7 @@ from tests.smc import SMCLinearRegressionTestCase -class PartialPosteriorSMCTest(SMCLinearRegressionTestCase): +class PartialPosteriorsSMCTest(SMCLinearRegressionTestCase): """Test posterior mean estimate.""" def setUp(self): From aec2e51d6e6bf83d148151e7b6f9b0e90ea9d366 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 14:55:52 -0300 Subject: [PATCH 22/29] exposing in top level api --- blackjax/__init__.py | 4 +++- blackjax/smc/__init__.py | 1 + blackjax/smc/partial_posteriors_path.py | 2 +- tests/smc/test_partial_posteriors_smc.py | 7 +++---- 4 files changed, 8 insertions(+), 6 deletions(-) diff --git a/blackjax/__init__.py b/blackjax/__init__.py index dfdcfc545..6d4258eed 100644 --- a/blackjax/__init__.py +++ b/blackjax/__init__.py @@ -36,6 +36,7 @@ from .smc import adaptive_tempered from .smc import inner_kernel_tuning as _inner_kernel_tuning from .smc import tempered +from .smc import partial_posteriors_path as _partial_posteriors_smc from .vi import meanfield_vi as _meanfield_vi from .vi import pathfinder as _pathfinder from .vi import schrodinger_follmer as _schrodinger_follmer @@ -119,8 +120,9 @@ def generate_top_level_api_from(module): adaptive_tempered_smc = generate_top_level_api_from(adaptive_tempered) tempered_smc = generate_top_level_api_from(tempered) inner_kernel_tuning = generate_top_level_api_from(_inner_kernel_tuning) +partial_posteriors_smc = generate_top_level_api_from(_partial_posteriors_smc) -smc_family = [tempered_smc, adaptive_tempered_smc] +smc_family = [tempered_smc, adaptive_tempered_smc, partial_posteriors_smc] "Step_fn returning state has a .particles attribute" # stochastic gradient mcmc diff --git a/blackjax/smc/__init__.py b/blackjax/smc/__init__.py index ef10b10e6..2c09aa67b 100644 --- a/blackjax/smc/__init__.py +++ b/blackjax/smc/__init__.py @@ -6,4 +6,5 @@ "tempered", "inner_kernel_tuning", "extend_params", + "partial_posteriors_path" ] diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py index 49244b4ae..753d00247 100644 --- a/blackjax/smc/partial_posteriors_path.py +++ b/blackjax/smc/partial_posteriors_path.py @@ -98,8 +98,8 @@ def as_top_level_api( mcmc_init_fn: Callable, mcmc_parameters: dict, resampling_fn: Callable, + num_mcmc_steps, partial_logposterior_factory: Callable, - num_mcmc_steps: Optional[int] = 10, update_strategy=update_and_take_last, ) -> SamplingAlgorithm: """ diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index 4abbb7c92..d6bad6146 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -7,7 +7,6 @@ import blackjax import blackjax.smc.resampling as resampling from blackjax.smc import extend_params -from blackjax.smc.partial_posteriors_path import build_kernel, init from tests.smc import SMCLinearRegressionTestCase @@ -49,13 +48,13 @@ def partial_logposterior(x): return jax.jit(partial_logposterior) - kernel = build_kernel( + init, kernel = blackjax.partial_posteriors_smc( hmc_kernel, hmc_init, + hmc_parameters, resampling.systematic, 30, - hmc_parameters, - partial_logposterior_factory=partial_logposterior_factory, + partial_logposterior_factory=partial_logposterior_factory ) init_state = init(init_particles, 1000) From cededec7302992b0e6c47075c17d75326605bda7 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 27 Aug 2024 14:57:46 -0300 Subject: [PATCH 23/29] reruning precommit --- blackjax/__init__.py | 2 +- blackjax/smc/__init__.py | 2 +- tests/smc/test_partial_posteriors_smc.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/blackjax/__init__.py b/blackjax/__init__.py index 6d4258eed..5858c34aa 100644 --- a/blackjax/__init__.py +++ b/blackjax/__init__.py @@ -35,8 +35,8 @@ from .sgmcmc import sgnht as _sgnht from .smc import adaptive_tempered from .smc import inner_kernel_tuning as _inner_kernel_tuning -from .smc import tempered from .smc import partial_posteriors_path as _partial_posteriors_smc +from .smc import tempered from .vi import meanfield_vi as _meanfield_vi from .vi import pathfinder as _pathfinder from .vi import schrodinger_follmer as _schrodinger_follmer diff --git a/blackjax/smc/__init__.py b/blackjax/smc/__init__.py index 2c09aa67b..9670fcb6e 100644 --- a/blackjax/smc/__init__.py +++ b/blackjax/smc/__init__.py @@ -6,5 +6,5 @@ "tempered", "inner_kernel_tuning", "extend_params", - "partial_posteriors_path" + "partial_posteriors_path", ] diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index d6bad6146..0ae1df3c4 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -54,7 +54,7 @@ def partial_logposterior(x): hmc_parameters, resampling.systematic, 30, - partial_logposterior_factory=partial_logposterior_factory + partial_logposterior_factory=partial_logposterior_factory, ) init_state = init(init_particles, 1000) From 14919f2ab5a5ffb6cbd8abd43f8141c96ca1acad Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Tue, 10 Sep 2024 16:33:53 -0300 Subject: [PATCH 24/29] adding more steps --- tests/smc/test_partial_posteriors_smc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index 0ae1df3c4..c74f83646 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -53,7 +53,7 @@ def partial_logposterior(x): hmc_init, hmc_parameters, resampling.systematic, - 30, + 50, partial_logposterior_factory=partial_logposterior_factory, ) From 601b74a0211dfc4179144bf76f90564e71a618d6 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Mon, 30 Sep 2024 17:24:16 -0300 Subject: [PATCH 25/29] smaller step size --- tests/smc/test_partial_posteriors_smc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index c74f83646..0b12be8f1 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -30,7 +30,7 @@ def test_partial_posteriors(self): hmc_parameters = extend_params( { - "step_size": 10e-2, + "step_size": 10e-3, "inverse_mass_matrix": jnp.eye(2), "num_integration_steps": 50, }, From 4d6089e06ee2349909c4f8ca1ceff7e243bdc5cf Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 4 Oct 2024 12:33:32 -0300 Subject: [PATCH 26/29] fixes on comments --- blackjax/smc/from_mcmc.py | 4 +- blackjax/smc/partial_posteriors_path.py | 53 ++++++++++++------------- 2 files changed, 27 insertions(+), 30 deletions(-) diff --git a/blackjax/smc/from_mcmc.py b/blackjax/smc/from_mcmc.py index 41546a308..0e60b5968 100644 --- a/blackjax/smc/from_mcmc.py +++ b/blackjax/smc/from_mcmc.py @@ -15,8 +15,8 @@ def build_kernel( update_strategy: Callable = update_and_take_last, ): """SMC step from MCMC kernels. - Builds MCMC kernels from the input parameters, which may change across iterations. - Moreover, it defines the way such kernels are used to update the particles. This layer + Builds MCMC kernels from the input parameters, which may change across iterations. + Moreover, it defines the way such kernels are used to update the particles. This layer adapts an API defined in terms of kernels (mcmc_step_fn and mcmc_init_fn) into an API that depends on an update function over the set of particles. Returns diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py index 753d00247..2381152f4 100644 --- a/blackjax/smc/partial_posteriors_path.py +++ b/blackjax/smc/partial_posteriors_path.py @@ -17,8 +17,8 @@ class PartialPosteriorsSMCState(NamedTuple): weights: Weights of the particles, so that they represent a probability distribution selector: - {Datapoints used to calculate the posterior the particles represent - + Datapoints used to calculate the posterior the particles represent, a 1D boolean + array to indicate which datapoints to include in the computation of the observed likelihood. """ particles: ArrayTree @@ -27,8 +27,7 @@ class PartialPosteriorsSMCState(NamedTuple): def init(particles: ArrayLikeTree, num_datapoints: int) -> PartialPosteriorsSMCState: - """ - num_datapoints are the number of observations that could potentially be + """num_datapoints are the number of observations that could potentially be used in a partial posterior. Since the initial selector is all 0s, it means that no likelihood term will be added (only prior). """ @@ -49,28 +48,27 @@ def build_kernel( """Build the Partial Posteriors (data tempering) SMC kernel. The distribution's trajectory includes increasingly adding more datapoints to the likelihood. See Section 2.2 of https://arxiv.org/pdf/2007.11936 - Parameters - ---------- - mcmc_step_fn - A function that computes the log density of the prior distribution - mcmc_init_fn - A function that returns the probability at a given - position. - resampling_fn - A random function that resamples generated particles based of weights - num_mcmc_steps - Number of iterations in the MCMC chain. - mcmc_parameters - A dictionary of parameters to be used by the inner MCMC kernels - partial_logposterior_factory: - A callable that given an array of 0 and 1, returns a function logposterior(x). - The array represents which values to include in the logposterior calculation. The logposterior - must be jax compilable. - - Returns - ------- - A callable that takes a rng_key and PartialPosteriorsSMCState and selectors for - the current and previous posteriors, and takes a data-tempered SMC state. + Parameters + ---------- + mcmc_step_fn + A function that computes the log density of the prior distribution + mcmc_init_fn + A function that returns the probability at a given position. + resampling_fn + A random function that resamples generated particles based of weights + num_mcmc_steps + Number of iterations in the MCMC chain. + mcmc_parameters + A dictionary of parameters to be used by the inner MCMC kernels + partial_logposterior_factory: + A callable that given an array of 0 and 1, returns a function logposterior(x). + The array represents which values to include in the logposterior calculation. The logposterior + must be jax compilable. + + Returns + ------- + A callable that takes a rng_key and PartialPosteriorsSMCState and selectors for + the current and previous posteriors, and takes a data-tempered SMC state. """ delegate = smc_from_mcmc(mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy) @@ -102,8 +100,7 @@ def as_top_level_api( partial_logposterior_factory: Callable, update_strategy=update_and_take_last, ) -> SamplingAlgorithm: - """ - A factory that wraps the kernel into a SamplingAlgorithm object. + """A factory that wraps the kernel into a SamplingAlgorithm object. See build_kernel for full documentation on the parameters. """ From a5922adb1c5d66c857a563d538e7111ff01db816 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 4 Oct 2024 12:37:56 -0300 Subject: [PATCH 27/29] small fix on formating --- blackjax/smc/base.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/blackjax/smc/base.py b/blackjax/smc/base.py index 4c7e6c76b..56df7f010 100644 --- a/blackjax/smc/base.py +++ b/blackjax/smc/base.py @@ -165,8 +165,7 @@ def update_and_take_last( num_mcmc_steps, n_particles, ): - """ - Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and + """Given N particles, runs num_mcmc_steps of a kernel starting at each particle, and returns the last values, waisting the previous num_mcmc_steps-1 samples per chain. """ From 26d271e683593c2018796f2450ebaac475a779be Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 4 Oct 2024 20:08:04 -0300 Subject: [PATCH 28/29] renaming to data mask --- blackjax/smc/partial_posteriors_path.py | 22 +++++++++++----------- tests/smc/test_partial_posteriors_smc.py | 16 ++++++++-------- 2 files changed, 19 insertions(+), 19 deletions(-) diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py index 2381152f4..1279ad245 100644 --- a/blackjax/smc/partial_posteriors_path.py +++ b/blackjax/smc/partial_posteriors_path.py @@ -16,19 +16,19 @@ class PartialPosteriorsSMCState(NamedTuple): The particles' positions. weights: Weights of the particles, so that they represent a probability distribution - selector: - Datapoints used to calculate the posterior the particles represent, a 1D boolean - array to indicate which datapoints to include in the computation of the observed likelihood. + data_mask: + A 1D boolean array to indicate which datapoints to include + in the computation of the observed likelihood. """ particles: ArrayTree weights: Array - selector: Array + data_mask: Array def init(particles: ArrayLikeTree, num_datapoints: int) -> PartialPosteriorsSMCState: """num_datapoints are the number of observations that could potentially be - used in a partial posterior. Since the initial selector is all 0s, it + used in a partial posterior. Since the initial data_mask is all 0s, it means that no likelihood term will be added (only prior). """ num_particles = jax.tree_util.tree_flatten(particles)[0][0].shape[0] @@ -73,11 +73,11 @@ def build_kernel( delegate = smc_from_mcmc(mcmc_step_fn, mcmc_init_fn, resampling_fn, update_strategy) def step( - key, state: PartialPosteriorsSMCState, selector: Array + key, state: PartialPosteriorsSMCState, data_mask: Array ) -> Tuple[PartialPosteriorsSMCState, smc.base.SMCInfo]: - logposterior_fn = partial_logposterior_factory(selector) + logposterior_fn = partial_logposterior_factory(data_mask) - previous_logposterior_fn = partial_logposterior_factory(state.selector) + previous_logposterior_fn = partial_logposterior_factory(state.data_mask) def log_weights_fn(x): return logposterior_fn(x) - previous_logposterior_fn(x) @@ -86,7 +86,7 @@ def log_weights_fn(x): key, state, num_mcmc_steps, mcmc_parameters, logposterior_fn, log_weights_fn ) - return PartialPosteriorsSMCState(state.particles, state.weights, selector), info + return PartialPosteriorsSMCState(state.particles, state.weights, data_mask), info return step @@ -118,7 +118,7 @@ def init_fn(position: ArrayLikeTree, num_observations, rng_key=None): del rng_key return init(position, num_observations) - def step(key: PRNGKey, state: PartialPosteriorsSMCState, selector: Array): - return kernel(key, state, selector) + def step(key: PRNGKey, state: PartialPosteriorsSMCState, data_mask: Array): + return kernel(key, state, data_mask) return SamplingAlgorithm(init_fn, step) # type: ignore[arg-type] diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index 0b12be8f1..5d5a5e0ed 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -38,12 +38,12 @@ def test_partial_posteriors(self): dataset_size = 1000 - def partial_logposterior_factory(selector): + def partial_logposterior_factory(data_mask): def partial_logposterior(x): lp = logprior_fn(x) return lp + jnp.sum( self.logdensity_by_observation(**x, **observations) - * selector.reshape(-1, 1) + * data_mask.reshape(-1, 1) ) return jax.jit(partial_logposterior) @@ -60,20 +60,20 @@ def partial_logposterior(x): init_state = init(init_particles, 1000) smc_kernel = self.variant(kernel) - selectors = jnp.array( + data_masks = jnp.array( [ - jnp.concat([jnp.ones(selector), jnp.zeros(dataset_size - selector)]) - for selector in np.arange(100, 1001, 50) + jnp.concat([jnp.ones(datapoints_chosen), jnp.zeros(dataset_size - datapoints_chosen)]) + for datapoints_chosen in np.arange(100, 1001, 50) ] ) - def body_fn(carry, selector): + def body_fn(carry, data_mask): i, state = carry subkey = jax.random.fold_in(self.key, i) - new_state, info = smc_kernel(subkey, state, selector) + new_state, info = smc_kernel(subkey, state, data_mask) return (i + 1, new_state), (new_state, info) - (steps, result), it = jax.lax.scan(body_fn, (0, init_state), selectors) + (steps, result), it = jax.lax.scan(body_fn, (0, init_state), data_masks) assert steps == 19 self.assert_linear_regression_test_case(result) From b87d8e40d67663064833b78b2ca6c70ea1232c84 Mon Sep 17 00:00:00 2001 From: Carlos Iguaran Date: Fri, 4 Oct 2024 20:11:51 -0300 Subject: [PATCH 29/29] linter --- blackjax/smc/partial_posteriors_path.py | 5 ++++- tests/smc/test_partial_posteriors_smc.py | 7 ++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/blackjax/smc/partial_posteriors_path.py b/blackjax/smc/partial_posteriors_path.py index 1279ad245..81f19716d 100644 --- a/blackjax/smc/partial_posteriors_path.py +++ b/blackjax/smc/partial_posteriors_path.py @@ -86,7 +86,10 @@ def log_weights_fn(x): key, state, num_mcmc_steps, mcmc_parameters, logposterior_fn, log_weights_fn ) - return PartialPosteriorsSMCState(state.particles, state.weights, data_mask), info + return ( + PartialPosteriorsSMCState(state.particles, state.weights, data_mask), + info, + ) return step diff --git a/tests/smc/test_partial_posteriors_smc.py b/tests/smc/test_partial_posteriors_smc.py index 5d5a5e0ed..78d57a934 100644 --- a/tests/smc/test_partial_posteriors_smc.py +++ b/tests/smc/test_partial_posteriors_smc.py @@ -62,7 +62,12 @@ def partial_logposterior(x): data_masks = jnp.array( [ - jnp.concat([jnp.ones(datapoints_chosen), jnp.zeros(dataset_size - datapoints_chosen)]) + jnp.concat( + [ + jnp.ones(datapoints_chosen), + jnp.zeros(dataset_size - datapoints_chosen), + ] + ) for datapoints_chosen in np.arange(100, 1001, 50) ] )