diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 85e231f..3f11761 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -8,7 +8,7 @@ repos: - id: ruff-format # formatter types_or: [ python, pyi, jupyter ] - repo: https://github.com/RobertCraigie/pyright-python - rev: v1.1.315 + rev: v1.1.368 hooks: - id: pyright additional_dependencies: ["equinox", "pytest", "jax", "jaxtyping"] \ No newline at end of file diff --git a/distreqx/bijectors/block.py b/distreqx/bijectors/block.py index 9e12022..c71f752 100644 --- a/distreqx/bijectors/block.py +++ b/distreqx/bijectors/block.py @@ -1,4 +1,5 @@ """Wrapper to turn independent Bijectors into block Bijectors.""" + from jaxtyping import Array from ..utils import sum_last diff --git a/distreqx/bijectors/tanh.py b/distreqx/bijectors/tanh.py index 3e384c4..32ef478 100644 --- a/distreqx/bijectors/tanh.py +++ b/distreqx/bijectors/tanh.py @@ -1,4 +1,5 @@ """Tanh bijector.""" + import jax import jax.numpy as jnp from jaxtyping import Array diff --git a/distreqx/distributions/__init__.py b/distreqx/distributions/__init__.py index 99ced36..e84a430 100644 --- a/distreqx/distributions/__init__.py +++ b/distreqx/distributions/__init__.py @@ -7,7 +7,9 @@ AbstractSurivialDistribution as AbstractSurivialDistribution, ) from .bernoulli import Bernoulli as Bernoulli +from .categorical import Categorical as Categorical from .independent import Independent as Independent +from .mixture_same_family import MixtureSameFamily as MixtureSameFamily from .mvn_diag import MultivariateNormalDiag as MultivariateNormalDiag from .mvn_from_bijector import ( AbstractMultivariateNormalFromBijector as AbstractMultivariateNormalFromBijector, diff --git a/distreqx/distributions/bernoulli.py b/distreqx/distributions/bernoulli.py index 4d12f70..8053645 100644 --- a/distreqx/distributions/bernoulli.py +++ b/distreqx/distributions/bernoulli.py @@ -74,8 +74,8 @@ def probs(self) -> Array: return jax.nn.sigmoid(self._logits) @property - def event_shape(self) -> tuple[int]: - return self.prob.shape + def event_shape(self) -> tuple[int, ...]: + return self.probs.shape def _log_probs_parameter(self) -> tuple[Array, Array]: if self._logits is None: diff --git a/distreqx/distributions/categorical.py b/distreqx/distributions/categorical.py new file mode 100644 index 0000000..e4dad79 --- /dev/null +++ b/distreqx/distributions/categorical.py @@ -0,0 +1,232 @@ +"""Categorical distribution.""" + +from typing import Optional, Union + +import jax +import jax.numpy as jnp +from jaxtyping import Array, PRNGKeyArray + +from ..utils.math import mul_exp, multiply_no_nan, normalize +from ._distribution import ( + AbstractSampleLogProbDistribution, + AbstractSTDDistribution, + AbstractSurivialDistribution, +) + + +class Categorical( + AbstractSTDDistribution, + AbstractSampleLogProbDistribution, + AbstractSurivialDistribution, + strict=True, +): + """Categorical distribution over integers. + + The Categorical distribution is parameterized by either probabilities (`probs`) or + unormalized log-probabilities (`logits`) of a set of `K` classes. + It is defined over the integers `{0, 1, ..., K-1}`. + """ + + _logits: Union[Array, None] + _probs: Union[Array, None] + + def __init__(self, logits: Optional[Array] = None, probs: Optional[Array] = None): + """Initializes a Categorical distribution. + + **Arguments:** + + - `logits`: Logit transform of the probability of each category. Only one + of `logits` or `probs` can be specified. + - `probs`: Probability of each category. Only one of `logits` or `probs` can + be specified. + """ + if (logits is None) == (probs is None): + raise ValueError( + f"One and exactly one of `logits` and `probs` should be `None`, " + f"but `logits` is {logits} and `probs` is {probs}." + ) + if (not isinstance(logits, jax.Array)) and (not isinstance(probs, jax.Array)): + raise ValueError("`logits` and `probs` are not jax arrays.") + + self._probs = None if probs is None else normalize(probs=probs) + self._logits = None if logits is None else normalize(logits=logits) + + @property + def event_shape(self) -> tuple: + """Shape of event of distribution samples.""" + return () + + @property + def logits(self) -> Array: + """The logits for each event.""" + if self._logits is not None: + return self._logits + if self._probs is None: + raise ValueError( + "_probs and _logits are None!" + ) # TODO: useless but needed for pyright + return jnp.log(self._probs) + + @property + def probs(self) -> Array: + """The probabilities for each event.""" + if self._probs is not None: + return self._probs + if self._logits is None: + raise ValueError( + "_probs and _logits are None!" + ) # TODO: useless but needed for pyright + return jax.nn.softmax(self._logits, axis=-1) + + @property + def num_categories(self) -> int: + """Number of categories.""" + if self._probs is not None: + return self._probs.shape[-1] + if self._logits is None: + raise ValueError( + "_probs and _logits are None!" + ) # TODO: useless but needed for pyright + return self._logits.shape[-1] + + def sample(self, key: PRNGKeyArray) -> Array: + """See `Distribution.sample`.""" + is_valid = jnp.logical_and( + jnp.all(jnp.isfinite(self.probs), axis=-1), + jnp.all(self.probs >= 0, axis=-1), + ) + draws = jax.random.categorical(key=key, logits=self.logits, axis=-1).astype( + "int8" + ) + return jnp.where(is_valid, draws, jnp.ones_like(draws) * -1) + + def log_prob(self, value: Array) -> Array: + """See `Distribution.log_prob`.""" + value_one_hot = jax.nn.one_hot( + value, self.num_categories, dtype=self.logits.dtype + ) + mask_outside_domain = jnp.logical_or(value < 0, value > self.num_categories - 1) + return jnp.where( + mask_outside_domain, + -jnp.inf, + jnp.sum(multiply_no_nan(self.logits, value_one_hot), axis=-1), + ) + + def prob(self, value: Array) -> Array: + """See `Distribution.prob`.""" + value_one_hot = jax.nn.one_hot( + value, self.num_categories, dtype=self.probs.dtype + ) + return jnp.sum(multiply_no_nan(self.probs, value_one_hot), axis=-1) + + def entropy(self) -> Array: + """See `Distribution.entropy`.""" + if self._logits is None: + if self._probs is None: + raise ValueError( + "_probs and _logits are None!" + ) # TODO: useless but needed for pyright + log_probs = jnp.log(self._probs) + else: + log_probs = jax.nn.log_softmax(self._logits) + return -jnp.sum(mul_exp(log_probs, log_probs), axis=-1) + + def mode(self) -> Array: + """See `Distribution.mode`.""" + if self._logits is None: + if self._probs is None: + raise ValueError( + "_probs and _logits are None!" + ) # TODO: useless but needed for pyright + parameter = self.probs + else: + parameter = self.logits + return jnp.argmax(parameter, axis=-1).astype("int8") + + def cdf(self, value: Array) -> Array: + """See `Distribution.cdf`.""" + # For value < 0 the output should be zero because support = {0, ..., K-1}. + should_be_zero = value < 0 + # For value >= K-1 the output should be one. Explicitly accounting for this + # case addresses potential numerical issues that may arise when evaluating + # derived methods (mainly, `log_survival_function`) for `value >= K-1`. + should_be_one = value >= self.num_categories - 1 + # Will use value as an index below, so clip it to {0, ..., K-1}. + value = jnp.clip(value, 0, self.num_categories - 1) + value_one_hot = jax.nn.one_hot( + value, self.num_categories, dtype=self.probs.dtype + ) + cdf = jnp.sum( + multiply_no_nan(jnp.cumsum(self.probs, axis=-1), value_one_hot), axis=-1 + ) + return jnp.where(should_be_zero, 0.0, jnp.where(should_be_one, 1.0, cdf)) + + def log_cdf(self, value: Array) -> Array: + """See `Distribution.log_cdf`.""" + return jnp.log(self.cdf(value)) + + def median(self): + raise NotImplementedError + + def variance(self): + raise NotImplementedError + + def mean(self): + raise NotImplementedError + + def kl_divergence(self, other_dist, **kwargs) -> Array: + """Calculates the KL divergence to another distribution. + + **Arguments:** + + - `other_dist`: A compatible disteqx distribution. + - `kwargs`: Additional kwargs. + + **Returns:** + + The KL divergence `KL(self || other_dist)`. + """ + return _kl_divergence_categorical_categorical(self, other_dist) + + +def _kl_divergence_categorical_categorical( + dist1: Categorical, + dist2: Categorical, + *unused_args, + **unused_kwargs, +) -> Array: + """Obtains the KL divergence `KL(dist1 || dist2)` between two Categoricals. + + The KL computation takes into account that `0 * log(0) = 0`; therefore, + `dist1` may have zeros in its probability vector. + + **Arguments:** + + - `dist1`: A Categorical distribution. + - `dist2`: A Categorical distribution. + + **Returns:** + + `KL(dist1 || dist2)`. + + **Raises:** + + ValueError if the two distributions have different number of categories. + """ + logits1 = dist1.logits + logits2 = dist2.logits + + num_categories1 = logits1.shape[-1] + num_categories2 = logits2.shape[-1] + + if num_categories1 != num_categories2: + raise ValueError( + f"Cannot obtain the KL between two Categorical distributions " + f"with different number of categories: the first distribution has " + f"{num_categories1} categories, while the second distribution has " + f"{num_categories2} categories." + ) + + log_probs1 = jax.nn.log_softmax(logits1, axis=-1) + log_probs2 = jax.nn.log_softmax(logits2, axis=-1) + return jnp.sum(mul_exp(log_probs1 - log_probs2, log_probs1), axis=-1) diff --git a/distreqx/distributions/independent.py b/distreqx/distributions/independent.py index 06e388f..5470dab 100644 --- a/distreqx/distributions/independent.py +++ b/distreqx/distributions/independent.py @@ -6,7 +6,6 @@ import jax.tree_util as jtu from jaxtyping import Array, PRNGKeyArray, PyTree -from .._custom_types import EventT from ._distribution import ( AbstractCDFDistribution, AbstractDistribution, @@ -43,7 +42,7 @@ def __init__( self._distribution = distribution @property - def event_shape(self) -> EventT: + def event_shape(self) -> tuple: """Shape of event of distribution samples.""" return self._distribution.event_shape diff --git a/distreqx/distributions/mixture_same_family.py b/distreqx/distributions/mixture_same_family.py new file mode 100644 index 0000000..01ca3b7 --- /dev/null +++ b/distreqx/distributions/mixture_same_family.py @@ -0,0 +1,171 @@ +"""Mixture distributions.""" + +import equinox as eqx +import jax +import jax.numpy as jnp +from jaxtyping import Array, PyTree + +from ._distribution import ( + AbstractCDFDistribution, + AbstractDistribution, + AbstractProbDistribution, + AbstractSampleLogProbDistribution, + AbstractSTDDistribution, + AbstractSurivialDistribution, +) +from .categorical import Categorical + + +class MixtureSameFamily( + AbstractSTDDistribution, + AbstractSampleLogProbDistribution, + AbstractSurivialDistribution, + AbstractProbDistribution, + AbstractCDFDistribution, + strict=True, +): + """Mixture with components provided from a single vmapped distribution.""" + + _mixture_distribution: Categorical + _components_distribution: AbstractDistribution + + def __init__( + self, + mixture_distribution: Categorical, + components_distribution: AbstractDistribution, + ) -> None: + """Initializes a mixture distribution for components of a shared family. + + **Arguments*:* + + - `mixture_distribution`: Distribution over selecting components. + - `components_distribution`: Component distribution. + """ + self._mixture_distribution = mixture_distribution + self._components_distribution = components_distribution + + @property + def components_distribution(self) -> AbstractDistribution: + """The components distribution.""" + return self._components_distribution + + @property + def mixture_distribution(self): + """The mixture distribution.""" + return self._mixture_distribution + + @property + def event_shape(self): + """Shape of event of distribution samples.""" + return self._components_distribution.event_shape + + def sample(self, key) -> Array: + """See `AbstractDistribution._sample`.""" + key_mix, key_components = jax.random.split(key) + mix_sample = self.mixture_distribution.sample(key_mix) + + num_components = self._mixture_distribution.num_categories + + # Sample from all components, then multiply with a one-hot mask and sum. + # While this does computation that is not used eventually, it is faster on + # GPU/TPUs, which excel at batched operations (as opposed to indexing). It + # is in particular more efficient than using `gather` or `where` operations. + mask = jax.nn.one_hot(mix_sample, num_components) + samples_all = self.components_distribution.sample(key_components) + + # Need to sum over the component axis, which is the last one for scalar + # components, the second-last one for 1-dim events, etc. + samples = jnp.sum( + jax.vmap(lambda x, y: x * y, in_axes=(1, None), out_axes=-1)( + samples_all, mask + ), + axis=0, + ) + return samples + + def mean(self) -> Array: + """Calculates the mean.""" + means = self.components_distribution.mean() + weights = self._mixture_distribution.probs + # Broadcast weights over event shape, and average over component axis. + weights = weights.reshape(weights.shape + (1,) * len(self.event_shape)) + return jnp.sum(means * weights, axis=-1 - len(self.event_shape)) + + def variance(self) -> Array: + """Calculates the variance.""" + means = self.components_distribution.mean() + variances = self.components_distribution.variance() + weights = self._mixture_distribution.probs + # Make weights broadcast over event shape. + weights = weights.reshape(weights.shape + (1,) * len(self.event_shape)) + # Component axis to reduce over. + component_axis = -1 - len(self.event_shape) + + # Using: Var(Y) = E[Var(Y|X)] + Var(E[Y|X]). + mean = jnp.sum(means * weights, axis=component_axis) + mean_cond_var = jnp.sum(weights * variances, axis=component_axis) + # Need to add an axis to `mean` to make it broadcast over components. + sq_diff = jnp.square(means - jnp.expand_dims(mean, axis=component_axis)) + var_cond_mean = jnp.sum(weights * sq_diff, axis=component_axis) + return mean_cond_var + var_cond_mean + + def _per_mixture_component_log_prob(self, value: Array) -> Array: + # Add component axis to make input broadcast with components distribution. + + # Compute `log_prob` in every component. + lp = eqx.filter_vmap( + lambda dist, x: dist.log_prob(x), in_axes=(eqx.if_array(0), None) + )(self.components_distribution, value) + # Last axis of mixture log probs are components. + return lp + jax.nn.log_softmax(self._mixture_distribution.logits, axis=-1) + + def log_prob(self, value: Array) -> Array: + # Reduce last axis of mixture log probs are components + return jax.scipy.special.logsumexp( + self._per_mixture_component_log_prob(value), axis=-1 + ) + + def posterior_marginal(self, observation: Array) -> Categorical: + """ + Generate the posterior distribution given a datapoint. + + **Arguments:** + + - `observation`: the data point to compute the distribution over + + **Returns:** + + The computed categorical distribution + + """ + return Categorical(logits=self._per_mixture_component_log_prob(observation)) + + def posterior_mode(self, observation: Array) -> Array: + """ + Compute the most likely component a data point falls into. + + **Arguments:** + + - `observation`: the data point to compute the mode of + + **Returns:** + + The computed mode + + """ + return jnp.argmax(self._per_mixture_component_log_prob(observation), axis=-1) + + def median(self): + raise NotImplementedError + + def mode(self): + raise NotImplementedError + + def entropy(self): + raise NotImplementedError + + def log_cdf(self, value: PyTree[Array]) -> PyTree[Array]: + raise NotImplementedError + + def kl_divergence(self, other_dist, **kwargs): + raise NotImplementedError diff --git a/distreqx/distributions/mvn_diag.py b/distreqx/distributions/mvn_diag.py index 3362988..2279101 100644 --- a/distreqx/distributions/mvn_diag.py +++ b/distreqx/distributions/mvn_diag.py @@ -51,7 +51,7 @@ class MultivariateNormalDiag(AbstractMultivariateNormalFromBijector, strict=True _loc: Array _scale: AbstractLinearBijector - _event_shape: tuple[int] + _event_shape: tuple[int, ...] _distribution: AbstractDistribution _bijector: AbstractBijector _scale_diag: Array diff --git a/distreqx/distributions/mvn_from_bijector.py b/distreqx/distributions/mvn_from_bijector.py index 158da39..cf64bfc 100644 --- a/distreqx/distributions/mvn_from_bijector.py +++ b/distreqx/distributions/mvn_from_bijector.py @@ -38,7 +38,7 @@ def _check_input_parameters_are_valid( class AbstractMultivariateNormalFromBijector(AbstractTransformed, strict=True): _loc: eqx.AbstractVar[Array] _scale: eqx.AbstractVar[AbstractLinearBijector] - _event_shape: eqx.AbstractVar[tuple[int]] + _event_shape: eqx.AbstractVar[tuple[int, ...]] _distribution: eqx.AbstractVar[AbstractDistribution] _bijector: eqx.AbstractVar[AbstractBijector] @@ -127,7 +127,7 @@ class MultivariateNormalFromBijector(AbstractMultivariateNormalFromBijector): _loc: Array _scale: AbstractLinearBijector - _event_shape: tuple[int] + _event_shape: tuple[int, ...] _distribution: AbstractDistribution _bijector: AbstractBijector diff --git a/distreqx/distributions/mvn_tri.py b/distreqx/distributions/mvn_tri.py index 2bbcd25..6fb96d5 100644 --- a/distreqx/distributions/mvn_tri.py +++ b/distreqx/distributions/mvn_tri.py @@ -62,7 +62,7 @@ class MultivariateNormalTri(AbstractMultivariateNormalFromBijector, strict=True) _is_lower: bool _loc: Array _scale: AbstractLinearBijector - _event_shape: tuple[int] + _event_shape: tuple[int, ...] _distribution: AbstractDistribution _bijector: AbstractBijector @@ -128,7 +128,7 @@ def __init__( @property def scale_tri(self) -> Array: """Triangular scale matrix `S`.""" - return jnp.broadcast_to(self._scale_tri, self.event_shape + self.event_shape) + return self._scale_tri @property def is_lower(self) -> bool: diff --git a/docs/api/distributions/categorical.md b/docs/api/distributions/categorical.md new file mode 100644 index 0000000..a9a5ca0 --- /dev/null +++ b/docs/api/distributions/categorical.md @@ -0,0 +1,7 @@ +# Categorical + +::: distreqx.distributions.categorical.Categorical + selection: + members: + - __init__ +--- \ No newline at end of file diff --git a/docs/api/distributions/mixture_same_family.md b/docs/api/distributions/mixture_same_family.md new file mode 100644 index 0000000..52bf196 --- /dev/null +++ b/docs/api/distributions/mixture_same_family.md @@ -0,0 +1,9 @@ +# Mixture Distribution + +::: distreqx.distributions.mixture_same_family.MixtureSameFamily + selection: + members: + - __init__ + - posterior_marginal + - posterior_mode +--- \ No newline at end of file diff --git a/examples/02_mixture_models.ipynb b/examples/02_mixture_models.ipynb new file mode 100644 index 0000000..be11064 --- /dev/null +++ b/examples/02_mixture_models.ipynb @@ -0,0 +1,819 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c3477e15-9c96-42c1-81a8-faca2db80a41", + "metadata": {}, + "outputs": [], + "source": [ + "import equinox as eqx\n", + "import jax\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import optax\n", + "import tensorflow_datasets as tfds\n", + "from jax import numpy as jnp\n", + "from jax.scipy.special import expit, logit\n", + "from tqdm.notebook import tqdm\n", + "\n", + "from distreqx.distributions import (\n", + " Bernoulli,\n", + " Categorical,\n", + " Independent,\n", + " MixtureSameFamily,\n", + " Normal,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "be5557f6-11df-4d44-8ba5-53a4245c91b7", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2024-07-28 11:38:41.110186: W tensorflow/core/framework/local_rendezvous.cc:404] Local rendezvous is aborting with status: OUT_OF_RANGE: End of sequence\n" + ] + } + ], + "source": [ + "N = 2_000\n", + "mnist_data = tfds.load(\"mnist\")[\"train\"]\n", + "mnist_data = tfds.as_numpy(mnist_data)\n", + "mnist_data = jnp.array(\n", + " [data[\"image\"] for count, data in enumerate(mnist_data) if count < N]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fd349c30-5143-4156-a57b-e4eaf664d4e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2000, 28, 28, 1)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "new_data = mnist_data / 255.0\n", + "new_data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "f7f563cb-9306-4f32-bf26-b2ec16cebb11", + "metadata": {}, + "outputs": [], + "source": [ + "class GMM(eqx.Module):\n", + " _model: MixtureSameFamily\n", + "\n", + " def __init__(self, K, n_vars, rng_key):\n", + " mixing_coeffs = jax.random.uniform(rng_key, (K,), minval=100, maxval=200)\n", + " mixing_coeffs = mixing_coeffs / mixing_coeffs.sum()\n", + " initial_probs = jnp.full((K, n_vars), 1.0 / K)\n", + "\n", + " self._model = MixtureSameFamily(\n", + " mixture_distribution=Categorical(probs=mixing_coeffs),\n", + " components_distribution=Independent(\n", + " Normal(initial_probs, 0.2 * jnp.ones_like(initial_probs))\n", + " ),\n", + " )\n", + "\n", + " @property\n", + " def mixing_coeffs(self):\n", + " return self._model.mixture_distribution.probs\n", + "\n", + " @property\n", + " def probs(self):\n", + " return self._model.components_distribution.distribution.loc\n", + "\n", + " @property\n", + " def model(self):\n", + " return self._model\n", + "\n", + " def responsibilities(self, observations):\n", + " return jnp.nan_to_num(self._model.posterior_marginal(observations).probs)\n", + "\n", + " def expected_log_likelihood(self, observations):\n", + " return jnp.nan_to_num(self._model.log_prob(observations))\n", + "\n", + " def em_step(self, observations):\n", + " n_obs, _ = observations.shape\n", + "\n", + " res = eqx.filter_vmap(self.responsibilities)(observations)\n", + " sum_res = jnp.sum(res, axis=0)\n", + " mus = jax.vmap(\n", + " lambda c, d: jax.vmap(lambda a, b: a * b, in_axes=(0, None))(c, d)\n", + " )(res, observations)\n", + " mus = jax.vmap(lambda a, b: a / b)(jnp.sum(mus, axis=0), sum_res)\n", + " # constant sigma\n", + " return sum_res / n_obs, mus\n", + "\n", + " def plot(self, n_row, n_col):\n", + " if n_row * n_col != len(self.mixing_coeffs):\n", + " raise TypeError(\n", + " \"The number of rows and columns does not match with \"\n", + " \"the number of component distribution.\"\n", + " )\n", + " fig, axes = plt.subplots(n_row, n_col)\n", + "\n", + " for (coeff, mean), ax in zip(\n", + " zip(self.mixing_coeffs, self.probs), axes.flatten()\n", + " ):\n", + " ax.imshow(mean.reshape((28, 28)), cmap=\"grey\")\n", + " ax.set_title(\"%1.2f\" % coeff)\n", + " ax.axis(\"off\")\n", + "\n", + " fig.tight_layout(pad=1.0)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "44655c5e-0405-4c5c-9c7d-aa61a52f11d0", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5d0dad544904463f82c4e01fb5c50961", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/20 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@eqx.filter_jit\n", + "def update_model_params(model, params):\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.mixture_distribution._probs, model, params[0]\n", + " )\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.components_distribution.distribution._loc, model, params[1]\n", + " )\n", + " return model\n", + "\n", + "\n", + "@eqx.filter_jit\n", + "def train_step(model, params, observations):\n", + " model = update_model_params(model, params)\n", + " log_likelihood = jnp.sum(\n", + " eqx.filter_vmap(model.expected_log_likelihood)(observations)\n", + " )\n", + " mixing_coeffs, probs = model.em_step(observations)\n", + " return (mixing_coeffs, probs), log_likelihood\n", + "\n", + "\n", + "data = new_data.reshape((N, 784))\n", + "data = ((data > 0.0).astype(\"int32\") + 1e-8) * 0.99\n", + "key = jax.random.PRNGKey(0)\n", + "key, subkey = jax.random.split(key)\n", + "K = 20\n", + "model = GMM(K, 784, subkey)\n", + "params = (model.mixing_coeffs, model.probs)\n", + "\n", + "batch_size = 2000\n", + "inner = N // batch_size\n", + "outer = 20\n", + "losses = []\n", + "\n", + "for epoch in tqdm(range(outer)):\n", + " inner_loss = []\n", + " for batch in range(inner):\n", + " key, subkey = jax.random.split(key)\n", + " inds = jax.random.randint(\n", + " subkey, minval=0, maxval=len(data), shape=(batch_size,)\n", + " )\n", + " real_batch = data[inds]\n", + " key, subkey = jax.random.split(key)\n", + " params, loss = train_step(model, params, real_batch)\n", + " model = update_model_params(model, params)\n", + " inner_loss.append(loss)\n", + "\n", + " losses.append(np.mean(inner_loss))\n", + "\n", + " if epoch % 10 == 0:\n", + " model.plot(5, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "10c08976-54b0-4ba4-be68-d000c73c2624", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(-np.array(losses))\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"NLL\")\n", + "plt.title(\"GMM EM\")\n", + "plt.show()\n", + "\n", + "model.plot(4, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "cca0d0d7-67bf-4f2c-93c2-cc1b020e3016", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "e22295e4452b44da8039443d8c2f9e5f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@eqx.filter_jit\n", + "def update_model_params(model, params):\n", + " params = (jax.nn.softmax(params[0]), params[1])\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.mixture_distribution._probs, model, params[0]\n", + " )\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.components_distribution.distribution._loc, model, params[1]\n", + " )\n", + " return model\n", + "\n", + "\n", + "def loss_fn(model, params, inp):\n", + " model = update_model_params(model, params)\n", + " return -model.expected_log_likelihood(inp)\n", + "\n", + "\n", + "def vmap_loss(params, model, batch):\n", + " return jnp.mean(\n", + " eqx.filter_vmap(loss_fn, in_axes=(None, None, 0))(model, params, batch)\n", + " )\n", + "\n", + "\n", + "@eqx.filter_jit\n", + "def step(model, params, batch, opt_state):\n", + " loss, grads = eqx.filter_value_and_grad(vmap_loss)(params, model, batch)\n", + " update, opt_state = optimizer.update(grads, opt_state, params)\n", + " params = eqx.apply_updates(params, update)\n", + " return params, opt_state, loss\n", + "\n", + "\n", + "data = new_data.reshape((N, 784))\n", + "data = (data > 0.0).astype(\"int32\")\n", + "key = jax.random.PRNGKey(0)\n", + "key, subkey = jax.random.split(key)\n", + "K = 20\n", + "model = GMM(K, 784, subkey)\n", + "params = (model.mixing_coeffs, model.probs)\n", + "optimizer = optax.adam(1e-1)\n", + "opt_state = optimizer.init((jax.nn.softmax(model.mixing_coeffs), model.probs))\n", + "\n", + "batch_size = 1000\n", + "inner = N // batch_size\n", + "outer = 100\n", + "losses = []\n", + "\n", + "for epoch in tqdm(range(outer)):\n", + " inner_loss = []\n", + " for batch in range(inner):\n", + " key, subkey = jax.random.split(key)\n", + " inds = jax.random.randint(\n", + " subkey, minval=0, maxval=len(data), shape=(batch_size,)\n", + " )\n", + " real_batch = data[inds]\n", + " key, subkey = jax.random.split(key)\n", + " params, opt_state, loss = step(model, params, real_batch, opt_state)\n", + " model = update_model_params(model, params)\n", + " inner_loss.append(loss)\n", + "\n", + " losses.append(np.mean(inner_loss))\n", + " if epoch % 40 == 0:\n", + " model.plot(5, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "256404f5-7974-4459-9d7f-17b2dee97729", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses)\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"NLL\")\n", + "plt.title(\"GMM SGD\")\n", + "plt.show()\n", + "\n", + "model.plot(4, 5)" + ] + }, + { + "cell_type": "markdown", + "id": "21921308", + "metadata": {}, + "source": [ + "## Bernoulli Mixture Models" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "058601f5-727c-45a4-8376-4e75e9816537", + "metadata": {}, + "outputs": [], + "source": [ + "class BMM(eqx.Module):\n", + " _model: MixtureSameFamily\n", + "\n", + " def __init__(self, K, n_vars, rng_key):\n", + " mixing_coeffs = jax.random.uniform(rng_key, (K,), minval=100, maxval=200)\n", + " mixing_coeffs = mixing_coeffs / mixing_coeffs.sum()\n", + " initial_probs = jnp.full((K, n_vars), 1.0 / K)\n", + "\n", + " self._model = MixtureSameFamily(\n", + " mixture_distribution=Categorical(probs=mixing_coeffs),\n", + " components_distribution=Independent(Bernoulli(probs=initial_probs)),\n", + " )\n", + "\n", + " @property\n", + " def mixing_coeffs(self):\n", + " return self._model.mixture_distribution.probs\n", + "\n", + " @property\n", + " def probs(self):\n", + " return self._model.components_distribution.distribution.probs\n", + "\n", + " @property\n", + " def model(self):\n", + " return self._model\n", + "\n", + " def responsibilities(self, observations):\n", + " return jnp.nan_to_num(self._model.posterior_marginal(observations).probs)\n", + "\n", + " def expected_log_likelihood(self, observations):\n", + " return jnp.nan_to_num(self._model.log_prob(observations))\n", + "\n", + " def em_step(self, observations):\n", + " n_obs, _ = observations.shape\n", + "\n", + " def m_step_per_bernoulli(responsibility):\n", + " norm_const = responsibility.sum()\n", + " mu = jnp.sum(responsibility[:, None] * observations, axis=0) / norm_const\n", + " return jax.numpy.nan_to_num(mu), jax.numpy.nan_to_num(norm_const)\n", + "\n", + " mus, ns = eqx.filter_vmap(m_step_per_bernoulli, in_axes=(1))(\n", + " eqx.filter_vmap(self.responsibilities)(observations)\n", + " )\n", + " return ns / n_obs, mus\n", + "\n", + " def plot(self, n_row, n_col):\n", + " if n_row * n_col != len(self.mixing_coeffs):\n", + " raise TypeError(\n", + " \"The number of rows and columns does not match with the \"\n", + " \"number of component distribution.\"\n", + " )\n", + " fig, axes = plt.subplots(n_row, n_col)\n", + "\n", + " for (coeff, mean), ax in zip(\n", + " zip(self.mixing_coeffs, self.probs), axes.flatten()\n", + " ):\n", + " ax.imshow(mean.reshape((28, 28)), cmap=\"grey\")\n", + " ax.set_title(\"%1.2f\" % coeff)\n", + " ax.axis(\"off\")\n", + "\n", + " fig.tight_layout(pad=1.0)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "90c8cabc-4fd5-44b5-bf66-f38ce0044e7e", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "50f9c4a4afc1409e8f5db7b6f737957f", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/20 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@eqx.filter_jit\n", + "def update_model_params(model, params):\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.mixture_distribution._probs, model, params[0]\n", + " )\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.components_distribution.distribution._probs, model, params[1]\n", + " )\n", + " return model\n", + "\n", + "\n", + "@eqx.filter_jit\n", + "def train_step(model, params, observations):\n", + " model = update_model_params(model, params)\n", + " log_likelihood = jnp.sum(\n", + " eqx.filter_vmap(model.expected_log_likelihood)(observations)\n", + " )\n", + " mixing_coeffs, probs = model.em_step(observations)\n", + " return (mixing_coeffs, probs), log_likelihood\n", + "\n", + "\n", + "data = new_data.reshape((N, 784))\n", + "data = ((data > 0.0).astype(\"int32\") + 1e-8) * 0.99\n", + "key = jax.random.PRNGKey(0)\n", + "key, subkey = jax.random.split(key)\n", + "K = 20\n", + "model = BMM(K, 784, subkey)\n", + "params = (model.mixing_coeffs, model.probs)\n", + "\n", + "batch_size = 2000\n", + "inner = N // batch_size\n", + "outer = 20\n", + "losses = []\n", + "\n", + "for epoch in tqdm(range(outer)):\n", + " inner_loss = []\n", + " for batch in range(inner):\n", + " key, subkey = jax.random.split(key)\n", + " inds = jax.random.randint(\n", + " subkey, minval=0, maxval=len(data), shape=(batch_size,)\n", + " )\n", + " real_batch = data[inds]\n", + " key, subkey = jax.random.split(key)\n", + " params, loss = train_step(model, params, real_batch)\n", + " model = update_model_params(model, params)\n", + " inner_loss.append(loss)\n", + "\n", + " losses.append(np.mean(inner_loss))\n", + "\n", + " if epoch % 10 == 0:\n", + " model.plot(5, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8dfe6168-e498-4b04-b727-8e6eaf4bcd95", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(-np.array(losses))\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"NLL\")\n", + "plt.title(\"GMM EM\")\n", + "plt.show()\n", + "model.plot(4, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "3bcc7747-9f7a-4a89-8fa4-c783856168bc", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6fe3621f05844c15aca9f31f43127853", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "@eqx.filter_jit\n", + "def update_model_params(model, params):\n", + " params = (jax.nn.softmax(params[0]), expit(params[1]))\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.mixture_distribution._probs, model, params[0]\n", + " )\n", + " model = eqx.tree_at(\n", + " lambda x: x._model.components_distribution.distribution._probs, model, params[1]\n", + " )\n", + " return model\n", + "\n", + "\n", + "@eqx.filter_jit\n", + "def step(model, params, batch, opt_state):\n", + " loss, grads = eqx.filter_value_and_grad(vmap_loss)(params, model, batch)\n", + " update, opt_state = optimizer.update(grads, opt_state, params)\n", + " params = eqx.apply_updates(params, update)\n", + " return params, opt_state, loss\n", + "\n", + "\n", + "data = new_data.reshape((N, 784))\n", + "data = (data > 0.0).astype(\"int32\")\n", + "key = jax.random.PRNGKey(0)\n", + "key, subkey = jax.random.split(key)\n", + "K = 20\n", + "model = BMM(K, 784, subkey)\n", + "params = (model.mixing_coeffs, model.probs)\n", + "optimizer = optax.adam(1e-1)\n", + "opt_state = optimizer.init((jax.nn.softmax(model.mixing_coeffs), logit(model.probs)))\n", + "\n", + "batch_size = 1000\n", + "inner = N // batch_size\n", + "outer = 100\n", + "losses = []\n", + "\n", + "for epoch in tqdm(range(outer)):\n", + " inner_loss = []\n", + " for batch in range(inner):\n", + " key, subkey = jax.random.split(key)\n", + " inds = jax.random.randint(\n", + " subkey, minval=0, maxval=len(data), shape=(batch_size,)\n", + " )\n", + " real_batch = data[inds]\n", + " key, subkey = jax.random.split(key)\n", + " params, opt_state, loss = step(model, params, real_batch, opt_state)\n", + " model = update_model_params(model, params)\n", + " inner_loss.append(loss)\n", + "\n", + " losses.append(np.mean(inner_loss))\n", + " if epoch % 40 == 0:\n", + " model.plot(5, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d5dbc2b9-278a-4a2c-8b23-4d1036fa64e6", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlEAAAHHCAYAAACfqw0dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABOMUlEQVR4nO3deXhU9d3+8Xsmk8m+ko1AErawRCBA2EXZIoqKotYNZNNKa9Gq1Fqfp636tFXUWosL1WpVXECQqij8RI1BoFCEsO+EHYQshJB9nzm/P0JGYgIkQ5LJ8n5dV67LnDlzzmeOwtx+V5NhGIYAAABQL2ZXFwAAANASEaIAAACcQIgCAABwAiEKAADACYQoAAAAJxCiAAAAnECIAgAAcAIhCgAAwAmEKAAAACcQogAAAJxAiALQbM2fP18mk6naT1hYmEaPHq0VK1bUOL/qnJ///Oe1Xu/3v/+945ysrCzH8enTp8tkMsnf31/FxcU13nfgwAHH+1588cVL1l1QUKCnnnpKvXv3lo+Pj9q1a6d+/frp4Ycf1qlTp2qcv2PHDs2YMUOdO3eWp6enfH191a9fPz3++OM6fPhwtXOraq368fX1VZcuXfSzn/1Mn3zyiex2+yXrA9AwLK4uAAAu5U9/+pM6d+4swzCUkZGh+fPn6/rrr9eyZct04403VjvX09NTn3zyif7xj3/IarVWe+2jjz6Sp6enSkpKatzDYrGoqKhIy5Yt0x133FHttQULFlzwfT9VXl6uq6++Wvv27dO0adP00EMPqaCgQLt379bChQt1yy23KDIy0nH+W2+9pQceeEAhISGaPHmyevbsqYqKCu3atUvvv/++5s6dq+LiYrm5uTne4+HhoX/961+SpOLiYh07dkzLli3Tz372M40aNUqff/65/P39L/1gAVweAwCaqXfffdeQZKSkpFQ7np2dbbi7uxuTJk2qdlySMXHiRMNsNhtLly6t9tq6desMScZtt91mSDJOnz7teG3atGmGj4+PMW7cOGPixIk16oiNjXW8769//etFa/74448NScaCBQtqvFZcXGzk5uZWq8nNzc24+uqrjby8vFrP/8Mf/mBUVFTUqLU2c+bMMSQZd9xxx0VrBNAw6M4D0OIEBgbKy8tLFkvNxvQOHTro6quv1sKFC6sdX7Bggfr06aPevXtf8LqTJk3SihUrlJOT4ziWkpKiAwcOaNKkSXWq7dChQ5KkK6+8ssZrnp6e1VqI/u///k8mk0kLFiyQn59fref/+c9/rtYKdTFPPPGExo0bpyVLlig1NbVO7wHgPEIUgGYvNzdXWVlZOn36tHbv3q0HHnhABQUFuueee2o9f9KkSVq2bJkKCgokSRUVFVqyZMklg9Ctt94qk8mkTz/91HFs4cKF6tmzpwYMGFCnWmNiYiRJ77//vgzDuOB5RUVFWrlypUaNGqWOHTvW6dp1MWXKFBmGoaSkpAa7JoDaEaIANHuJiYkKDQ1VWFiYevfurfnz5+udd97RNddcU+v5P/vZz2Sz2bR06VJJ0jfffKOsrCzdfffdF72Pn5+fbrzxRkcrlt1u16JFiy75vvNNnDhRPXr00JNPPqnOnTtrxowZeuedd5SZmVntvIMHD6qioqLWlrHs7GxlZWU5fsrKyup8/6rrVbWIAWg8hCgAzd68efOUlJSkpKQkffjhhxo9erR+/vOfV2sxOl9QUJCuu+46ffTRR5IqW5OGDx/uaCW6mEmTJmnVqlVKT0/XypUrlZ6eXueuPEny8vLShg0b9Nvf/lZS5QzD++67T+3bt9dDDz2k0tJSSVJeXp4kydfXt8Y1unTpotDQUMfPF198Uef7V10vPz+/zu8B4BxCFIBmb/DgwUpMTFRiYqImT56s//f//p/i4uL04IMPXrCVZtKkSUpKStLx48e1dOnSOgeh66+/Xn5+flq8eLEWLFigQYMGqVu3bvWqNyAgQC+88IKOHj2qo0eP6u2331aPHj302muv6c9//rMkOcZAVXU5nu/zzz9XUlJSnZZT+Kmq69U2xgpAwyJEAWhxzGazRo8erbS0NB04cKDWc2666SZ5eHho2rRpKi0trbFswYV4eHjo1ltv1XvvvafPPvusXq1QtYmJidG9996rdevWKTAwUAsWLJAkdevWTRaLRbt27arxnpEjRyoxMVEJCQn1vl/V9eob/ADUHyEKQItUUVEhqfaWHKmyW23ixIlatWqVrrnmGoWEhNT52pMmTdLWrVuVn5+vu+66q0HqDQoKUteuXZWWliZJ8vHx0ahRo7R69WqdPHmyQe4hSR988IFMJtMFx4sBaDgstgmgxSkvL9c333wjq9WqXr16XfC8xx57TF27dtW1115br+uPHj1af/7zn9WuXTtFRETU673bt29Xhw4daoS2Y8eOac+ePerRo4fj2JNPPqlRo0bpnnvu0bJly2qMj7rY7L7aPPfcc/rmm2901113KTY2tl7vBVB/hCgAzd6KFSu0b98+SVJmZqYWLlyoAwcO6Iknnrjoytzx8fGKj4+v9/3MZrP+8Ic/OFVrUlKSnnrqKd10000aOnSofH19dfjwYb3zzjsqLS3V008/7Tj3qquu0muvvaaHHnpIsbGxjhXLy8rKlJqaqgULFshqtdYIchUVFfrwww8lSSUlJTp27Ji++OIL7dixQ6NHj9abb77pVO0A6ocQBaDZe/LJJx3/7OnpqZ49e+r111/XL37xCxdWVbvbbrtN+fn5+uabb7Ry5UplZ2crKChIgwcP1m9+8xuNHj262vkPPPCAhg0bpr///e9asmSJ0tPT5e7urq5du2ratGl64IEH1LVr12rvKS0t1ZQpUyRJ3t7eCgsLU0JCgp588kndcsstMpsZqQE0BZNR3/ZiAAAAMLAcAADAGYQoAAAAJxCiAAAAnECIAgAAcAIhCgAAwAmEKAAAACewTlQjstvtOnXqlPz8/GQymVxdDgAAqAPDMJSfn6/IyMiLrrtGiGpEp06dUlRUlKvLAAAATjhx4oQ6dux4wdcJUY3Iz89PUuW/hIttTQEAAJqPvLw8RUVFOb7HL4QQ1YiquvD8/f0JUQAAtDCXGorDwHIAAAAnEKIAAACcQIgCAABwAiEKAADACYQoAAAAJxCiAAAAnECIAgAAcAIhCgAAwAmEKAAAACcQogAAAJxAiAIAAHACIQoAAMAJhKgWqMJm19GsQp3OL3V1KQAAtFmEqBbosSXbNerFVfr35h9cXQoAAG0WIaoF6hTiI0k6fLrAxZUAANB2EaJaoK6hvpKkQ4QoAABchhDVAnUJPdcSlVXo4koAAGi7CFEtUOdz3Xk5ReXKLixzcTUAALRNhKgWyNtqUYdAL0l06QEA4CqEqBbK0aVHiAIAwCUIUS3Uj4PLGRcFAIArEKJaKFqiAABwLUJUC9UlpLIl6jAtUQAAuAQhqoXqGlbZEnUsu0hlFXYXVwMAQNtDiGqhIvw95W11k81u6Hh2kavLAQCgzSFEtVAmk4lxUQAAuBAhqgWrGhfFDD0AAJoeIaoFoyUKAADXIUS1YGxEDACA6xCiWjA2IgYAwHUIUS1Y1ZgoNiIGAKDpEaJaMC+rGxsRAwDgIoSoFo7B5QAAuAYhqoWrGlzO9i8AADQtQlQLV9USRXceAABNixDVwtESBQCAaxCiWriqlqjj2UUqt7ERMQAATYUQ1cJVbURcYTd07AwbEQMA0FQIUS0cGxEDAOAahKhGMG/ePMXFxWnQoEFNcj82IgYAoOkRohrBrFmztGfPHqWkpDTJ/WiJAgCg6RGiWgHHDD320AMAoMkQoloB1ooCAKDpEaJagfM3Ij5TUOriagAAaBsIUa2Al9VNHYMqNyI+mElrFAAATYEQ1UrEhlW2Rh0gRAEA0CQIUa1EbLifJFqiAABoKoSoVqLbuZYoQhQAAE2DENVKdHN05+W7uBIAANoGQlQrURWiMvJKlVtc7uJqAABo/QhRrYS/p7si/D0l0aUHAEBTIES1IrHhVeOi6NIDAKCxEaJakartX2iJAgCg8RGiWpGqlijWigIAoPERolqR2LDKtaIOZBCiAABobISoVqRq1fKTOcUqLK1wcTUAALRuhKhWJMjHqhBfqyTp0GlaowAAaEyEqFaGweUAADQNQlQrw+ByAACaBiGqlWFwOQAATYMQ1crEhrHgJgAATYEQ1cpU7aF3PLtIJeU2F1cDAEDrRYhqZUL9POTvaZHdkI5kFbq6HAAAWi1CVCtjMpkUG35uXBSDywEAaDSEqFbIMS4qg3FRAAA0FkJUK1Q1LoqWKAAAGg8hqhUiRAEA0PgIUa1Q1Zioo1mFKrfZXVwNAACtEyGqFYoM8JSP1U0VdkPHzjBDDwCAxkCIaoVMJtOPXXqsXA4AQKMgRLVS3cJY5gAAgMZEiGqlqlqiUlnmAACARkGIaqW6h1ftoUdLFAAAjYEQ1UrFnuvOO3y6UBXM0AMAoMERolqpjkFe8nJ3U5nNrmPZRa4uBwCAVocQ1UqZzefP0GNcFAAADY0Q1YrFhrPMAQAAjYUQ1YpVjYtKZXA5AAANjhDVinUPpzsPAIDGQohqxbqHM0MPAIDGQohqxToEMkMPAIDGQohqxZihBwBA4yFEtXLM0AMAoHEQolq5qnFRzNADAKBhEaJauVi68wAAaBSEqFaOGXoAADQOQlQrxww9AAAaByGqlWOGHgAAjYMQ1QYwQw8AgIZHiGoDmKEHAEDDI0S1AeyhBwBAwyNEtQGxYczQAwCgoRGi2gBm6AEA0PAIUW2A2Ww6b3A5XXoAADQEQlQb8eMyBwwuBwCgIRCi2ghm6AEA0LAIUW0EM/QAAGhYhKg2ghl6AAA0LEJUG9Eh0EveVmboAQDQUAhRbYTZbFIse+gBANBgCFFtSNXg8n3phCgAAC4XIaoN6RFxboYeLVEAAFw2QlQbUtUStZ+WKAAALhshqo5OnDihUaNGKS4uTn379tWSJUtcXVK9VbVEHT1TpJJym4urAQCgZSNE1ZHFYtHcuXO1Z88effPNN3rkkUdUWFjo6rLqJczPQwFe7rLZDR0+3bJqBwCguSFE1VH79u3Vr18/SVJERIRCQkKUnZ3t2qLqyWQyqUc446IAAGgIzSpEPffcczKZTHrkkUca9Lpr1qzRhAkTFBkZKZPJpKVLl9Z63rx589SpUyd5enpqyJAh2rhxY63nbd68WTabTVFRUQ1aZ1PoHlG5zMF+QhQAAJel2YSolJQU/fOf/1Tfvn0vet66detUXl5e4/iePXuUkZFR63sKCwsVHx+vefPmXfC6ixcv1uzZs/XUU09py5Ytio+P17XXXqvMzMxq52VnZ2vq1Kl688036/Cpmh9HSxSDywEAuCzNIkQVFBRo8uTJeuuttxQUFHTB8+x2u2bNmqVJkybJZvtxYPT+/fs1ZswYvffee7W+b/z48frLX/6iW2655YLXfumll3T//fdrxowZiouL0xtvvCFvb2+98847jnNKS0s1ceJEPfHEExo+fPgFrzVv3jzFxcVp0KBBF/vYLtEjwl8SLVEAAFyuZhGiZs2apRtuuEGJiYkXPc9sNuvLL7/U1q1bNXXqVNntdh06dEhjxozRxIkT9fjjjzt1/7KyMm3evLna/c1msxITE7V+/XpJkmEYmj59usaMGaMpU6Zc8vPs2bNHKSkpTtXTmKo2Iv7hbLEKSitcXA0AAC2Xy0PUokWLtGXLFs2ZM6dO50dGRmrlypVau3atJk2apDFjxigxMVGvv/660zVkZWXJZrMpPDy82vHw8HClp6dLquxGXLx4sZYuXap+/fqpX79+2rlzp9P3dJVAb6vC/T0ksf0LAACXw+LKm584cUIPP/ywkpKS5OnpWef3RUdH64MPPtDIkSPVpUsXvf322zKZTI1YqTRixAjZ7fZGvUdT6R7up4y8UqVm5Kt/9IW7TwEAwIW5tCVq8+bNyszM1IABA2SxWGSxWLR69Wq98sorslgs1cY9nS8jI0MzZ87UhAkTVFRUpEcfffSy6ggJCZGbm1uNgekZGRmKiIi4rGs3Rz0cK5cXuLgSAABaLpeGqLFjx2rnzp3atm2b42fgwIGaPHmytm3bJjc3txrvycrK0tixY9WrVy99+umnSk5O1uLFi/XYY485XYfValVCQoKSk5Mdx+x2u5KTkzVs2DCnr9tcdWcPPQAALptLu/P8/PzUu3fvasd8fHzUrl27GselymAzfvx4xcTEaPHixbJYLIqLi1NSUpLGjBmjDh061NoqVVBQoIMHDzp+P3LkiLZt26bg4GBFR0dLkmbPnq1p06Zp4MCBGjx4sObOnavCwkLNmDGjgT+16zlaoghRAAA4zaUhqr7MZrOeffZZXXXVVbJarY7j8fHx+vbbbxUaGlrr+zZt2qTRo0c7fp89e7Ykadq0aZo/f74k6c4779Tp06f15JNPKj09Xf369dNXX31VY7B5axB7bobe6fxSZReWKdjHeol3AACAnzIZhmG4uojWKi8vTwEBAcrNzZW/v7+ry6nm6he+0/HsIi2aOVRDu7RzdTkAADQbdf3+dvkSB3CN7uyhBwDAZSFEtVE9qvbQY/sXAACcQohqo2iJAgDg8hCi2qgeEVVrReWLYXEAANQfIaqN6hLiK4vZpLySCmXklbq6HAAAWhxCVBtltZjVOcRHkrQvPc/F1QAA0PIQotowVi4HAMB5hKg2jD30AABwHiGqDWOGHgAAziNEtWHdz23/cjCzQHY7M/QAAKgPQlQbFtPOR1aLWcXlNv1wttjV5QAA0KIQotowN7NJXUMrW6Po0gMAoH4IUW1cVZdeaiYhCgCA+iBEtXFVg8sPZDBDDwCA+iBEtXGxYXTnAQDgDEJUG1fVEnUws0A2ZugBAFBnhKg2LirYWx4Ws0or7DqRXeTqcgAAaDEIUW2cm9mkbnTpAQBQb4Qo/Di4PJPB5QAA1BUhCooNpyUKAID6IkRB3cOq9tCjJQoAgLoiRMHRnXfoNDP0AACoK0IU1DHIS17ubiqrsOvYmUJXlwMAQItAiILM1Wbo0aUHAEBdEKIg6cfB5QcYXA4AQJ0QoiDpx3FRqSxzAABAnRCiIEnqTksUAAD1QoiCJCn23DIHh08XqsJmd3E1AAA0f4QoSJI6BHrJ2+qmMptdR8+whx4AAJdCiIKkyhl6sWF06QEAUFeEKDjEhrNyOQAAdUWIgkPV4PLUTFqiAAC4FEIUHKpaoujOAwDg0ghRcKhaK+pIVqHKmaEHAMBFEaLgEBngKV8Pi8ptho5msYceAAAXQ4iCg8lkcmz/si+dLj0AAC6GEIVqerX3lyTtTctzcSUAADRvhChUUxWi9hCiAAC4KEIUqomrClGnCFEAAFwMIQrV9Izwk8kkZeaXKqug1NXlAADQbBGiUI2Ph0Wd2vlIYlwUAAAXQ4hCDXTpAQBwaYQo1BAXyQw9AAAuhRCFGnq1r1y5nBl6AABcGCEKNcS1D5AkHTpdqJJym4urAQCgeSJEoYZwfw8FebvLZjd0IKPA1eUAANAsEaJQg8lkcoyL2pOW6+JqAABonghRqBUz9AAAuDhCFGr14x56bEQMAEBtCFGo1Y/deXmy2w0XVwMAQPNDiEKtuob6yupmVkFphX44W+zqcgAAaHYIUaiVu5tZseG+klgvCgCA2hCicEGOweWEKAAAaiBE4YJ6MUMPAIALIkThgthDDwCAC2vQEHX48GGNGzeuIS8JF6pqiTqZU6zconIXVwMAQPPSoCEqPz9fycnJDXlJuFCAl7s6BHpJYlwUAAA/RXceLoouPQAAakeIwkUxQw8AgNoRonBRzNADAKB2lvqc3L9/f5lMpgu+XlRUdNkFoXm54lx33sHMApVV2GW1kLsBAJDqGaImTpzYSGWgueoY5CU/D4vySyt06HSBo2UKAIC2rl4h6qmnnmqsOtBMmUwm9Wzvp5SjZ7U3LY8QBQDAOQ3aN7Njxw5ZrdaGvCSagarB5czQAwDgRw0aogzDUEVFRUNeEs1AL2boAQBQQ4OPEr7YwHO0TD+uFZUvwzBcXA0AAM0DU61wSd3D/WQ2SdmFZcrIK3V1OQAANAv1Gliel3fx7pz8/PzLKgbNk6e7m7qE+upgZoH2puUpIsDT1SUBAOBy9QpRgYGBF+2uMwyD7rxWKq69vw5mFmhPWp5G9wxzdTkAALhcvULUypUrCUltVK/2/vpi+ykGlwMAcE69QtSoUaMaqQw0d73a+0limQMAAKrUK0SZzeZLtkSZTCaWOWiFqmboHckqVFFZhbyt9fpPBwCAVqde34SfffbZBV9bv369XnnlFdnt9ssuCs1PmJ+nQnytyioo0/70fPWPDnJ1SQAAuFS9QtTNN99c49j+/fv1xBNPaNmyZZo8ebL+9Kc/NVhxaF56tffXfw5kaW8aIQoAAKfXiTp16pTuv/9+9enTRxUVFdq2bZvee+89xcTENGR9aEbiHCuX57q4EgAAXK/eISo3N1e/+93v1K1bN+3evVvJyclatmyZevfu3Rj1NRsnTpzQqFGjFBcXp759+2rJkiWuLqnJ9Wr/48rlAAC0dfXqznvhhRf0/PPPKyIiQh999FGt3XutlcVi0dy5c9WvXz+lp6crISFB119/vXx8fFxdWpOpGly+Ly1Pdrshs5nlLgAAbZfJqMdmaGazWV5eXkpMTJSbm9sFz/v0008bpLjmLD4+XsuXL1dUVNQFz8nLy1NAQIByc3Pl7+/fhNU1jgqbXXFPfa2yCrtWPTZKnULaToAEALQddf3+rld33tSpU3XHHXcoODhYAQEBF/ypj9dff119+/aVv7+//P39NWzYMK1YsaJe17iUNWvWaMKECYqMjJTJZNLSpUtrPW/evHnq1KmTPD09NWTIEG3cuLHW8zZv3iybzXbRANUaWdzM6hHOelEAAEj17M6bP39+gxfQsWNHPffcc4qNjZVhGHrvvfd08803a+vWrbriiitqnL9u3ToNHjxY7u7u1Y7v2bNH7dq1U3h4eI33FBYWKj4+Xvfee69uvfXWWutYvHixZs+erTfeeENDhgzR3Llzde2112r//v0KC/txm5Ps7GxNnTpVb7311mV+8papV3s/7TyZqz1peRrfp72rywEAwGWcnp3XUCZMmKDrr79esbGx6t69u5555hn5+vrq+++/r3Gu3W7XrFmzNGnSJNlsNsfx/fv3a8yYMXrvvfdqvcf48eP1l7/8RbfccssF63jppZd0//33a8aMGYqLi9Mbb7whb29vvfPOO45zSktLNXHiRD3xxBMaPnz4ZXzqluvHweW0RAEA2jaXh6jz2Ww2LVq0SIWFhRo2bFiN181ms7788ktt3bpVU6dOld1u16FDhzRmzBhNnDhRjz/+uFP3LSsr0+bNm5WYmFjtXomJiVq/fr2kys2Vp0+frjFjxmjKlCkXvd68efMUFxenQYMGOVVPcxbHDD0AACQ1kxC1c+dO+fr6ysPDQ7/85S/12WefKS4urtZzIyMjtXLlSq1du1aTJk3SmDFjlJiYqNdff93p+2dlZclms9XoCgwPD1d6erqkym7ExYsXa+nSperXr5/69eunnTt31nq9WbNmac+ePUpJSXG6puaq57kQdTKnWDlFZS6uBgAA12kWG6D16NFD27ZtU25urv79739r2rRpWr169QWDVHR0tD744AONHDlSXbp00dtvv33JPf0u14gRI9jSRlKAl7s6BHrpZE6x9qbla1jXdq4uCQAAl2gWLVFWq1XdunVTQkKC5syZo/j4eL388ssXPD8jI0MzZ87UhAkTVFRUpEcfffSy7h8SEiI3NzdlZGTUuE9ERMRlXbs1uuLcelE7T+a4thAAAFyoWYSon7Lb7SotLa31taysLI0dO1a9evXSp59+quTkZC1evFiPPfaY0/ezWq1KSEhQcnJytRqSk5NrHZvV1lXtm7f52FkXVwIAgOu4vDvvf/7nfzR+/HhFR0crPz9fCxcu1KpVq/T111/XONdut2v8+PGKiYnR4sWLZbFYFBcXp6SkJI0ZM0YdOnSotVWqoKBABw8edPx+5MgRbdu2TcHBwYqOjpYkzZ49W9OmTdPAgQM1ePBgzZ07V4WFhZoxY0bjffgWamCnqhCVI8MwGr0rFQCA5sjlISozM1NTp05VWlqaAgIC1LdvX3399de65pprapxrNpv17LPP6qqrrpLVanUcj4+P17fffqvQ0NBa77Fp0yaNHj3a8fvs2bMlSdOmTXOsfXXnnXfq9OnTevLJJ5Wenq5+/frpq6++qnXdqbauT4cAubuZlFVQquPZRYppx8rlAIC2p17bvqB+Wtu2L+e75R/rtPV4jv52e7xuS+jo6nIAAGgwjbLtC1BlYExll94mxkUBANooQhSckhATLEnaQogCALRRhCg4JeFcS1RqZr5yi8tdXA0AAE2PEAWnhPp5qFM7bxmGtOU4rVEAgLaHEAWnDTjXGrX5KCEKAND2EKLgtIHnxkWx6CYAoC0iRMFpVYtubjuRo3Ib+woCANoWQhSc1i3UV/6eFhWX27Q3Lc/V5QAA0KQIUXCa2Wz6cVwUXXoAgDaGEIXLwqKbAIC2ihCFy1K16Obmo2fFDkIAgLaEEIXL0i8qUG5mk9LzSnQyp9jV5QAA0GQIUbgsXlY3XRFZuTkj46IAAG0JIQqXLYHB5QCANogQhctWtejmJlYuBwC0IYQoXLaqRTf3pecpr4TNiAEAbQMhCpct3N9TMe28ZTfYRw8A0HYQotAghnSu7NL7/sgZF1cCAEDTIEShQQzu3E6StPFItosrAQCgaRCi0CCqWqJ2/pCrorIKF1cDAEDjI0ShQXQM8lJkgKcq7Ia2HMtxdTkAADQ6QhQahMlk0pAulV16GxgXBQBoAwhRaDBVXXobDjMuCgDQ+hGi0GAGnwtR207kqKTc5uJqAABoXIQoNJjOIT4K9fNQmc2ubSdyXF0OAACNihCFBmMymRytUSx1AABo7QhRaFBDq8ZFMbgcANDKEaLQoKoW3dx87KzKKuwurgYAgMZDiEKDig3zVZC3u0rK7dp5MtfV5QAA0GgIUWhQZrNJgzrRpQcAaP0IUWhwVYtuMrgcANCaEaLQ4KoW3dx09KwqbIyLAgC0ToQoNLhe7f3l52lRQWmF9qTlubocAAAaBSEKDc7tvHFR3x9mXBQAoHUiRKFRXNktRJKUvDfTxZUAANA4CFFoFOPiwiVJKUezdbawzMXVAADQ8AhRaBRRwd7qGeEnuyGt3EdrFACg9SFEodFcc641KmlPhosrAQCg4RGi0GjGxUVIktYcOK2ScpuLqwEAoGERotBoenfwV/sATxWV2fTfQ1muLgcAgAZFiEKjMZlMSuxV2aX3zW669AAArQshCo2qalzUt3szZbcbLq4GAICGQ4hCoxrapZ38PCzKKijV1hM5ri4HAIAGQ4hCo7JazBrVM0wSs/QAAK0LIQqN7selDtJdXAkAAA2HEIVGN6pHqNzdTDp0ulCHThe4uhwAABoEIQqNzt/TXUO7tJNElx4AoPUgRKFJjGP1cgBAK0OIQpNIPBeithw/q4y8EhdXAwDA5SNEoUm0D/BSQkyQDENatv2Uq8sBAOCyEaLQZCb27yBJ+mzrSRdXAgDA5SNEocnc0Ke9LGaTdp/K04GMfFeXAwDAZSFEockE+1g1qkeoJGnpNlqjAAAtGyEKTaqqS2/p1lPspQcAaNEIUWhSib3C5eth0cmcYm06dtbV5QAA4DRCFJqUp7ubrusdIYkuPQBAy0aIQpO75VyX3v/bkabSCpuLqwEAwDmEKDS5oV3aKczPQ7nF5Vq1/7SrywEAwCmEKDQ5N7NJN/eLlCR9TpceAKCFIkTBJapm6X27N1O5xeUurgYAgPojRMEl4tr7KzbMV2UVdq3YmebqcgAAqDdCFFzCZDLplgGVrVHvrDsiG2tGAQBaGEIUXGbykBj5e1qUmlHApsQAgBaHEAWXCfBy1y9GdpUkzf02VeU2u4srAgCg7ghRcKnpwzupnY9VR88U6dMtP7i6HAAA6owQBZfy8bDogVGVrVGvJB9k8U0AQItBiILL3TM0RuH+HjqZU6xFG0+4uhwAAOqEEAWX83R304NjYiVJr313UMVltEYBAJo/QhSahTsHRqljkJdO55fq/fVHXV0OAACXRIhCs2C1mPXw2MrWqNdXH1J+CauYAwCaN0IUmo1b+ndQl1Af5RSV65+rD7u6HAAALooQhWbD4mbW767rKUn619rDSs8tcXFFAABcGCEKzcq4uHANjAlSSbldf09KdXU5AABcECEKzYrJZNL/XN9LkrRk8wntT893cUUAANSOEIVmJyEmSNf3iZDdkJ5bsdfV5QAAUCtCFJql317bUxazSd/tP63/HsxydTkAANRAiEKz1DnER5OHREuS5qzYJ7vdcHFFAABUR4hCs/XrsbHy9bBo58lcLdtxytXlAABQDSEKzVY7Xw/H5sSvrjwow6A1CgDQfBCi0KxNGRYjb6ubDmYWaP3hM64uBwAAB0IUmjV/T3fdOqCDJOn9/x5zcTUAAPyIEIVmb+qwTpKkpL0ZOpVT7NpiAAA4hxCFZq97uJ+GdgmWzW5o4Ybjri4HAABJhCi0EFWtUYtSjqu0wubaYgAAECEKLcQ1ceGK8PdUVkGZVuxMd3U5AAAQotAyuLuZNenc4pvvrz/q2mIAABAhCi3IXYOj5O5m0pbjOdp1MtfV5QAA2jhCFFqMMD9Pje/dXhKtUQAA1yNEoUWZNjxGkvT5tlO0RgEAXIoQhRZlQHSQ4qMCVVph102vrdX/frZTZwpKXV0WAKANIkShRTGZTHprSoImxEfKbkgLNxzXqBdX6e21R1Rus7u6PABAG2Iy2NW10eTl5SkgIEC5ubny9/d3dTmtzsYj2fq/Zbu1+1SeJCk62Fu/HNlVtyV0kIfFzcXVAQBaqrp+fxOiGhEhqvHZ7IaWbDqhF7/Zr6yCMklShL+n7r+6i+4eHCVvq8XFFQIAWhpCVDNAiGo6xWU2fbTxuN5cc1jpeSWSpBBfq/4xOUGDOwe7uDoAQEtS1+9vxkShVfCyuuneEZ21+vFRmnNrH0UHeyuroEwz3t2ozceyXV0eAKAVIkShVfGwuOnuwdH65tGrNaJbiArLbJr2Toq2Hj/r6tIAAK0MIQqtkqe7m96aOlDDurRTQWmFpr69UdtP5Li6LABAK0KIQqvlZXXT29MHanDnYOWXVmjK2xtYoBMA0GAIUWjVvK0WvTt9kAbGBCmvpELT392o0/kszgkAuHyEKLR6Ph4Wzb93sHpG+CmroExPfLJDTEoFAFwuQhTaBF8Pi+be1U9Wi1nJ+zK1cONxV5cEAGjhCFFoM3pG+Ot31/WUJP15+R4dOl3g4ooAAC0ZIQptyozhnTSiW4hKyu16dPE29tsDADiNEIU2xWw26cXb4xXg5a4dP+TqleQDKiyt0OZj2Xp//VH9z6c79GryAdntjJkCAFwc2740IrZ9ab6+3JmmXy3YIkkymaSf/il4YFRXR9cfAKBtYdsX4CKu79Netyd0lFQZoML8PDS6R6juHBglSXp91SF9sP6oCysEADR3bHGPNmvOrX1095BoRQV5K9TPw3G8Q5CXXkpK1VNf7Fa4v6fGXRHhwioBAM0VLVFosyxuZg2IDqoWoCTpoTHddNegKNkN6deLtmoL++4BAGpBiAJ+wmQy6S8Te2tUj1CVlNv18/c2aW9anqvLAgA0M4QooBYWN7PmTRqg3h38lV1YphtfXaunv9it3KLyGufml5Tru32Zyikqc0GlAABXYXZeI2J2XsuXVVCq//10p77ZkyFJCvJ212/G9dC1V0Tou32ZWrErTesOnlGZza7OIT766P6higjwdHHVAIDLUdfvb0JUIyJEtR5rD2TpT8t3KzWj9lXOrW5mR5BaNHOowv0JUgDQUrHEQQM7ceKERo0apbi4OPXt21dLlixxdUloQiNiQ/Tlr6/S/910hQK83CVJV0T66zfXdFfSo1cr+Tcj1SHQS0eyCnX3m98rI6/E8V6b3dCKnWm6d36KXl91iM2PAaCVoCWqjtLS0pSRkaF+/fopPT1dCQkJSk1NlY+PzwXfQ0tU61RSblN+SUWNWX0nsot015vf62ROsbqE+Ohf0wbqu/2nNf+/R3Qiu9hx3m0DOuq52/rI3Y3/hwGA5ojuvEYWHx+v5cuXKyoq6oLnEKLanvOD1PmCvN01pme4lm47KZvd0FWxIXr9ngT5eliqvffzbSfVNdRX4/u0b+rSAQDntJjuvDlz5mjQoEHy8/NTWFiYJk6cqP379zfoPdasWaMJEyYoMjJSJpNJS5curfW8efPmqVOnTvL09NSQIUO0cePGWs/bvHmzbDbbRQMU2qaoYG99dP9QRZ4bXN4l1EfP3NJb/31irP52R7z+NXWgvNzd9J8DWbrjjfU6lVOsr3ena9o7G3X1X7/Ti9+k6oEFW7R060kXfxIAwKW4PEStXr1as2bN0vfff6+kpCSVl5dr3LhxKiwsrPX8devWqby85jTzPXv2KCMjo9b3FBYWKj4+XvPmzbtgHYsXL9bs2bP11FNPacuWLYqPj9e1116rzMzMaudlZ2dr6tSpevPNN+vxKdGWRLfz1pcPX6VPHhiubx8dqclDYuRldZMkje4ZpkUzh6qdj1V70vJ05fMr9YsPNmt16mkZhtQtzFeS9NiS7VqTetqVHwMAcAnNrjvv9OnTCgsL0+rVq3X11VdXe81ut2vAgAGKjY3VokWL5OZW+cW0f/9+jRw5UrNnz9bjjz9+0eubTCZ99tlnmjhxYrXjQ4YM0aBBg/Taa6857hUVFaWHHnpITzzxhCSptLRU11xzje6//35NmTLlkp+F7jxcyLEzhZr+boqOZBWqnY9Vtw+M0t2DoxQV5K1HFm/TF9tPydvqpo/uH6r4qEBXlwsAbUqL6c77qdzcXElScHBwjdfMZrO+/PJLbd26VVOnTpXdbtehQ4c0ZswYTZw48ZIB6kLKysq0efNmJSYmVrtXYmKi1q9fL0kyDEPTp0/XmDFjLhmg5s2bp7i4OA0aNMipetD6xbTz0RcPXqmF9w/R+v8ZqyfG91RMOx+ZzSa9eHu8rooNUVGZTTPmp+jw6dqXVahSWmHTwcx8ldvsTVQ9AEBqZi1RdrtdN910k3JycrR27doLnnf8+HFdddVVGjZsmNavX69Ro0Zp/vz5MplMl7xHbS1Rp06dUocOHfTf//5Xw4YNcxx//PHHtXr1am3YsEFr167V1Vdfrb59+zpe/+CDD9SnT58L3ouWKDiroLRCk976Xjt+yFWHQC/dN6KzOoV4KzrYR1HBXjqdX6pV+09r1f5M/ffQGRWV2dQ5xEePX9tD1/WOqNOfBQBA7er6/W254CsuMGvWLO3ateuiAUqSoqOj9cEHH2jkyJHq0qWL3n777Ub/0hgxYoTsdv5PH03D18Oid6cP0s/eWK8jWYX60/I9jtdMJumn/+vjZjbpSFahHliwRf2jA/X763tpYKearbkAgIbTbELUgw8+qOXLl2vNmjXq2LHjRc/NyMjQzJkzNWHCBKWkpOjRRx/Vq6++6vS9Q0JC5ObmVmNgekZGhiIiIpy+LnA52vl6aPHMofrg+2M6dLpAR7OKdOxMoQrLbDKbpAHRQRrdM0yjeoQqOthbb/3niN5ac1hbj+foZ2+s1+DOweoW5qsOgV7qEOiliABPWS3m8wKYoYiAytcAAPXn8hBlGIYeeughffbZZ1q1apU6d+580fOzsrI0duxY9erVS0uWLFFqaqpGjRolDw8Pvfjii07VYLValZCQoOTkZEc3n91uV3Jysh588EGnrgk0hDB/T/1mXA/H74ZhKKugTB7uZvl7ulc7d/Y13XXPkGj9/dsDWpxyXBuPZGvjkeyLXt9kkp66MU7Tr7z4nzsAQE0uD1GzZs3SwoUL9fnnn8vPz0/p6emSpICAAHl5Vf8/ZLvdrvHjxysmJkaLFy+WxWJRXFyckpKSNGbMGHXo0EGPPvpojXsUFBTo4MGDjt+PHDmibdu2KTg4WNHR0ZKk2bNna9q0aRo4cKAGDx6suXPnqrCwUDNmzGjETw/Uj8lkqrFS+vnC/D0159Y+mnl1F208ckYnc0p08myxTuUUKz2vRBXnuqRNMslmN3Qyp1hPL9ujnOJyPTw2lrFUAFAPLh9YfqG/tN99911Nnz69xvGkpCRdddVV8vSsvsHr1q1bFRoaWmtX4KpVqzR69Ogax6dNm6b58+c7fn/ttdf017/+Venp6erXr59eeeUVDRkypH4f6DwMLEdzZhiGXkk+qL9/mypJmj68k568MU5mc+WfyYOZBfp40wntS8/XkM7BGhcXrm5hvgQtAK0e2740A4QotATv/feonvpityRpYr9IjYgN1eKU40o5erbGuV1CfHTNFeEa1qWduof7qX2AJ6EKQKtDiGoGCFFoKT7fdlK/+Xi7Kuw//nXgZjZpdI9QDe3STmsPZum/B8+o7CdrUfl6WNQtzFc9I/w0IT5Sw7q0c7RkVTl2plDzvjuoFbvS1SXER1d3D9XI7qHqFxUoy0U2YTYMQ8fOFMlkqlxXCwCaCiGqGSBEoSVZuS9Dv/5om4J9rLpzUJR+ltBR4f4/dpvnl5RrdeppfbsnQ7tO5eloVmG10CVJnUN8NGlwtG5L6KicojLN++6QY9Pln/LztCghJkgxwd6KOvcT5uehfen5+v7wGX1/+Iwy8kolST8f0VlPjO9Za+gqKbfpRHaRott5y8Pi1sBPBUBbRIhqBghRaGnKbXZZzKY6ddGVVdh19EyhDmQUaP3hLC3dekoFpRWSJKubWRV2u6qy06geofr5iC5Kyy3W6tTTWnswSzlFNffA/Cl3N5PKbZUXubJbO7169wAF+1glSXa7oS+2n9LzX+1TWm6J3N1MiosMUP+oQPWPDtSV3UIU4nvhQfgAcCGEqGaAEIW2pLC0Ql9sP6UPvz+m3afyJEljeobp12Nj1e8n+//Z7IZ2/JCjPWl5OpFdrBNni/RDdpHSckvUKcRHQ7u009DOweofHaTv9mfqsSXbVVRmU8cgL/1zSoJKK+z607I92nYiR1L1sFXFajHrzoFRmnl1F0UFe1+y/lM5xTqaVaj4qED5eDTsxOVv92Toq93pemhMN7omgRaAENUMEKLQFhmGof0Z+XJ3M6trqG+DXHN/er5mfrBJx84UyepmdozN8ra6adbobrpvRGdl5pVq64mz2nYiRxsOZ2tPWmWQs5hNurlfB/38qs7y93JXcVmFispsKiy16UBmvjYdPavNx87qZE6xJKmdj1UPjOqqe4bGyNP98rsHv9yZpgcXbpHdkAK93fWPyQM0vGvIZV8XQOMhRDUDhCig4eQWleuhRVu1JvW0TCbp9oSOemxcD4X5e9Y41zAMfX84W/9YdVD/OZBVp+u7mU0K9HLXmcIySVKEv6d+PTZWN/RtryNZhUrNyFdqer5O5hRrVI9Q3Z4QVWMQ/U8l783QLz7YrAq7oSBvd50tKpfFbNJTN12hKUNj6v8QamEYhspthqyWZrefPNBiEaKaAUIU0LBsdkMrdqWpS4iv4iLr9mdq24kczfvuoFbuy5SbySQvq5t8rG7ysropMtBLA2OCNahTkOKjAuVhMeuTLT/o5W8P6FRuyUWvGx8VqL/c3Ft9OgbU+vp/DpzWffM3qcxm1839IjXn1j763093aum2U5KkyUOide+IztrxQ462HMvR1hNndbawXL8Y2UVThsZcclyazW7os60n9dI3+1VhN7T4F8PUOaRldBWeLSzT59tO6qruoZfdWrn7VK7C/DwvughtbfdfuS9T11wRXmPl/8t1/EyRNh3L1s39OsjtEiEbzRchqhkgRAHNh91uXLLlqEpJuU0fbTyued8dVFZBmUJ8PdQjwlfdw/0qN4ded1QFpRUymaR7hsTosXE9FOD945fx94fPaPq7G1VSbtd1V0TotUn9ZXEzyzAMvbH6sF74el+NTaTPd9uAjnrmlt4X7E5ck3pac1bs095zXZaS1CXUR5/96koFeNUMBbtO5io1I9/lX+x2u6F/b/5Bc1bs1dmicnm6m/X0hCt056Coeq83lltcrv9btlufbjmpEF8PLX9ohCICarZK/lTK0Wz9+qOtSsstUUJMkD66f2iDteLll5Trurn/0cmcYv322h6aNbpbg1wXTY8Q1QwQooCWrdxmV1GprVpAkqTMvBI98+VefX6uVclkkkySDKlaOBrdI1T/nDKwxpf0t3sy9Nt/b1dhmU19OlTNKAzSsexCvfj1ftkNqU+HAL1+zwB1DKocFJ+ZX6J1B7P0yeaTWnuwsovSz9OimVd10cKNx5WWW6KrYkP07vRB1ZaC+HjTCf3+s50qtxka3ztCf7+zX53Hep3OL5Wvh0Ve1ssfG7YvPU9/+GyXNh0766g9v6RyNucNfdtrzq196twq9J8Dp/X4v3co7bzWwv7RgVo8c9gFA5HdbuiNNYf0t29Sqy25MWlItJ69pY+zH6ua3/17hxZvOiFJ8rCYlfToSEW3u/SkBler6v6OCvZy/PfW1hGimgFCFNC6rT90Rk9+vksHMgtqvDa2Z5jmTR5wwcBitxuqsNccy7TuYJYeXLhFZ4vKFexj1YS+7bXhSLb2pec7znF3M2nqsE56cHQ3BflYtetkrm5/Y72Ky22aPryTnr7pCtnthv76zX69vupQtesP6Ryst6YNvGhg2flDrt5YfUhf7kpThL+n3rgnQfE/mWFZV4Zh6O/fHtC87w7KZjfkbXXTI4mxmja8k95dd1Qvfl3ZHRkV7KVX7uqv/tFBF7xWUVmFnv1yrz78/rgkqVM7b80e10N/+Gyn8koqNGVojP48sXeN950pKNXsj7drdeppSZUr8yfGheuhj7bKMKRnb+mjSUOinfp8VVbuy9C98zfJZJK6hvrqYGaBRvUI1bvTB9VoZTuaVagVu9J1U79IdQj0usAVm0aFza6nl+3Wh98fV5C3u758+Cq1D3BtTc0BIaoZIEQBrZ9hGDqdX7koqEyVmzu7mU2O9ayc8cPZIj3w4RbtPJlb7fgVkf4aERuiyYNjarRwfLUrTb/8cIsk6ckb45RyNFsrdlVu6P7rMd00pEs7/eKDzSoorVCv9v56b8agaoPy7XZD6w5l6Y3Vh7Tu4Jlq17ZazHpmYm/dPjCq2udenXpa//jukHw9LXrutj4K86venWa3G/rj57u0YENl6Ln2inA9NeEKRZ4XHLYeP6uHPtqqH84Wy2I26a+399Ut/WvugZqZX6Lp76Q4Zl1OGxaj343vKW+rRd/ty9S976XIMKQXb4/XzxIq319hs+vjTT/opaRUZRWUysNi1p9uvkJ3DKzsPpz33UH99ev9cnczadHMoUqICb7ovxeb3ZBJqtEtfLawTOPmrtHp/FLdN6KzJg2J1vi5/1GZza55kwbohr7tHefuOZWne97eoOzCMnlYzLpvRGc9MKqr/Bp4bNb58krK5WlxqxHYC0or9ODCLVq1/7Tj2OBOwVp4/5CL7ibQFhCimgFCFABnlZTb9M/Vh5WeV6JhXdvpyq7t1O4Si4e+mnxAf0tKdfxudTPrudv66NYBlaFi18lcTX83RVkFpeoY5KVb+3fQ4axCHT5dqCNZhSout0mqnKl4U3yk7hkao9dXHdK3ezMkSVOHxegPN8Rp87Gz+ts3+x1dc5IU7u+hf0xOUEJMZUuSzW7od5/s0L83/yCTSZpzSx/dNbj21p68knL97t87HKHvf6/vqfuv6uJowTl2plBT3t6o49lFCvH10Nw7+2lEbPVlIuZ+m6q53x6onBzwwHBl5pdozpf7HK2E3cJ89dqk/uoZ8ePfxYZhaNbCLfpyZ7pC/SrHVYX/ZLZnUVmF1qRmKWlPhlbuy1BxuU33DInRL0Z2dQxmf3DhFi3fkaZuYb5a/tAIebq76e9JqXo5+YDC/Dz07W9Gyt/TXTt+yNGUtzcqt7i8WndmOx+rHrmmuyb0ba+zReXKKijVmYJSlVbYNapHWK3j3OpiX3qeXv72gFbsSlegt7tuio/UbQM6qm/HAGXklWrG/BTtTcuTp7tZv7uup/72TaoKSiv06zHdNHtcD6fu2VoQopoBQhSApmQYhh5etE1fbD+lIG93/XPKQA3uXL115fiZIk19Z4OOnimq8X5vq5vuHBSl+0Z0doyNsdsNvbryoP7+bWU4C/XzcLS8eVjMmjQkWmsPZOlAZoHc3Ux6csIVumtQlGZ/vF3Ltp+Sm9mkl+6I1839Oly0drvd0LNf7tW/1h6RJN03orN+f30v7UnL0/R3NyqroEwx7bz1/r2Da12w1G439PP3N2nlvkx5WMwqrahcSyzQ210Pj43V5CExtY6XKiyt0K3/+K/2Z+SrfYCnooK85W4xyd3NrHKbXZuOnnVc63ye7mZNGRqj6GBv/fHz3XIzm/TZr4arb8dASZUhePzL/9GRrEJNGxajm/p10PR3Niq/tEIDogP17ozB2ngkW3O+3KvDWYUXfC4R/p6ac2sfje4ZdtHnd7796fl6OTlVX+5Mr/X1bmG+yi8pV0ZeqUJ8rfrXtEHqFxWoz7ed1MOLtslkkhbcN0TDu1UPqsfP7WVZl8VrWzpCVDNAiALQ1EorbPpqV7oGdQqu1m12vqyCUr2afEAl5XZ1DfNRlxBfdQn1UVSwt9wv0I2TvDdDjyzapvzSCrm7mXT34GjNGt1N4f6eKiit0OP/3u740o4O9tbx7CK5u5n06t39dV3v9rVeszZvrTmsZ77cK0ka2T1Um4+dVUFpha6I9Nf8GYMvupRBblG5bpq3tnJRVotZM67spF+N6nbJlpxjZwp187x1F9yKqGOQl66JC9c1ceEqrbDr5W8POFbLr/LrsbGafU33asfWHsjSPW9vkMkkebm7qajMpsGdg/XO9EHyPbcqfrnNro82HtfL3x7QmcIy+XpY1M7XqhBfD2XkleiHs5WLwP4soaP+eGPcBT9LbnG5kvZkaPmOU47uOZNJur5Pez04uptO55fqky0/6Ovd6SoprwyFsWG+emf6oGqh6IlPdmhRygmF+nloxcNXKdjbqtWpp/WvtYcd3bwDY4J0+8COuqFvpONz1FV6bok2HDmjE9lFqrAbsp0bG2gYUo8IX10dG1pri2tRWYV2nazsyo3w91R4gEej7pVJiGoGCFEAWpOjWYX6ene6ru/TvkZrhGEYenPNYT3/1T7ZjcpxVG/cM0BjeobX+z6fbzupx5Zsd2zlM6xLO705NaFO44Z+OFuk5TvSdGPf9vWaaXa2sEybjp1Vhc2uMptd5TZDNrtdfTsGqmeEX7XB4YZhaFXqac399oC2n8hR344B+uSB4bUG0EcWbXWsDTaiW4jemjqw1tmONruhcpu92kSEknKbXvx6v95ed0SGUdllOmt0N/l6WGQ2mWQySUVlNiXvzdCa1CzHSv6SdEOf9vr12Fj1iPCrdp/8knJ9uTNNJ7KLdf/VXWqEsuIym26et1apGQWKjwpUYWmFDp7rEq0aClY1udHL3U3je0do5sgu1bpJf3q9/7czTd8fPqONR7J1PLtmC+j5TCapb4cAjeoRpm5hvtp+Ikcpx85q98ncGhueB/tYFe7vqfuv6uzosm4ohKhmgBAFoK3578Esvb/+mKYN76RhXds5fZ21B7L0+L+3a2jXdnr2lj4NsgVPQzMMQ3vT8tUpxFve1tpbZLIKSjXz/U3qFOLj9OfYfCxbv12y46LdfpLUPdxXN/SJ1IT49upyGYuYpmbk66bX1jparHw9LLprUJSmX9lJ7m5mfbrlpJZsPqHDpyvrMZmkW/p30OxrujuCa1FZhT78/pjeXHNYWQVljmubTdIVkQHq1d5P7m5mWcwmmc0m2e2GUo6edUwcqE24v4c83d2UlluisvO6WJ+5pbcmD2mYHQCqEKKaAUIUADjPMIx6L8LZWpWU2/T6qkPaeiJHVV/bdsOQSSYlxATphr7t1T3c7xJXqbuvdqXpX/85out6R+jOQVE1WgENw9CW4zl6e+1hRzeu1c2syUOjFernoX/954iyz22hFBXspQl9IzW4c7ASYoIu2qKYkVei1ftPa1Vqpn44W6w+HQI0qFOwBnYKUodAL5lMJhmGoZyicqXnlSg9t0Sx4b4Nvr4VIaoZIEQBAFq77Sdy9PxX+/TfQ9WXxohp561Zo7vplv4dLjjWrrmq6/d3/UaEAQAAnCc+KlALfj5Eaw9m6W/fpKqwtEK/GNlVE/tFtvr1pghRAADgsphMJl0VG6qrYkNdXUqTat0REQAAoJEQogAAAJxAiAIAAHACIQoAAMAJhCgAAAAnEKIAAACcQIgCAABwAiEKAADACYQoAAAAJxCiAAAAnECIAgAAcAIhCgAAwAmEKAAAACcQogAAAJxgcXUBrZlhGJKkvLw8F1cCAADqqup7u+p7/EIIUY0oPz9fkhQVFeXiSgAAQH3l5+crICDggq+bjEvFLDjNbrfr1KlT8vPzk8lkarDr5uXlKSoqSidOnJC/v3+DXRe143k3HZ510+FZNx2eddNpqGdtGIby8/MVGRkps/nCI59oiWpEZrNZHTt2bLTr+/v78weyCfG8mw7PuunwrJsOz7rpNMSzvlgLVBUGlgMAADiBEAUAAOAEQlQL5OHhoaeeekoeHh6uLqVN4Hk3HZ510+FZNx2eddNp6mfNwHIAAAAn0BIFAADgBEIUAACAEwhRAAAATiBEAQAAOIEQ1QLNmzdPnTp1kqenp4YMGaKNGze6uqQWb86cORo0aJD8/PwUFhamiRMnav/+/dXOKSkp0axZs9SuXTv5+vrqtttuU0ZGhosqbj2ee+45mUwmPfLII45jPOuGc/LkSd1zzz1q166dvLy81KdPH23atMnxumEYevLJJ9W+fXt5eXkpMTFRBw4ccGHFLZPNZtMf//hHde7cWV5eXuratav+/Oc/V9t7jWftnDVr1mjChAmKjIyUyWTS0qVLq71el+eanZ2tyZMny9/fX4GBgbrvvvtUUFBw2bURolqYxYsXa/bs2Xrqqae0ZcsWxcfH69prr1VmZqarS2vRVq9erVmzZun7779XUlKSysvLNW7cOBUWFjrOefTRR7Vs2TItWbJEq1ev1qlTp3Trrbe6sOqWLyUlRf/85z/Vt2/fasd51g3j7NmzuvLKK+Xu7q4VK1Zoz549+tvf/qagoCDHOS+88IJeeeUVvfHGG9qwYYN8fHx07bXXqqSkxIWVtzzPP/+8Xn/9db322mvau3evnn/+eb3wwgt69dVXHefwrJ1TWFio+Ph4zZs3r9bX6/JcJ0+erN27dyspKUnLly/XmjVrNHPmzMsvzkCLMnjwYGPWrFmO3202mxEZGWnMmTPHhVW1PpmZmYYkY/Xq1YZhGEZOTo7h7u5uLFmyxHHO3r17DUnG+vXrXVVmi5afn2/ExsYaSUlJxsiRI42HH37YMAyedUP63e9+Z4wYMeKCr9vtdiMiIsL461//6jiWk5NjeHh4GB999FFTlNhq3HDDDca9995b7ditt95qTJ482TAMnnVDkWR89tlnjt/r8lz37NljSDJSUlIc56xYscIwmUzGyZMnL6seWqJakLKyMm3evFmJiYmOY2azWYmJiVq/fr0LK2t9cnNzJUnBwcGSpM2bN6u8vLzas+/Zs6eio6N59k6aNWuWbrjhhmrPVOJZN6QvvvhCAwcO1O23366wsDD1799fb731luP1I0eOKD09vdqzDggI0JAhQ3jW9TR8+HAlJycrNTVVkrR9+3atXbtW48ePl8Szbix1ea7r169XYGCgBg4c6DgnMTFRZrNZGzZsuKz7swFxC5KVlSWbzabw8PBqx8PDw7Vv3z4XVdX62O12PfLII7ryyivVu3dvSVJ6erqsVqsCAwOrnRseHq709HQXVNmyLVq0SFu2bFFKSkqN13jWDefw4cN6/fXXNXv2bP3v//6vUlJS9Otf/1pWq1XTpk1zPM/a/k7hWdfPE088oby8PPXs2VNubm6y2Wx65plnNHnyZEniWTeSujzX9PR0hYWFVXvdYrEoODj4sp89IQr4iVmzZmnXrl1au3atq0tplU6cOKGHH35YSUlJ8vT0dHU5rZrdbtfAgQP17LPPSpL69++vXbt26Y033tC0adNcXF3r8vHHH2vBggVauHChrrjiCm3btk2PPPKIIiMjedatGN15LUhISIjc3NxqzFLKyMhQRESEi6pqXR588EEtX75c3333nTp27Og4HhERobKyMuXk5FQ7n2dff5s3b1ZmZqYGDBggi8Uii8Wi1atX65VXXpHFYlF4eDjPuoG0b99ecXFx1Y716tVLx48flyTH8+TvlMv329/+Vk888YTuuusu9enTR1OmTNGjjz6qOXPmSOJZN5a6PNeIiIgak68qKiqUnZ192c+eENWCWK1WJSQkKDk52XHMbrcrOTlZw4YNc2FlLZ9hGHrwwQf12WefaeXKlercuXO11xMSEuTu7l7t2e/fv1/Hjx/n2dfT2LFjtXPnTm3bts3xM3DgQE2ePNnxzzzrhnHllVfWWKojNTVVMTExkqTOnTsrIiKi2rPOy8vThg0beNb1VFRUJLO5+leqm5ub7Ha7JJ51Y6nLcx02bJhycnK0efNmxzkrV66U3W7XkCFDLq+AyxqWjia3aNEiw8PDw5g/f76xZ88eY+bMmUZgYKCRnp7u6tJatAceeMAICAgwVq1aZaSlpTl+ioqKHOf88pe/NKKjo42VK1camzZtMoYNG2YMGzbMhVW3HufPzjMMnnVD2bhxo2GxWIxnnnnGOHDggLFgwQLD29vb+PDDDx3nPPfcc0ZgYKDx+eefGzt27DBuvvlmo3PnzkZxcbELK295pk2bZnTo0MFYvny5ceTIEePTTz81QkJCjMcff9xxDs/aOfn5+cbWrVuNrVu3GpKMl156ydi6datx7NgxwzDq9lyvu+46o3///saGDRuMtWvXGrGxscbdd9992bURolqgV1991YiOjjasVqsxePBg4/vvv3d1SS2epFp/3n33Xcc5xcXFxq9+9SsjKCjI8Pb2Nm655RYjLS3NdUW3Ij8NUTzrhrNs2TKjd+/ehoeHh9GzZ0/jzTffrPa63W43/vjHPxrh4eGGh4eHMXbsWGP//v0uqrblysvLMx5++GEjOjra8PT0NLp06WL8/ve/N0pLSx3n8Kyd891339X69/O0adMMw6jbcz1z5oxx9913G76+voa/v78xY8YMIz8//7JrMxnGecupAgAAoE4YEwUAAOAEQhQAAIATCFEAAABOIEQBAAA4gRAFAADgBEIUAACAEwhRAAAATiBEAUAj6tSpk+bOnevqMgA0AkIUgFZj+vTpmjhxoiRp1KhReuSRR5rs3vPnz1dgYGCN4ykpKZo5c2aT1QGg6VhcXQAANGdlZWWyWq1Ovz80NLQBqwHQnNASBaDVmT59ulavXq2XX35ZJpNJJpNJR48elSTt2rVL48ePl6+vr8LDwzVlyhRlZWU53jtq1Cg9+OCDeuSRRxQSEqJrr71WkvTSSy+pT58+8vHxUVRUlH71q1+poKBAkrRq1SrNmDFDubm5jvs9/fTTkmp25x0/flw333yzfH195e/vrzvuuEMZGRmO159++mn169dPH3zwgTp16qSAgADdddddys/Pb9yHBqDeCFEAWp2XX35Zw4YN0/3336+0tDSlpaUpKipKOTk5GjNmjPr3769Nmzbpq6++UkZGhu64445q73/vvfdktVq1bt06vfHGG5Iks9msV155Rbt379Z7772nlStX6vHHH5ckDR8+XHPnzpW/v7/jfo899liNuux2u26++WZlZ2dr9erVSkpK0uHDh3XnnXdWO+/QoUNaunSpli9fruXLl2v16tV67rnnGulpAXAW3XkAWp2AgABZrVZ5e3srIiLCcfy1115T//799eyzzzqOvfPOO4qKilJqaqq6d+8uSYqNjdULL7xQ7Zrnj6/q1KmT/vKXv+iXv/yl/vGPf8hqtSogIEAmk6na/X4qOTlZO3fu1JEjRxQVFSVJev/993XFFVcoJSVFgwYNklQZtubPny8/Pz9J0pQpU5ScnKxnnnnm8h4MgAZFSxSANmP79u367rvv5Ovr6/jp2bOnpMrWnyoJCQk13vvtt99q7Nix6tChg/z8/DRlyhSdOXNGRUVFdb7/3r17FRUV5QhQkhQXF6fAwEDt3bvXcaxTp06OACVJ7du3V2ZmZr0+K4DGR0sUgDajoKBAEyZM0PPPP1/jtfbt2zv+2cfHp9prR48e1Y033qgHHnhAzzzzjIKDg7V27Vrdd999Kisrk7e3d4PW6e7uXu13k8kku93eoPcAcPkIUQBaJavVKpvNVu3YgAED9Mknn6hTp06yWOr+19/mzZtlt9v1t7/9TWZzZQP+xx9/fMn7/VSvXr104sQJnThxwtEatWfPHuXk5CguLq7O9QBoHujOA9AqderUSRs2bNDRo0eVlZUlu92uWbNmKTs7W3fffbdSUlJ06NAhff3115oxY8ZFA1C3bt1UXl6uV199VYcPH9YHH3zgGHB+/v0KCgqUnJysrKysWrv5EhMT1adPH02ePFlbtmzRxo0bNXXqVI0cOVIDBw5s8GcAoHERogC0So899pjc3NwUFxen0NBQHT9+XJGRkVq3bp1sNpvGjRunPn366JFHHlFgYKCjhak28fHxeumll/T888+rd+/eWrBggebMmVPtnOHDh+uXv/yl7rzzToWGhtYYmC5Vdst9/vnnCgoK0tVXX63ExER16dJFixcvbvDPD6DxmQzDMFxdBAAAQEtDSxQAAIATCFEAAABOIEQBAAA4gRAFAADgBEIUAACAEwhRAAAATiBEAQAAOIEQBQAA4ARCFAAAgBMIUQAAAE4gRAEAADiBEAUAAOCE/w/eXLrxfuUHywAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(losses)\n", + "plt.yscale(\"log\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"NLL\")\n", + "plt.title(\"BMM SGD\")\n", + "plt.show()\n", + "model.plot(4, 5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "917ae4d7-afe3-4acd-bce3-af231b8ab38a", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3.10.14 ('dev_diffrax')", + "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.10.14" + }, + "vscode": { + "interpreter": { + "hash": "01761703e8e304055600d311574f89f8a646f73edac04b8bff1580ad2d98581f" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/mkdocs.yml b/mkdocs.yml index aa78f76..cc548f4 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -92,6 +92,7 @@ nav: - 'index.md' - Examples: - Binary MNIST VAE: 'examples/01_vae.ipynb' + - GMM/BMM: 'examples/02_mixture_models.ipynb' - API: - Distributions: - Gaussians: @@ -100,7 +101,9 @@ nav: - 'api/distributions/mvn_from_bijector.md' - 'api/distributions/mvn_tri.md' - 'api/distributions/bernoulli.md' + - 'api/distributions/categorical.md' - 'api/distributions/independent.md' + - 'api/distributions/mixture_same_family.md' - 'api/distributions/transformed.md' - 'api/distributions/_distribution.md' - Bijectors: diff --git a/pyproject.toml b/pyproject.toml index 2912431..76a5bdc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -3,7 +3,7 @@ name = "distreqx" version = "0.0.1" description = "Lightweight JAX library of probability distributions and bijectors." readme = "README.md" -requires-python =">=3.9" +requires-python = ">=3.9" license = {file = "LICENSE"} authors = [ {name = "Owen Lockwood", email = "owen_jax@outlook.com"}, @@ -24,7 +24,7 @@ classifiers = [ "Topic :: Scientific/Engineering :: Physics", "Topic :: Software Development :: Libraries :: Python Modules", ] -urls = {repository = "https://github.com/lockwo/distreqx" } +urls = {repository = "https://github.com/lockwo/distreqx"} dependencies = ["jax>=0.4.11", "jaxtyping>=0.2.20", "equinox>=0.11.0"] [build-system] @@ -38,12 +38,12 @@ include = ["distreqx/*"] addopts = "--jaxtyping-packages=distreqx,beartype.beartype(conf=beartype.BeartypeConf(strategy=beartype.BeartypeStrategy.On))" [tool.ruff] +[tool.ruff.lint] select = ["E", "F", "I001"] ignore = ["E402", "E721", "E731", "E741", "F722"] -ignore-init-module-imports = true fixable = ["I001", "F401"] -[tool.ruff.isort] +[tool.ruff.lint.isort] combine-as-imports = true lines-after-imports = 2 extra-standard-library = ["typing_extensions"] diff --git a/tests/categorical_test.py b/tests/categorical_test.py new file mode 100644 index 0000000..5255b3c --- /dev/null +++ b/tests/categorical_test.py @@ -0,0 +1,466 @@ +"""Tests for `categorical.py`.""" + +from unittest import TestCase + +import equinox as eqx +import jax +import jax.numpy as jnp +import numpy as np +from parameterized import parameterized # type: ignore + +from distreqx.distributions import categorical +from distreqx.utils import math + + +class CategoricalTest(TestCase): + def setUp(self): + self.dist = categorical.Categorical + self.key = jax.random.PRNGKey(0) + + @parameterized.expand( + [ + ("1d probs", (4,), True), + ("1d logits", (4,), False), + ("2d probs", (3, 4), True), + ("2d logits", (3, 4), False), + ] + ) + def test_properties(self, name, shape, from_probs): + rng = np.random.default_rng(42) + probs = rng.uniform(size=shape) # Intentional unnormalization of `probs`. + logits = np.log(probs) + dist_kwargs = ( + {"probs": jnp.array(probs)} if from_probs else {"logits": jnp.array(logits)} + ) + dist = self.dist(**dist_kwargs) + self.assertEqual(dist.event_shape, ()) + self.assertEqual(dist.num_categories, shape[-1]) + np.testing.assert_allclose( + dist.logits, math.normalize(logits=jnp.array(logits)), rtol=1e-3 + ) + np.testing.assert_allclose( + dist.probs, math.normalize(probs=jnp.array(probs)), rtol=1e-3 + ) + + @parameterized.expand( + [ + ( + "probs and logits", + {"logits": jnp.array([0.1, -0.2]), "probs": jnp.array([0.6, 0.4])}, + ), + ("both probs and logits are None", {"logits": None, "probs": None}), + ] + ) + def test_raises_on_invalid_inputs(self, name, dist_params): + with self.assertRaises(ValueError): + self.dist(**dist_params) + + @parameterized.expand( + [ + ("1d logits, no shape", {"logits": jnp.array([0.0, 1.0, -0.5])}, ()), + ("1d probs, no shape", {"probs": jnp.array([0.2, 0.5, 0.3])}, ()), + ( + "2d logits, 1-tuple shape", + {"logits": jnp.array([[0.0, 1.0, -0.5], [-0.1, 0.3, 0.0]])}, + (2,), + ), + ( + "2d probs, 1-tuple shape", + {"probs": jnp.array([[0.1, 0.4, 0.5], [0.5, 0.25, 0.25]])}, + (2,), + ), + ] + ) + def test_sample_shape(self, name, distr_params, sample_shape): + distr_params = {k: jnp.asarray(v) for k, v in distr_params.items()} + dist = self.dist(**distr_params) + samples = dist.sample(self.key) + self.assertEqual(samples.shape, sample_shape) + + @parameterized.expand( + [ + ("1d logits, no shape", {"logits": jnp.array([0.0, 1.0, -0.5])}, ()), + ("1d probs, no shape", {"probs": jnp.array([0.2, 0.5, 0.3])}, ()), + ( + "2d logits, 1-tuple shape", + {"logits": jnp.array([[0.0, 1.0, -0.5], [-0.1, 0.3, 0.0]])}, + (2,), + ), + ( + "2d probs, 1-tuple shape", + {"probs": jnp.array([[0.1, 0.4, 0.5], [0.5, 0.25, 0.25]])}, + (2,), + ), + ] + ) + def test_sample_and_log_prob(self, name, distr_params, sample_shape): + distr_params = {k: jnp.asarray(v) for k, v in distr_params.items()} + dist = self.dist(**distr_params) + samples, log_prob = dist.sample_and_log_prob(self.key) + self.assertTupleEqual(samples.shape, sample_shape) + self.assertTupleEqual(log_prob.shape, sample_shape) + + @parameterized.expand( + [ + ("sample, float16", "sample", jnp.float16), + ("sample, float32", "sample", jnp.float32), + ("sample_and_log_prob, float16", "sample_and_log_prob", jnp.float16), + ("sample_and_log_prob, float32", "sample_and_log_prob", jnp.float32), + ] + ) + def test_sample_dtype(self, name, method, dtype): + dist_params = {"logits": jnp.array([0.1, -0.1, 0.5, -0.8, 1.5]).astype(dtype)} + dist = self.dist(**dist_params) + samples = getattr(dist, method)(self.key) + samples = samples[0] if method == "sample_and_log_prob" else samples + self.assertEqual(samples.dtype, jnp.int8) + + @parameterized.expand( + [ + ("sample, from probs", "sample", True), + ("sample, from logits", "sample", False), + ("sample_and_log_prob, from probs", "sample_and_log_prob", True), + ("sample_and_log_prob, from logits", "sample_and_log_prob", False), + ] + ) + def test_sample_values(self, name, method, from_probs): + probs = np.array([[0.5, 0.25, 0.25], [0.0, 0.0, 1.0]]) # Includes edge case. + num_categories = probs.shape[-1] + logits = np.log(probs) + n_samples = 100000 + dist_kwargs = ( + {"probs": jnp.array(probs)} if from_probs else {"logits": jnp.array(logits)} + ) + dist = self.dist(**dist_kwargs) + sample_fn = lambda key: jax.jit(jax.vmap(getattr(dist, method)))( + jax.random.split(key, n_samples) + ) + samples = sample_fn(self.key) + samples = samples[0] if method == "sample_and_log_prob" else samples + self.assertEqual(samples.shape, (n_samples,) + probs.shape[:-1]) + self.assertTrue(np.all(np.logical_and(samples >= 0, samples < num_categories))) + np.testing.assert_array_equal(jnp.floor(samples), samples) + samples_one_hot = jax.nn.one_hot(samples, num_categories, axis=-1) + np.testing.assert_allclose(np.mean(samples_one_hot, axis=0), probs, rtol=0.1) + + @parameterized.expand( + [ + ("sample", "sample"), + ("sample_and_log_prob", "sample_and_log_prob"), + ] + ) + def test_sample_values_invalid_probs(self, name, method): + # Check that samples=-1 if probs are negative or NaN after normalization. + n_samples = 1000 + probs = np.array( + [ + [0.1, -0.4, 0.2, 0.3], # Negative probabilities. + [-0.1, 0.1, 0.0, 0.0], # NaN probabilities after normalization. + [0.1, 0.25, 0.2, 0.8], # Valid (unnormalized) probabilities. + ] + ) + dist = self.dist(probs=jnp.array(probs)) + sample_fn = lambda key: jax.jit(jax.vmap(getattr(dist, method)))( + jax.random.split(key, n_samples) + ) + samples = sample_fn(self.key) + samples = samples[0] if method == "sample_and_log_prob" else samples + np.testing.assert_allclose(samples[..., :-1], -1, rtol=1e-4) + np.testing.assert_array_compare(lambda x, y: x >= y, samples[..., -1], 0) + + @parameterized.expand( + [ + ("1d logits, 1d value", {"logits": [0.0, 0.5, -0.5]}, [1, 0, 2, 0]), + ("1d probs, 1d value", {"probs": [0.3, 0.2, 0.5]}, [1, 0, 2, 0]), + ("1d logits, 2d value", {"logits": [0.0, 0.5, -0.5]}, [[1, 0], [2, 0]]), + ("1d probs, 2d value", {"probs": [0.3, 0.2, 0.5]}, [[1, 0], [2, 0]]), + ( + "2d logits, 1d value", + {"logits": [[0.0, 0.5, -0.5], [-0.2, 0.3, 0.5]]}, + [1, 0], + ), + ( + "2d probs, 1d value", + {"probs": [[0.1, 0.5, 0.4], [0.3, 0.3, 0.4]]}, + [1, 0], + ), + ( + "2d logits, 2d value", + {"logits": [[0.0, 0.5, -0.5], [-0.2, 0.3, 0.5]]}, + [[1, 0], [2, 1]], + ), + ( + "2d probs, 2d value", + {"probs": [[0.1, 0.5, 0.4], [0.3, 0.3, 0.4]]}, + [[1, 0], [2, 1]], + ), + ("extreme probs", {"probs": [0.0, 1.0, 0.0]}, [0, 1, 1, 2]), + ] + ) + def test_method_with_input(self, name, distr_params, value): + distr_params = {k: jnp.asarray(v) for k, v in distr_params.items()} + dist = self.dist(**distr_params) + value = jnp.asarray(value) + for method in [ + "prob", + "log_prob", + "cdf", + "log_cdf", + "survival_function", + "log_survival_function", + ]: + with self.subTest(method=method): + fn = getattr(dist, method) + x = fn(value) + self.assertEqual(value.shape, x.shape) # TODO: test for known solutions + + def test_method_with_input_unnormalized_probs(self): + # We test this case separately because the result of `cdf` and `log_cdf` + # differs from TFP when the input `probs` are not normalized. + + probs = jnp.array( + [0.1, 0.2, 0.3], "float32" + ) # float32 because float64 does pass the latest test (see comment below) + normalized_probs = probs / jnp.sum(probs, axis=-1, keepdims=True) + distr_params = {"probs": jnp.array(probs)} + value = jnp.asarray([0, 1, 2]) + dist = self.dist(**distr_params) + np.testing.assert_allclose(dist.prob(value), normalized_probs, rtol=1e-3) + np.testing.assert_allclose( + dist.log_prob(value), np.log(normalized_probs), rtol=1e-3 + ) + np.testing.assert_allclose( + dist.cdf(value), np.cumsum(normalized_probs), rtol=1e-3 + ) + np.testing.assert_allclose( + dist.log_cdf(value), np.log(np.cumsum(normalized_probs)), atol=5e-5 + ) + np.testing.assert_allclose( + dist.survival_function(value), 1.0 - np.cumsum(normalized_probs), atol=1e-5 + ) + # In the line below, we compare against `jnp` instead of `np` because the + # latter gives `1. - np.cumsum(normalized_probs)[-1] = 1.1e-16` instead of + # `0.`, so its log is innacurate: it gives `-36.7` instead of `-np.inf`. + np.testing.assert_allclose( + dist.log_survival_function(value), + jnp.log(1.0 - jnp.cumsum(normalized_probs)).at[-1].set(-jnp.inf), + atol=1e-5, + ) + + def test_method_with_input_outside_domain(self): + probs = jnp.asarray([0.2, 0.3, 0.5]) + dist = self.dist(probs=probs) + value = jnp.asarray([-1, -2, 3, 4]) + np.testing.assert_allclose( + dist.prob(value), np.asarray([0.0, 0.0, 0.0, 0.0]), atol=1e-5 + ) + self.assertTrue(np.all(dist.log_prob(value) == -jnp.inf)) + np.testing.assert_allclose( + dist.cdf(value), np.asarray([0.0, 0.0, 1.0, 1.0]), atol=1e-5 + ) + np.testing.assert_allclose( + dist.log_cdf(value), np.log(np.asarray([0.0, 0.0, 1.0, 1.0])), rtol=1e-3 + ) + np.testing.assert_allclose( + dist.survival_function(value), np.asarray([1.0, 1.0, 0.0, 0.0]), atol=1e-5 + ) + np.testing.assert_allclose( + dist.log_survival_function(value), + np.log(np.asarray([1.0, 1.0, 0.0, 0.0])), + atol=1e-5, + ) + + @parameterized.expand( + [ + ("2d probs", True), + ("2d logits", False), + ] + ) + def test_method(self, name, from_probs): + rng = np.random.default_rng(42) + probs = rng.uniform(size=(4, 3)) + probs /= np.sum(probs, axis=-1, keepdims=True) + logits = np.log(probs) + distr_params = ( + {"probs": jnp.array(probs)} if from_probs else {"logits": jnp.array(logits)} + ) + dist = self.dist(**distr_params) + for method in ["entropy", "mode"]: + fn = getattr(dist, method) + x = fn() + x_shape = ( + dist.logits.shape + if method == "logits_parameter" + else dist.logits.shape[:-1] + ) + self.assertEqual(x_shape, x.shape) # TODO: test for known solutions + + @parameterized.expand( + [ + ("kl distreqx_to_distreqx", "kl_divergence", "distreqx_to_distreqx"), + ("cross-ent distreqx_to_distreqx", "cross_entropy", "distreqx_to_distreqx"), + ] + ) + def test_with_two_distributions(self, name, function_string, mode_string): + dist1_kwargs = {"probs": jnp.asarray([[0.1, 0.5, 0.4], [0.2, 0.4, 0.4]])} + dist2_kwargs = {"logits": jnp.asarray([0.0, 0.1, 0.1])} + dist1 = self.dist(**dist1_kwargs) + dist2 = self.dist(**dist2_kwargs) + + with self.subTest(method=function_string): + fn = getattr(dist1, function_string) + x = fn(dist2) + self.assertEqual( + dist1.logits.shape[:-1], x.shape + ) # TODO: test for known solutions + + @parameterized.expand( + [ + ("kl distreqx_to_distreqx", "kl_divergence", "distreqx_to_distreqx"), + ("cross-ent distreqx_to_distreqx", "cross_entropy", "distreqx_to_distreqx"), + ] + ) + def test_with_two_distributions_extreme_cases( + self, name, function_string, mode_string + ): + dist1_kwargs = { + "probs": jnp.asarray([[0.1, 0.5, 0.4], [0.4, 0.0, 0.6], [0.4, 0.6, 0.0]]) + } + dist2_kwargs = {"logits": jnp.asarray([0.0, 0.1, -jnp.inf])} + dist1 = self.dist(**dist1_kwargs) + dist2 = self.dist(**dist2_kwargs) + with self.subTest(method=function_string): + fn = getattr(dist1, function_string) + x = fn(dist2) + self.assertEqual( + dist1.logits.shape[:-1], x.shape + ) # TODO: test for known solutions + + @parameterized.expand( + [ + ("kl distreqx_to_distreqx", "kl_divergence"), + ("cross-ent distreqx_to_distreqx", "cross_entropy"), + ] + ) + def test_with_two_distributions_raises_on_invalid_num_categories( + self, name, function_string + ): + probs1 = jnp.asarray([0.1, 0.5, 0.4]) + distreqx_dist1 = self.dist(probs=probs1) + logits2 = jnp.asarray([-0.1, 0.3]) + distreqx_dist2 = self.dist(logits=logits2) + first_fn = getattr(distreqx_dist1, function_string) + with self.assertRaises(ValueError): + _ = first_fn(distreqx_dist2) + second_fn = getattr(distreqx_dist2, function_string) + with self.assertRaises(ValueError): + _ = second_fn(distreqx_dist1) + + def test_jittable(self): + @eqx.filter_jit + def f(dist): + return dist.sample(key=jax.random.PRNGKey(0)) + + dist_params = {"logits": jnp.array([0.0, 4.0, -1.0, 4.0])} + dist = self.dist(**dist_params) + y = f(dist) + self.assertIsInstance(y, jax.Array) + + # TODO: test_slice, test_slice_ellipsis + + def test_vmap_inputs(self): + def log_prob_sum(dist, x): + return dist.log_prob(x).sum() + + dist = self.dist(jnp.arange(3 * 4 * 5).reshape((3, 4, 5))) + x = jnp.zeros((3, 4), jnp.int_) + + with self.subTest("no vmap"): + actual = log_prob_sum(dist, x) + expected = dist.log_prob(x).sum() + np.testing.assert_allclose(actual, expected) + + with self.subTest("axis=0"): + actual = jax.vmap(log_prob_sum, in_axes=0)(dist, x) + expected = dist.log_prob(x).sum(axis=1) + np.testing.assert_allclose(actual, expected) + + with self.subTest("axis=1"): + actual = jax.vmap(log_prob_sum, in_axes=1)(dist, x) + expected = dist.log_prob(x).sum(axis=0) + np.testing.assert_allclose(actual, expected) + + def test_vmap_outputs(self): + def summed_dist(logits): + logits1 = logits.sum(keepdims=True) + logits2 = -logits1 + logits = jnp.concatenate([logits1, logits2], axis=-1) + return self.dist(logits) + + logits = jnp.arange((3 * 4 * 5)).reshape((3, 4, 5)) + actual = jax.vmap(summed_dist)(logits) + + logits1 = logits.sum(axis=(1, 2), keepdims=True) + logits2 = -logits1 + logits = jnp.concatenate([logits1, logits2], axis=-1) + expected = self.dist(logits) + + np.testing.assert_equal(actual.event_shape, expected.event_shape) + + x = jnp.array([[[0]], [[1]], [[0]]], jnp.int_) + np.testing.assert_allclose(actual.log_prob(x), expected.log_prob(x), rtol=1e-6) + + @parameterized.expand( + [ + ("-inf logits", np.array([-jnp.inf, 2, -3, -jnp.inf, 5.0])), + ("uniform large negative logits", np.array([-1e9] * 11)), + ("uniform large positive logits", np.array([1e9] * 11)), + ("uniform", np.array([0.0] * 11)), + ("typical", np.array([1, 7, -3, 2, 4.0])), + ] + ) + def test_entropy_grad(self, name, logits): + clipped_logits = jnp.maximum(-10000, logits) + + def entropy_fn(logits): + return self.dist(logits).entropy() + + entropy, grads = jax.value_and_grad(entropy_fn)(logits) + expected_entropy, expected_grads = jax.value_and_grad(entropy_fn)( + clipped_logits + ) + np.testing.assert_allclose(expected_entropy, entropy, rtol=1e-6) + np.testing.assert_allclose(expected_grads, grads, rtol=1e-6) + self.assertTrue(np.isfinite(entropy).all()) + self.assertTrue(np.isfinite(grads).all()) + + @parameterized.expand( + [ + ( + "-inf logits1", + np.array([-jnp.inf, 2, -3, -jnp.inf, 5.0]), + np.array([1, 7, -3, 2, 4.0]), + ), + ( + "-inf logits both", + np.array([-jnp.inf, 2, -1000, -jnp.inf, 5.0]), + np.array([-jnp.inf, 7, -jnp.inf, 2, 4.0]), + ), + ("typical", np.array([5, -2, 0, 1, 4.0]), np.array([1, 7, -3, 2, 4.0])), + ] + ) + def test_kl_grad(self, name, logits1, logits2): + clipped_logits1 = jnp.maximum(-10000, logits1) + clipped_logits2 = jnp.maximum(-10000, logits2) + + def kl_fn(logits1, logits2): + return self.dist(logits1).kl_divergence(self.dist(logits2)) + + kl, grads = jax.value_and_grad(kl_fn, argnums=(0, 1))(logits1, logits2) + expected_kl, expected_grads = jax.value_and_grad(kl_fn, argnums=(0, 1))( + clipped_logits1, clipped_logits2 + ) + np.testing.assert_allclose(expected_kl, kl, rtol=1e-6) + np.testing.assert_allclose(expected_grads, grads, rtol=1e-6) + self.assertTrue(np.isfinite(kl).all()) + self.assertTrue(np.isfinite(grads).all()) diff --git a/tests/mixture_same_family_test.py b/tests/mixture_same_family_test.py new file mode 100644 index 0000000..f2fbd70 --- /dev/null +++ b/tests/mixture_same_family_test.py @@ -0,0 +1,86 @@ +import unittest + +import equinox as eqx +import jax +import jax.numpy as jnp +from parameterized import parameterized # type: ignore + +from distreqx.distributions import ( + Categorical, + MixtureSameFamily, + MultivariateNormalDiag, +) + + +class MixtureSameFamilyTest(unittest.TestCase): + def setUp(self): + super().setUp() + self.key = jax.random.PRNGKey(0) + self.num_components = 3 + self.logits_shape = (self.num_components,) + self.logits = jax.random.normal(key=self.key, shape=self.logits_shape) + self.probs = jax.nn.softmax(self.logits, axis=-1) + + key_loc, key_scale = jax.random.split(self.key) + self.components_shape = (5,) + self.loc = jax.random.normal( + key=key_loc, shape=self.logits_shape + self.components_shape + ) + self.scale_diag = ( + jax.random.uniform( + key=key_scale, shape=self.logits_shape + self.components_shape + ) + + 0.5 + ) + + def test_event_shape(self): + mixture_dist = Categorical(logits=self.logits) + components_dist = eqx.filter_vmap(MultivariateNormalDiag)( + self.loc, self.scale_diag + ) + dist = MixtureSameFamily( + mixture_distribution=mixture_dist, components_distribution=components_dist + ) + self.assertEqual(dist.event_shape, self.logits_shape + self.components_shape) + + def test_sample_shape(self): + mixture_dist = Categorical(logits=self.logits) + components_dist = eqx.filter_vmap(MultivariateNormalDiag)( + self.loc, self.scale_diag + ) + dist = MixtureSameFamily( + mixture_distribution=mixture_dist, components_distribution=components_dist + ) + samples = dist.sample(self.key) + self.assertEqual(samples.shape, self.components_shape) + + @parameterized.expand( + [ + ("mean", "mean"), + ("variance", "variance"), + ("stddev", "stddev"), + ] + ) + def test_method(self, name, method_name): + mixture_dist = Categorical(logits=self.logits) + components_dist = eqx.filter_vmap(MultivariateNormalDiag)( + self.loc, self.scale_diag + ) + dist = MixtureSameFamily( + mixture_distribution=mixture_dist, components_distribution=components_dist + ) + method = getattr(dist, method_name) + result = method() + self.assertIsInstance(result, jnp.ndarray) + + def test_jittable(self): + mixture_dist = Categorical(logits=self.logits) + components_dist = eqx.filter_vmap(MultivariateNormalDiag)( + self.loc, self.scale_diag + ) + dist = MixtureSameFamily( + mixture_distribution=mixture_dist, components_distribution=components_dist + ) + sample_fn = lambda x: dist.sample(x) + sample = jax.jit(sample_fn)(self.key) + self.assertIsInstance(sample, jnp.ndarray)