From c1d50c319a701c11ba3d40c90c11e7987c2dcc47 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 1 Dec 2020 23:00:44 -0600 Subject: [PATCH 001/222] expose potential_fn_gen (#831) --- numpyro/infer/hmc.py | 2 ++ numpyro/infer/sa.py | 2 ++ 2 files changed, 4 insertions(+) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 965509e16..1db4c93fb 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -399,6 +399,7 @@ def __init__(self, self._find_heuristic_step_size = find_heuristic_step_size # Set on first call to init self._init_fn = None + self._potential_fn_gen = None self._postprocess_fn = None self._sample_fn = None @@ -415,6 +416,7 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): self._init_fn, self._sample_fn = hmc(potential_fn_gen=potential_fn, kinetic_fn=self._kinetic_fn, algo=self._algo) + self._potential_fn_gen = potential_fn self._postprocess_fn = postprocess_fn elif self._init_fn is None: self._init_fn, self._sample_fn = hmc(potential_fn=self._potential_fn, diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index 2e61c7574..b229089ab 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -243,6 +243,7 @@ def __init__(self, model=None, potential_fn=None, adapt_state_size=None, self._dense_mass = dense_mass self._init_strategy = init_strategy self._init_fn = None + self._potential_fn_gen = None self._postprocess_fn = None self._sample_fn = None @@ -258,6 +259,7 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): init_params = init_params[0] # NB: init args is different from HMC self._init_fn, sample_fn = _sa(potential_fn_gen=potential_fn) + self._potential_fn_gen = potential_fn if self._postprocess_fn is None: self._postprocess_fn = postprocess_fn else: From b0fa27b04912e5e0caf7cd90027a8522ce7d1a84 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 2 Dec 2020 00:12:00 -0600 Subject: [PATCH 002/222] Fix a bug at MCMC.print_summary (#821) --- numpyro/contrib/tfp/distributions.py | 2 +- numpyro/distributions/transforms.py | 6 ++--- numpyro/distributions/util.py | 3 +-- numpyro/handlers.py | 10 ++++++--- numpyro/infer/mcmc.py | 33 ++++++++++++++++++++-------- 5 files changed, 36 insertions(+), 18 deletions(-) diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index 3e3055a2a..3d198328d 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -24,7 +24,7 @@ def _get_codomain(bijector): return constraints.positive elif bijector.__class__.__name__ == "GeneralizedPareto": loc, scale, concentration = bijector.loc, bijector.scale, bijector.concentration - if not_jax_tracer(concentration) and np.all(concentration < 0): + if not_jax_tracer(concentration) and np.all(np.less(concentration, 0)): return constraints.interval(loc, loc + scale / jnp.abs(concentration)) # XXX: here we suppose concentration > 0 # which is not true in general, but should cover enough usage cases diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 82facf7c9..073913629 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -98,19 +98,19 @@ def codomain(self): elif self.domain is constraints.real_vector: return constraints.real_vector elif isinstance(self.domain, constraints.greater_than): - if not_jax_tracer(self.scale) and np.all(self.scale < 0): + if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)): return constraints.less_than(self(self.domain.lower_bound)) # we suppose scale > 0 for any tracer else: return constraints.greater_than(self(self.domain.lower_bound)) elif isinstance(self.domain, constraints.less_than): - if not_jax_tracer(self.scale) and np.all(self.scale < 0): + if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)): return constraints.greater_than(self(self.domain.upper_bound)) # we suppose scale > 0 for any tracer else: return constraints.less_than(self(self.domain.upper_bound)) elif isinstance(self.domain, constraints.interval): - if not_jax_tracer(self.scale) and np.all(self.scale < 0): + if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)): return constraints.interval(self(self.domain.upper_bound), self(self.domain.lower_bound)) else: diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index 9c87f1438..45a0b4934 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -329,8 +329,7 @@ def signed_stick_breaking_tril(t): # we omit the step of computing s = z * z_cumprod by using the fact: # y = sign(r) * s = sign(r) * sqrt(z * z_cumprod) = r * sqrt(z_cumprod) z = r ** 2 - z1m_cumprod = jnp.cumprod(1 - z, axis=-1) - z1m_cumprod_sqrt = jnp.sqrt(z1m_cumprod) + z1m_cumprod_sqrt = jnp.cumprod(jnp.sqrt(1 - z), axis=-1) pad_width = [(0, 0)] * z.ndim pad_width[-1] = (1, 0) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index c5c00b909..44603f983 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -79,6 +79,8 @@ from collections import OrderedDict import warnings +import numpy as np + from jax import lax, random import jax.numpy as jnp @@ -524,12 +526,14 @@ class scale(Messenger): This is typically used for data subsampling or for stratified sampling of data (e.g. in fraud detection where negatives vastly outnumber positives). - :param float scale: a positive scaling factor + :param scale: a positive scaling factor that is broadcastable to the shape + of log probability. + :type scale: float or numpy.ndarray """ def __init__(self, fn=None, scale=1.): if not_jax_tracer(scale): - if scale <= 0: - raise ValueError("'scale' argument should be a positive number.") + if np.any(np.less_equal(scale, 0)): + raise ValueError("'scale' argument should be positive.") self.scale = scale super().__init__(fn) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index dfe0155a6..9470ec966 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -39,10 +39,10 @@ class MCMCKernel(ABC): >>> import numpyro.distributions as dist >>> from numpyro.infer import MCMC - >>> MHState = namedtuple("MHState", ["z", "rng_key"]) + >>> MHState = namedtuple("MHState", ["u", "rng_key"]) >>> class MetropolisHastings(numpyro.infer.mcmc.MCMCKernel): - ... sample_field = "z" + ... sample_field = "u" ... ... def __init__(self, potential_fn, step_size=0.1): ... self.potential_fn = potential_fn @@ -52,12 +52,12 @@ class MCMCKernel(ABC): ... return MHState(init_params, rng_key) ... ... def sample(self, state, model_args, model_kwargs): - ... z, rng_key = state + ... u, rng_key = state ... rng_key, key_proposal, key_accept = random.split(rng_key, 3) - ... z_proposal = dist.Normal(z, self.step_size).sample(key_proposal) - ... accept_prob = jnp.exp(self.potential_fn(z) - self.potential_fn(z_proposal)) - ... z_new = jnp.where(dist.Uniform().sample(key_accept) < accept_prob, z_proposal, z) - ... return MHState(z_new, rng_key) + ... u_proposal = dist.Normal(u, self.step_size).sample(key_proposal) + ... accept_prob = jnp.exp(self.potential_fn(u) - self.potential_fn(u_proposal)) + ... u_new = jnp.where(dist.Uniform().sample(key_accept) < accept_prob, u_proposal, u) + ... return MHState(u_new, rng_key) >>> def f(x): ... return ((x - 2) ** 2).sum() @@ -66,6 +66,7 @@ class MCMCKernel(ABC): >>> mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000) >>> mcmc.run(random.PRNGKey(0), init_params=jnp.array([1., 2.])) >>> samples = mcmc.get_samples() + >>> mcmc.print_summary() # doctest: +SKIP """ def postprocess_fn(self, model_args, model_kwargs): """ @@ -491,11 +492,25 @@ def get_extra_fields(self, group_by_chain=False): return {k: v for k, v in states.items() if k != self._sample_field} def print_summary(self, prob=0.9, exclude_deterministic=True): + """ + Print the statistics of posterior samples collected during running this MCMC instance. + + :param float prob: the probability mass of samples within the credible interval. + :param bool exclude_deterministic: whether or not print out the statistics + at deterministic sites. + """ # Exclude deterministic sites by default sites = self._states[self._sample_field] if isinstance(sites, dict) and exclude_deterministic: - sites = {k: v for k, v in self._states[self._sample_field].items() - if k in self._last_state.z} + state_sample_field = attrgetter(self._sample_field)(self._last_state) + # XXX: there might be the case that state.z is not a dictionary but + # its postprocessed value `sites` is a dictionary. + # TODO: in general, when both `sites` and `state.z` are dictionaries, + # they can have different key names, not necessary due to deterministic + # behavior. We might revise this logic if needed in the future. + if isinstance(state_sample_field, dict): + sites = {k: v for k, v in self._states[self._sample_field].items() + if k in state_sample_field} print_summary(sites, prob=prob) extra_fields = self.get_extra_fields() if 'diverging' in extra_fields: From e06d0e0ccee60f44c8f44e2c5cb0a1fcc7fe33f6 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 2 Dec 2020 15:35:45 -0600 Subject: [PATCH 003/222] Allow a callable to return an init value in param primitive (#832) --- numpyro/infer/svi.py | 3 ++- numpyro/primitives.py | 22 ++++++++++++++++------ test/test_svi.py | 4 ++-- 3 files changed, 20 insertions(+), 9 deletions(-) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 6738d45a1..66970ea4f 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -60,7 +60,8 @@ class SVI(object): >>> def guide(data): ... alpha_q = numpyro.param("alpha_q", 15., constraint=constraints.positive) - ... beta_q = numpyro.param("beta_q", 15., constraint=constraints.positive) + ... beta_q = numpyro.param("beta_q", lambda rng_key: random.exponential(rng_key), + ... constraint=constraints.positive) ... numpyro.sample("latent_fairness", dist.Beta(alpha_q, beta_q)) >>> data = jnp.concatenate([jnp.ones(6), jnp.zeros(4)]) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 4dfd8c109..acc94fd39 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -130,13 +130,15 @@ def param(name, init_value=None, **kwargs): """ Annotate the given site as an optimizable parameter for use with :mod:`jax.experimental.optimizers`. For an example of how `param` statements - can be used in inference algorithms, refer to :func:`~numpyro.svi.svi`. + can be used in inference algorithms, refer to :class:`~numpyro.infer.SVI`. :param str name: name of site. - :param numpy.ndarray init_value: initial value specified by the user. Note that - the onus of using this to initialize the optimizer is on the user / - inference algorithm, since there is no global parameter store in - NumPyro. + :param init_value: initial value specified by the user or a lazy callable + that accepts a JAX random PRNGKey and returns an array. + Note that the onus of using this to initialize the optimizer is + on the user inference algorithm, since there is no global parameter + store in NumPyro. + :type init_value: numpy.ndarray or callable :param constraint: NumPyro constraint, defaults to ``constraints.real``. :type constraint: numpyro.distributions.constraints.Constraint :param int event_dim: (optional) number of rightmost dimensions unrelated @@ -151,13 +153,21 @@ def param(name, init_value=None, **kwargs): """ # if there are no active Messengers, we just draw a sample and return it as expected: if not _PYRO_STACK: + assert not callable(init_value), \ + "A callable init_value needs to be put inside a numpyro.handlers.seed handler." return init_value + if callable(init_value): + def fn(init_fn, *args, **kwargs): + return init_fn(prng_key()) + else: + fn = identity + # Otherwise, we initialize a message... initial_msg = { 'type': 'param', 'name': name, - 'fn': identity, + 'fn': fn, 'args': (init_value,), 'kwargs': kwargs, 'value': None, diff --git a/test/test_svi.py b/test/test_svi.py index 480ee40b9..34912a781 100644 --- a/test/test_svi.py +++ b/test/test_svi.py @@ -79,9 +79,9 @@ def model(data): numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): - alpha_q = numpyro.param("alpha_q", 1.0, + alpha_q = numpyro.param("alpha_q", lambda key: random.normal(key), constraint=constraints.positive) - beta_q = numpyro.param("beta_q", 1.0, + beta_q = numpyro.param("beta_q", lambda key: random.exponential(key), constraint=constraints.positive) numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) From 08c4bfe0d1637fece8ef96d7090ee055d6bfdcd9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Thu, 10 Dec 2020 07:28:19 +0100 Subject: [PATCH 004/222] Kernels module for stein VI (#828) * added kernels module for stein VI * fixed whitespaces * FIXED: style * Fixed docstring for kernels module. * Moved utils functions for stein kernels into stein dedicated file. * Added last formulas for stein kernels. * Added docstring for SteinKernel.compute return, add skeleton for testing einstein/kernels, and removed .const cast to array in IMQKernel. * Added shape tests and fixed docstrings. * Removed unused imports * Added kernel values. * Fixed docstring and added test case for precond kernel. * Cleaned up. * Added comments to utils. * Fixed last test and added docstring for utils. --- numpyro/distributions/directional.py | 6 +- numpyro/infer/einstein/__init__.py | 0 numpyro/infer/einstein/kernels.py | 388 +++++++++++++++++++++++++++ numpyro/infer/einstein/utils.py | 37 +++ test/test_einstein_kernels.py | 83 ++++++ 5 files changed, 511 insertions(+), 3 deletions(-) create mode 100644 numpyro/infer/einstein/__init__.py create mode 100644 numpyro/infer/einstein/kernels.py create mode 100644 numpyro/infer/einstein/utils.py create mode 100644 test/test_einstein_kernels.py diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index 5f45ff417..a1cba2b70 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -32,9 +32,9 @@ def __init__(self, loc, concentration, validate_args=None): def sample(self, key, sample_shape=()): """ Generate sample from von Mises distribution - :param sample_shape: shape of samples - :param key: random number generator key - :return: samples from von Mises + :param key: random number generator key + :param sample_shape: shape of samples + :return: samples from von Mises """ assert is_prng_key(key) samples = von_mises_centered(key, self.concentration, sample_shape + self.shape()) diff --git a/numpyro/infer/einstein/__init__.py b/numpyro/infer/einstein/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/numpyro/infer/einstein/kernels.py b/numpyro/infer/einstein/kernels.py new file mode 100644 index 000000000..692556ab1 --- /dev/null +++ b/numpyro/infer/einstein/kernels.py @@ -0,0 +1,388 @@ +from abc import ABC, abstractmethod +from typing import Callable, List, Dict, Tuple + +import jax.numpy as jnp +import jax.scipy.linalg +import jax.scipy.stats +import numpy as np +import numpy.random as npr + +import numpyro.distributions as dist +from numpyro.infer.einstein.utils import sqrth, posdef, safe_norm + + +class PrecondMatrix(ABC): + @abstractmethod + def compute(self, particles: jnp.ndarray, loss_fn: Callable[[jnp.ndarray], float]): + """ + Computes a preconditioning matrix for a given set of particles and a loss function + + :param particles: The Stein particles to compute the preconditioning matrix from + :param loss_fn: Loss function given particles + """ + raise NotImplementedError + + +class SteinKernel(ABC): + @property + @abstractmethod + def mode(self): + """ + Returns the type of kernel, either 'norm' or 'vector' or 'matrix'. + """ + raise NotImplementedError + + @abstractmethod + def compute(self, particles: jnp.ndarray, particle_info: Dict[str, Tuple[int, int]], + loss_fn: Callable[[jnp.ndarray], float]): + """ + Computes the kernel function given the input Stein particles + + :param particles: The Stein particles to compute the kernel from + :param particle_info: A mapping from parameter names to the position in the particle matrix + :param loss_fn: Loss function given particles + :return: The kernel_fn to compute kernel for pair of particles. + Modes: norm `(d,) (d,)-> ()`, vector `(d,) (d,) -> (d)`, or matrix `(d,) (d,) -> (d,d)` + """ + raise NotImplementedError + + +class RBFKernel(SteinKernel): + """ + Calculates the Gaussian RBF kernel function, from [1], + :math: `k(x,y) = \\exp(\\frac{1}{h} \\|x-y\\|^2)`, + where the bandwidth h is computed using the median heuristic + :math: `h = \\frac{1}{\\log(n)} \\med(\\|x-y\\|)`. + + ** References: ** + 1. *Stein Variational Gradient Descent* Liu and Wang + + :param str mode: Either 'norm' (default) specifying to take the norm of each particle, 'vector' to return a + component-wise kernel or 'matrix' to return a matrix-valued kernel + :param str matrix_mode: Either 'norm_diag' (default) for diagonal filled with the norm kernel or 'vector_diag' + for diagonal of vector-valued kernel + :param bandwidth_factor: A multiplier to the bandwidth based on data size n (default 1/log(n)) + """ + + def __init__(self, mode='norm', matrix_mode='norm_diag', + bandwidth_factor: Callable[[float], float] = lambda n: 1 / jnp.log(n)): + assert mode == 'norm' or mode == 'vector' or mode == 'matrix' + assert matrix_mode == 'norm_diag' or matrix_mode == 'vector_diag' + self._mode = mode + self.matrix_mode = matrix_mode + self.bandwidth_factor = bandwidth_factor + + def _normed(self): + return self._mode == 'norm' or (self.mode == 'matrix' and self.matrix_mode == 'norm_diag') + + def compute(self, particles, particle_info, loss_fn): + diffs = jnp.expand_dims(particles, axis=0) - jnp.expand_dims(particles, axis=1) # N x N (x D) + if self._normed() and particles.ndim == 2: + diffs = safe_norm(diffs, ord=2, axis=-1) # N x D -> N + diffs = jnp.reshape(diffs, (diffs.shape[0] * diffs.shape[1], -1)) # N * N (x D) + factor = self.bandwidth_factor(particles.shape[0]) + if diffs.ndim == 2: + diff_norms = safe_norm(diffs, ord=2, axis=-1) + else: + diff_norms = diffs + median = jnp.argsort(diff_norms)[int(diffs.shape[0] / 2)] + bandwidth = jnp.abs(diffs)[median] ** 2 * factor + 1e-5 + if self._normed(): + bandwidth = bandwidth[0] + + def kernel(x, y): + diff = safe_norm(x - y, ord=2) if self._normed() and x.ndim >= 1 else x - y + kernel_res = jnp.exp(- diff ** 2 / bandwidth) + if self._mode == 'matrix': + if self.matrix_mode == 'norm_diag': + return kernel_res * jnp.identity(x.shape[0]) + else: + return jnp.diag(kernel_res) + else: + return kernel_res + + return kernel + + @property + def mode(self): + return self._mode + + +class IMQKernel(SteinKernel): + """ + Calculates the IMQ kernel + :math:`k(x,y) = (c^2 + \\|x+y\\|^2_2)^{\\beta},` + from [1]. + + ** References: ** + 1. *Measuring Sample Quality with Kernels* by Gorham and Mackey + + :param str mode: Either 'norm' (default) specifying to take the norm of each particle, + or 'vector' to return a component-wise kernel + :param float const: Positive multi-quadratic constant (c) + :param float expon: Inverse exponent (beta) between (-1, 0) + """ + + def __init__(self, mode='norm', const=1.0, expon=-0.5): + assert mode == 'norm' or mode == 'vector' + assert 0.0 < const + assert -1.0 < expon < 0.0 + self._mode = mode + self.const = const + self.expon = expon + + @property + def mode(self): + return self._mode + + def compute(self, particles, particle_info, loss_fn): + def kernel(x, y): + diff = safe_norm(x - y, ord=2, axis=-1) if self._mode == 'norm' else x - y + return (self.const ** 2 + diff ** 2) ** self.expon + + return kernel + + +class LinearKernel(SteinKernel): + """ + Calculates the linear kernel + :math: `k(x,y) = x \\cdot y + 1` + from [1]. + + ** References ** + 1. Stein Variational Gradient Descent as Moment Matching" by Liu and Wang + """ + + def __init__(self, mode='norm'): + assert mode == 'norm' + self._mode = 'norm' + + @property + def mode(self): + return self._mode + + def compute(self, particles: jnp.ndarray, particle_info, loss_fn): + def kernel(x, y): + if x.ndim == 1: + return x @ y + 1 + else: + return x * y + 1 + + return kernel + + +class RandomFeatureKernel(SteinKernel): + """ + Calculates the random kernel + :math:`k(x,y)= 1/m\\sum_{l=1}^{m}\\phi(x,w_l)\\phi(y,w_l), + from [1]. + + + ** References: ** + 1. *Stein Variational Gradient Descent as Moment Matching* by Liu and Wang + + :param bandwidth_subset: How many particles should be used to calculate the bandwidth? + (default None, meaning all particles) + :param random_indices: The set of indices which to do random feature expansion on. + (default None, meaning all indices) + :param bandwidth_factor: A multiplier to the bandwidth based on data size n (default 1/log(n)) + + """ + + def __init__(self, mode='norm', bandwidth_subset=None, random_indices=None, + bandwidth_factor: Callable[[float], float] = lambda n: 1 / jnp.log(n)): + assert bandwidth_subset is None or bandwidth_subset > 0 + assert mode == 'norm' + self._mode = 'norm' + self.bandwidth_subset = bandwidth_subset + self.random_indices = None + self.bandwidth_factor = bandwidth_factor + self._random_weights = None + self._random_biases = None + + @property + def mode(self): + return self._mode + + def compute(self, particles, particle_info, loss_fn): + if self._random_weights is None: + self._random_weights = jnp.array(npr.randn(*particles.shape)) + self._random_biases = jnp.array(npr.rand(*particles.shape) * 2 * np.pi) + factor = self.bandwidth_factor(particles.shape[0]) + if self.bandwidth_subset is not None: + particles = particles[npr.choice(particles.shape[0], self.bandwidth_subset)] + diffs = jnp.expand_dims(particles, axis=0) - jnp.expand_dims(particles, axis=1) # N x N x D + if particles.ndim == 2: + diffs = safe_norm(diffs, ord=2, axis=-1) # N x N x D -> N x N + diffs = jnp.reshape(diffs, (diffs.shape[0] * diffs.shape[1], -1)) # N * N x 1 + if diffs.ndim == 2: + diff_norms = safe_norm(diffs, ord=2, axis=-1) + else: + diff_norms = diffs + median = jnp.argsort(diff_norms)[int(diffs.shape[0] / 2)] + bandwidth = jnp.abs(diffs)[median] ** 2 * factor + 1e-5 + + def feature(x, w, b): + return jnp.sqrt(2) * jnp.cos((x @ w + b) / bandwidth) + + def kernel(x, y): + ws = self._random_weights if self.random_indices is None else self._random_weights[self.random_indices] + bs = self._random_biases if self.random_indices is None else self._random_biases[self.random_indices] + return jnp.sum(jax.vmap(lambda w, b: feature(x, w, b) * feature(y, w, b))(ws, bs)) + + return kernel + + +class MixtureKernel(SteinKernel): + """ + Calculates a mixture of multiple kernels + :math: `k(x,y) = \\sum_i w_ik_i(x,y)` + + ** Reference ** + 1. *Stein Variational Gradient Descent as Moment Matching* by Liu and Wang + + :param ws: Weight of each kernel in the mixture + :param kernel_fns: Different kernel functions to mix together + """ + + def __init__(self, ws: List[float], kernel_fns: List[SteinKernel], mode='norm', ): + assert len(ws) == len(kernel_fns) + assert len(kernel_fns) > 1 + assert all(kf.mode == mode for kf in kernel_fns) + self.ws = ws + self.kernel_fns = kernel_fns + + @property + def mode(self): + return self.kernel_fns[0].mode + + def compute(self, particles, particle_info, loss_fn): + kernels = [kf.compute(particles, particle_info, loss_fn) for kf in self.kernel_fns] + + def kernel(x, y): + res = self.ws[0] * kernels[0](x, y) + for w, k in zip(self.ws[1:], kernels[1:]): + res = res + w * k(x, y) + return res + + return kernel + + +class HessianPrecondMatrix(PrecondMatrix): + """ + Calculates the constant precondition matrix based on the negative Hessian of the loss from [1]. + + ** References: ** + 1. *Stein Variational Gradient Descent with Matrix-Valued Kernels* by Wang, Tang, Bajaj and Liu + """ + + def compute(self, particles, loss_fn): + hessian = -jax.vmap(jax.hessian(loss_fn))(particles) + return hessian + + +class PrecondMatrixKernel(SteinKernel): + """ + Calculates the const preconditioned kernel + :math: `k(x,y) = Q^{-\\frac{1}{2}}k(Q^{\\frac{1}{2}}x, Q^{\\frac{1}{2}}y)Q^{-\\frac{1}{2}},` + or anchor point preconditioned kernel + :math: `k(x,y) = \\sum_{l=1}^m k_{Q_l}(x,y)w_l(x)w_l(y)` + both from [1]. + + ** References: ** + 1. "Stein Variational Gradient Descent with Matrix-Valued Kernels" by Wang, Tang, Bajaj and Liu + + :param precond_matrix_fn: The constant preconditioning matrix + :param inner_kernel_fn: The inner kernel function + :param precond_mode: How to use the precondition matrix, either constant ('const') + or as mixture with anchor points ('anchor_points') + """ + + def __init__(self, precond_matrix_fn: PrecondMatrix, inner_kernel_fn: SteinKernel, + precond_mode='anchor_points'): + assert inner_kernel_fn.mode == 'matrix' + assert precond_mode == 'const' or precond_mode == 'anchor_points' + self.precond_matrix_fn = precond_matrix_fn + self.inner_kernel_fn = inner_kernel_fn + self.precond_mode = precond_mode + + @property + def mode(self): + return 'matrix' + + def compute(self, particles, particle_info, loss_fn): + qs = self.precond_matrix_fn.compute(particles, loss_fn) + if self.precond_mode == 'const': + qs = jnp.expand_dims(jnp.mean(qs, axis=0), axis=0) + qs_inv = jnp.linalg.inv(qs) + qs_sqrt = sqrth(qs) + qs_inv_sqrt = sqrth(qs_inv) + inner_kernel = self.inner_kernel_fn.compute(particles, particle_info, loss_fn) + + def kernel(x, y): + if self.precond_mode == 'const': + wxs = jnp.array([1.]) + wys = jnp.array([1.]) + else: + wxs = jax.nn.softmax( + jax.vmap(lambda z, q_inv: dist.MultivariateNormal(z, posdef(q_inv)).log_prob(x))(particles, qs_inv)) + wys = jax.nn.softmax( + jax.vmap(lambda z, q_inv: dist.MultivariateNormal(z, posdef(q_inv)).log_prob(y))(particles, qs_inv)) + return jnp.sum( + jax.vmap(lambda qs, qis, wx, wy: wx * wy * (qis @ inner_kernel(qs @ x, qs @ y) @ qis.transpose()))( + qs_sqrt, qs_inv_sqrt, wxs, wys), axis=0) + + return kernel + + +class GraphicalKernel(SteinKernel): + """ + Calculates graphical kernel + :math: `k(x,y) = diag({K^(l)(x,y)}_l) + from [1]. + + ** References: ** + 1. *Stein Variational Message Passing for Continuous Graphical Models* by Wang, Zheng and Liu + + :param local_kernel_fns: A mapping between parameters and a choice of kernel function for that parameter + (default to default_kernel_fn for each parameter) + :param default_kernel_fn: The default choice of kernel function when none is specified for a particular parameter + """ + + def __init__(self, mode='matrix', local_kernel_fns: Dict[str, SteinKernel] = None, + default_kernel_fn: SteinKernel = RBFKernel()): + assert mode == 'matrix' + + self.local_kernel_fns = local_kernel_fns if local_kernel_fns is not None else {} + self.default_kernel_fn = default_kernel_fn + + @property + def mode(self): + return 'matrix' + + def compute(self, particles, particle_info, loss_fn): + def pk_loss_fn(start, end): + def fn(ps): + return loss_fn(jnp.concatenate([particles[:, :start], ps, particles[:, end:]], axis=-1)) + + return fn + + local_kernels = [] + for pk, (start_idx, end_idx) in particle_info.items(): + pk_kernel_fn = self.local_kernel_fns.get(pk, self.default_kernel_fn) + pk_kernel = pk_kernel_fn.compute(particles[:, start_idx:end_idx], {pk: (0, end_idx - start_idx)}, + pk_loss_fn(start_idx, end_idx)) + local_kernels.append((pk_kernel, pk_kernel_fn.mode, start_idx, end_idx)) + + def kernel(x, y): + kernel_res = [] + for kernel, mode, start_idx, end_idx in local_kernels: + v = kernel(x[start_idx:end_idx], y[start_idx:end_idx]) + if mode == 'norm': + v = v * jnp.identity(end_idx - start_idx) + elif mode == 'vector': + v = jnp.diag(v) + kernel_res.append(v) + return jax.scipy.linalg.block_diag(*kernel_res) + + return kernel diff --git a/numpyro/infer/einstein/utils.py b/numpyro/infer/einstein/utils.py new file mode 100644 index 000000000..ad57a8570 --- /dev/null +++ b/numpyro/infer/einstein/utils.py @@ -0,0 +1,37 @@ +import jax +import jax.numpy as jnp + + +def posdef(m): + """ Map a matrix to a positive definite matrix, where all eigenvalues are >= 1e-5. """ + mlambda, mvec = jnp.linalg.eigh(m) + if jnp.ndim(mlambda) >= 2: + mlambda = jax.vmap(lambda ml: jnp.diag(jnp.maximum(ml, 1e-5)), in_axes=tuple(range(jnp.ndim(mlambda) - 1)))( + mlambda) + else: + mlambda = jnp.diag(jnp.maximum(mlambda, 1e-5)) + return mvec @ mlambda @ jnp.swapaxes(mvec, -2, -1) + + +def sqrth(m): + """ Map a matrix to a positive definite matrix and square root it. """ + mlambda, mvec = jnp.linalg.eigh(m) + if jnp.ndim(mlambda) >= 2: + mlambdasqrt = jax.vmap(lambda ml: jnp.diag(jnp.maximum(ml, 1e-5) ** 0.5), + in_axes=tuple(range(jnp.ndim(mlambda) - 1)))(mlambda) + msqrt = mvec @ mlambdasqrt @ jnp.swapaxes(mvec, -2, -1) + else: + mlambdasqrt = jnp.diag(jnp.maximum(mlambda, 1e-5) ** 0.5) + msqrt = mvec * mlambdasqrt * jnp.swapaxes(mvec, -2, -1) + + return msqrt + + +def safe_norm(a, ord=2, axis=None): + if axis is not None: + is_zero = jnp.expand_dims(jnp.isclose(jnp.sum(a, axis=axis), 0.), axis=axis) + else: + is_zero = jnp.ones_like(a, dtype='bool') + norm = jnp.linalg.norm(a + jnp.where(is_zero, jnp.ones_like(a) * 1e-5 ** ord, jnp.zeros_like(a)), ord=ord, + axis=axis) + return norm diff --git a/test/test_einstein_kernels.py b/test/test_einstein_kernels.py new file mode 100644 index 000000000..540243945 --- /dev/null +++ b/test/test_einstein_kernels.py @@ -0,0 +1,83 @@ +from collections import namedtuple + +import jax.numpy as jnp +import pytest +from numpy.testing import assert_allclose + +from numpyro.infer.einstein.kernels import ( + RBFKernel, + RandomFeatureKernel, + GraphicalKernel, + IMQKernel, + LinearKernel, + MixtureKernel, + HessianPrecondMatrix, + PrecondMatrixKernel +) + +T = namedtuple('TestSteinKernel', ['kernel', 'particle_info', 'loss_fn', 'kval']) + +PARTICLES_2D = jnp.array([[1., 2.], [-10., 10.], [0., 0.], [2., -1]]) + +TPARTICLES_2D = (jnp.array([1., 2.]), jnp.array([10., 5.])) # transformed particles + +TEST_CASES = [ + T(RBFKernel, + lambda d: {}, + lambda x: x, + {'norm': 3.8147664e-06, + 'vector': jnp.array([0., 0.2500005]), + 'matrix': jnp.array([[3.8147664e-06, 0.], + [0., 3.8147664e-06]])} + ), + T(RandomFeatureKernel, + lambda d: {}, + lambda x: x, + {'norm': -4.566867}), + T(IMQKernel, + lambda d: {}, + lambda x: x, + {'norm': .104828484, + 'vector': jnp.array([0.11043153, 0.31622776])} + ), + T(LinearKernel, + lambda d: {}, + lambda x: x, + {'norm': 21.} + ), + T(lambda mode: MixtureKernel(mode=mode, ws=jnp.array([.2, .8]), kernel_fns=[RBFKernel(mode), RBFKernel(mode)]), + lambda d: {}, + lambda x: x, + {'matrix': jnp.array([[3.8147664e-06, 0.], + [0., 3.8147664e-06]])} + ), + T(lambda mode: GraphicalKernel(mode=mode, local_kernel_fns={'p1': RBFKernel('norm')}), + lambda d: {'p1': (0, d)}, + lambda x: x, + {'matrix': jnp.array([[3.8147664e-06, 0.], + [0., 3.8147664e-06]])} + ), + T(lambda mode: PrecondMatrixKernel(HessianPrecondMatrix(), RBFKernel(mode='matrix')), + lambda d: {}, + lambda x: x[0] ** 4 - x[1] ** 3 / 2, + {'matrix': jnp.array([[5.608312e-09, 0.], + [0., 9.347186e-05]])} + ) +] + +PARTICLES = [(PARTICLES_2D, TPARTICLES_2D)] + +TEST_IDS = [t[0].__class__.__name__ for t in TEST_CASES] + + +@pytest.mark.parametrize('kernel, particle_info, loss_fn, kval', TEST_CASES, ids=TEST_IDS) +@pytest.mark.parametrize('particles, tparticles', PARTICLES) +@pytest.mark.parametrize('mode', ['norm', 'vector', 'matrix']) +def test_kernel_forward(kernel, particles, particle_info, loss_fn, tparticles, mode, kval): + if mode not in kval: + return + d, = tparticles[0].shape + kernel_fn = kernel(mode=mode).compute(particles, particle_info(d), loss_fn) + value = kernel_fn(*tparticles) + + assert_allclose(value, kval[mode]) From c48f7b1cc3b03d1dedeaf360073124738a87dddc Mon Sep 17 00:00:00 2001 From: Armin Stepanjan Date: Tue, 15 Dec 2020 00:38:14 +0000 Subject: [PATCH 005/222] Create CONTRIBUTING.md (#840) * Create CONTRIBUTING.md * Incorporate changes suggested in review. * Create readme for docs * Set code block language --- CONTRIBUTING.md | 59 +++++++++++++++++++++++++++++++++++++++++++++++++ docs/README.md | 19 ++++++++++++++++ 2 files changed, 78 insertions(+) create mode 100644 CONTRIBUTING.md create mode 100644 docs/README.md diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md new file mode 100644 index 000000000..563fda9a7 --- /dev/null +++ b/CONTRIBUTING.md @@ -0,0 +1,59 @@ +# Development + +Please follow our established coding style including variable names, module imports, and function definitions. +The NumPyro codebase follows the [PEP8 style guide](https://www.python.org/dev/peps/pep-0008/) +(which you can check with `make lint`) and follows +[`isort`](https://github.com/timothycrosley/isort) import order (which you can enforce with `make format`). + +# Setup + +To set up local development environment, install NumPyro from source: + +```sh +git clone https://github.com/pyro-ppl/numpyro.git +# install jax/jaxlib first for CUDA support +pip install -e .[dev] # contains additional dependencies for NumPyro development +``` + +# Testing + +Before submitting a pull request, please autoformat code and ensure that unit tests pass locally +```sh +make format # runs isort +make test # linting and unit tests +make doctest # test module's docstrings +``` + +To run all tests locally in parallel, use the `pytest-xdist` package +```sh +pip install pytest-xdist +pytest -vs -n auto +``` + +To run a single test from the command line +```sh +pytest -vs {path_to_test}::{test_name} +# or in cuda mode and double precision +JAX_PLATFORM_NAME=gpu JAX_ENABLE_X64=1 pytest -vs {path_to_test}::{test_name} +``` + +# Profiling + +TensorBoard can be used to profile NumPyro following the instructions following [JAX documentation](https://jax.readthedocs.io/en/latest/profiling.html). + +# Submitting + +For relevant design questions to consider, see past [design documents](https://github.com/pyro-ppl/pyro/wiki/Design-Docs). + +For larger changes, please open an issue for discussion before submitting a pull request. + +In your PR, please include: +- Changes made +- Links to related issues/PRs +- Tests +- Dependencies + +If you add new files, please run `make license` to automatically add copyright headers. + +For speculative changes meant for early-stage review, include `[WIP]` in the PR's title. +(One of the maintainers will add the `WIP` tag.) diff --git a/docs/README.md b/docs/README.md new file mode 100644 index 000000000..51225778f --- /dev/null +++ b/docs/README.md @@ -0,0 +1,19 @@ +# Documentation + +Pyro Documentation is supported by [Sphinx](http://www.sphinx-doc.org/en/stable/). +To build the docs, run from the toplevel directory: +``` +make docs +``` + +## Installation ## +``` +pip install -r requirements.txt +``` + +## Workflow ## +To change the documentation, update the `*.rst` files in `source`. + +To build the docstrings, `sphinx-apidoc [options] -o [exclude_pattern, ...]` + +To build the html pages, `make html` From df81aa126fe5b2993a284fd798846d83cd60fba7 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Mon, 14 Dec 2020 19:34:26 -0600 Subject: [PATCH 006/222] add HMCGibbs sampler (#839) * initial commit * doc string * add assertion * add test * address some reviewer comments * remove import * remove summary() * fix if/else * change arg names; better docs * add hmcgibbs to mcmc.rst * address comments --- docs/source/mcmc.rst | 6 ++ numpyro/infer/__init__.py | 2 + numpyro/infer/hmc_gibbs.py | 143 ++++++++++++++++++++++++++++++++++++ test/test_hmc_gibbs.py | 147 +++++++++++++++++++++++++++++++++++++ 4 files changed, 298 insertions(+) create mode 100644 numpyro/infer/hmc_gibbs.py create mode 100644 test/test_hmc_gibbs.py diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index e91ea207b..782ce93f3 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -22,6 +22,12 @@ MCMC Kernels :show-inheritance: :member-order: bysource +.. autoclass:: numpyro.infer.hmc_gibbs.HMCGibbs + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + .. autoclass:: numpyro.infer.hmc.NUTS :members: :undoc-members: diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index b7378afc4..041e50801 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -3,6 +3,7 @@ from numpyro.infer.elbo import ELBO, RenyiELBO, Trace_ELBO, TraceMeanField_ELBO from numpyro.infer.hmc import HMC, NUTS +from numpyro.infer.hmc_gibbs import HMCGibbs from numpyro.infer.initialization import ( init_to_feasible, init_to_median, @@ -27,6 +28,7 @@ 'Trace_ELBO', 'TraceMeanField_ELBO', 'HMC', + 'HMCGibbs', 'MCMC', 'NUTS', 'Predictive', diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py new file mode 100644 index 000000000..b9eaf2c38 --- /dev/null +++ b/numpyro/infer/hmc_gibbs.py @@ -0,0 +1,143 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from collections import namedtuple +import copy +from functools import partial + +from jax import device_put, random, value_and_grad + +from numpyro.handlers import condition, seed, trace, substitute +from numpyro.infer.mcmc import MCMCKernel +from numpyro.infer.hmc import HMC + + +HMCGibbsState = namedtuple("HMCGibbsState", "z, hmc_state, rng_key") +""" + - **z** - a dict of the current latent values (both HMC and Gibbs sites) + - **hmc_state** - current hmc_state + - **rng_key** - random key for the current step +""" + + +def _wrap_model(model): + def fn(*args, **kwargs): + gibbs_values = kwargs.pop("_gibbs_sites", {}) + with condition(data=gibbs_values), substitute(data=gibbs_values): + model(*args, **kwargs) + return fn + + +class HMCGibbs(MCMCKernel): + """ + [EXPERIMENTAL INTERFACE] + + HMC-within-Gibbs. This inference algorithm allows the user to combine + general purpose gradient-based inference (HMC or NUTS) with custom + Gibbs samplers. + + Note that it is the user's responsibility to provide a correct implementation + of `gibbs_fn` that samples from the corresponding posterior conditional. + + :param inner_kernel: One of :class:`~numpyro.infer.HMC` or :class:`~numpyro.infer.NUTS`. + :param gibbs_fn: A Python callable that returns a dictionary of Gibbs samples conditioned + on the HMC sites. Must include an argument `rng_key` that should be used for all sampling. + Must also include arguments `hmc_sites` and `gibbs_sites`, each of which is a dictionary + with keys that are site names and values that are sample values. Note that a given `gibbs_fn` + may not need make use of all these sample values. + :param gibbs_sites: a list of site names for the latent variables that are covered by the Gibbs sampler. + + **Example** + + .. doctest:: + + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.infer import MCMC, NUTS, HMCGibbs + + >>> def model(): + ... x = numpyro.sample("x", dist.Normal(0.0, 2.0)) + ... y = numpyro.sample("y", dist.Normal(0.0, 2.0)) + ... numpyro.sample("obs", dist.Normal(x + y, 1.0), obs=jnp.array([1.0])) + + >>> def gibbs_fn(rng_key, gibbs_sites, hmc_sites): + ... y = hmc_sites['y'] + ... new_x = dist.Normal(0.8 * (1-y), math.sqrt(0.8)).sample(rng_key) + ... return {'x': new_x} + + >>> hmc_kernel = NUTS(model) + >>> kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['x']) + >>> mcmc = MCMC(kernel, 100, 100, progress_bar=False) + >>> mcmc.run(random.PRNGKey(0)) + >>> mcmc.print_summary() # doctest: +SKIP + """ + + sample_field = "z" + + def __init__(self, inner_kernel, gibbs_fn, gibbs_sites): + if not isinstance(inner_kernel, HMC): + raise ValueError("inner_kernel must be a HMC or NUTS sampler.") + if not callable(gibbs_fn): + raise ValueError("gibbs_fn must be a callable") + assert inner_kernel.model is not None, "HMCGibbs does not support models specified via a potential function." + + self.inner_kernel = copy.copy(inner_kernel) + self.inner_kernel._model = _wrap_model(inner_kernel.model) + self._gibbs_sites = gibbs_sites + self._gibbs_fn = gibbs_fn + + @property + def model(self): + return self.inner_kernel._model + + def postprocess_fn(self, args, kwargs): + def fn(z): + model_kwargs = {} if kwargs is None else kwargs.copy() + hmc_sites = {k: v for k, v in z.items() if k not in self._gibbs_sites} + gibbs_sites = {k: v for k, v in z.items() if k in self._gibbs_sites} + model_kwargs["_gibbs_sites"] = gibbs_sites + hmc_sites = self.inner_kernel.postprocess_fn(args, model_kwargs)(hmc_sites) + return {**gibbs_sites, **hmc_sites} + + return fn + + def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): + model_kwargs = {} if model_kwargs is None else model_kwargs.copy() + rng_key, key_u, key_z = random.split(rng_key, 3) + prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) + + gibbs_sites = {name: site["value"] for name, site in prototype_trace.items() if name in self._gibbs_sites} + model_kwargs["_gibbs_sites"] = gibbs_sites + hmc_state = self.inner_kernel.init(key_z, num_warmup, init_params, model_args, model_kwargs) + + z = {**gibbs_sites, **hmc_state.z} + + return device_put(HMCGibbsState(z, hmc_state, rng_key)) + + def sample(self, state, model_args, model_kwargs): + model_kwargs = {} if model_kwargs is None else model_kwargs + rng_key, rng_gibbs = random.split(state.rng_key) + + def potential_fn(z_gibbs, z_hmc): + return self.inner_kernel._potential_fn_gen( + *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + + z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} + z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} + # TODO: give the user more control over which sites are transformed from unconstrained to constrained space + z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs)(z_hmc) + + z_gibbs = self._gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc) + + pe, z_grad = value_and_grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) + hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) + + model_kwargs_ = model_kwargs.copy() + model_kwargs_["_gibbs_sites"] = z_gibbs + hmc_state = self.inner_kernel.sample(hmc_state, model_args, model_kwargs_) + + z = {**z_gibbs, **hmc_state.z} + + return HMCGibbsState(z, hmc_state, rng_key) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py new file mode 100644 index 000000000..dd6514a26 --- /dev/null +++ b/test/test_hmc_gibbs.py @@ -0,0 +1,147 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +from numpy.testing import assert_allclose +import pytest + +from functools import partial + +import jax.numpy as jnp +from jax import random +from jax.scipy.linalg import cho_factor, cho_solve, solve_triangular, inv + +import numpyro +import numpyro.distributions as dist +from numpyro.infer import HMC, MCMC, NUTS, HMCGibbs + + +def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): + N, P = X.shape + + sigma = jnp.exp(hmc_sites['log_sigma']) if 'log_sigma' in hmc_sites else hmc_sites['sigma'] + + sigma_sq = jnp.square(sigma) + covar_inv = XX / sigma_sq + jnp.eye(P) + + L = cho_factor(covar_inv, lower=True)[0] + L_inv = solve_triangular(L, jnp.eye(P), lower=True) + loc = cho_solve((L, True), XY) / sigma_sq + + beta_proposal = dist.MultivariateNormal(loc=loc, scale_tril=L_inv).sample(rng_key) + + return {'beta': beta_proposal} + + +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +def test_linear_model_log_sigma(kernel_cls, N=100, P=50, sigma=0.11, warmup_steps=500, num_samples=500): + np.random.seed(0) + X = np.random.randn(N * P).reshape((N, P)) + XX = np.matmul(np.transpose(X), X) + Y = X[:, 0] + sigma * np.random.randn(N) + XY = np.sum(X * Y[:, None], axis=0) + + def model(X, Y): + N, P = X.shape + + log_sigma = numpyro.sample("log_sigma", dist.Normal(1.0)) + sigma = jnp.exp(log_sigma) + beta = numpyro.sample("beta", dist.Normal(jnp.zeros(P), jnp.ones(P))) + mean = jnp.sum(beta * X, axis=-1) + + numpyro.sample("obs", dist.Normal(mean, sigma), obs=Y) + + gibbs_fn = partial(_linear_regression_gibbs_fn, X, XX, XY, Y) + + hmc_kernel = kernel_cls(model) + kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['beta']) + mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + + mcmc.run(random.PRNGKey(0), X, Y) + + beta_mean = np.mean(mcmc.get_samples()['beta'], axis=0) + assert_allclose(beta_mean, np.array([1.0] + [0.0] * (P - 1)), atol=0.05) + + sigma_mean = np.exp(np.mean(mcmc.get_samples()['log_sigma'], axis=0)) + assert_allclose(sigma_mean, sigma, atol=0.25) + + +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +def test_linear_model_sigma(kernel_cls, N=90, P=40, sigma=0.07, warmup_steps=500, num_samples=500): + np.random.seed(1) + X = np.random.randn(N * P).reshape((N, P)) + XX = np.matmul(np.transpose(X), X) + Y = X[:, 0] + sigma * np.random.randn(N) + XY = np.sum(X * Y[:, None], axis=0) + + def model(X, Y): + N, P = X.shape + + sigma = numpyro.sample("sigma", dist.HalfCauchy(1.0)) + beta = numpyro.sample("beta", dist.Normal(jnp.zeros(P), jnp.ones(P))) + mean = jnp.sum(beta * X, axis=-1) + + numpyro.sample("obs", dist.Normal(mean, sigma), obs=Y) + + gibbs_fn = partial(_linear_regression_gibbs_fn, X, XX, XY, Y) + + hmc_kernel = kernel_cls(model) + kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['beta']) + mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + + mcmc.run(random.PRNGKey(0), X, Y) + + beta_mean = np.mean(mcmc.get_samples()['beta'], axis=0) + assert_allclose(beta_mean, np.array([1.0] + [0.0] * (P - 1)), atol=0.05) + + sigma_mean = np.mean(mcmc.get_samples()['sigma'], axis=0) + assert_allclose(sigma_mean, sigma, atol=0.25) + + +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +def test_gaussian_model(kernel_cls, D=2, warmup_steps=3000, num_samples=5000): + np.random.seed(0) + cov = np.random.randn(4 * D * D).reshape((2 * D, 2 * D)) + cov = jnp.matmul(jnp.transpose(cov), cov) + 0.25 * jnp.eye(2 * D) + + cov00 = cov[:D, :D] + cov01 = cov[:D, D:] + cov10 = cov[D:, :D] + cov11 = cov[D:, D:] + + cov_01_cov11_inv = jnp.matmul(cov01, inv(cov11)) + cov_10_cov00_inv = jnp.matmul(cov10, inv(cov00)) + + posterior_cov0 = cov00 - jnp.matmul(cov_01_cov11_inv, cov10) + posterior_cov1 = cov11 - jnp.matmul(cov_10_cov00_inv, cov01) + + # we consider a model in which (x0, x1) ~ MVN(0, cov) + + def gaussian_gibbs_fn(rng_key, hmc_sites, gibbs_sites): + x1 = hmc_sites['x1'] + posterior_loc0 = jnp.matmul(cov_01_cov11_inv, x1) + x0_proposal = dist.MultivariateNormal(loc=posterior_loc0, covariance_matrix=posterior_cov0).sample(rng_key) + return {'x0': x0_proposal} + + def model(): + x0 = numpyro.sample("x0", dist.MultivariateNormal(loc=jnp.zeros(D), covariance_matrix=cov00)) + posterior_loc1 = jnp.matmul(cov_10_cov00_inv, x0) + numpyro.sample("x1", dist.MultivariateNormal(loc=posterior_loc1, covariance_matrix=posterior_cov1)) + + hmc_kernel = kernel_cls(model, dense_mass=True) + kernel = HMCGibbs(hmc_kernel, gibbs_fn=gaussian_gibbs_fn, gibbs_sites=['x0']) + mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + + mcmc.run(random.PRNGKey(0)) + + x0_mean = np.mean(mcmc.get_samples()['x0'], axis=0) + x1_mean = np.mean(mcmc.get_samples()['x1'], axis=0) + + x0_std = np.std(mcmc.get_samples()['x0'], axis=0) + x1_std = np.std(mcmc.get_samples()['x1'], axis=0) + + assert_allclose(x0_mean, np.zeros(D), atol=0.15) + assert_allclose(x1_mean, np.zeros(D), atol=0.15) + + assert_allclose(x0_std, np.sqrt(np.diagonal(cov00)), rtol=0.05) + assert_allclose(x1_std, np.sqrt(np.diagonal(cov11)), rtol=0.05) From b84a680808ce46f4ecf5e12d0b62fb0509cf2054 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 14 Dec 2020 23:13:56 -0600 Subject: [PATCH 007/222] Make scan compatible with unconstrain reparam (#837) * compose scan and unconstrain reparam * add test * adjust to make the test more meaningful --- docs/source/handlers.rst | 8 +++++ numpyro/contrib/control_flow/scan.py | 27 +++++++++++++---- numpyro/contrib/funsor/enum_messenger.py | 20 +------------ numpyro/distributions/util.py | 2 +- numpyro/handlers.py | 19 ++++++++++++ numpyro/infer/util.py | 24 +++++++++++---- test/contrib/test_control_flow.py | 37 ++++++++++++++++++++++-- 7 files changed, 103 insertions(+), 34 deletions(-) diff --git a/docs/source/handlers.rst b/docs/source/handlers.rst index bd7d22690..465252d6f 100644 --- a/docs/source/handlers.rst +++ b/docs/source/handlers.rst @@ -35,6 +35,14 @@ do :show-inheritance: :member-order: bysource +infer_config +------------ +.. autoclass:: numpyro.handlers.infer_config + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + lift ---- .. autoclass:: numpyro.handlers.lift diff --git a/numpyro/contrib/control_flow/scan.py b/numpyro/contrib/control_flow/scan.py index d0310b5f1..7bf4b6b9b 100644 --- a/numpyro/contrib/control_flow/scan.py +++ b/numpyro/contrib/control_flow/scan.py @@ -29,14 +29,20 @@ def tree_flatten(self): # scanned sites have stop field because we trace them inside a block handler elif key != 'stop': aux_trace[name][key] = site[key] - return (trace,), aux_trace + # keep the site order information because in JAX, flatten and unflatten do not preserve + # the order of keys in a dict + site_names = list(trace.keys()) + return (trace,), (aux_trace, site_names) @classmethod def tree_unflatten(cls, aux_data, children): + aux_trace, site_names = aux_data trace, = children - for name, site in trace.items(): - site.update(aux_data[name]) - return cls(trace) + trace_with_aux = {} + for name in site_names: + trace[name].update(aux_trace[name]) + trace_with_aux[name] = trace[name] + return cls(trace_with_aux) def _subs_wrapper(subs_map, i, length, site): @@ -122,7 +128,11 @@ def body_fn(wrapped_carry, x, prefix=None): init = True if (not_jax_tracer(i) and i == 0) else False rng_key, subkey = random.split(rng_key) if rng_key is not None else (None, None) - seeded_fn = handlers.seed(f, subkey) if subkey is not None else f + # we need to tell unconstrained messenger in potential energy computation + # that only the item at time `i` is needed when transforming + fn = handlers.infer_config(f, config_fn=lambda msg: {'_scan_current_index': i}) + + seeded_fn = handlers.seed(fn, subkey) if subkey is not None else fn for subs_type, subs_map in substitute_stack: subs_fn = partial(_subs_wrapper, subs_map, i, length) if subs_type == 'condition': @@ -201,7 +211,12 @@ def body_fn(wrapped_carry, x): rng_key, subkey = random.split(rng_key) if rng_key is not None else (None, None) with handlers.block(): - seeded_fn = handlers.seed(f, subkey) if subkey is not None else f + + # we need to tell unconstrained messenger in potential energy computation + # that only the item at time `i` is needed when transforming + fn = handlers.infer_config(f, config_fn=lambda msg: {'_scan_current_index': i}) + + seeded_fn = handlers.seed(fn, subkey) if subkey is not None else fn for subs_type, subs_map in substitute_stack: subs_fn = partial(_subs_wrapper, subs_map, i, length) if subs_type == 'condition': diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index a7cf3b553..6275c3c92 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -9,7 +9,7 @@ import jax.numpy as jnp import funsor -from numpyro.handlers import trace as OrigTraceMessenger +from numpyro.handlers import infer_config, trace as OrigTraceMessenger from numpyro.primitives import Messenger, apply_stack from numpyro.primitives import plate as OrigPlateMessenger @@ -553,24 +553,6 @@ def markov(fn=None, history=1, keep=False): return LocalNamedMessenger(fn, history=history, keep=keep) -class infer_config(Messenger): - """ - Given a callable `fn` that contains Pyro primitive calls - and a callable `config_fn` taking a trace site and returning a dictionary, - updates the value of the infer kwarg at a sample site to config_fn(site). - - :param fn: a stochastic function (callable containing Pyro primitive calls) - :param config_fn: a callable taking a site and returning an infer dict - """ - def __init__(self, fn, config_fn): - super().__init__(fn) - self.config_fn = config_fn - - def process_message(self, msg): - if msg["type"] in ("sample", "param"): - msg["infer"].update(self.config_fn(msg)) - - #################### # New primitives #################### diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index 45a0b4934..ed08e972a 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -261,7 +261,7 @@ def sum_rightmost(x, dim): Sum out ``dim`` many rightmost dimensions of a given tensor. """ out_dim = jnp.ndim(x) - dim - x = jnp.reshape(x[..., jnp.newaxis], jnp.shape(x)[:out_dim] + (-1,)) + x = jnp.reshape(jnp.expand_dims(x, -1), jnp.shape(x)[:out_dim] + (-1,)) return jnp.sum(x, axis=-1) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 44603f983..0fa21767c 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -93,6 +93,7 @@ 'block', 'collapse', 'condition', + 'infer_config', 'lift', 'mask', 'reparam', @@ -376,6 +377,24 @@ def process_message(self, msg): msg['is_observed'] = True +class infer_config(Messenger): + """ + Given a callable `fn` that contains Pyro primitive calls + and a callable `config_fn` taking a trace site and returning a dictionary, + updates the value of the infer kwarg at a sample site to config_fn(site). + + :param fn: a stochastic function (callable containing NumPyro primitive calls) + :param config_fn: a callable taking a site and returning an infer dict + """ + def __init__(self, fn=None, config_fn=None): + super().__init__(fn) + self.config_fn = config_fn + + def process_message(self, msg): + if msg["type"] in ("sample", "param"): + msg["infer"].update(self.config_fn(msg)) + + class lift(Messenger): """ Given a stochastic function with ``param`` calls and a prior distribution, diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 742f75bfc..ff0d68cad 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -12,7 +12,7 @@ import jax.numpy as jnp import numpyro -from numpyro.distributions.constraints import _GreaterThan, _Interval, real, real_vector +from numpyro.distributions import constraints from numpyro.distributions.transforms import biject_to from numpyro.distributions.util import is_identically_one, sum_rightmost from numpyro.handlers import seed, substitute, trace @@ -118,9 +118,23 @@ def _unconstrain_reparam(params, site): if name in params: p = params[name] support = site['fn'].support - if support in [real, real_vector]: - return p t = biject_to(support) + # in scan, we might only want to substitute an item at index i, rather than the whole sequence + i = site['infer'].get('_scan_current_index', None) + if i is not None: + # TODO: leverage t.input_event_dim, t.output_event_dim when they are available + if support in (constraints.corr_cholesky, constraints.corr_matrix, + constraints.positive_definite, constraints.lower_cholesky): + event_dim_shift = 1 + else: + event_dim_shift = 0 + expected_unconstrained_dim = len(site["fn"].shape()) - event_dim_shift + # check if p has additional time dimension + if jnp.ndim(p) > expected_unconstrained_dim: + p = p[i] + + if support in [constraints.real, constraints.real_vector]: + return p value = t(p) log_det = t.log_abs_det_jacobian(p, value) @@ -278,9 +292,9 @@ def _get_model_transforms(model, model_args=(), model_kwargs=None): inv_transforms[k] = biject_to(support) # XXX: the following code filters out most situations with dynamic supports args = () - if isinstance(support, _GreaterThan): + if isinstance(support, constraints._GreaterThan): args = ('lower_bound',) - elif isinstance(support, _Interval): + elif isinstance(support, constraints._Interval): args = ('lower_bound', 'upper_bound') for arg in args: if not isinstance(getattr(support, arg), (int, float)): diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 22031e5fc..6d636c3cb 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -4,7 +4,7 @@ from numpy.testing import assert_allclose import pytest -import jax +from jax import random import jax.numpy as jnp import numpyro @@ -12,6 +12,7 @@ import numpyro.distributions as dist from numpyro.handlers import seed, substitute, trace from numpyro.infer import MCMC, NUTS, Predictive +from numpyro.infer.util import potential_energy def test_scan(): @@ -37,7 +38,7 @@ def transition(state, i): num_samples = 100 kernel = NUTS(model) mcmc = MCMC(kernel, 100, num_samples) - mcmc.run(jax.random.PRNGKey(0), T=T) + mcmc.run(random.PRNGKey(0), T=T) assert set(mcmc.get_samples()) == {'x', 'y', 'y2', 'x_0', 'y_0'} mcmc.print_summary() @@ -48,7 +49,7 @@ def transition(state, i): future = 5 predictive = Predictive(numpyro.handlers.condition(model, {'x': x}), samples, return_sites=['x', 'y', 'y2'], parallel=True) - result = predictive(jax.random.PRNGKey(1), T=T + future) + result = predictive(random.PRNGKey(1), T=T + future) expected_shape = (num_samples, T + future) assert result['x'].shape == expected_shape assert result['y'].shape == expected_shape @@ -78,3 +79,33 @@ def body_fn(z, val): with trace(), seed(rng_seed=0), substitute(data={"z": data}): zs = model() assert_allclose(zs, data) + + +def test_scan_constrain_reparam_compatible(): + def model(T, q=1, r=1, phi=0., beta=0.): + x = 0. + mu = 0. + for i in range(T): + x = numpyro.sample(f'x_{i}', dist.LogNormal(phi * x, q)) + mu = beta * mu + x + numpyro.sample(f'y_{i}', dist.Normal(mu, r)) + + def fun_model(T, q=1, r=1, phi=0., beta=0.): + def transition(state, i): + x, mu = state + x = numpyro.sample('x', dist.LogNormal(phi * x, q)) + mu = beta * mu + x + numpyro.sample('y', dist.Normal(mu, r)) + return (x, mu), None + + scan(transition, (0., 0.), jnp.arange(T)) + + T = 10 + params = {} + for i in range(T): + params[f'x_{i}'] = (i + 1.) / 10 + params[f'y_{i}'] = -i / 5 + fun_params = {'x': jnp.arange(1, T + 1) / 10, 'y': -jnp.arange(T) / 5} + actual_log_joint = potential_energy(fun_model, (T,), {}, fun_params) + expected_log_joint = potential_energy(model, (T,), {}, params) + assert_allclose(actual_log_joint, expected_log_joint) From 64a9b2c8d1cad5fc9779c61f16afe0898fbb4902 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Tue, 15 Dec 2020 10:26:40 -0600 Subject: [PATCH 008/222] add diagnostic string (#841) --- numpyro/infer/hmc_gibbs.py | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index b9eaf2c38..ea03ef0dc 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -92,6 +92,12 @@ def __init__(self, inner_kernel, gibbs_fn, gibbs_sites): def model(self): return self.inner_kernel._model + def get_diagnostics_str(self, state): + state = state.hmc_state + return '{} steps of size {:.2e}. acc. prob={:.2f}'.format(state.num_steps, + state.adapt_state.step_size, + state.mean_accept_prob) + def postprocess_fn(self, args, kwargs): def fn(z): model_kwargs = {} if kwargs is None else kwargs.copy() From 56efeffe0a0f68eeac512773a12b244a245a2051 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 15 Dec 2020 11:58:25 -0600 Subject: [PATCH 009/222] Incorporate input_event_dim/output_event_dim to transforms (#836) * add test for input event dim * update biject_to test * use event_dim instead of len(event_shape) * use input_event_dim in unconstrained reparam * use event_shape=-1 for unexpected cases --- numpyro/contrib/funsor/enum_messenger.py | 2 +- numpyro/distributions/distribution.py | 26 ++++++++-- numpyro/distributions/transforms.py | 48 +++++++++++++++--- numpyro/infer/autoguide.py | 2 +- numpyro/infer/util.py | 7 +-- test/test_distributions.py | 64 ++++++++++++++++++++++-- 6 files changed, 126 insertions(+), 23 deletions(-) diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index 6275c3c92..6f63948b3 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -526,7 +526,7 @@ def postprocess_message(self, msg): if msg["type"] == "sample": total_batch_shape = lax.broadcast_shapes( tuple(msg["fn"].batch_shape), - msg["value"].shape[:len(msg["value"].shape)-len(msg["fn"].event_shape)] + msg["value"].shape[:len(msg["value"].shape) - msg["fn"].event_dim] ) msg["infer"]["dim_to_name"] = NamedMessenger._get_dim_to_name(total_batch_shape) if msg["type"] in ("sample", "param"): diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index a1c3eceec..5bba2a52f 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -36,7 +36,7 @@ import jax.numpy as jnp from numpyro.distributions.constraints import is_dependent, real -from numpyro.distributions.transforms import Transform +from numpyro.distributions.transforms import ComposeTransform, Transform from numpyro.distributions.util import lazy_property, promote_shapes, sum_rightmost, validate_sample from numpyro.util import not_jax_tracer @@ -725,9 +725,23 @@ def __init__(self, base_distribution, transforms, validate_args=None): # to pay attention to any inference function that inspects # transformed distribution's shape. shape = base_distribution.batch_shape + base_distribution.event_shape - event_dim = max([len(base_distribution.event_shape)] + [t.event_dim for t in transforms]) - batch_shape = shape[:len(shape) - event_dim] - event_shape = shape[len(shape) - event_dim:] + base_ndim = len(shape) + transform = ComposeTransform(self.transforms) + transform_input_event_dim = transform.input_event_dim + if base_ndim < transform_input_event_dim: + raise ValueError("Base distribution needs to have shape with size at least {}, but got {}." + .format(transform_input_event_dim, base_ndim)) + event_dim = transform.output_event_dim + max(self.base_dist.event_dim - transform_input_event_dim, 0) + # See the above note. Currently, there is no way to interpret the shape of output after + # transforming. To solve this issue, we need something like Bijector.forward_event_shape + # as in TFP. For now, we will prepend singleton dimensions to compromise, so that + # event_dim, len(batch_shape) are still correct. + if event_dim <= base_ndim: + batch_shape = shape[:base_ndim - event_dim] + event_shape = shape[base_ndim - event_dim:] + else: + event_shape = (-1,) * event_dim + batch_shape = () super(TransformedDistribution, self).__init__(batch_shape, event_shape, validate_args=validate_args) @property @@ -766,7 +780,9 @@ def log_prob(self, value, intermediates=None): x = transform.inv(y) if intermediates is None else intermediates[-i - 1][0] t_inter = None if intermediates is None else intermediates[-i - 1][1] t_log_det = transform.log_abs_det_jacobian(x, y, t_inter) - log_prob = log_prob - sum_rightmost(t_log_det, event_dim - transform.event_dim) + batch_ndim = event_dim - transform.output_event_dim + log_prob = log_prob - sum_rightmost(t_log_det, batch_ndim) + event_dim = transform.input_event_dim + batch_ndim y = x log_prob = log_prob + sum_rightmost(self.base_dist.log_prob(y), diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 073913629..11228465a 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -54,6 +54,14 @@ class Transform(object): codomain = constraints.real event_dim = 0 + @property + def input_event_dim(self): + return self.event_dim + + @property + def output_event_dim(self): + return self.event_dim + def __call__(self, x): return NotImplementedError @@ -147,7 +155,21 @@ def codomain(self): @property def event_dim(self): - return max(p.event_dim for p in self.parts) + raise ValueError("Please use `.input_event_dim` or `.output_event_dim` instead.") + + @property + def input_event_dim(self): + input_event_dim = self.parts[-1].input_event_dim + for part in self.parts[len(self.parts) - 1::-1]: + input_event_dim = part.input_event_dim + max(input_event_dim - part.output_event_dim, 0) + return input_event_dim + + @property + def output_event_dim(self): + output_event_dim = self.parts[0].output_event_dim + for part in self.parts[1:]: + output_event_dim = part.output_event_dim + max(output_event_dim - part.input_event_dim, 0) + return output_event_dim def __call__(self, x): for part in self.parts: @@ -166,16 +188,20 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): .format(len(intermediates), len(self.parts))) result = 0. + input_event_dim = self.input_event_dim for i, part in enumerate(self.parts[:-1]): y_tmp = part(x) if intermediates is None else intermediates[i][0] inter = None if intermediates is None else intermediates[i][1] logdet = part.log_abs_det_jacobian(x, y_tmp, intermediates=inter) - result = result + sum_rightmost(logdet, self.event_dim - part.event_dim) + batch_ndim = input_event_dim - part.input_event_dim + result = result + sum_rightmost(logdet, batch_ndim) + input_event_dim = part.output_event_dim + batch_ndim x = y_tmp # account the the last transform, where y is available inter = None if intermediates is None else intermediates[-1] - logdet = self.parts[-1].log_abs_det_jacobian(x, y, intermediates=inter) - result = result + sum_rightmost(logdet, self.event_dim - self.parts[-1].event_dim) + part = self.parts[-1] + logdet = part.log_abs_det_jacobian(x, y, intermediates=inter) + result = result + sum_rightmost(logdet, input_event_dim - part.input_event_dim) return result def call_with_intermediates(self, x): @@ -217,7 +243,12 @@ class :class:`StickBreakingTransform` to transform :math:`X_i` into a """ domain = constraints.real_vector codomain = constraints.corr_cholesky - event_dim = 2 + input_event_dim = 1 + output_event_dim = 2 + + @property + def event_dim(self): + raise ValueError("Please use `.input_event_dim` or `.output_event_dim` instead.") def __call__(self, x): # we interchange step 1 and step 2.a for a better performance @@ -371,7 +402,12 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): class LowerCholeskyTransform(Transform): domain = constraints.real_vector codomain = constraints.lower_cholesky - event_dim = 2 + input_event_dim = 1 + output_event_dim = 2 + + @property + def event_dim(self): + raise ValueError("Please use `.input_event_dim` or `.output_event_dim` instead.") def __call__(self, x): n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 673862d93..40745b8c8 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -417,7 +417,7 @@ def __call__(self, *args, **kwargs): transform = biject_to(site['fn'].support) value = transform(unconstrained_value) log_density = - transform.log_abs_det_jacobian(unconstrained_value, value) - event_ndim = len(site['fn'].event_shape) + event_ndim = site['fn'].event_dim log_density = sum_rightmost(log_density, jnp.ndim(log_density) - jnp.ndim(value) + event_ndim) delta_dist = dist.Delta(value, log_density=log_density, event_dim=event_ndim) diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index ff0d68cad..6f8aa7bcf 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -122,12 +122,7 @@ def _unconstrain_reparam(params, site): # in scan, we might only want to substitute an item at index i, rather than the whole sequence i = site['infer'].get('_scan_current_index', None) if i is not None: - # TODO: leverage t.input_event_dim, t.output_event_dim when they are available - if support in (constraints.corr_cholesky, constraints.corr_matrix, - constraints.positive_definite, constraints.lower_cholesky): - event_dim_shift = 1 - else: - event_dim_shift = 0 + event_dim_shift = t.output_event_dim - t.input_event_dim expected_unconstrained_dim = len(site["fn"].shape()) - event_dim_shift # check if p has additional time dimension if jnp.ndim(p) > expected_unconstrained_dim: diff --git a/test/test_distributions.py b/test/test_distributions.py index c565d0ef0..d9734b47a 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -874,10 +874,7 @@ def test_constraints(constraint, x, expected): @pytest.mark.parametrize('shape', [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) def test_biject_to(constraint, shape): transform = biject_to(constraint) - if transform.event_dim == 2: - event_dim = 1 # actual dim of unconstrained domain - else: - event_dim = transform.event_dim + event_dim = transform.input_event_dim if isinstance(constraint, constraints._Interval): assert transform.codomain.upper_bound == constraint.upper_bound assert transform.codomain.lower_bound == constraint.lower_bound @@ -988,6 +985,65 @@ def test_bijective_transforms(transform, event_shape, batch_shape): assert_allclose(actual, -inv_expected, atol=1e-6) +@pytest.mark.parametrize('batch_shape', [(), (5,)]) +def test_composed_transform(batch_shape): + t1 = transforms.AffineTransform(0, 2) + t2 = transforms.LowerCholeskyTransform() + t = transforms.ComposeTransform([t1, t2, t1]) + assert t.input_event_dim == 1 + assert t.output_event_dim == 2 + + x = np.random.normal(size=batch_shape + (6,)) + y = t(x) + log_det = t.log_abs_det_jacobian(x, y) + assert log_det.shape == batch_shape + expected_log_det = jnp.log(2) * 6 + t2.log_abs_det_jacobian(x * 2, y / 2) + jnp.log(2) * 9 + assert_allclose(log_det, expected_log_det) + + +@pytest.mark.parametrize('batch_shape', [(), (5,)]) +def test_composed_transform_1(batch_shape): + t1 = transforms.AffineTransform(0, 2) + t2 = transforms.LowerCholeskyTransform() + t = transforms.ComposeTransform([t1, t2, t2]) + assert t.input_event_dim == 1 + assert t.output_event_dim == 3 + + x = np.random.normal(size=batch_shape + (6,)) + y = t(x) + log_det = t.log_abs_det_jacobian(x, y) + assert log_det.shape == batch_shape + z = t2(x * 2) + expected_log_det = jnp.log(2) * 6 + t2.log_abs_det_jacobian(x * 2, z) + \ + t2.log_abs_det_jacobian(z, t2(z)).sum(-1) + assert_allclose(log_det, expected_log_det) + + +@pytest.mark.parametrize('batch_shape', [(), (5,)]) +@pytest.mark.parametrize('prepend_event_shape', [(), (4,)]) +@pytest.mark.parametrize('sample_shape', [(), (7,)]) +def test_transformed_distribution(batch_shape, prepend_event_shape, sample_shape): + base_dist = dist.Normal(0, 1).expand(batch_shape + prepend_event_shape + (6,)).to_event( + 1 + len(prepend_event_shape) + ) + t1 = transforms.AffineTransform(0, 2) + t2 = transforms.LowerCholeskyTransform() + d = dist.TransformedDistribution(base_dist, [t1, t2, t1]) + assert d.event_dim == 2 + len(prepend_event_shape) + + y = d.sample(random.PRNGKey(0), sample_shape) + t = transforms.ComposeTransform([t1, t2, t1]) + x = t.inv(y) + assert x.shape == sample_shape + base_dist.shape() + log_prob = d.log_prob(y) + assert log_prob.shape == sample_shape + batch_shape + t_log_det = t.log_abs_det_jacobian(x, y) + if prepend_event_shape: + t_log_det = t_log_det.sum(-1) + expected_log_prob = base_dist.log_prob(x) - t_log_det + assert_allclose(log_prob, expected_log_prob, atol=1e-5) + + @pytest.mark.parametrize('transformed_dist', [ dist.TransformedDistribution(dist.Normal(jnp.array([2., 3.]), 1.), transforms.ExpTransform()), dist.TransformedDistribution(dist.Exponential(jnp.ones(2)), [ From 17474f5dee2e6acba883378203191b27a1ac1e7a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Wed, 16 Dec 2020 20:58:41 +0100 Subject: [PATCH 010/222] Fixed bandwidth for RBF kernel and test cases (#843) * Fixed bandwidth computation for RBF kernel and made negative hessian positive definite for precondition example. * Cleaned up * Cleaned print --- numpyro/infer/einstein/kernels.py | 5 +---- test/test_einstein_kernels.py | 29 +++++++++++++++-------------- 2 files changed, 16 insertions(+), 18 deletions(-) diff --git a/numpyro/infer/einstein/kernels.py b/numpyro/infer/einstein/kernels.py index 692556ab1..b9aad37a6 100644 --- a/numpyro/infer/einstein/kernels.py +++ b/numpyro/infer/einstein/kernels.py @@ -85,10 +85,7 @@ def compute(self, particles, particle_info, loss_fn): diff_norms = safe_norm(diffs, ord=2, axis=-1) else: diff_norms = diffs - median = jnp.argsort(diff_norms)[int(diffs.shape[0] / 2)] - bandwidth = jnp.abs(diffs)[median] ** 2 * factor + 1e-5 - if self._normed(): - bandwidth = bandwidth[0] + bandwidth = jnp.median(diff_norms) ** 2 * factor + 1e-5 def kernel(x, y): diff = safe_norm(x - y, ord=2) if self._normed() and x.ndim >= 1 else x - y diff --git a/test/test_einstein_kernels.py b/test/test_einstein_kernels.py index 540243945..ed07013e3 100644 --- a/test/test_einstein_kernels.py +++ b/test/test_einstein_kernels.py @@ -15,9 +15,10 @@ PrecondMatrixKernel ) +jnp.set_printoptions(precision=100) T = namedtuple('TestSteinKernel', ['kernel', 'particle_info', 'loss_fn', 'kval']) -PARTICLES_2D = jnp.array([[1., 2.], [-10., 10.], [0., 0.], [2., -1]]) +PARTICLES_2D = jnp.array([[1., 2.], [-10., 10.], [7., 3.], [2., -1]]) TPARTICLES_2D = (jnp.array([1., 2.]), jnp.array([10., 5.])) # transformed particles @@ -25,15 +26,15 @@ T(RBFKernel, lambda d: {}, lambda x: x, - {'norm': 3.8147664e-06, - 'vector': jnp.array([0., 0.2500005]), - 'matrix': jnp.array([[3.8147664e-06, 0.], - [0., 3.8147664e-06]])} + {'norm': 0.040711474, + 'vector': jnp.array([0.056071877, 0.7260586]), + 'matrix': jnp.array([[0.040711474, 0.], + [0., 0.040711474]])} ), T(RandomFeatureKernel, lambda d: {}, lambda x: x, - {'norm': -4.566867}), + {'norm': 12.190277}), T(IMQKernel, lambda d: {}, lambda x: x, @@ -48,20 +49,20 @@ T(lambda mode: MixtureKernel(mode=mode, ws=jnp.array([.2, .8]), kernel_fns=[RBFKernel(mode), RBFKernel(mode)]), lambda d: {}, lambda x: x, - {'matrix': jnp.array([[3.8147664e-06, 0.], - [0., 3.8147664e-06]])} + {'matrix': jnp.array([[0.040711474, 0.], + [0., 0.040711474]])} ), T(lambda mode: GraphicalKernel(mode=mode, local_kernel_fns={'p1': RBFKernel('norm')}), lambda d: {'p1': (0, d)}, lambda x: x, - {'matrix': jnp.array([[3.8147664e-06, 0.], - [0., 3.8147664e-06]])} + {'matrix': jnp.array([[0.040711474, 0.], + [0., 0.040711474]])} ), - T(lambda mode: PrecondMatrixKernel(HessianPrecondMatrix(), RBFKernel(mode='matrix')), + T(lambda mode: PrecondMatrixKernel(HessianPrecondMatrix(), RBFKernel(mode='matrix'), precond_mode='const'), lambda d: {}, - lambda x: x[0] ** 4 - x[1] ** 3 / 2, - {'matrix': jnp.array([[5.608312e-09, 0.], - [0., 9.347186e-05]])} + lambda x: -.02 / 12 * x[0] ** 4 - .5 / 12 * x[1] ** 4 - x[0] * x[1], # -hess = [[.02x_0^2 1] [1 .5x_1^2]] + {'matrix': jnp.array([[2.3780507e-04, - 1.6688075e-05], + [-1.6688075e-05, 1.2849815e-05]])} ) ] From d22676563ecf9d6fb619ab3ed4cd87ed8cbc12ac Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 17 Dec 2020 00:38:00 -0600 Subject: [PATCH 011/222] Add capture-recapture models (#835) --- docs/source/index.rst | 1 + examples/capture_recapture.py | 295 +++++++++++++++++++++++++++ numpyro/contrib/funsor/infer_util.py | 8 +- numpyro/examples/datasets.py | 25 +++ test/test_examples.py | 2 + 5 files changed, 327 insertions(+), 4 deletions(-) create mode 100644 examples/capture_recapture.py diff --git a/docs/source/index.rst b/docs/source/index.rst index 334d93e5c..60a4ec378 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -35,6 +35,7 @@ NumPyro documentation examples/annotation examples/hmm_enum + examples/capture_recapture tutorials/discrete_imputation .. nbgallery:: diff --git a/examples/capture_recapture.py b/examples/capture_recapture.py new file mode 100644 index 000000000..4b7a369ed --- /dev/null +++ b/examples/capture_recapture.py @@ -0,0 +1,295 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +""" +Example: CJS Capture-Recapture Model for Ecological Data +======================================================== + +This example is ported from [8]. + +We show how to implement several variants of the Cormack-Jolly-Seber (CJS) +[4, 5, 6] model used in ecology to analyze animal capture-recapture data. +For a discussion of these models see reference [1]. + +We make use of two datasets: + + - the European Dipper (Cinclus cinclus) data from reference [2] + (this is Norway's national bird). + - the meadow voles data from reference [3]. + +Compare to the Stan implementations in [7]. + +**References** + + 1. Kery, M., & Schaub, M. (2011). Bayesian population analysis using + WinBUGS: a hierarchical perspective. Academic Press. + 2. Lebreton, J.D., Burnham, K.P., Clobert, J., & Anderson, D.R. (1992). + Modeling survival and testing biological hypotheses using marked animals: + a unified approach with case studies. Ecological monographs, 62(1), 67-118. + 3. Nichols, Pollock, Hines (1984) The use of a robust capture-recapture design + in small mammal population studies: A field example with Microtus pennsylvanicus. + Acta Theriologica 29:357-365. + 4. Cormack, R.M., 1964. Estimates of survival from the sighting of marked animals. + Biometrika 51, 429-438. + 5. Jolly, G.M., 1965. Explicit estimates from capture-recapture data with both death + and immigration-stochastic model. Biometrika 52, 225-247. + 6. Seber, G.A.F., 1965. A note on the multiple recapture census. Biometrika 52, 249-259. + 7. https://github.com/stan-dev/example-models/tree/master/BPA/Ch.07 + 8. http://pyro.ai/examples/capture_recapture.html + +""" + +import argparse +import os + +from jax import random +import jax.numpy as jnp +from jax.scipy.special import expit, logit + +import numpyro +from numpyro import handlers +from numpyro.contrib.control_flow import scan +import numpyro.distributions as dist +from numpyro.examples.datasets import DIPPER_VOLE, load_dataset +from numpyro.infer import HMC, MCMC, NUTS +from numpyro.infer.reparam import LocScaleReparam + + +# %% +# Our first and simplest CJS model variant only has two continuous +# (scalar) latent random variables: i) the survival probability phi; +# and ii) the recapture probability rho. These are treated as fixed +# effects with no temporal or individual/group variation. + + +def model_1(capture_history, sex): + N, T = capture_history.shape + phi = numpyro.sample("phi", dist.Uniform(0.0, 1.0)) # survival probability + rho = numpyro.sample("rho", dist.Uniform(0.0, 1.0)) # recapture probability + + def transition_fn(carry, y): + first_capture_mask, z = carry + with numpyro.plate("animals", N, dim=-1): + with handlers.mask(mask=first_capture_mask): + mu_z_t = first_capture_mask * phi * z + (1 - first_capture_mask) + # NumPyro exactly sums out the discrete states z_t. + z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) + mu_y_t = rho * z + numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + + first_capture_mask = first_capture_mask | y.astype(bool) + return (first_capture_mask, z), None + + z = jnp.ones(N, dtype=jnp.int32) + # we use this mask to eliminate extraneous log probabilities + # that arise for a given individual before its first capture. + first_capture_mask = capture_history[:, 0].astype(bool) + # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it + scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + + +# %% +# In our second model variant there is a time-varying survival probability phi_t for +# T-1 of the T time periods of the capture data; each phi_t is treated as a fixed effect. + + +def model_2(capture_history, sex): + N, T = capture_history.shape + rho = numpyro.sample("rho", dist.Uniform(0.0, 1.0)) # recapture probability + + def transition_fn(carry, y): + first_capture_mask, z = carry + # note that phi_t needs to be outside the plate, since + # phi_t is shared across all N individuals + phi_t = numpyro.sample("phi", dist.Uniform(0.0, 1.0)) + + with numpyro.plate("animals", N, dim=-1): + with handlers.mask(mask=first_capture_mask): + mu_z_t = first_capture_mask * phi_t * z + (1 - first_capture_mask) + # NumPyro exactly sums out the discrete states z_t. + z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) + mu_y_t = rho * z + numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + + first_capture_mask = first_capture_mask | y.astype(bool) + return (first_capture_mask, z), None + + z = jnp.ones(N, dtype=jnp.int32) + # we use this mask to eliminate extraneous log probabilities + # that arise for a given individual before its first capture. + first_capture_mask = capture_history[:, 0].astype(bool) + # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it + scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + + +# %% +# In our third model variant there is a survival probability phi_t for T-1 +# of the T time periods of the capture data (just like in model_2), but here +# each phi_t is treated as a random effect. + + +def model_3(capture_history, sex): + N, T = capture_history.shape + phi_mean = numpyro.sample("phi_mean", dist.Uniform(0.0, 1.0)) # mean survival probability + phi_logit_mean = logit(phi_mean) + # controls temporal variability of survival probability + phi_sigma = numpyro.sample("phi_sigma", dist.Uniform(0.0, 10.0)) + rho = numpyro.sample("rho", dist.Uniform(0.0, 1.0)) # recapture probability + + def transition_fn(carry, y): + first_capture_mask, z = carry + with handlers.reparam(config={"phi_logit": LocScaleReparam(0)}): + phi_logit_t = numpyro.sample("phi_logit", dist.Normal(phi_logit_mean, phi_sigma)) + phi_t = expit(phi_logit_t) + with numpyro.plate("animals", N, dim=-1): + with handlers.mask(mask=first_capture_mask): + mu_z_t = first_capture_mask * phi_t * z + (1 - first_capture_mask) + # NumPyro exactly sums out the discrete states z_t. + z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) + mu_y_t = rho * z + numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + + first_capture_mask = first_capture_mask | y.astype(bool) + return (first_capture_mask, z), None + + z = jnp.ones(N, dtype=jnp.int32) + # we use this mask to eliminate extraneous log probabilities + # that arise for a given individual before its first capture. + first_capture_mask = capture_history[:, 0].astype(bool) + # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it + scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + + +# %% +# In our fourth model variant we include group-level fixed effects +# for sex (male, female). + + +def model_4(capture_history, sex): + N, T = capture_history.shape + # survival probabilities for males/females + phi_male = numpyro.sample("phi_male", dist.Uniform(0.0, 1.0)) + phi_female = numpyro.sample("phi_female", dist.Uniform(0.0, 1.0)) + # we construct a N-dimensional vector that contains the appropriate + # phi for each individual given its sex (female = 0, male = 1) + phi = sex * phi_male + (1.0 - sex) * phi_female + rho = numpyro.sample("rho", dist.Uniform(0.0, 1.0)) # recapture probability + + def transition_fn(carry, y): + first_capture_mask, z = carry + with numpyro.plate("animals", N, dim=-1): + with handlers.mask(mask=first_capture_mask): + mu_z_t = first_capture_mask * phi * z + (1 - first_capture_mask) + # NumPyro exactly sums out the discrete states z_t. + z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) + mu_y_t = rho * z + numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + + first_capture_mask = first_capture_mask | y.astype(bool) + return (first_capture_mask, z), None + + z = jnp.ones(N, dtype=jnp.int32) + # we use this mask to eliminate extraneous log probabilities + # that arise for a given individual before its first capture. + first_capture_mask = capture_history[:, 0].astype(bool) + # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it + scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + + +# %% +# In our final model variant we include both fixed group effects and fixed +# time effects for the survival probability phi: +# logit(phi_t) = beta_group + gamma_t +# We need to take care that the model is not overparameterized; to do this +# we effectively let a single scalar beta encode the difference in male +# and female survival probabilities. + + +def model_5(capture_history, sex): + N, T = capture_history.shape + + # phi_beta controls the survival probability differential + # for males versus females (in logit space) + phi_beta = numpyro.sample("phi_beta", dist.Normal(0.0, 10.0)) + phi_beta = sex * phi_beta + rho = numpyro.sample("rho", dist.Uniform(0.0, 1.0)) # recapture probability + + def transition_fn(carry, y): + first_capture_mask, z = carry + phi_gamma_t = numpyro.sample("phi_gamma", dist.Normal(0.0, 10.0)) + phi_t = expit(phi_beta + phi_gamma_t) + with numpyro.plate("animals", N, dim=-1): + with handlers.mask(mask=first_capture_mask): + mu_z_t = first_capture_mask * phi_t * z + (1 - first_capture_mask) + # NumPyro exactly sums out the discrete states z_t. + z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) + mu_y_t = rho * z + numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + + first_capture_mask = first_capture_mask | y.astype(bool) + return (first_capture_mask, z), None + + z = jnp.ones(N, dtype=jnp.int32) + # we use this mask to eliminate extraneous log probabilities + # that arise for a given individual before its first capture. + first_capture_mask = capture_history[:, 0].astype(bool) + # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it + scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + + +# %% +# Do inference + + +models = {name[len('model_'):]: model + for name, model in globals().items() + if name.startswith('model_')} + + +def run_inference(model, capture_history, sex, rng_key, args): + if args.algo == "NUTS": + kernel = NUTS(model) + elif args.algo == "HMC": + kernel = HMC(model) + mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc.run(rng_key, capture_history, sex) + mcmc.print_summary() + return mcmc.get_samples() + + +def main(args): + # load data + if args.dataset == "dipper": + capture_history, sex = load_dataset(DIPPER_VOLE, split='dipper', shuffle=False)[1]() + elif args.dataset == "vole": + if args.model in ["4", "5"]: + raise ValueError("Cannot run model_{} on meadow voles data, since we lack sex " + "information for these animals.".format(args.model)) + capture_history, = load_dataset(DIPPER_VOLE, split='vole', shuffle=False)[1]() + sex = None + else: + raise ValueError("Available datasets are \'dipper\' and \'vole\'.") + + N, T = capture_history.shape + print("Loaded {} capture history for {} individuals collected over {} time periods.".format( + args.dataset, N, T)) + + model = models[args.model] + rng_key = random.PRNGKey(args.rng_seed) + run_inference(model, capture_history, sex, rng_key, args) + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description="CJS capture-recapture model for ecological data") + parser.add_argument("-m", "--model", default="1", type=str, + help="one of: {}".format(", ".join(sorted(models.keys())))) + parser.add_argument("-d", "--dataset", default="dipper", type=str) + parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) + parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) + parser.add_argument("--num-chains", nargs='?', default=1, type=int) + parser.add_argument('--rng_seed', default=0, type=int, help='random number generator seed') + parser.add_argument('--algo', default='NUTS', type=str, + help='whether to run "NUTS" or "HMC"') + args = parser.parse_args() + main(args) diff --git a/numpyro/contrib/funsor/infer_util.py b/numpyro/contrib/funsor/infer_util.py index 679be1d50..7ba7dfe56 100644 --- a/numpyro/contrib/funsor/infer_util.py +++ b/numpyro/contrib/funsor/infer_util.py @@ -141,18 +141,18 @@ def model(*args, **kwargs): log_prob = scale * log_prob dim_to_name = site["infer"]["dim_to_name"] - log_prob = funsor.to_funsor(log_prob, output=funsor.reals(), dim_to_name=dim_to_name) + log_prob_factor = funsor.to_funsor(log_prob, output=funsor.reals(), dim_to_name=dim_to_name) time_dim = None for dim, name in dim_to_name.items(): if name.startswith("_time"): - time_dim = funsor.Variable(name, funsor.domains.bint(site["value"].shape[dim])) - time_to_factors[time_dim].append(log_prob) + time_dim = funsor.Variable(name, funsor.domains.bint(log_prob.shape[dim])) + time_to_factors[time_dim].append(log_prob_factor) time_to_init_vars[time_dim] |= frozenset( s for s in dim_to_name.values() if s.startswith("_init")) break if time_dim is None: - log_factors.append(log_prob) + log_factors.append(log_prob_factor) if not site['is_observed']: sum_vars |= frozenset({site['name']}) diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index b7ec550b0..45ad5ad55 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -7,6 +7,7 @@ import os import pickle import struct +import zipfile from urllib.parse import urlparse from urllib.request import urlretrieve @@ -36,6 +37,11 @@ ]) +DIPPER_VOLE = dset('dipper_vole', [ + 'https://github.com/pyro-ppl/datasets/blob/master/dipper_vole.zip?raw=true', +]) + + MNIST = dset('mnist', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-images-idx3-ubyte.gz', 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-labels-idx1-ubyte.gz', @@ -105,6 +111,23 @@ def _load_covtype(): } +def _load_dipper_vole(): + _download(DIPPER_VOLE) + + file_path = os.path.join(DATA_DIR, 'dipper_vole.zip') + data = {} + with zipfile.ZipFile(file_path) as zipper: + data['dipper'] = ( + np.genfromtxt(zipper.open('dipper_capture_history.csv'), delimiter=',')[:, 1:].astype(int), + np.genfromtxt(zipper.open('dipper_sex.csv'), delimiter=',')[:, 1].astype(int) + ) + data['vole'] = ( + np.genfromtxt(zipper.open('meadow_voles_capture_history.csv'), delimiter=',')[:, 1:], + ) + + return data + + def _load_mnist(): _download(MNIST) @@ -222,6 +245,8 @@ def _load(dset): return _load_baseball() elif dset == COVTYPE: return _load_covtype() + elif dset == DIPPER_VOLE: + return _load_dipper_vole() elif dset == MNIST: return _load_mnist() elif dset == SP500: diff --git a/test/test_examples.py b/test/test_examples.py index 9cb080426..de34c86ae 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -20,6 +20,8 @@ 'annotation.py --model lre', 'baseball.py --num-samples 100 --num-warmup 100 --num-chains 2', 'bnn.py --num-samples 10 --num-warmup 10 --num-data 7 --num-chains 2', + 'capture_recapture.py --num-samples 4 --num-warmup 1 -m 3', + 'capture_recapture.py --num-samples 4 --num-warmup 1 -m 5', 'covtype.py --algo HMC --num-samples 10', 'gp.py --num-samples 10 --num-warmup 10 --num-chains 2', 'hmm.py --num-samples 100 --num-warmup 100 --num-chains 2', From 2531cfecbf2d598c6a70e3dc732adbe88beeda4c Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 17 Dec 2020 18:58:43 -0600 Subject: [PATCH 012/222] support deterministic sites in gibbs (#845) --- numpyro/infer/hmc_gibbs.py | 50 ++++++++++++++++++++------------------ test/test_hmc_gibbs.py | 5 ++-- 2 files changed, 29 insertions(+), 26 deletions(-) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index ea03ef0dc..6c356a8f9 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -39,7 +39,7 @@ class HMCGibbs(MCMCKernel): Note that it is the user's responsibility to provide a correct implementation of `gibbs_fn` that samples from the corresponding posterior conditional. - :param inner_kernel: One of :class:`~numpyro.infer.HMC` or :class:`~numpyro.infer.NUTS`. + :param inner_kernel: One of :class:`~numpyro.infer.hmc.HMC` or :class:`~numpyro.infer.hmc.NUTS`. :param gibbs_fn: A Python callable that returns a dictionary of Gibbs samples conditioned on the HMC sites. Must include an argument `rng_key` that should be used for all sampling. Must also include arguments `hmc_sites` and `gibbs_sites`, each of which is a dictionary @@ -51,27 +51,28 @@ class HMCGibbs(MCMCKernel): .. doctest:: - >>> from jax import random - >>> import jax.numpy as jnp - >>> import numpyro - >>> import numpyro.distributions as dist - >>> from numpyro.infer import MCMC, NUTS, HMCGibbs - - >>> def model(): - ... x = numpyro.sample("x", dist.Normal(0.0, 2.0)) - ... y = numpyro.sample("y", dist.Normal(0.0, 2.0)) - ... numpyro.sample("obs", dist.Normal(x + y, 1.0), obs=jnp.array([1.0])) - - >>> def gibbs_fn(rng_key, gibbs_sites, hmc_sites): - ... y = hmc_sites['y'] - ... new_x = dist.Normal(0.8 * (1-y), math.sqrt(0.8)).sample(rng_key) - ... return {'x': new_x} - - >>> hmc_kernel = NUTS(model) - >>> kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['x']) - >>> mcmc = MCMC(kernel, 100, 100, progress_bar=False) - >>> mcmc.run(random.PRNGKey(0)) - >>> mcmc.print_summary() # doctest: +SKIP + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.infer import MCMC, NUTS, HMCGibbs + ... + >>> def model(): + ... x = numpyro.sample("x", dist.Normal(0.0, 2.0)) + ... y = numpyro.sample("y", dist.Normal(0.0, 2.0)) + ... numpyro.sample("obs", dist.Normal(x + y, 1.0), obs=jnp.array([1.0])) + ... + >>> def gibbs_fn(rng_key, gibbs_sites, hmc_sites): + ... y = hmc_sites['y'] + ... new_x = dist.Normal(0.8 * (1-y), jnp.sqrt(0.8)).sample(rng_key) + ... return {'x': new_x} + ... + >>> hmc_kernel = NUTS(model) + >>> kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['x']) + >>> mcmc = MCMC(kernel, 100, 100, progress_bar=False) + >>> mcmc.run(random.PRNGKey(0)) + >>> mcmc.print_summary() # doctest: +SKIP + """ sample_field = "z" @@ -132,15 +133,16 @@ def potential_fn(z_gibbs, z_hmc): z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} + model_kwargs_ = model_kwargs.copy() + model_kwargs_["_gibbs_sites"] = z_gibbs # TODO: give the user more control over which sites are transformed from unconstrained to constrained space - z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs)(z_hmc) + z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs_)(z_hmc) z_gibbs = self._gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc) pe, z_grad = value_and_grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) - model_kwargs_ = model_kwargs.copy() model_kwargs_["_gibbs_sites"] = z_gibbs hmc_state = self.inner_kernel.sample(hmc_state, model_args, model_kwargs_) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index dd6514a26..320ecd1df 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -48,6 +48,7 @@ def model(X, Y): sigma = jnp.exp(log_sigma) beta = numpyro.sample("beta", dist.Normal(jnp.zeros(P), jnp.ones(P))) mean = jnp.sum(beta * X, axis=-1) + numpyro.deterministic("mean", mean) numpyro.sample("obs", dist.Normal(mean, sigma), obs=Y) @@ -141,7 +142,7 @@ def model(): x1_std = np.std(mcmc.get_samples()['x1'], axis=0) assert_allclose(x0_mean, np.zeros(D), atol=0.15) - assert_allclose(x1_mean, np.zeros(D), atol=0.15) + assert_allclose(x1_mean, np.zeros(D), atol=0.2) assert_allclose(x0_std, np.sqrt(np.diagonal(cov00)), rtol=0.05) - assert_allclose(x1_std, np.sqrt(np.diagonal(cov11)), rtol=0.05) + assert_allclose(x1_std, np.sqrt(np.diagonal(cov11)), rtol=0.1) From 3ea6194a34ed7e108a2cd188cdfd868f432403c8 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 18 Dec 2020 08:23:03 -0600 Subject: [PATCH 013/222] Add plots to examples (#846) * add images to example files * fix a flaky test * add thumbnail image for tutorials --- docs/source/_static/img/examples/bnn.png | Bin 30699 -> 64551 bytes docs/source/_static/img/examples/funnel.png | Bin 35123 -> 158575 bytes docs/source/_static/img/examples/gp.png | Bin 25617 -> 49485 bytes docs/source/_static/img/examples/hmm.png | Bin 58474 -> 98616 bytes docs/source/_static/img/examples/neutra.png | Bin 116283 -> 674216 bytes docs/source/_static/img/examples/ode.png | Bin 58586 -> 184479 bytes .../img/examples/stochastic_volatility.png | Bin 44446 -> 81059 bytes docs/source/_static/img/examples/ucbadmit.png | Bin 20132 -> 31282 bytes ...ayesian_hierarchical_linear_regression.png | Bin 0 -> 74878 bytes .../img/tutorials/bayesian_regression.png | Bin 0 -> 28238 bytes .../img/tutorials/discrete_imputation.png | Bin 0 -> 7216 bytes .../img/tutorials/ordinal_regression.png | Bin 0 -> 17477 bytes .../img/tutorials/time_series_forecasting.png | Bin 0 -> 30676 bytes examples/bnn.py | 6 +++-- examples/funnel.py | 6 +++-- examples/gp.py | 6 +++-- examples/hmm.py | 6 +++-- examples/neutra.py | 3 +++ examples/ode.py | 24 ++++++++++-------- examples/stochastic_volatility.py | 6 +++-- examples/ucbadmit.py | 6 +++-- test/test_einstein_kernels.py | 2 +- 22 files changed, 41 insertions(+), 24 deletions(-) create mode 100644 docs/source/_static/img/tutorials/bayesian_hierarchical_linear_regression.png create mode 100644 docs/source/_static/img/tutorials/bayesian_regression.png create mode 100644 docs/source/_static/img/tutorials/discrete_imputation.png create mode 100644 docs/source/_static/img/tutorials/ordinal_regression.png create mode 100644 docs/source/_static/img/tutorials/time_series_forecasting.png diff --git a/docs/source/_static/img/examples/bnn.png b/docs/source/_static/img/examples/bnn.png index 65c4c621fec0dbf92a555a322ac10dce86631a15..749645ece017b8fa0f4bc85cc180559d4fa40b34 100644 GIT binary patch literal 64551 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

X{7&Y z$91@mYfMe{EFze5Qx8)clB8st_>XWXyK>3g|LzUBdg*n0clSUnkKv#u=+PG4Tc=7b zuF~d!ME7oeAz{+WQPu!O-C&@uS$Qi^zcjfDLn44I5G(~|3igSZ%^yyXeOy7w7N`te z;4)FaT!e3hyxfmh5hz6JFb>D$MlCIq9tEmLXM*wr9HOG}66D~SA{ijO5}3cZ*yWGS zy}})3(;LPU-V=W9?d`okKit`UKJojv`7C(lzJGs-Dc?uzT|kfi04pbxS$)bE_l@ z^LUApU2C(hDD%DmfiM+=B|ddTNAYi5ppyNoe3Iai@1=!D{yFuQZ8wd5S5VvI^NYEu z{XOZjPM4N$#R60QmB}EF3(PCbSr}(7zir8y1^gHO@EA<7f}Q zo&2`+0f+gPWQp1t@|pIp`Mf(3kXnZ~*-kRP4Nt95COmxkwkSWQtw8V{#4XD=Obui* zf}!)nXM)WXF~}W!38oM;V*LSXMs%htZg(5)Fri@IjY4n(mbm5i*>8V3-vdjMwMA@i zPPHbDI_nF)02KY;OvP`sB8+x)QQT)5`gR`j8(EeAPZPmC;~jdowW4SLEWld}FoVAb(^Y!I5{DPQy&6=r)h5BZUML{%(@Pnl~4? zMYi(y!9y-Z;pX1k;%9M+G~qPTK#)niOs?MR%;cQ6IyAzi#<0sG%&2&BMBdQc04<~i z;XW=@!$1S!y#waz*Exx?-g>Y@c*u7Ci{P{kW-8L?|N!FApd(kTeUd5 zo^==a#oWQk#TJ{d!^zIB4nV+Q4Uan0jVKmTIue>p;)3Gh*fHn0PV3Bj!=>%*O4Vb| zV6UNGzpmVEQfyz}&*?usR8IQrWSZ<`h>qEedth^aqHx~RINloIyvzrvbL{7VAWboV401X+twU7%wp%wQ3`}{rCJsFS>d-xt5OiV5C7*smYsr6d1 zeJ6~YPYvkT(KF7jn($BjVcR_JyCzWwGz-3kmbZIHVY`jP((peEgzv7>*A`>_>OLhW z7ZnuOgcXg+)PW7$8~ZP49zN#>%>sPz*`_;X`La_|i#Zz9IV}GA^&w5>`vdS_OB8gU z+jiQ2f0oh@w7Yznr*E~A_GlRJ4w688N>S;GGSzqit81Ns&q;|cVNnix!A3~8m(tRp zK(d~-^T60+vDC%(-;;mrE@ zfB%;=r33obRBo9W88QR}1OSLf4=g$LSk#{!`+|ddsuI3C+MryY?RVX@dn3rKtjDaZ ztT3rQN8#DIx!$NES6`3OitDbU9wgsv9&wqSzdXoQ^3{9?hwVT@i*i^tv3jOs(-y$W zh}!qDW1OoJK?y67BHaQ}V4r9z2u2c};Pc7e2?*R@Ph4N<56A40#OV~j!08kZh$JEO za`3aMz^BT}eS3eVw*do$_U_%c>FR3=B1Ab33GkTK8xc})_w?my;S<<2$e`g7C-|sa zYnx!_U^h4lYWGXGrcQKq=<dVBH4WS~K{dv?Ubjh|uz;P>hs zaeTRM!-K-cb#N5#*L4|Vz)1L9ybam4Alv`jccaa@a~B^l<>%*X>+0r2M@Nedfa>yg zpvbA9I_+>yTU#5Dlv02Xc@sNxKvGz>mCoZ`enEj$Addz|SE3l=04hadrlBz|a z0VA#X4M0n5LqNdMic0`y0i8K?#m(NOQlwSl5Yj5K#|>1v!471M#c-c9adm1yEq4y~ zlT~v;%{>r9Y0n=tHOW}n*i@YR{oSc*EC-~*`+ZYaCY}jlg;&OEtAIKbxzz6m6W?gv zvHm9;ue)FMzh(x5&&$ihVRF^#q$E>aQvKz@8Bi2Baws;yV^IFM&Ue@P!uL>6271j+ zYH)ufKW8upOeRspMHdRCp=Ih?>D-z7V#7H3<#H;)#T#jg+Io6iz~A9RQWmH2uLk@3 z`>^`4=d0E8p5PBG-{5(%jn&(3yv+DhP^B~ezWjv$VG#fivac)EeTQ=z#xJuh;+--m z@5G{LSm}uV;x>&0Cs@I8)pwVif`BB}JFQ%x+fBOQO41WnMs|$^8AM3ATK+kj#iKV% zvFvcvYsASK3WYAav)sJr^7YRX%#`aVhRD{f!=t$*Q4iZ+6pm^mTLXuIb_v$t9IT3B z89||#=fbnDRH@W6QU9L~;CPGmogb-fWn~4H6F$0oc+9$2+eQh0Q3($V)7IDjj6@1% z=j8MTI!#jjml8a*|BOWXrHgpQ{(l+a|7(7c8i1^TSe$%(6SI}CUcDN`4M0vU^5HLg z6b>x94dmsf$7SxbO0czYV_@qBfIa374?@U6 zY&}F15YlPfxBivp_TPu_xd^~<`=N5H4R{?Q z%O=%N7o2p6!6A5XmtesmxC9z$+=9EiyWh&(&1~kG z1&ivg>N?-i_ZX2XpXJa|iBVx-V9>$x(qCX;VB>*5LS#hX6KB0VFBlk)I;lEVx=Mb!J6rVl-UU57NEj%93w=+Jn3}5Pi~dA_@lmk1)9(pp zzQ!0%M@J{Xd+GVv*H@GrCd|0Tenk)!6?IHONV%w-@t0P0|Jhw(IirApfXv$P*qFuB z?MZ+Sxj}U*!h8H0&kK`xL4Uw&OU+KyUC)>AiHL~kR?eOut^|DV9Vh2FIXU?q*Z<^- z_FwE-jb#Zi>(qtx^hmSXsSJ@rU4VcZr%=b)>YJ-(L0BHHT*kHUflN3$Rcz zoip_K*lw}$>oA^{UQpH1NUm5ekL|3{@Bdm3iZe?MIt0DEynNqY?$m#2#`HxKOqZ%s z3%VbBPMH#ib!!>=$$a^OeKc21$G{NjbJ~Iw-Pcp0Q_r5RXt&auEE_{SS+2p<`TA%( zH8o{5TR}9Z@9_}}C5o-<89Q}Y#@?P)^A}#ABmeiRBN#Ia3r_PP+{?>LtHlNefCRJt z??iU1?deLHypxr>eB4S*tuMfd(|NxVXB1DCsnH$&EraAsh2P)I88YZLG7qP+v9%SX~Uf`O+wJkO0XxUIiUAHc6KIdqxtjb;D41>k(nHR)IePqaA2pS|3G*kbF3 zuS+R33Mq~cJE>g8J@BIU>u`rNzXswdrS7+rls(sjkl4|JJ=XkEf!lLlp6=@H7B~}= zlA^2j;()VBxx4ck`d%R5McgtBkO@qn${)oV>ieK<}Hwi``6z%cJTp6GBAM+&F+tY;y8(K;^_W zHSz76GK1idI4#FW%eAV~e?abg4!hx) z=Fs^Nre)w2S|}IC8SwgCu(t)+Z#sMc%{8&Ii;$jFTa%Ul{h zzPq9)kG2(Q85!6-dQ^bOo1?j;^z_IAdi4tJ4}lh=8MT(j_n5|ZAAVTJI%mH}CngzRMw>f>+ zquH1k623Z%QDWIxQm~>T8gONCxjp!|LMN%cT^P`cFc8>ou>nPC8m8vIN`6ude3t)0 zn1^M$UG;2i7*h?r8BP{|OKE5TTB!Le`Qd6$t<%>l$7`1ehSy5xItr)&K?;9Il z`(^ny_Y)X^TxgwQ<$u5BKY!lsCvku`0<4SMY9bI|6=5Lo)_U_{{KW=qHP<(QL3@B! zTTB&!0j2}0@h4f!0L)ImVe;^G30h%@A;LaOsoWz*$Os^L_vsT?50 zzNw!I)_@CdT5%^y1i>cclnrcAva+7qb&P~yEBb=4#4Rv32Wth9Mdx4PM? zYse&mp8drDe>ajNl3Au!vgyd*eA2k2{o4i)hgNa@Vu0N8{(R$ar7l6-032{gdg8EJ zZDtvVQ##Jf(Pq7>f+eOXNq$mURopLMzQE8kGxr|dTn@8!ou4$VVPk~1T#X4`cnZ&- z+!pY)?eFgwbiv7-xbu^i2v-$blU56Po4lyzj>{=3DozHp>9Kz6Hkw?E!<^Hu)C8#d zCr`k_npf;|{2#3W&+0bylCDT=Gg~p(wB{cT*~oL*8+*RrinCj4i~*cn?sZma`G0?d z1y`$zii(m>nQ&3FT|fS|owGQeua%Md#PVN5p3O{o@4&#;)kBnh0Px!dIiG%hN^U-? zYU6j_Mh+4W1pH2&)g%=nCfUf{T0p?mcI$#&vHQs)vtj4+k3E&<^MBDYqS#u-p%D%V zWBX^SL5~^d2V{6;_;-5V2S3%zzJvn)>Y^7%*>RYqX`;qh3gB^yIiO-pT2*F!QFze0 z@5Y4i?}7^Wrhy<(UQQ=c3<7(082oc8W7$Fv`-O4zT2-VdC@ApnV0$*$VE}6_0mRE~ zznu2Z7FhLL|NSb!1hBuq=yZv)B_s@8X2bdU;$097aKiQV?qJ`$6_4YE`f%XrfQJNh zyHd9)F+Cm3Ps(bu258LKKkwRL^#LGh8#rYNpcL@I-31h|$f1(*iM>Fu1!VTmz5qdH znGdIAPhA>oaF(=QMsNst%t! z*+kH?JzqG+$DX~bY}}qY=IJ&Mht9`Crp~8RAq+BMDDXTXmjzmRIiOz3Pu=45*}YgP zjvhUR>8VT?B z$D1RUHNU$LAY24!oVeLOJ#g~Bf7Mrg zuara|wsHLLH;{lJ(NB}ACs}RK;Ry(gh}VvAT=)u2DTBLv!%^jzCd)r1EXnncDz?5p zm<|V=R}J7PSlf>43L57sbyJ;phCZMnJ{zTMlW5aMEo}alO3YR1|9jy_LDxL{l~%wVtrz9W`1(GB@4gZu z0-?loJVyis0-ew5I^f;>XAtn>2H0PpZFNUK;CcrDPp^7?27oXyAgEI9S}FjY6f2SZ z^TU91V*qRg95)I07uh(n(K*9_(KxZ!2p}E~F;z>e;vUXbE2ndszxFXH(GP;0$Rbq! zBQ<>BaX;23=CjvZ9{ms!okQ4z{RthM2tXFCNxg6i zy=@Y>EsRQ`$Omp4si$uR7vLkd0zA}OUR-5*A$gDCv=}(o4{a*(*AOZ&sWTG4$~x2k zekM;NDh~J{AUgptOwJt+k{cYaIo>8pB-bp01lDV5Z*F9#^UkN@&)HFHXLJGr=|DcS z=_)urY^s0_-$RVF;(tgho1Hp<3lPil$u|(d;30rA<{t@qEIT3j+@1aeuvf|Qn3*77 zDis(Txc|9aw$hV;RUtB92$1(!H1?alRsBMmh!1ZPopP~cDC*x*)xv!rAVqRm6BQ=I z1Q3G&T^t*D9o=?&&pWb7=l@8BRBdxl90mxg5SMWgISMSJtKCrr{{etF%xtycH~{G7E^HxW?8WB*=zY!11KOEP(ZPGnn*>%h?N!-89+}7$UjiLCBTz1UKbw9I`IKi zZnR^=UXp_oLkugR*ubxVfJYJoYbB7mfH14xcNl1t{M=1eIB=oTjgo?vM z7iharh1qrr?RpnS`c{Y~_}S`wDeY*}{T>W%x1Zt@RM6od?DNTcG6^6vuw)8FpY_kr zU(ljJ8{Cl;45NVIm}6s2xpDeQe4yw-U@JNxr9ZFbSqf&BF?gygGJ;|!7Jn21tIKMd z0bzayeF~0P!Sd~so+~b&!RmL<`rcR;-3jzyAj}Zl(V)D2L&g&4aMBFVGy`Ga-j`vS z6YPZ|6I66O7)&ku*ZJl{Bl8iVb>D>e!UM+@7CvcAxMc^9%Z*J!ie^ju#?Wnb>K)0- zW^6eg!VfC!1Mt$H+!H%3`J|9;*iIF&Uw>kYMZW%nUI6$wpEr%;aM>NH_kU|eB$A^s zdpJgj1j)p9to%5T<&%!Y+34BCD6bf&H!>~GWHvSyJ7tKzsPsAXUQT{u)dfbNmU#;EG3_5?|EX`K@v8l(w!%;~8q_L2t55>?gRI(BNd?BR9_~V{TeycyGOtlaZz|Pv0 zvq|41=iG{wbH@Nrau1-#@%>kG1V*hOog_Ws8IH&V<-S_eY=rv0KW48E9pQP!^(-Y= zO4pJh@Bi%D@sZS_qLd2`8M@A(udGioRZ)?m)ju}1aN9WvI1QT1FLflvh2L3T#7#qo zhyIw=I)ay&4yK-n`fmbKUY43R=FoX9+b%+7l#96O@i+{%wV{84;QoPRu)I9|V=D-( zUTu)w+bdn6$plm?-X1&ITHyPYZZEr~la&)Gtgk1$nwnl-Jp#9iJ_viIAN=_B1zkr|o;7zU zaY1b2pj$2;H?%=tXuj5;hsB{eRKJDn5G4Cz?jT2RKqI;;2jCc>7}L`qLqa6zN`G*0 zP|~5#Pb#`KFyV%bMB}Pd;B-U*>4a`P+&P268V`2T+|;>IrYBTP7SY`dT@nFODIkp2 z7kKqrA$@xNShh)#)vJ4Ia0*K3H{Z)e3SMUY2rj{}6%wuUC6A>2=lw$IKK}VObC##Z zuX$T9cTQI0vKS`|k}ZrHC1+aDsH=GlTfct}$&VS)ar7#|mAu zor}3E>$yQ?{^#-V2GAdzFAE83@{k{C0hwaoRG3{MMoQkIav~CFpY^lp!PwZ??%~l) z4o5xL7Ymgj>^YMvV%L%peyGUzta z1ASM}2|ll_i}19^SNc=GDzT4kVv6*HFzcm!e_GM3{^P}uCLCjQ0s=pXh6X6HxEhd8 zvr`bpM?}tf*?GdA2tE+;QG`vh^(H1&IbH#7ho%nxJ~ux0M$)EN$SFRpGM|IR{{1K(bib_;xD=m^(SA$c z&}pz$cMHon%LyI6G$9nk(87hSCQypA6X!;QlS$-1Mll+7b+KNUPZTqAPWW(U5g?%^ zp_&J7qwrfBH&t9C1o){Wn<3e>hw3CtWOcZ<76%XCApdi^N@t7ZJEjzW$qEA%clXUsag_|%^@*6A^L zE|qq=)E5xC&s7~vag|JRlefE{8(L5C``fS4)&ls$K8uh+Ca7{JaKW4LLgJ(F$yT-P zP0}C4V!Dh8v91-=D}P<~%nOSWkwKIV1qGUid+Qzc64XDx$t4|eI_CXRP9{Wh|EHh% zQzEdMC3`qiXrHytCd^V)A;z3jtmaFL#LO8wu=8L@O8W9d2N|ziV5r#lLW60oNM(j- zVvLu7&=j;2`wJIk@^qf}6^bO}eW?yK6yP(Ju23RN#Xtk8uv)(pZ&wW#V!kApnF&C_ zpfn7%Y0{Ma*izTXZ~2bMiNm(SSD(o|M0KDk$(pO4!a3O_BWZ8l@0h?q7}vNZh){bU zn#hoMXa{x0nH4De&%P)pIiwGDLGFr3Y@&}u8KjzKh?lvgpC@qFkrv0SL`@1Un#=R3 zS=>q!^%p)0Fbu2GMGgl^2FbT1h13bot!$b0{hWrtBqYK{jt2}MVh{X29y-#86SPd!VltJG z{Dyfqlqjv8xR9bxZ!?mN1>n0s7dxGm)tD2uj<9l=^xyYC$~^{kVSdm_1Yqwmfxc5d zJal-}eC0Nq^s+1s7YDXFHHyc^$!yJlwnN~%vf;&w*?OFCq7&!ng$D((Fi| zMciKb(wQuJ_<^IAhyDI71)vo2F=44#IJwZ-nPFHI8C7|)<~U5GE_nk@T3xN`_4*G| z=TGeb=B`qJej!vM5wB+=aB(aNrNpG=d<=D%@33aT&qUWzMGluFUF}Fxbckop-4Fc% z52QwLJj_m`A4R><8P@+`a8-*E4+MQI?#jkVFpq?@C-;KAP@urAZYVqex*Vo~wyk1u{9De2T{4yS!X!I^T#-ZEhP^_-nTeucX0& z2A8z(X-6;>3l)8RXej{nWECO9Rc-pb?l9kKLm4&LyFKYpx8CL;t~&oiBSOoLo!R~0 zaUc;P^5Iqf-e?ga&@}(rZF2?sfZ9$L&L2PPMFw0}7a5UDOj!(*G45`*ulT|^+xJ8O zl%dh&VZM0p5uxOXum6M`%@en`c2(oILL%&=ASZnKF2`q2itM8x_OH>g*x$eYu$O9f zQFes22QkrxF}fX1+nyiw(*4Y{C9WHk4lU<_3cKd*S73eKuQ+NQ!{c)+o^fm9w4EBA z&&s7#O@&)BG+hq7Knu9HZx2Oq^{>Fhjz7Yz6`0ny8_&c75(F{M@A3>kGRe-TP6YUb zW_9kjlL`Mino-Z>CL};FL+O#DP~7r8kB6^nsoUadwe%vZ4k{jR2>vq+;37#Kw}eco zFMCl(D)5@ty6-ieJtZU=1eQ?bBC;&T|5u2g2y!}eVN>h!vX$(n&^Y`{$4mKvhg23l zl-}^CAOju~#fWagcLZ{l^s3)I;xRw~7u6SJh&_`u{p*X9J9 zo6hy9%v6&`_1!FQ;#srDPp@#s|@<#5dS-p-csOX-&qGQYK4=r!hA9(y(R z>GCTmWrm2CK|It(fI0n!3%oPLbsT+Q_7S|bIk|5iFarnRt#Y zM$t#5)5&euSU*@X&l3KpAApnd&38zv>~kD!^*Katiyk^k%PN4NKL?lroMRfUE96fF zR6WKm{^0!vH&es$1B~@4%t5Gu`pSCL(&;;WDK+X}AJ8G|VLs$VdOL?9!LS+ne$-J5 zy^AtkwWeQ@VvpNmm&j3SET^3hdA_1Z?_y7*!u^f#h!oW6lZJ=t6xkYi5DVXaf`xd~ z`@ULm5AJaPw?-IYSMUfI31x6-yA%e^Z+#Y6QNkJvMRTaJ+HWu!6;v;qh5-XGuctL*{fd0@oY=BvxuN;ggMztn z-;Gz!IGe=2Kx0-!?mKu6c+B86+kzeGp}+Od`p#~!FhbdZ(w26#WWBSKw60RX6Ri9@ zlL`xyiUi7PI0TDZGA6v-gZJOcsRlU@knXk|Wj-XuN8~H0mnX|+W^z89v}HV>mqq(L zdLlnkbDdj6hpr&N4z<{Aj%1rqJo@bg5{EI~^au-3k#}iXT)(d+6)81(Olsy0)PFGG z$YIJ-%P6jOeKPPR_I!Uip`P5+uBXn^``1bJ`8qVISPS9cu^CA}sYa-75=!fA>xqN<#&foK7nG3VS>rj?iq?Zm#v~PoiQfDmY7%*NePb_!Gw@J+q({(7%d~lk5zr(KACkA05nxhs;Um zYh#8T_Cu;N%T_?r15YBJmn7$(#&hp||5A_z+b5d{~0^7erejD6a!w=A%bHe%79(fxYt8%rwi9v72T-< z93S~6sJ8ecmOIb6%~yjZ^X)xB zbAIR-3<^+D&OjCU0h{`*D_j#^-5Tx6{ji`>&@?|yhU_56p6|~*`0cYr#W`L3-Q6d$ z-Ps&vm7~OA!nrrEU4O3h7a{-dGcS_nkp8dzoLfmA3(c+^7STi=+B@<4p;=l$tr!hr z1QcC`&;P)+->v%etz>Z(lw)5o5G%)x(9s%L0`_UAZPI7Lr2;WNAS{(`9h1Fc zKxEsZn9Kc?vtV=c-soJRGzdm%s85x8%xzT@+5Nzq&M(*d+o39c1>y2kA>Vk%6QwP| z%h0yR8f96J-e%&8oq@l=$1|Upv=Bm9eIz)H=9hvmXI|=?aMFpOR`-)39A)94wSdEt z=&fH;t{r9``Vh)UVsyy07ZWBVK8>9@Be+d5O%X8>kdAEYw;xCJJoi+Z!K|20zI>MstqAj*z65nMgXLOz&FcU$ledZ=tn-9yEjt&`y zZXbWMeeI9S?Hty~zN@qL`s$yxzg@<+oHj!H*D+1eF#g#njX$%cIWwS}2~Py8dQQQ@ zf);43Z}05jq3gnGGvfnAJ@>W_Lf!juB1EeU={>pkWqNcYmeh7e4f%U{689Zs{ntJj zkE8!N4@2VWO;2pXZvArHtcm(o?DBtrna-0A(5Z+JCofQhUl-|TSqysCpBnRQSzCp7 zyNP~Y4I~(@ut)sPu>OG^{7^jv&XrT;WeN`KknF%u-C}V~(#xl6y7di1)xenCB+jN0 zTUcoC8CYepg_)p{A?0_=`SD!~x|Sy3LJO3QHzx9>zLW69s_g$I2v?1ItY}39Py!|< zz4)B*bu{>R(TYk`AXZQ*<7$CKO6Pn9m$vH(F}1;3uGPlm7k|InefYbK?kZt6(xo!W zVbqp`CkALsy5qh(KMgzoK;Bv2-yEEiWMYTEmiSrwUi{SZNpAF3u)cDqHx8QK|Zby#^4|eLetybs5E=lLxs}E3O z51;w(o58XrJ?;;ydCn1>>b;~SR<6TztEp)-!Br2jWSd#@?P(F~zmKSkYtBfrN0%&5jZia^=<;BkBSSo@APLooXJn916ECfe@5&cL|vn=KVh zi~~{C)$M;YJLjW@=P3=qU}7?^uYcw;jEyqhnxZ*gX$(3#?aUn=4zRo{cB7B_#tgO_ zXT{Zb*v~o2}k{vYNlpbiU~;j^TIW*peE)MDE-c%6(qHKatyQYO?WK+}5R^X3&>L-B@insFyfp1!PZWZFu*en5 z`K}AjNeAK0Trf0^10MC5CIux-g)O@k}gHCaR|eDJWBT`T~W~9*hYjRw;01$e=4^||7$;XZwRKK=XrMd*W z=r+nJmcN&g%;=VAB9~E}Z}mp_<(~=p`L){Y#-Vbdo~TuXAdlUFQfSUWTEH0GY%ESx z@>@My$~0v?5z*~nxec?ms{T1O_h3;dd0rZ!?aJEy>%4@0|A%-y44-$F*Fp@>TtJ2o z3m4VXW1M3Bg*W9F6Wt^QLzFjI^{;Z&ZsHFs8@gry*v7}My&4LK5hv2CscubfJiz!~ z+Mo%fW6PJ^a^vc3M$rAagm~Te$wHzHa>RP0s9U!0HF|8q14?Wv;AFHC@Iu>iPseZW8n&mHe2Y%Xp~+2M z5?>a~CU~6Tj8SDAUa~&GUh-X=hVKE?6@2Z3U(`@6GHLku3tX%ziTfL;pfr2Ez@{Pz z5j@$Tq_jRX6!};AJCGR-c+>QYEfSGneEQo7l5W~tK3=fP9{d za6;xGHi#-O-$#_z!TnE5o<5o6bn`1dF|CX#3~fDv(sXm9Eez=Xt2cKY74;yt@rsdL zRY`NEPdCsGB>;hYta()h`Xx?6fD~Huc(-fygT1O5kn`BkwKi8MqTM7FloEa&uun|* z*_A7#3c>z(7M(>|=bj%k$+lhh*z^EIlo3rPA-)RpzU2jI)HiSn{~=1)n1C_kImJA^w=VMeHaI3m!JKg}CvK$$huzdgFbGH1MWsZ50>*L&2LIn#6p>i?e5Skhl?;gx+ge!ndDJ)kgu_;2NA+=c`z_4H{H9tSOX zyR}7!K4*u}XCy~&l@Eb|G?=p6@K!c9;4F5PjP)zY_MOg**ROHol($PbpC-F)pt_cT zhwu=h-*Z|s)JTdc!I9;ric(Ij`&!fe*NjtsiJHS)5f{;Cq9Fn8-jj1BmmCV9zdDBj ze2`4OcSRDv&jC7S1gT^)@y9Z8%FL09EHQM4ZXr)pGyL(X^y^&;URHg1H0^Dw<-zI@>fNR6($53dYGS{IM|Wjy@1EBf*0U^?0D>C)t& zl6C7JmF73ZXud_X_g??d9vWK2U#TALg70!P9ve03PHKUmp0U;as5hFO{0-tL3Q}sT9wP{eIYva+xSq?$Pn`Gcj=rR;iS{&KY0{IiR8GMj^mB*w=`Vw2?_Z}QOyhO zfV4er%$QOjwNLt`h@O~6&XkWKU=?R_^nRHnQrRn`lphXEHo8Y0V0th<&7Q9O(Ldfi z@>x8sav`(;V*-JBn#4>_f}Qg(F$N{2u}d0ICLZA{EG*Mw8qrtAFR&)IxqlP+!h>7< zZCEm@{<^aDkx9e!WA7ph?(WXT$*ys9~&nS}u z%(qxN{fFUm*}hlzAj!cV$U@{*q1!?#qpHnqO3X#)2hABhda(HZt%TywZx4G={`ZjL z*MNNuzCR|3*72nJn;w~Ox)}A6F}+s!W6u~ewJv)}d{kg2?YFj2bcMUR!=~Ky+ioEs zAvRHl>S#VAyeS0IN2C0rQmZ1Ig~;iSHZYS9^aKmsYgAeZFPZV0?h7W{&dF$+F>B%} zOHghhX>AWEtCi^qWe)wO4u{SD+$bh(tU}XoLpx?K%5=pqdBKS`pT0-KS6XNEXvWK` z1D(k}Gm$>?xj%*6;BJ4;_rF4`YF?1xx1t#2?637cse|X)%$ips*lpodMQu2Aq{b+D zUoW#4m5IrRmL~V-?t_Q$YHoX;tjaX&{9Yb^1Q~KXv3ZHt1HYc7*VtCBvyLM7 zr`Y}is8v`H^DuMHg9wtly%b0K1W)!_ae(sHFyGZaJDX3VyzlcTZlFw%o6Yr8K7r?) zDQ>rR(=mtM&lwhajku7wBg>oKauyn7R{YWII$F6PZAdjfcMrTPyeuIOO`P9fhN&_~p|nhV?$yyui1_2o>;0!4Wpfn>uPPDLWVOUc zcG$3zX7eRk!|tJ7>%3`{==&spFb~I156;*3Wv*s6Y+abZe@Q zba@6AY!gWAosdn^A7o~}+GKdK62c*0_f002*`p&~D4$lR_;WiB0vuXshi;b?`Z%m0 zhr{8gx;Qczos9?~icc`vGF0N9;yGEFMu+;0Q-SX74Mx?WFM*$ZXH<(?=X&Ia!i8ot zj{yZx)lknZb%=DV=o zvvB8y+%pK%w<2{EYeC(5Q~^CgaRK*+s|qlA?bj2@s#ZVJ&Yqm2qGBi8ar#a#2kycg zuaMvG_oh#0tK_lu60xNke!HGM+|%jd;|!`|+@8#jZIX9wrjT(!o!_zD!gO7CK6^*|x-hCYxS_+Ejuzn^Wel1_d|EVx$~e*_ z97E8TEX~HTjGpobF|Nb#hvnz>!uGW{0pC#j%|x~NE>onZrt18IWEXl}FVd%`bgya$ z8QPdM2p->B@5hc@^WH7YIv0qbH-=_qS)<@UwkUR5)d5Q; zC02uj9hhcVe)!8(@leU(!wcyc$D1!XgfZTe)BM3cD$xA+PfcZ11nQE zt*B>*<`ik}C>v@uH#m^+!V8$|K#+cBjdq0@0=mCpU5MM!EHG-N(DCI11p)$s@9l!6 zVvcaS`1)oV{4c{wP8=~(xlrew=JqX?WyiB%U*UGKeDT1$JytrJ-;C7WV&aO=Pd}<3 zKUlX(nSJyl0NeKtd96(zA0Bb&R#fQolOJFX^TwU&8G3Q&>U$ZezWW&>xPMzOFdSn+ zNOwb_h=1=_97!(vdpb`h9>XJazQyT1Pv2L3j1P(yF2XN$-MV$SsRw2<3zQr>cuoJD<1+@gXn=J7huil z-?)0UVONrk1ZV22A>l@c!!>hd@<09FW~DJ;5CP5FEBKl-F0 z(gaSElgroZ)V(0k z*dbEv4=ePSF1X%k^m#TN>>F6~#~6B(9Hqv1CE$E;x^`kxV$>N`l&U~#41Z>*3VrXh zLsy>tG@R#3d}ABwLyH{pLkI3B{9c&T0If~9qP#qqlIck1VPFbbkydSzJ;j)iS-pzCFgb+hqA;G#$x7meqi?lAk*^ZL=yrHDF)RgU*2<9!?;JFRtQB7svZ>VWQWcow zf~ZG_Z+}a9-aT|2uXQFIQ$MBin?M;fd@1X;wNj|eReUqLZ|(THN_HY>y85JN&}YqY z0jI9gP^K<$>r$_c?*BA4c2<9^=OPzaeDW>iUBVJ!7_bFKNT?q9JNHJ={%0gmm>@gr zwX2PHyR5`=^Xd5)Gc7G*^;~q-5ztC2 zFQ2zd__zg(f&O1Zqfzx`d+IaVbQUreqm#aeJYA%&G5hz@MW(}oM?ewu_V=&(x=oR) zQ@zweq#UE+^6vJFZEe!3IWOm41-;o*L7)Q(6SXh`xbdy1$c@7>51ezabU}CAo6M$S z`+Cg^!9=+oZ6pp}E?{G5$SY|J)2VbKj#)vz?)!q>#>A?=^nlEU8y%;)A~y%h12EDh zp_qcptEb3vFP(dJmnA{`rJ zI<)}QRa6{U&5{a5#Um7O1_8@>z?u>k35n0p$+v-3LN>E9Rd;7!%3HkqiMZ_1SP&&8 zhszZFl>5p0f`{n(osQx3;iELFbM@v#jzP#fC8xc8iZY7p=?M3ANG0i zRDavtT&2Zbe}bp(8Ih>d_n0;v6rTJaO4S#?dll;%q48nBN(r%P>mye(XOkLz=m;5) zQY$FgOoesixW9Zs+PG`zWd~42l7zaRFcyQ>7d8&mO!}E1a7sjd#vsN$@}meSMPK@M z^0dMLOKHa2KErS(h`wG?e!5nVA~`ZzDl%YKkrpQy36mBWXl`{ox_rJG&*emO;Q&gp z5OZ@AY6Zc_>mF3+y7^jnp1ThAc-zzF)Umi*)9K4dP|88So5$Ay6YH@w{~Mqsjkj%a zDm4coM8w_Rbv(&l@p@WVWqvc~jYB7iWTI`f8mtDVAX_6^hx+4_jYJ;H(Vu^qRnDOX z+L;<6UM?x+&#_OA<@UC}W(O2Yy2#C150b}&cU0EIs$9!0%>e z`W8R*ZTcFzJ4PKEWJ-cSZ8+za9l~i2)VyrbT0Ic0eU@OE;~dafuy0)wtrq;lfdXB6__tm6c;pKd5x6==j=uVB#Hgy322wz)BA8k*A$Db}Oy%T*-EHu(whtW_ zt-I-Jlb3qA4npR%L|kh4h02>2&^Xhw)9-kv#dS3S=O=7GE4mS$E_3?)1tt@2$%rg) zfx%yG3loZ8E<{c!f z!arBi>mDefiG)%=$*wzgh*$Qr0QEfEB6azl+KobahTO*{Ddo%BPhAJA6uR{y%<{uO z%}d6(9TuY6PFtgaNCm8*rAB*~UYvPC7>DDwYpLggufwx9{o|0528|$RqOx84y%QqK zPs{FhvHAd`QV!8cT-;K9?l0;uju+}8{{wTV$91vCmWnJTR&e4I{jHIH!I!`uwqbtm z{``k7ABr8i!TtcNTK1?Ixpw|VF){B`Mer=%rc;J;fN&Kvlih!>LOxBW1z##Jw=KK= zoOJkipI%;!rY(LyGK?Eu6jM_Cmh=PFJW}B^gP_zV8+oRDJQN!m)ze^zf4SAZ)_i*U zl-^{;F+5kbx4GPZdw2QHIE8FzD_-dQtq&^@1O~g_#hIM}y*bLU!`{f|8z zof{4q0gq}+|2Zp=4marr%;E~i0lnXh)HqW=Z`g$(71a}J9aZS~pvmL?9Z-oy0=gT= ziw$HB-Q#*rE|h9(NJ?$tY-@E1nX2N^w!uY3hw{$bitaio33zHnbS}rQu1dfh3L3Su z(TA|0wIkz2q_e4FHG-;BUxKS*zfl)BL=MltR);BU3W<=AViFTKtQxkpf!HibU*fbM z&@1|3PSLngfr9HC6q@$z3Cl$ zn-<)WO|28QpRx-;d5sE|r3(FgOPX%jzj3n097`vWe-k~C06AJC%yK=e{hIgdVlU8S z0Cs5iHcvyRBkI#ziWJe@r{8?2fXQwbey^G}6;@jh^wh?VL?N;xDc?_c?he2P-YQFx zY$4F)Z;nwmh{<=DgO|M1 zD51b8?sP-T1^%-EX6o8RW?#)}6tes5RNyL0F z#&CvTecuw8uA40;Sl4h9eh{!Kj{*%Rh$Twb2>h$Zo8C8novk6 zfm}>S{Ye(Qd<-#91hA!+Zkb~Y?41J3q)Dl%;cI7N1ekQBIJR8V1$v~lnq2=X&WQNG zlD99*fW_$Ia@^g$1gCSDm7I?wGx}t^2YhTlA9&!()=X%l3fKc|q!3rM!p_7N2lgB~ zKmAFK<`T>ZTpJju#xQ~;hB9YzB~7vkcWa$}r+8WS7bU*s?Cg;Q=|mkz%yNHWRPVKk zshAqV47oVMKI?pgRlXyErW{N9uQX>rksWupqLaWNhqH}1?SC^$+X=tYcIS@^wiio; z2j(;$rfIK6eW-!TJnps`hyA+C-i~dV5s;1b ze>>qa(fF=stJ!opp5Jmrd^p_>|GHc__Ml*Y#Q#q#qQv<-FzfaMey#yZhW?@*x7|sA zr25-ms@GRWb%meppv4;L#C~cXZq5b}B&_GxRq$=iUzR??jww?$$&|xz-jcnG*3nutW(H|4D zs~?IIW0-;AcvtQJGQ9L~jLjJ=p7pUnGs2Q|ua`JrRf^p2`a>q4!)}5cSw65k2n@4A zHva4g^6ha}YuA1gaM@)C{!N67^V`puViIPNECnEk32~irDh6iZHse<8YMrgdSy%lw zR8g0P?1JL zTBN&Ekj_Q7fV6;gcT0zKmvonOgVG%WBHi8Hu;=pMH~Z?GOO&xl8{tu}94Z&7k=A7;6+lGQ)u!mIWe zQRLz^4CO1?6PgP#4++(0h#bN^<6xaMRKhas_RkMglrd&Trsw2!ud`S`K`kp(spk3U zr~#^vpB4Pv8y^>4Cry@(hkYr|y&SP%n#%Rv&q|ew zj3Jc-jXe5$La!&&&_=@Bbc7%je9C6VhOH@PWZ*H-&3n}1*J*p{Ubc*B<B^ec8)K~M^om71p)HB;;+!ty__a)p-+148CmacQWpq^`Nfs$Y zH!gX|Nd>5sqHaN?gU{gf$;qA8UH&HT2_=y4Qa0Hn%l?&N<%|_p09(#Ovq&s*C%4g2 zce|~}TC!O5O!^kMqokb#V`XzaN zhHqfMxA6ZYz5iZ*j>{a_lvqo(eWh4wZ0R5ycF%%rU`e@4B^Gj~Iie6VII`Pn`i)>R zvT1nMZr!J&e$6Sn*uL?!?v6#ZSV}Txrq&d*DqEr6YGKvNF2q?5cD?=H4)Kd_%Ytw$ zD+|3qjD(jU!)*Jr=#2Q$gH15=oO^*%uUDr|ty~11^XXoyVhGoC6pZ1B892%|bx*c5 z&%W76rT*5a4K&YPW*(T3LP*uvYVkEZ?JE<`(lzY^HOG;^+OZ$7t@*&SuU?O*;g+8EO-J35 z7gF|!I8s<;p;Z@}68?z;he|l#n2=6TXE$}={F!y`?+=UDGZLuaHZaCjX!=P6 zg_ASVyy#?ZxSB~kaYJN5ZZ+}hG33lKcQd>g4>81Z_Ilecn<0Gn>FB2+OZEA(P{L^X zu&lFlFDb;|F}<*mI*k%92qFY;P)Zq-t_IYM>yxyG8yjcBOKmk)3n`UH-an=Nf_^L! z{Umzz`ZGuL3eqZTYTxn8%2cdVKavhjav9Pud6MhTJE&vM3%*38${0I{z>~xB6N3z| zc|v#$C$hqZ{1|)NXZ`+YrXZ-X<*HXfe`fbO zq&C^qBJ5X%89ii>f(ch#9EkGHG5K$TV7t_ZwGSKL|IZb>bE~)48)Pux(&xtZK1#gO#~FYON3aXQt&W- zk3ZY8v7C1A9~|9^{RnS=_JF3`3}HirrK&h^PQkXId{JR$^JOXPyk!Spy!{Nd!ix{C zn8WZQdj3fO`Duy73Wil_9Vx|DcyxQzeYPt5hto+#u1aC>jKRj*3X^hjvM3F0RIAd8Xni>%j6NXs)dhgeK-@CAxUdNP{WcZBl7?WkJ1FRYf%#HnY3@ z=R3zt0~Wul5mNCj0d8gqEu=^lno0yFF*LoJkws*n>rz}a>NHi9OTOYnhHD-a+autq zv^ufIT3;W#-`xwNT;f1+SQr|)*i*l92Q$a1{S7z#vkqx8TBpLC4E4ur1yg^kcX%n0 zEe8gjNAq>6B}_d#QT7+ALgjV$Bz|sDE?*p<96u8NttD!o9&C6vdOAbU2~B=Io=zJ2 zaz7N*$+D#GJl+cuDk^$#>CD}N%Vu!@v5SMaI(g1G2|fE3b=9g zU@s+>K(olRD+{DgRZicqKP08Cd%d8`JroskqP1}IazLfjwe+fBH8dno^C2+$fn7Xz z!0LutG5f(Hq&hjIGUZhO@-AnkQkfU0dwl{K6<@^H437~$Po3P+9JJ~$SBI-sW>6tM z=>~hMi4J1~$TY!+6e5R}VW=rFL4$s!nk(@4mq~80=n$>F{18;|uHD2-T3Hp`NB{EV z8<%VJH^aCR+#kLQWze?p(gnHSUfcE%c8!^%qk8r^V;<`F`5_)%q)TYoeX6lRW(gT* zH(LlD6-O3E3OZ?87)oRRIupyk2^uPjS+o7Ek!uA^QZfF#OhLYB7R6j9GC(4n%>T$& zg-X1cf9FopUvPvcDXJ!Ru+S8uks-hQD>3l5cL$D%SrT5xH{P8Vmnh~>^kNjQ-g^f%&3SA`S4%xDMOV>|F7L3-6W01) zH_nfL>RAcR?siQ7F}p7o1`h^~l~s}9N<(GJT&6QnqY<9I(?jBHXQK?0^91CnxXx4! z8|f)09KmuJ?Uc?lah}g;G2@=ukg7==4AU4)QzZ(@+F^(%lfjM#T>abPhS@H6DcD+$ zcj@5vSsl9FieU`KZT*a}6w6yg=>!trv!Bu;e}Non?PW_JQR|&@tq$CP%B0DR{tMMT z{w_A_imhZtel3WfkRaZ?-Vls{g@jh3CnkY({x4xf zY~piij4VMISyhCa2M_jrBigCbPG##BiOnoOP}>ReuQEzzy)5fnKg(#@*#)gY1J>4; zk(q9O;<$oWTkvDWBE8uVb4bjqTTft^6w-0;G4zH`s6Fw0ER~q>xj&CJ&}*Nrb)ji+ zexY2F#T~rlpet0U#iy*65{l@_;=79SvY~#_7;ox5_*y45P5R6n_W48R-b*uThk+_H zB4#=a&?Qu2lp1nRvjm;^?JV?W5W#={QclH)H=wp7Ca%djBY|eWQRW;qzsy=w-7a?M zYcI!%@dmy!`nVmb5I<<%3)S7%(9JJtIGRnIoW_p7KEJrY1NO;r*3c{Cf=|)*`T4D0NC~+1O~KfQxn}y_3?ThP{5AK1trbh>H^Fsask%g_~UvM5~m4 z&~0V&Eoq(?Sr|-t+KDlMBt%m*ngq3x_xFW*DEXMA^h_T`WWM7KJ7hvO97w7M8h9X} z>anPObAemR$vZb)zTP;;6Q$XTPu89qo=^E>*&XvNzv*wYYL*;ke2-<@m(lzy*B?(M zV71kBa2h1Wdzpk4(nG_df>D6<9kb~fNcrt1F}uu^aUX5iQxoTKIml93i%8fRSRGuA z@zBKipzkG!o?dP2PS;#J}-@tzTtz9 z%(Unp@VGbgZu7WvJoKz1#xDK?-L~D=DEU1fu*(nam_9B#@giw@^`Gj#JRT~n|NCRI zJB}rpI-kcM_F+r~_pVCnVRJgul!iW;Xf=lOjiC{nEd&CVg0utk#8YUpS*N6WX*t(5 zVI7fYkv9Ok&E@9jgxB~l)9ktqL%>V8_H-wUEFz&Se{T&3=4K!7VJO@9{d>zzAtifO ztKjy$8?+mDrHLVbjr!tmofAUQ6kR4Y#N#5OBjp7G;VfKv66~Sp;__{?pJ;dO%9Tcd z%PC(RJ>t(SsNb+=r%PPTED!Kg;SlL zN#0wDVP!FRb;1;P4WrRuLz3ZfiU175fYVw_L#n;v4{FxL_>eqiEMsLg5{)+W6sxov zXHjL<0oC#z(BvWIrvXZyhNA!>8LuN*O5~khvd+czpCgtY_X99IPDeu3B^8}VC}XR$ zj4CBdzSmf6(+&t@h4I81{p3u8GU6%8u1h8spFVf)9dA-T z60q^N!peV5t!%%Sis#`taevr0TgPnew(1-UkL5(dKQ7>1e@X)a8cf7%+lFiqF@X6Q z)I=l>LeZF?23#zA)z;Ss%?~Q2?_;Oh#VViHiW>~(8?pt~H{r1l-A;Abhef$@frgDM zi#T=dI%loi#XSxP=RpCo}SJ^IT^V6%rIfTHy@H#oWCIF2U zC1qt`U1WZJvz765>I9~aXDFnjJ6%%pL~XkW4BWpHdvmkaqoclLNgi%6Sc@V@Pz^`M z?hh57?#);OGXS4mMy-IDiDz*-c5`}BaQknJX6KkBqwZ_ji7^yONZE6fT$NXf?a4xR zHxwYXoYtBJd?s_YwTw=hl2u5%YwoASY+xT&Wn zRX$KzOL6RtfgVMH$0|SnmCv);%I|)GqTIPktwQ$r^)o*YW#wOI#B>-PI39YeI(lU^ zX2|R6ex>L7h3Cnu!&RD8P-XC4SQs%k_pOkc!~Tdz@nq%a+9M&911c=U-#?5ffC?+D zJe`?}RA@Xpr1#MZ7vx@)Y}=Z_yC|A5nh$1|R^b#pZ36FiV)4d5bs9>M5(fI9#n3gF zxZ4NQStBXsl?Q!%`>Fc2I--y@wFvYsx8xFrE0rsDD&Z!hfY4omZ=HNV$zYLIIu3&+q}&w$sQroGe7gMM z>4%^GaUWUaSc|JY)ZxbcsI?b(jCl;S6L47(0&ATW;P?sk?0E+F604U&>qmwCSux+3yl z*x@m%9p9l2g{|tsoUSFYoJL*DXnw9eeZ4;ArR6%Oy}#I!QM2GWKbs@41HUFIA3IYs zBy1I!tS8u=Uh<6dUGNMBDIqO6e>cSLJ-lP;3$os%Vhoxh+GiF1-L(33crFVHQI^IR zummF}M5#ol_A-XKLO;zjO{1stx?fhc1p8Q{)C>HMPCbkytNbSCHtW?!#PzadK`fne z7wR~uM&k^BT_8h z@)LZC`&upm+a~85<^~z>UYKXIQe=-Q7;bj_t^5pa`J>>o!@Miq1C9bQ#IM#+1NzbMEHqkuOPc08 zRqGwQw=TfMwjxyg-;(lhy z-k$HXv$oW;`F99qAtlRHA66%%1NH?6IZJ78b?(8)v)!zuROO19gLUKW+=5?+!;F*4 zDd@2DeXQGVFvmo9&8gRMtThdkf_5*$PgPY6yJdcQMY~_CuKQh0pK=1X zuL%qfNb3E#dy0%p7N=*P_y(N__>5s>@tFSH`p2u9E!klQxUw%D#;TX(}RH zi;x8>7-bnPs1U0*ZH)iJbv^DE%_jk}@Lch^5XP+d%rNDUSLoN?>i6Tol@{vtmda_F z?fvxl;cmaWtGgT9^U0+lnCay~Lp8!-Wsmo?yvO2xy2Urnz}(<7IM z%lqii3 zIEk#ohgy^9=TBU8*;TubRG%SqKMyg|1Cw6pMD+nl{zSMvq)H`B+1<5w4Rw31*B>Y& z_SyOd6UJ2$bhG@+>Go$El3G7~wCikjW;WXYgtci&TBOCwwdhV{X>}MnoKM>SlCoM@ zuE%T9`^MF3f6;HCcJFM&zICSFk?Lkfkmtu^1N`PA_z!PL;g)E|A35bncyQyZMiEDguV`5abYP zANeUT(z;SrWt)w0N*tF2bHfJag^aexvcN0`yDaY)cqN2_db26owuj44Kr192Ppj&3 z*tmrY767KU>s3g7Y?P#}Cd5{=2tCg(^Jgzmb+GbKYKTvTxAS31sj8Z>H~51IQ#ifp z9>@9FH5OPe;uSrgngw16Bz!V~$5kLSIeakThw(31Gws=wU6fDgsPHqbwnTexh6~IV z++2{5fN2gG$GsGvo{}`hfMomq35Hld_Ti8*6(}7v8RnM>E0@@+ZXriPs682zodt))o#Lmw(I9f}!pwb# zOR4t!5hB$^*f;Zz6XQDpn9M0GmI6Mp=o&Rq@$q87<@D)t$@or~TFJ1%*fKEnUJzH~ z*1O`w!4;#3EN|I%i>>_0UdydpRcq-$$m{+bj-<4< zw7>1$_BcKqdhF`_Ny`&>=u4O9mj{cJV9Z#=MKH4VR_ydkmZ!N2U^gI##wUI`PWG1& z6%>eZ!n#AJl_ec4v<$t2`=3if`#B)@7=Qf3tIquyAKK}v<63wrdf5lYQ?m9XPfw~Y zNt6iH@W~~@5N0rpXI8XOv0wg}(ObE4THM9#eehhEUmO&nb}4m;)K?%Ifvm+P8CV^( z+ba%zeMRxn!eSrtWLc^HsOTcN?s2)M86OE`8ta8rf(cAm8Yd2=dYKL#8u&exZ1dXV zEDr96MxaXZ4%8?`CRBh34%aDhFHUKLM^~k-YYYV#$gVuA7`qyYpue_4?BvfF z0Xm4>cT}mW?IT%2VVn&H2Fcewdf?YU-==D_-gRHS{bhBxFg0kU)|KsRwWpMstJyq- z`BCfELcMS89tk%+@361Vccfd5q1^#gHY(Xn+daBqhzu#=t+&x<)rlw+za|95>}f?| ziua|!UnaX`EK@a@6`SLYm-SW(uLrkQbiV^=SgPP=N`3RgP2CP4q=FUYX3~1|BC%U2 z4;TJWFX@M|O#?GHX-S2NlagK$5~Ulp2}j!LV(ECEizHSjtgCa^5MW^ebe7*QADK>K_7jreyW=md3V@ikvtb*Q_Y6U$Axp&U0MNtP*wy@k^W*;f*H zV+A6E7z!XgDDL5=W=hyjP=}x*8EXhnAY&-AYwB!mHKT#;)?zbe&~H1d4?fMOxRO7| zhZ7r9?*0D00R=eI3UX?m=?}m3NlJJ89f@?+bC`4O#tx{aD@gT^7kbzJ)_cV|nINx&94PwX6LtA%3lyA25t))8@q>!jZ_R?@`Q? z^X$lahd%RUz?w|fO4TX&5{Md#@Q%nwjNe#uQfSpo$(YrI1O1?iYWBs&Gq3Bu?p5Lg zt>2XD4!jzngrs%6qtfBr(@P^e+Q`5juv?r|iL*Pqk9(LBTqK|+$MR=K&HJ((}&_xGNc|miC zZH7*7VhkpH=_y#lJ3D3DPU$I${SpPntv=uJiB$Zmh*fIDk12m`$+5yrrxM|)@W&L} z$WbcGr5U?~bY+@ipV4oy0*%?r202wNsd4vGa9ms|q%UnQ5Sc46A%x*#%I&En>~1#z zWAu6M+f;!FX7ZrOz_M2Rbdp7a)_7EO;9k z?MfZKpChq-yMBh-)Z@;?Cl>iwfu0)oEo-l^cO>YD!{s@!acQ6KtaWzm#lw_Vx>2E> zDv~fOJtuuNHl2}a}vXP1KNj!^=IuLLUd&e>?=R?!zz+cMCQ`Boa1xWDvm+ z4`?L}p~6o)9Yjo#SFa{!H0&&bsBEIl<=)HK`|@?r!4oF1?;+_egpbNTS%lCmsDSo!Eq1y`onYGA1>06WEBDk>Yxs~)ip z>MFrut9c(6GkY1P*|thT=5N-WWuDNzQmqQq*3e@d21t^@i0th**!f?~wU}Bs3&(k{ z&{uqoVm4yk=qknbu4Hq$$taozXSKz;-@VX(+NCgQlA9>uiAuczL)$f5S2K$9e?=R#_Bl(Y^z^QUwGhJlcJ&^pK zr#NdN`^S3_w9q1)DpAY(HX;5enw_%shPEHOG_Is7D$N0&AfYRh+IyioD!1>sdmvX| zwqK(~pH20;0wZ0-dNeV&r`T>(ek}2;*v-pox@nOnDxZ7;U@2(}0xK|9!D-ZpP)Jen zk!%xcb}OgAI4gI>@0rZL%i&hro)*Z^9Ho%YU|%3Qe)wmZCU&QQjEIi3iE9a7^zjg- zD9&+4(oX%ADG!KvDK$tZaJmTojGaqTz=e@wf*#NTlEmAv&x7AoQBsQxJvVWn1PdG3 z0u7S!;^nJ5n}%$b_x$=5UFLvCs*K_xFVE7rC z!K2ujrbt8&ffY+oKp6|U*9OCBui>c{QKiIOe73&=f73M433g3RYq_vyFpR|Au=ACw zQ2jHbfOq<6=#A0ewm-rTn_1rTNH;mZU!y#I`|l$^4JyYrF6RoKt8-n{X4Pa_eA52@4Br4450g1#p8^E2t0Z*XOC&K^ng*cKTlG z{fw`_OJW)CXNpZ{Z)FXpe|iWlMbZd4{0e-Q-Ojgvf#QTLAXz{SY-fqh5z=fv0f*M= zZhb}Yo`sEkA7>A#if1q1-T%B`Kv%N)>B+(QwmVz&9O|S1oRoofJpKFv>X9E61@m*Y zI}A9qqn;wbMFLs8=>+BJ+1X5u>4d9gH8?6xgu>TH#`8iAkOT|f~$-E>V` z%S{ZudSmq<07U;9)y62mqMNSR*cA7rcC!-&3CUMb4fqaB?T>*)c81EqZ)Rktqs3w1 z0X|c2O$>oRx*ZXG-)Z^85WWF3Osp+Jz$SGf)50iz@92cp)d35Xv+Nylh_jXhYU*|~ z=l~gIkQMMBu1wpx9CuZq4&SNPZ6VzT?>CkfoaQWHpziZ{Y{qG4b%?$;CqPeP5|->B z|HI^=EWblF-E-)n=hqeSds8Pzn4m#HCf9iJkwy$YcnrhU#X)dqCpCMogV{Lqaih)mb-GYkjFSe_L^NG)FmvArD5lOlyMk*EH+LdFyL=q z!w-nf$lavm3rW2QFK^`|oHgIfSyA-&(_(k5VvHFCR?64btCq%E#uGHX6M=ph(+(HE zR~VTFy(`)7kha8>sidL))ExqPY&0stbvaM^bB+3&}aw?58j zIMbjfvJQKs2cD)h?GPs#QOSTL_P*_=f$4CI6=Pp5Fa3?j$AaiLt|Hk{hSdCmbe!0Z*9f!MkbBODG zB_lrMLJM8gz<2z*<5s|Jf(sc~C&moyo#Q2s#@F8_vCaHyp+Qx9GRxB+M6bU%Rj3RM z?KaK~B(K5n_~Tae3SE0TnknJ74_Ha#8;enL%#Hwk?|?uO+Iu-=vS$t&ckeDzf|8yr zqp*f*WL4^;0ipI z5Uwo?e$DW?9d#q=#e3=Ri$RI$uz$EVTkfScQV*=LP&pZ@e;Aa9CuaoEd{oWZP!*cx zw?8ajkpV8WrU1i{&f{oswAc!@$tSRCcvd~*F>p|-X3kP0hwdMiK4{Qk#Io|yPx2`n z$8P@QT{O9gXKRMq^bKUr$Y831)9ZS&d!W%+ZM5Fb9?9?0a`e}Wdw2>;K>$=JF8+Sb zkvc3cC55=;afWiXHCg~xO{##P@;#4>sgL`!wP8Rgpad8aXA2fW=+8kJw#wtzlLK+@ zmIREFd7(<_PS!)2my-o^wPAjG!}GxzlU)r}@TN?#Q_3X$1nL6dcKQq$l0k>^z~anq zHW>_9JAhmO2n-Ecj4vy5qP!s5^Jt`(H&@QN-lLaJzBCSSNVD3-G#&(tqQ>0l- z3$tRQ4qYy~NrAd_(TZf6SeQS|+{Tfw>V7&~^fJa~ciXd)_VqK^XmrK6*a=ltRZ6+E zK44LV5Y(yVeo*VpBXiNa!US&O8OW&EuzY63N}woH-# z*1h-WMjW7$Xe)&F`QPHqEwM`ubxs&(8bklb0JDim!cL}TL0w03`1s%JY+ndQ(g(&P zkg9P0`xAs<>i$&mvRZSqH5dI~)D_V^JM>rP^u;vN|9*#tEGrnbOJe$A)cW6X`tcwr zf{VE+EcL&~^_5&mBQc!1#O@ce(SJuGPai51Kt1+gK6xNyE3om1EqrH_ZXz}YVYm}6HN4Z@BAY6a+WsFlJ`U-R$of-!7 z62QIxIf%py@%Or@#cJjL?Xz*{ENX0lLPax%)X-fr%Rjg-r7(6oTgL!P;dGBNA>}=E zD?mzDg<9gE2&zxaByaIurpLUe`S%cIJul86l>Ih5^oJ0QM3wGvGc5rSGC+Xx6%-Ma zzWGVVz_Z1byb~dybp@8Cl0UH0m2s`jm z9O@my>40{<%dgu_a_`XJVIgLjQrOQuEkzsQX(TAB0)B?w2ryO6rpCGFNRgrJSh2C? z+DHR{pjCWnZtZEnmD<{WWJ-bw2@eM}8HNux>#^HSI`hLf(}o(9OiXBzy&`~&BW?NW z5gV8TyR`z?gi@{9l+um;EidR1UqzooJ@CHKy1&6kXC+WSZdO-aBOzJ9n;)?3GIiU%aMn{x=m!B5Dnwr3 zAr8RCw4(ovigH&Q7oCf@c9N!k;7gdZ0L~e#55a@-r9eO91-<(I*B0 z!6&l{#h6_CH>Y`AYVvDZ{EAzC+0sRqmk01MJ`oKo%nJ@RA*C|LIZC50O(1XwhUtD$tEZC8`Z z@`~!}lAr_+Wo3bkg{ddudos98Y-W?xbrv%nfHouBXtxpCwsm%c%WC)v*t`D)P#9Dq zDS#MasjFKDCX5)FfbVvGv_xDm;W|)2TroYEsO!}a*dI_o_zcfWjiP&YUfWesfZAaN zyEGIk7ly;czjOB=YtC+z?G3X5+OJL4!+-Q0L8 zD=PtL3ktkrm+joUfQ`;OkX}9D&jZ>S zfJA;mW}r{*qAfi$8P662Sjt?J_nG>*^LB#_HRjW(oy>C0DheR#@FIy^D$msfnJYl7 zOhBdqgzYZ&644~ZX@JQrkx?54P^;!$x6+}T&FRKq#!^qlGcm`=Sd|#cHy^2D$kR`S+(Ev_%_;DNtg~7e04j0YMlC?`!*-5+ss$&i4CoQy3*I|y zql4w+xt|bt{)Iu12a%R01IpFmR4%eX);D2!4XO7PJ53RzTL7*Zosl6Ax>hrQV+YWR zTQSm%E8yK*1slKdKhp#akecu~K8=y!6v9KUOSxFqnr zyENMQo#z3th`Eb@ae2r0vw`=2zy1*&Mh#0M16e4xqsM>+%)GAQp8P&4CSlZpRu zzp?^ECg{2W@SHSO?htyKE8Co z%LF_78z>D-S)Q*OVEjNK2o6ZCR>2!-1Wr?>Ofw#=MQ;-aRp(_HUyJ(0!Ss4Rk0H<6 zyM58RcTo|z?4Zq5+X+YEX>y`PH!RS+7NOf2(jH0G^w+zmfb2gy6j|OKnIGUnDOmj5 z@c$1cszam3=|B^em>*eG?K^{ZQ;mvMDW<=-FbGo9#K6@uK3@I>qAn;L3_$-B=4CPb z?ZrzwF#N0cr#|XJX`E2Jm)&}wk|$yDyL;@Dfj8j40C+JQoF;UcApPKvlmbd(9U1@^ z>v?-lLP;425Qspoa-gI!D}w%rzyeSD>Pra7T8@9gcXf3^R~dlibOn%8X;~wEq3e2Z z)EyeYj0Z4MKAa7)!9X`@a!SfKs&?4^Na6pY4fK)Ve`UA-b8a9$_?;Y3sI5S+2q3?K+1T36+ogQ9l8mk0d$V>fGUmDCu@WiKEXJY_x{M+38U&Yt`1B@H-Du{l|dO@ zoT_*$@yjIf0@tEk#iU&17NzHtw^_=;`<^$(FXUp$CB)Ip-WyUWwkU=NbA6-rdXTIz zpiGvi;K1j{RSt%qzYP4_buzCVJcPtbpAKm@Al@;7MLdEYZQk@E6I8r_MHGS2@K`jk zgK%c%%`R#mBJQrjvs5gm)*$E}Lndh@dCWABRgi+APkp3U6JX#!_^)t(urGH`7l9C@ zs_nz`@xe+*B(xo09A}I*J$e>$caV|tIt5>)7zTh{fj5?uk%Ihv{*~2M7!N){a(JWV z41r)6J^z6!5-qd>A0oKOD!fM6LVXEK#OjH$DguF!Lu94I-@7jyE`M^-wfH1@deY`> zvC3;l6(wCmeNsar7;Pe0j};nJrmUEqE}%wDekYLa8hlIy;G`Tpq%UuZ~^N~@;7hFX-2>~Hp@<+1nbeY@Mr zPTNU0dp|xRMG&S0B84gGX#(6o{|drH7W>bK*nZEKoSLVwb>ZGkYZKl1nqfhO3`=vK?10wM6u!|+sPYJyaO~`a=KKkz;9(l7; z2SH;>;5My3T{UR7dwrV!t0emPC+Dr4k`ji`McOKP+9=DAO`YbH#<7rr=MnewcO@AT zQ~x}TjVZRC4>M}YAH>QhX9PQ;>3`Zze5HejJ5tv=|IxL?*=T|2HVy4w!@PLAJLa#u!KZJa{4h+l!&m<4o$jiw-RI$e8kdh_)@B> zSQ}@2(IkTKQ-!3r;*cTm+(23l)uwjiE@2r z?_6}*@|bK7Csr*Uy*hdE`UM_~Zs*`2;-RacdW9}h?xf~<#&sdp%doY%Y7^zsnYngv z!7V3#h#`0!tx|^6$B*1RwsVjadG)Ik$!yGMGEww=m9TQ128nX@aR%Ypk+hV&+sC*e z>Q;SLVswOrw`S~0@CXQCnFFp9ajTxta`5?jvLLd!`XyxiC5KBu-y5Ey( z)ta`_X6xE1@&#X?Qd0?S=c=;Z$7+WPQxZl}3M_aA!liThd>;5<#XFCeTP*Z`Bf!Hu zoNc^*uc5IyCU}zW*py;-n`ZZoF1g~iNP}~nA>i=}Oz5DLGWgB3QA6liO~*_Rd4s z`@Gpq&tragzt_2w8#b%AV{Z76tJS}ct3OOR*deHpTJ7?~pT(-RKC5aS58JFMGuCF1 zuPVi+kh!a)#re58%`;)qyU7@Q2repop~A(}lIHe$}eC4 zT(h?Qd8t}DBcHFr4k@dsi2lasn6ss+n*V|36K6b^L1|%OD3oExO&@D`B?-S%5R@S^ zGxMvH$4&&1&U*W0?JJ>7kNslfyVbuPm6azU!`*fIKDTD(wexSMKCt1>4Gs>LU0BiV zIJN!xai!UDH&gjlz0?e%siU)4CL$R}eKk|*lL%%2D{dG-UKK^eThsBl*zxV1-dBbH zZb!-Ub{y!9H0guw2pHdC^lUBt8$Yxad12M;oVl-m_U*(glpZ_W_|rOHwD9d#JX8G8 z(rH^tY+p1uxAsPmb1>&x=bf>{hw*JEUSdBcgZ6Y1A@|sACw|xcpY-agsy(iUbL(Vku$!KHYcx^)%-qB!KX+v325`Fnv?xjFRqYKa2X1AUtl$ zp(VdFF@cE!AIOA{%JB}{LJzm%^6sFLGkS9l21BT`xut~wj29Z}Y9oRbw{qF`{C_r# zB{|~p>AJ%rOez2k9er${^XYN*?>8tzCE-i#h=ENe(wN#xpUcv|{&RVl*p!5h`Cnm9 zd#RNk+|v(f$J*)}0{S|5)UphuoBMyk9NE%F`;VIsDvSwIWknR+j<=6-o&yUU1~82( zL$*PXweG>|#`&U63~q-t>~~k>pEGzYKOFh?lc!Jy5xUsZj_*_9R@>@LKQGuQFw^mU z?@0D~n^~56*49o4HcUhM?*pCH)Q|dMIfEco-QUf2h|srn z{Czx;Te)8g#NdF$6W-X&R+z%TB`y36&K>f z&&e#wDV)4F#kpwG_HaJJ`#_M!V`t2$QDGWKjk8K6`%(u4R2lUDzI-Pc*iq8+%^wfG zj%*w2SGxVW<(g?q7Ca_#Tk0YtBz&9U%GN*EgCY9kyEe02zKU~2Oc0Ya7eY|1&Ti)4 z+sx{Z2fyNG3)09OglETSt*os4sbx>yg)HsuGtTZo{sKiHMDU~)i?#JsV#qTzG!zN~ zvbva!%|YZ?#LlO~r6#Purx<_zCMVws{h5$#1X;s~BZa2z`r-D%eJ?+GVs+I(cZ}nk zVs1x=@02Gv0>^QgL_|c{>ZR58%gwTtVAEuM|4v9^BtCfkeY}>$gmrOokxxmQ-x`&l z_9|a)aog;}GmrwM6r_B`bUyz|uWd$rBBCB}5Kp(_m5f*0y(cWW=4#AF(uddNM}DX^ z>7s*b(n~9H7G^b2u=<7|^{DB`w&wM++bWuG|Mp1o8Q8&QQ$^?jNB1><1d!zW2zDOj zM^`c=i|<>#EwN?sdS`1tspU#Mi1_4K@ZZe4`uZE<(TzV#G}T+-8F zhsUi7pAS;a)mmV%=rso^r16Y4p<~v}DMKU%nSV}A1%QO5et7Z6!`liDFK7er-gX5q zX5h=H`Q++qjPK*D?>CopaEnB~%IN;ma|su^KdikO{ooUr`FLm%JF zFYCZU^qxTEetz5-ynn9AnU)C`MY*q?04Sv{0?TUxxp^F+y4B$G7-Rdm*?dD1y$q}rBe5zSkg30IQxi(j8{%AbsRSJEGO52N*p zx@i@+B^rs17Vp849yfTLF<6h{UFpma_N;O}THxQFzNCJM^d|0oy{@h|GcmeG9y+E3 z6e2|)<(AW@`OB@!$L?kV7XcD%WH?f4u`S_tAP^Zwxg|CV4?(R;987tS) zRv&1o?g9At(QL%4+Ht>p^47=asBV@#d?PQLCUG#W zcuFV{91xSgPmgmgZXX=!XOfa|8+BQPE`D$hZadAA_&9wO4KU^4KQY@hPslEwQVla1 z{muESLN5ZmIN^|z6+9`#=GCyltNmWDpQZEqfljmM<|}SsJ-NM(Yz%rh$AtpNeXeSq zhYM4FF*fN&kEZc%Ud|fG2z+C?T`sL`N3NZZoGI0qPA18Q1Yy=V94^$M5D%=gK5ej0 zOiu>_fcwuPCo*dM-o9CVJa&5#CUpu8+PT%ks_Ri7&{ko1!dMUV1U(J3X|b zx3Uia{E$h@$h?RdsJ0jis)>_;OS*32AMP;asNu2=h={wkJD6D(A(Pq z-v^n8-@F~-Z1}y;7eJkT0f5NOM5qYYPHT!)Y9Wdkv_E9*o1n&&P7B!l!^H*+ns_84 z9^0>1oB*alLB>VynO3|m6k0ET>EO(Nx|_Gid`3GPeYjxNXLzv=w7>$WZiqyg>p}Faa^TdsS0f#cYB5GA|lZ-z7Ly?Ubh@e_PiM$ z`}D+o4iJOKeGS^9A<03zz~AdwP6z5;srF=;{rLAQ*X;w~=)-inXIMNZig`B>DfAj$ z&92*D4W7=EQ6UHW`>8Yc6#`CMh%KAZf^XILR7z(Ks|QFKS@ihh)v5xz$ZbA+un-!@ z6P3Y)y(;v*D}2RB|IyX8My*sGXVrv@aQ+!{RX>BT0aDMy=Dly$+f|}>xuV7gzsl48 zT>k~|Vx**`Bz!=p!G1YU=qrQwGgvS9#IWx0b;y*XVAArfdgm=ba($4h7_TiVPJwZY zOz$La9vj7O4LS!I3Yt+ZRN&uMb2{^ALKZAQ%;G5cHwk>Voo_ka28 zZ?unX0K*D`>P7~lz&+#65HV3y0x{(S7i`489GBxm(S7iL=q`BHzod9i%gI>`;JULO zvM0`w@8dqU&%-9!^bF;{_d&-F z69Qx)e7ywIrjG$}5cmf8u#B&-s2=mb!^drcW=(!Yy>ELL%{SC|>HdJ;Ol7c_4xP5rV<$>$tP=xWZy zY}I#nf}-`b8>KH3D-0GOG(D|J;K_vxZ9Qz=6z48!-P$HffkpC!tMn0iFAdp#Z)4E&S#y?%2-{OlI% z*TM8}S~~7qYW}-@re~VU@e{A#Niie_%vdvjTDGpE#EqEz|1Hf6SSXMS`Yy&rF)C+K zvewYuVuRT2lpUa=ub<1jg>Fa-^k+NZp zCYzU+cXJ|J5;3&r>({S-;AZLEY{q|Y0N|fDX2>*P$TWvh>ff)t>{iA7PjLNDWc*J= zQT&ha^FP=A7g6Z{cI}yN{CAuFjne<`nG6cXFR5vkldSM|&*RhVDEa-vdSTC1NVS`A z(F0)^#9tFgg0I9bM$_(hC3fPt=a53g+OkO*Z5fpdD{~=1u}#Ba{ONzvdta}<&U2#o zgW+>1`lV)~)5F6Tr8rFeylzW8EcdLN6KfQC7gqQ<(vVJY>mOLps-7ko#v?|0pcJtv zMrCv(jU)ZswO0O6gaG+0-|JwCe-D4PK3OkgG&@J1`#kKLt=o7XVgey(e%8>QL%MeR z=>@h7{DH~!+$x)+Dl1z#5mrld#3uTHVse%{mK<#zw7@B4FTMVuHI61s#Zbpd&o3O| z&+E_t=QbCmNfW|gHflNREiy+pq2SNAj2;<4R@QiCX9Z7Q~NzG>OjaBEa%vf ztpp>SxZy%fSs4g~CNb>y!t+y5q{wl;UU_Q0Qtiq-UH!R<5d!~WEGRp!Sh>7ZI=A=* zwCLY;2psuV!Jypj9!iG17)_@Cpwyr^)S&KmFY#DR=0N_L+-LLLH9mCd#1}TDzl`l> z7Id7PpW}Ma6T20fvbT6qkqIMT_mgV0_q;EGOlUM^YM2Cts+cJyK7Nu;l1Zoy!gnWT zIC430CafMyFYIDnWaJcR?q)*GpGk`}j~@A?9Eu_734!U!$)jW~{pk7f{3km}!})BO zq@C_w#FSX?^2-B8wipN)>c75`?*=Q$$LR`>o0!knB$|M1)Zr<*k-}HcYma~s%|HXj z>Zhd*gU{0XARBr!1{hn`=z_YJaN2mz^eR#l`M`0( z^2LH;7G#TN7ujX~X3!BfUff}goE-^_&F$y1KN>etr?Z^zzCw8gE?Pf4>g$jRTYDDz zpJBGp1nhxoYNefy7mIWmZ{*iH*Pu{kLMV2&!FufsjQ3Pjn^FHy<4sq!6 zgt`pzu-r=BIB+c|v2G#+H|0+Ld{Y|ze0Up_*!+cG6ZLd1!hC(J+YKkSBghfn6I1%K*u6Ghc3If{Ix@D z^~1H1t6nFOhjVn_W!q{cKAJg_6Cs1u@8sFx$-7h8MR(~bf_gT6m z{8Mwba8;1sE-kvS!s?6p7Lny>;z#3*1$FVko2i6puy!DqE`)Qd*}Pr&!pp#Dz8>Xi zq>?uLq)#N2BJ>PwAdxhi~$6;S)`e97=yE z!gDJ*(S3hQJStU4GE9>^^kSs1C}4&1WjyAn6a_nyKyby}=IghKL~%gEmWz64)ho%2 z(S>zEo{pY7vKlN!4wXBM7%>bTy}1_U$xcktzr5GtSeVOU7iR@SpuQXVP06L9(o~X- zq|e=$*!AOW8?&u75qvicA~nneK6it{>z2h&y!BkR{)4?b3!R90&=3txWOtRmExuiB zfyjPoJUvn(YT&yoQn8j5e|qWGj!j z`9TkC9aU14_^YA`TkHOk6158via1P(-w~0?T~;mk zuwTL&^i~{*8^}F)D|ri?+C3o**(;hDq(U#7dh=HMYS;(OocR8rmtFB0etWCin+w6AXz{Wke}IoOGbg+9-E>dWwv z=+{_TL>h7NggdV|^X>76$+gSL3A6>po`>Z2e74vy<0a)PR(KO(1SzThgh-lG=V@yr$~I8U0#l+xYJG6QK7ngHctYgc})L?GG0tiVL3-Gd3v|EdEq195kFe(0&4sMY(IYY z9vk@0GixW^R-J*|DHLu>$+ylAm6*ja@9;KXO}z4FE|@vIB#iok#!CGs7pskz0yF|3 zm1kkE5J_0hE==O>_MEM6x>sFxy=w5#Q5;^sId#-M)dP7JYQWJjvMY~c{rIls!vTl* z;1NwavLuE4BbP37(Tg_-zrBc)hl1_K?D#~yh=sdIEw>1_dWma{aYxEVs_KjmT3KVi zlf%T$8u*eZ37x^_Ows{i3@G?Mpw6$ahmz?}z{ygm8YX(O|bA1Fwfh}uC8mY zT{yw~^cn+R?uLz+K$;6HSUOugsvaJ#Kjd}wlv%!p7A3DVvxd?=mk{lC z))zJN!Kb_Z%c5WECTv`Yz6%(M@^Iii=BgKY_osFQelD)A8&qVsh#5Y2R?ko@lpOK& z{;@9+8n?Ml&1PNcW|DmpDoPh7N;eQht0fIGSo{`Zw|Ds+NK?05t&SfYR}-!EF7x1% z-zpn{q<%;?7qgG%ehPw9lUx1Ja;e(#+WLh%l-ti0f3+*MSAyBA;c3Y9hukpg zK7$5AL^4c7J!XH+mfkrdSi5lJ=)@W^iG)1D+_U47F|x=zjCrDSFAyHO9Hme5ZG^+i z&cnW(hb^4-!jj3@24y?;1?T6TjVhBpSn@COuz3BfofUP-KSnnADkj)Iqi#Ih zd;*B(E<e_iTc-=Wn9vWHPKmBW9WW15WD4}iXYCZW$8!GB!m(L$q54JCj{gAAfH3dA&YatZUZ(xo?dpwScD!IR~-=*}-h( z0B^_b=!OkXn%yKeO|ZQGed@7fTXs8N^;8~@k;$@jSyg!>vwBDB2bgTAR?c&DFIlp$ zgPmu@KNvW9X6zWEJzGma9vVmz4FS2R-`E7?o0k4)b2(0VhUuJfl*Funw}m+pjuDAA zURzqE-cKTpRQ8br1KFy(r~8Q-la{uN#``oPF7JpS@slj}BGL zmgK_go6OGLMY%F^o3?*{P_nl%Rx7ParM{rPk#j=1|L0?0beI&6|Cc#L^*Qyd`Keaw z>Gn0~SnvC*b)akXKJyP^ekWL9I=F9y(N>v{rq-O0k&yH~n@>AHs}_sP(@BMIl8>HI zE3Iy}zD&44dt>HqOxntQihFKMs!%{P$fxDV*Ru%oL9&0Os=GdC>jRe)+OPNJU8yD9 z3H}kWbYZ8xLWl(cAlqbdWp&L}WvM5YOwNeqPLL;{<7klVp}XWRuA;T6V6>^kTyh`0 zD=d}tZ6pIY4WmIssBq1YoXfBJMpO0_3fp5=Pa3Z|a2X#FgXy#PXBQ`ulDZlEa5Re4 zu#Ke~{?nHj5ev}%cmVOraOt_XP5x}m3W*sF?xkjv7yc8xN4t}J~Q`w z$g^?)(3_nmYW>fy6<11H!7^sN#U=QT|uvSd%f6Z(`>Z^n5p z9^0aMKa-w;*m$Q{XQ#$M`yx2*oD{l!)L=6l91ghDsL@@d%eA*_$j4ToNod#P=$=Ab_;MaXU1%O6br zw-+F}D&J@%j;;efABrIb8DLWFzAakfNqKAl*a`hJ5?JRvm1#o67}&N$>cB@>T}VMw z*>E_1x=6ZE;}`KsraPV4lXHlGZA{M5>C)ioZG9?8Dy<%=L$N9OMV^2RrE7#(r(mZu zCCQHWQ=UG0GfSB+YkIHB?L`0K(%>(*4@jma*T>5@&kE4hhm23Z319=eHvTrOc%U%g zpowcmE*bIqxNW=L_>%m^_&alEa8numx4R|7?aPowfo)`TU%zrb82yST?M*yvC}l>T6LH!ziZBN(MvR$nPC{ezsjfSr)2&(ao~pFR}e zQBe3oUYm)3C~_NO(z2ahsQyudN;UaqJCQJ7 zz2K*pA!vntW*tO_uj7l0w}!rUB3bfq=L*h6Wr$(${Iu7^ZxbYr`N(}RVQtq39;G~- zplQZxTjh3y7okfdBaj@@n@6NCUielc7+@?jjRqsbH#^g+W5SJU)|Yjbl~$ozX3~K9 zb)vA9j`mS#ycG|7FA`k#Rqtg>p7UB&z7Gmmj5}!Wi9v2<xTpvev?y1Reeas(%Y_fEbeGye=|K7{vz z#Qt~%F3Xue+#HQ%G91$A+iQ{zI8F@L;fF;n)m)euzWE&&j8nBDLp7T=-aqC5cS9j76To-?DRf4-@Dh*IVzI+&=9a`!S1xq%bgrBpe zj6F>G6baxsVbqBPA!w8O^{n|xS9BpSA`4AjA=V2vBnv%)YW41A@i}XrG}b_FTQf}E5@ z1XyfyZJxXWf`Vtj0N#i&c%alPe`O7zuo#D*y3Ik}Dm~mQkjw$**R(UxTX28zUejJL zI+seu=slsF#~T8ZQz>ChBOR#H5c?82agof-dViKp)9LHeW$Ksl6C}IRp_MS}^7zDj zK(wf;_h2SOMT0;>SD-+p{j!Tl7>SnOCBx(2njlk}|50%V)Yht6M_Tkoj4Z(kw8SiE z1oUDrWVKWVK@kQ%FV`a|4SE zA3=Z087F>Bj3l!L747d>EN3v~D1gA28^2f7R7wC&1ema5TWuqTI%Qht8y8qNfn!}Z z=UpHiHS|7v30^0jt38`BqUgX*aTkgn2Qu4DTE{I>v$ouOj%3*DP~UBUp?f*1YZ$}J zOZ7s-wqQLZgxN}efV^vZp#?iF&WDP=q~?of*X=cJkaOOL=d{BTsGWE(tCk2Jt!r!w5gUVX{qt$k7XOoTZ^yYkk9q1dHwy0~!j85EXX^ezkTlqpEl#-`~4}%e( z02t$o8q*?^WG`?DYBKVj!l;u+>t}b7 zcgY%44)xT#&e3i;O(r-(ci99uI_{QQez==0V+1RCl4!s0D&$C0r!C3e*co#K`)X|u z@PUAfbnS_=|*k;+Qvz9FVonc)L-_IEY&mXW0E$>{cN#` z=?>*u?mbl%>CO|~6Bs&4au`A_8+*n9w#Al^=-8?iL7|{PHuFI4W&&?Fkas;;H?}9+ zIje698o(xX8^$dTe#Mw?A*}0?`adLdCk*3Fuy}sir=P9JX1gFFEF*mR@rw2+kOPyj z)4vPGz4gek2<|d~d9&+1rc6k*A518&vz+XvBPF}PoAio!V!gHgwGGHJZgXg$GCMG! zma9Zan@}ZbB{4T|iw72yUtJyby|IOr&VS*g9}Oxu&>S>%>Tm`11TBbz9M;yj1lG9( z@D%QdP|O%rBB%t0@8x>Dx)zu|dOxR@sCGwj}s38NN z)l%7@loaPX+ptldYpnmZHz-i%v7?MC4b0x-jLD8I<2h%b-HbgvNAZUHGxX_v3>quu!^CU2Km9R+*Y+ zeem=JAe1>n4=ctHR8*=jFP;g&vJ=T+>a{Ct$3{m$k7VeJkzPEjjqL_;X5*I%`Lby#Ww z01IVy@je!S&y(zi2ySFFK&V-_9bInd#yrRIPU>>Q-nrZeR87^t1j~;%`nx%YdSmzW z9f-S0YkOvN@tW@E1c1_xQZ%Kez|Uk~tc)AMb_$ndiTG9$`74dj*Hr0LPOEPvk47MD_)r00A-p;1U^4YD)6d}7QsA` z!2dmjR$3`b+Msq#{SCu_nbWhDJqh56vMC}cAo?@WJUT=`N@}3~P`FU*zsYw>9HVJ| zK9%$~<)x+=${4Jwc&E@_^_4P;m0 z$u)EkCDXF>tY{*NwK}q*W01m+U%ZOiFI9Slj!xPen&gWJbcBq}9WDbKCLSKEuCP+Z zfHPtY0FcNDG$*zN(~*=G9RLIY+QN^;Td?2`9)Gxq;bmk4fucCMcM_zY-51?Y60sq& zD|g3+Pbw8yosI9++JPlUJDUw;8nt@0hDVOUNcKM=9*#y2&;dh+XP(V%1tiQ#xX4mZ zm=mN#A|XI=T;qQ>766b2^~QU>d+eN3>+{;i&Fl2jbTMiY|Hx$VIO?J;hO$!q(3bs^ z)Ot>CD)ZB^Q^7_dM}j@CW(U^a{67y4s+XI*yL<~(AriPj;PjC1Z1WumM*!Ia-y}FJ zmD|QKd6Na1>9--B%A8%ZZe@v@-D|Kw$5o#1V9CXd_`*l6dU$MGws&%HeG-X z{6aOu$rv5a8_!6Ykmm9?gDEnQ&?mM}Bs@Rf2WUIFGE~c>0+^bp+!6v-6F*%U9m+Z95;A^n7`bU6#TY_1vn63T2dXr43Z4&Vcsn-6aCz zF(g!*G?nM;5z5v2!~}&UELzgyil-CNNdI$@1xOU&`~uXMF=%8xDb<_~yCi+igL0ox zLlCMfeaT4eJiohR6at5bURQ6Ss&7iga_h~f-9!(~_eu0bXdt()G~#Koqts=E^sHsQ zavMR+mrzEW{!_xhby{dy+fM{^_6e+A`j%8ha9mWBS#A=|q-1*m@iI?rven}(i9CJf zbxQka=zGI!CJc|!U%ep#WfI1|yS06g7a8xrb4#BL|E*j=l4Q(dJco56)KCBsXh;Cg zD!2m;Ju9j7tg{9I_fH+Ln*#kQXt!xbE5Yai+TcTtPMa1R?*|~Q-_R0MtJp#58w(#7 z9U6Gy=RB$iN=TEo=*Uq#3?xTWb1N^d$BillafyN#x)=hqd?1E5%2&WG(*xzGXXr~j zfbDFhD~m^Zl@lgH{Lz4YuCeg}@2kb`#X8gEcBuJyliHs9S?tV+DiTkI$!`;;~?9 zD@9J=NBg^r;l9N9aaIz;Z7@n`g!M*2R?i$Sbu_p?aQa67)9~+F2bm>@6y%P|?`JoB zS7?VlnqH{D@`0u`Bp33FXpaCUj?JOXFwX*iMjBVTRd!8DIa?7bV!otVXus|^(Yz#$ z-}-Z8`vdD;Js?Juk%zl8SmdREhts0lf@?d$gH0eIkjbL8+mn3SMdC^o7uHF1P05^p zCNuIEvHaJs#dA-dL^+Cdbfu>KOciBH+TXyEC`1)APQibm|C`XG$jpEOYEv-IuVGm7 zr#!NGuX^emx?ge*Y;Mn5202;n{1Me{GjC^4I%c$0b z^SGkpzTP(h9s5e#P(Q?0L~u{`js7rzeD4Z%JleDuIdob%7_)JFHdl3)-Q+b(-=JCy0 z1)X?Y%{DW`lm#iG`Lx%CiwBvXl~qUq)47QAXIDvej_A*rtCA}%w7$1nFL$rpOxT1z zM<)2|*$r@vZ~%N9j?{RIc0;?-?N_X(1p?cb~a*f^aq zx_Q|iH`4>08BmlO*?gd87WQS8&I9(yQIRF*IchNp)TF;_)NKM-@hqlUBAWma;03Vh zh_v}D(g9BZlnD4#ljh#6N*5}mkJ&z_YiACNJt$7q2@V3fD*fu(y3NPl{;HvrRPhF^X@>?$*LYF|2j&IlL=_cjRo6XJKk!k}2%KLJJ8oKJgXE>^F4BEU*8S zHdX3T`i(>|B3DwzXnG+$ZAmr`R%t2F`|-Fmb=@n2enV5tsQ!Lq$yc<$f#WL{(UfmI z^0mL#5&u1WS&4QqIGL1th(KzUHIt~TAOxZ$fNom!f}7uF05V$H_eJTMGy+x{V!9u= zl?8#tMD>WqwqjNH45C^&u?Z$o%~OvHzJrQNlZb>KXtDr5Du4W~J*bk;v`*RphM#o+ zP)Q&xHU6lG3!xsr&{VC1_q@N#an7lwhJ=}!AW}m&7M^8^j+w131G*dDGIK%R1gyYw2RkOH1p{%WU-MaDu`Q5t$$m0 zBR_@yHCrZASASQpH!rmYcj$2BM~?L@Lhxk5L4Z|QR#VvxNWkj``t?h|FVe3wLSNg_ z-v+FGA_WHbA9znkpF<&Q9UBYp59^%@)`(}sF@($ITC(y9QpBVJky7`t_!LUeswVKDStaT1IE~7C4^3E&zoeoQy@n6-FxXcg%N@fE6)TU?&dB z@|S%tm#WSGqyjTm#%TC~#qqy?9{n*X;ntZ<2sh|^T){1Hv z4FA5V%?_kx({$VZsGHV=fiLS+_)*C$i^$mhSDErRfkU7#1>h#&?Yl;K zD_*no<5%2NuKnDlhgI=6{-idX06IW`PymDwGjKSp>*`)9$sV|Td?s!HY%crTgD@5v zk)%*vQylmW%vjQK9CGC4L_H)F$&O%Oo4Fa9mN0{=&U4SOVQzoT2v@-)vdoPH

OFyQmE^BzEB2}r|Wc1FXrkswn5&kG<^n&lI44ya{Q&zweThYws}0cD;f+e3)Q z@5JHp%ZF@XsN7;dU3IQ@m(=8}C}X7kdX{>t3am$4g~Nx#wLn6Y+>xSv*#zr;3gD2Y zK`rTs-N?vQDj@hk$mk=Amo*ER-qm#yzR96B2I=aomyhEXRo)s4h+>=!ojKIFWI7>J z*%Fd>-tpWiy=!5gz$(3vhkG$3HGy{+IC9wSx^wlKQ#Wf0w6h$4XeR^MApF)`B}F;6 zRI4h+Vu!E@%$lh-VO4Jl^nGxNgufU0xO~eR$==vw?{eD$%r*!{dllDryVrdo7^8j4 zE{FilgDMtxc7R(4#~>aow;~5*U8R=wyvXEr(j8&oWp38|<|@lS zhwC&oYSBS`*SmhGu=ja}8EgbWk*u~pzbviOU8w}&pDi`e&eW56iWfNW+;wq9&@^09 zF9EtOQp1w$9D+G0zAr9XEcuZ{#B`Ck08pq%NCPyW7mA^i{F7n0awx!N1~Ry@Mf__! z@o(++zdn|-&V{TW= zz^jU<69@+a1h` zcfDPO9?+2wS8ZW{UX@uhx*(H)omGs?@S{EMf*Hl=EX$a8GXQ4y2=mC~`iU497V{XI z+_oyP8ypDJ`wEQ+^WmSi$_+a6XeU(hC2rc+?IGk2(5dnY_=sqRY#e-6-0e+8)3fXC zzwaGfcIiAGg!}GtuoD_DRhg74tpZOecU;(OJ z&C{FTNu%9|f??FD0Qxrdo4!Yv0;)|jO)G=2#H+-?Elx~#qcJ74_$F#8S-|Vt?3del zR+XaDdqD%kLllrY^$AQ1yesLEgSXCP22y56|tod!iZf<9x*+V4hb&Wn+})CYixj<)kc zK@{V$pjpY|#|`O(g5J;sgzAv75Vs2X%?C@8@bEV8p_W%kWL_|^=s&e?i{aO zikVg)(4=06Jfpk#rsBMdU1>qeBvVMYvk)+kfob#Hw$(KO0iFa9Ux4?+>y0-L{C6M# zTXOLxl_j4{2!>a*d- zC+G!7s>-_j)n#u%oe>C3DoGi`*#$YmYwv6k5bl`c{gZfyj4Wn4g_S)Z1m`9jP1NNm z4Nmre3lGlhA=y%l7zZTzwhfJV`c}e3D~{UBa2}z8Xb{xN6%uc}HD!+U?fte=+KIsF zjOiQ00|bkYdJnR`*|T@v*FV>H*{IbK3*hv{7?J}NOnNL`utDwGJaYs}Ajn9luR{&r z>3}ALje_J&aAe-laBR0S)%HhbpJH~WoCctXvD~serzhePjSocwmM-6wqdRkLa!`2c z&;sN;#VjF!3xt2v1)?d{emA6gTrX(TSeBhZp2i}!r0^wnlH_rIqw1= zcQG!Qr{?MF-`<~NIvGZf~YV8`T_{TX?SvCzNPI(6oAnI6fn(yb|RDqvGL_1 zyU2Mvv)#xuBJh6c&EgOeb0|Jjj;>upSqSA@N}%=ktsvB8Nyj%KmG^Y<3;eei;MXty zaU$e`fIiYZ20OKEJSF*Oe*~zlq`FsYIhvxr43t=)Sr|waa1Gcdi3P|}1=3)lCynjt z_p)Vorazk*&*?VYHly{d7_v&yB*Btt@S`aLy_EeWN%0S958lBdE=nr%0{f+!Lj^Qf z&%ic5Zdc@XO`|zwI+AWFV`$Kh&60}(emWO)Cw;hT4+D7k*l`60)I0SbIY5IQc^Uy_ z2GHQ={!IND{Xw_SX5%egnqPZ3i3wPEB8A^!tQ`9iy`&bJcz{sOBZ9^W0Dk~w(KW{- zREVm5oBUc0zuWbw_u<-&g%0jj|K{eaQW+?}x5`~+uGxYUQJ{Lv3fGJ7g|e=vov&z= zm$JZX)TaFTHfjNEyg9lTDW3shM_n>)1w0B&+dn`9o7bTg*aHBLfS#` z93RaO7*#|Q+{lmk(57f9nbW`Xg5x`UV-I7#&7K}kik%RA>X)$M?;>-g!hXKppgH*E zxl$@%u*}$TPFC~bFxhAOyv<>zt?FP{O~XyiV)fRG(dyMZ#&%_T9S=aZ}(BtuPPU&YUULlrsehG>Kob}$HsGJ zEoC+|vqPSHF{iC0c9n{h`xQL$MEl^1slILJNwtJaCqv9j%Y%o9Mzwn30hsYdtlEq+LsuC4uI2xA1tHy?||uCw)p(4`;CQc}Hk zZmQPFnslsHy86Gn{{+*jyR)MPDotm`*=*Na<+qsPiOa+WpF?MwiELU-i{AGici8V@ zFTPHFETDh48;vescBP`ZJhp0HS07$de3LGME`#pO=W!!QRYM;3vNEzwLdWW&>LE6Z z>NC^O_dDih>tqwj0e67Jmfom8GxvOH4aOJ`+-kMNiJ-(09h!5gH#s9?NR+aDe}bm_df z4|xRZ?4vRk7H2cIsy(aZTy0*`c|EPFzg$&QsHs`q+X*^=HF;t`#y)Xia17s+9FV<> zSNbj^^p4^PRkK7a@P=SU5vOwb{#zRHb)ATJU55#>z&;W8=)E@o@%9P(2Fd#2S6M$_ z+;+K=inx-3MvcaS$0_fUBL)+Hb{pRXbr(sl?J}bJC2FcRUHgW=Jw<0;6zl z&$xLc{7)`;2!c>A)Jft$=(Y1Ui&)=Jo`JM!M&BVZkEZ2B&qlL}47E(W$Vel<<+9~_ z^XCCoY2Po~oI*L`uUE^^mS!5Y@+`FVhB>P&w0>803c1`1nQ8LPdLrv%^~av>&!{rq zLGZTtAw0NYoVQ!Tz(A#Oo0aK?=h^FtbDzjfWUbO~G=V+|88nSY2Ww|FvHJ09v)Z2V zLOE~7@md)tq%9S8EQ)&mZ0PPI5NM=mF)uuu$)?2QA;$H}_NH14-rqC4A#yr$Qp;l; zQgEZVdTdBu-0fpTd|BO<$Ws2qFl8m8r&&9k;^{1cSgM$H2O|oKS>VSHs=g=M)$xA1 z`%pAFu{l3@C>6B;+j3*@G<-{A+BLEG{;-vc+daICAlhUy-e;POxto1lUcH9x@M&6| z++Yyf(S!>}eEhnfOatD0<+xq9sA2NgtpNo$_qZEuL5x55jfxB3schJCxyJOYQguZd z$e<(_gzILJ7piLi$}Oo>s3;ar6Ie$H&rVlmWD>v+Cv{&ipHZGP=im%*esr`f)QbVN zCXqN;haAdqE>Wvtlv4D`$A=W@c$iptm+WS-S*KuPQe@8~WhfsH|6BT7=zAG~?=!!C zq_H1iTx;!nwT#E-;WVMyzPKCu*RejRX?2`)m}xVZg&5Z;tETz${yh;vipAgpb*+}A z{g~FUFzy_z9S7%F6q&=#^PIVgp%Z2K%bU*23WKvU{>n6anzC;-JO`Vc${0KUsw~h5 z!@mSiP7M6F&wGW#xd1K8jUL@BANr-Hl-9EL2J!v-aoINfPKoxcJ%9WETIg?U@``n1 zk#D2y8UN7MtQFTVv5KF^_xo#V5&13W`M=@`fu^9-I#v7QK z+u2yEaRQ4d^l%@QTJB`+3TA}qX4U9-?gnx+?lQ-U`uVr`Q!RJ(o8(wLO+pZeJ?}uD zG(VFY*etIoa|uFBM=Xit2sh>+k)@Q`d4tHu*m}K0^(#N_<4d-aVbnh)`u9>d@XsXA zHgY_Kb}`7r+U+Ckos$E0ZxF?b3%k5?Xw(C=aU5S1m_p` zJ_S#viid6>H z)VYN!@sVK`4l?3j67}f1_3Zl({t<}S2v2Mic~7B=BAg!kpq>welJ+LP~q1& zttH*2n`_@@5hCF|D22X;5n%_ZoIh29x#Ei-f9@s5WGGxk#rZrmFU! zg5*cA&%T`nxO^O^ybKo6+gfASnsOTOgiFxTKq2-~jK-SAFMx~`zUpLMhiWqKzoaJ@OKkYL^F&?+)s*Jc$#Rg^xQrCob8&n z{7HE%iqv8OH`4e6&6yer1rytH=jY|yhQk7#hIUw=o zABM@z(I7S<-WsC@RGUW6WqS4rnS3TY!;q83mL8&U46G?V#<}iz-Pe*db+l*K!Kh8- z6?vvSyQI58rd|D94kKArUj1SRmTIR+22o`*hpxuFuJXBb90uihsqPieiA3pZ<9V&b znw6mk{$w?_JYRWe?u}ZlFUHCSrx}1Y>ChTP_h2?!8PzzNhkEW>3J}Lgp}|oM|*Pri5g!+h#vO;)ySF3)D)| zVODFH2!AQs%AUY=hlyrqevW(pK7a_b2{VMmzn}Y&s`aVIx?equbA7Qfn>4!QdGK0h zg1ca7R;l{9^mUtGu*Z&1XMAP+bm!bhDmJ}m&EBN*g>F*M=O-TxrEIimi)Dl@3>{}u zeCZ$}vWquP%RDiDDZQF%=eC>uE1Py!%jJ3IG6kO0Q~O77%ANJmpR7FW65o8M!~tmS zt_d3NkPqgvr8@?scRq!QVV-KCVlo6BOtVMRfRRHiS0!zjHa3)Cz)#Y#P;TyLZW(tZ z*V|g1wY1WZeiYR59*fP?G5J4ZqYSlIGssO&%Cm)e!cQp?q@0EOpXsMpd3UWAv7M7d z8@KY?z^@`iAz211R)$jM)izPagw^3`=M+sKV&=>tK-25gqUzg7>V{mMK+V`n$H=+Ih5FW+BITe z?wv(EHstz?z=T3>vi!fsCFCV^WdYJ{6pgKE3#X;x%XMR-!ydj$WwdHz>TP5@&#S99 z0$%~<25IY&)=R(nnZ;%^HGRpE^$g*&X?drui_1?b7ug+{R$Q@MmH7d`BC$q>YKjlh z&^iQJLYvLb7M;!mD#(9KQtHQd=No#qgpFf9t!qZ_T{6}2RlmVeVO0Uh@@Z;U6kEhR z6}7%eR%a_BFOwVNbwR${vfX(MicDOmk6*B`ZGoc&DqOU?C2$gIQjUSv0wY|w5DK>P z>)6iR{|;FP(B~xEQ@gh!^5M^@(5aHmQWwHNs6k_bY7XfsMh)TGC0RS^7;|AdA@)+e zeE?|cPo76V-ttI*O8s;F6^5a=??REPyp^ec=byN|XH$C9`d|qc*PMeRjB?_~0z0-s z&ec3q4BG2N%af?)x!h?6mLQZzkD6w6gPVh6v@ZLq8B;$jo;e85)e4g%$$qy(;cY^3 z@f$a{WWkG>KG>TujOyrL9+Uab%B-4Ak7@tN$r-O6K8UVi$7RcgwP1mW>y zEn5|8m8nyo!Z(e78UWCSi))Kl3u0x8%a6*rvAIivnhNG*7J8JjNo0=J3`En;RQ z2k}kycrnIS92_0&wo-o7P9IDu1&e+P>qLpLJKL|lk6I@3_pA!b7^i2!O2msvkgy17 z8C>lPZLeiiTi2Vi zpW;FNX+n8ay)CCyX>@A~e!kf?Vxl0`71oa`O3UY#SoR3CPMyuuuLft>URQ^t6{bba zi;h2|Qj$KfJzV*G*;(KegLQy)m5+G)4Zb7eUDEb~{vyR%Ywymdvu#d6Pm4wN-r%J4 z{CJu59?u9EkieR%dt|1ujQE&u6fL*tiB1lhVSACvnkof3>#Mn(-zeqO~rM8kCSk42Jtzxm_5<*$x4sr`IdPi+)r8lEh^P){D2dK=@*@BPE`}0bwFK1vOtb%E zXUh^$w)xOa@ZRHJ2YpFHq|n4VZ{ zK(9MFGKDM_e`y;WtlibUL3!z+mIB`Hj)e$dBlMBMp{za{j&?ve|8Sb|3}kz>dMuUv z80Apy8*2V)<%2ng#9wM;^QrE_%>ymjK$P=0o%)6{%rIHLpfHgD)-@rIYyN zb(m1-Z&k#{hMc#FVT^h0Y|3RDN>IL*w-8}Q_Y-?tt74R1)oAO2r#1Ar;(jwJW9H)HzkKCBLrjM1Y^v1YP6 zdRP_+iGmRd$J{DQ*2m15ezIXE`o_luQGa#BHujm&Z+$!Ff0d5Hq^cC9qx&;5y3bSl z{jxRdZ0kE>tBb)^qz6g3hMC5Q(x};1#g3(`dS9cQS(P6t62Le!8D0yS(QLDEN?w5D z;Wx`=seh>^-m^XI>37tW1ieLVmGutirqU%4@cK(Srr;uv$V5sKM4v~*3QQDdwx>Ns zL`2K^bn!Z8-(#%N?Cfx|*(^aOp^T5ryLX;dh3YAS?wFlCj)B6iN=eu;HHn)0_j9od ztqKeFsXD@{l(gTSSag1^)30V@T)&`?3FxPke3C9n+2Z+XO=J7@2x~2QT#sg|TRov> zW_BWTCHe|OXhdmJg1~=!+<}NJCTQteBv)l=X2nS@D=%j8o%k<;4QdvN>%X1*o|Q)# zn=j2u**9x1IP=E#iZA~N|DMeHxZavalu^MM+_t+gR$PCh?D6olx}7Ocd)e`ZLsw;- zO^eN5BJpXx#uZUw02*M!o@EV%HyoTD`lKeb`o?~(K<8VXFno3Lfjm&|a^3h#+ZQ$;`vwD} z#y=Hao1sghyQsPvKV#+SXa!m^viTBpmtK(NWb5k(bNhG8oof4ZRboJ2(6HDO--dGt zaDU&!hNRs3fGE95-X;K8oa##kOnXF|sTtl1p>R@N+(!)Qr8`?N5?lmMUZ*Q}yuc~H zV8}DdA6jSUddllfiUcf^hsTPc?rmNq`8?7GEDL&N92Zs3_Si7i1nDFXbIikvH8>#m zOm5#J#Tze~AJU(ACbk^Du#qK%rrC|9msY6T=!-CvK5kje`aE$71R-dem`*-YtW7K3 z23KeTMKnvLZUI%P8Hj(E&2a2@ayHq=IP!P;Q=<_A(hkx@rZFwotQ0mBVMMfMg((mQ z6MLpM^DjtRXIlH`jiwLN%59CTXKS%(2|uO4*3#u+3mRH&CU@gvw?%#z8iOW_KD`uw zP4!skW80A`4Z}Vtmo?=V#5@XuV0zEs?WtNjTmSW*jv;dtK=I5js&?onYD+^Bkp<`4oa~j`eYS#-|2SB!zSh zvc+J&s59ng2_Ks|8zmfkI~snmlg;sjwB6Uk5m|1)6$e^@J0@^Iqn}f_npL%uDBm`~M{VqvthgOhFrScE-a8y2 z2s$X;BHv>t!$Hvf(57n^K3~9H$9}aF(JW-5`!lWwdJRB;$nIx=`O;?PcBA*urM)mYFTXA%JBN?NjW~LF5nwO~sxVJeNe{2~j{s`E*!}ueby~8*obkmj62S?onHDr* zK<4K=tJv?y9IhM%JTsF;>;JY9kg#qO&0^X2FryH2l8(P@a3t(qpj|yWiprjht`^wK zoXwogi9n&;*wn)5`u2m@0IdxT-3PDowQ9|768(uoV8%x~iiqsXXR-0KfzEr@2l$VB%zZp_CrECioko zaqe_|UVMinB=0z8cPcHzWDEw5KU^G%Rk%v^!T|O_Ovk^jmCK9^v_#cNPcg| zi9|(y4Kt9DhFbo5cm6a3rNYVQk3biQBLNM~!TM$SC$Xq~mX{Z%4v|g@d-5hKQl8@W zgpY?fSCn_7R)U_|h^qc!JZv0)G8Micl+z%#MH0)*uEiPu*paiZEqSebJ=SQoc)tzX z*YPvJAYfN=Y!9QiKXUMx9iG&QQl>)2`7=I?$VTM_blVIhVXN&9Zc5Ny!!X(xe8N}qShqGf#jp`8jgcW1uyOTrg|&6 z@V2+0WdOu0C>*k=$&8EGqJGPG_48uiyFtp?5B`X!LwdY{bwbr|`Z1@+mR}6D7ig++ zd=p>T=<*i`y#H%33&Z+RodbCs*&c?VQD}8b_1CZVidav}Mhag#NWfsbOgxYum!wyT zw)q;+3_ejf^{>VBdpJYb)qDdzP3g&B<8x5OsetZE5kTtSOn)N?~ zS5V8e6E&J0gmq@>{(vRVd8})(O(xV>W8*wKciEqjFF-*%`L99s$bvEudC^ zzYrU+4?=7~Xp8@($~_8;CMiVd6R54u=7W6PjVte;4c>`NK9N*#a{ zL3_v*ae>aLVG=Kzlyv?^)-NB2%ZufRn(b2B)fBya+jF_v-Q$P{aPitwUm6}h_!+^I zf2k(Hwu1TuNph@LvjOkTn>XykpZ!1NYAnsS|0PPS2Kd&!wwiTf`T@#fRrLzDcwpjl zM;z#SBL^y#RW6ZWYB8gj^V`iK^LR@=qRKik)10bl&1$9v2c<&)dA-g*e)MnXKscka z)xTVc|r83)oPYW}+~^wj!Me>D#{KYkuf75dTapTl;FMi{(|R)}nK z372kca%_~gMk^BPzUOV-2{4KLylh&Ry$;!|K`2&C_0pAERJ#F7Vf^;PXe4l!c!Dhg2WX# zIpw*K0Vk0~dXJF7=LZW9czNzYOU(O~&zzi`IkhLh zH_DCu+9x|}IgZ<2c^LSdQph=@4}GU*Ox>I5=WCWXjFFZP--U94R}rv) zRW0-b1%(5j0D-iLVT=Y%DN} zDQv*?PxH5#(7gK~vm9L9tMY%hq79hyU{bM$F<~PoRpqMpTO@ zmWf_o>vQCiEbtRc%rZNS&OqNIeu9XN@VU677&MFAD+c71`$(%*T-e;rbb9%q%0Uyc zgE|MLNRas$kc8b@@lTbRYxl|C|G~V-M&`p;o@eX92{z}U7%_cdf3d**-j=< zT)(@I_yB4TT8Iy)VEeO1s&V5i1}F$X$p_=oC%HO3SAif$00UXi;!n+^v0DPm$f#Ue z({u(Oq|F#!!^UHT{s9Kr-(Y>zMV5bO+zBVDHl7wd@hGwsZ`M-rN0_r zbEP9z@&o4#`AjvN5j-b^?R%gYTfkG5bKg5ehKvbhjOJP>1Raj^BP3?HY!^5=kCh&> z*#HnMo19&Exf?YDz@#F+zDv_S_}>-Zlk|s%jjV*hgc<#`?{|NIEU>z)ca96;`Ry&M zY6DIn+2=_#cj^J7l+OH@5p?je``=3~U_B0i_H?wloWn~M4+OdTUp2i_6cD8Pp+0l{ zsEPIMv+RZHIqS)UEBnJtA3`$XAH?tTqQZXdye7RwyPnXRLmx$?P?A>DDuJU~j}>qY z+!@5*HLAX_ymXUee5! zdGPc2zmTRc(8ocK0Ks;L3&UP(?v)@M#*$$iXfS9#Xx5fjgy0gF9q2vUu`80E#i~)n zG3cf0V=H9<@zZMvZ>XT%*z1K}0~Z`B9;2ey$zA zTO!$BKL^qz;A!>p){&kZiU%E^iRC05T!Hb)wVgW`0 z4GQ&}^=<+8qeFW|t+zw$-#(F8BS?vv#uM}~kE{Y)8BqdlAI_rcUTk*GT|iMJyfv!;uNb3oNum4Hq+exB1lxOXZ7HdL4rHCeXs+DWsP$L0NmDlh?6+?k_KqVg^ua-r zUw>|V8b9Z9@F`c{h=~mO1r!G;{0~x;0y9XF7g=fJ#N5e&RN_l~@uI&bj}?6+*7Z3! z_|qq?A}m{9YjHGp8Iqh4r3~Sr>6g=s5#7|F)q-B7SoN%=NOYQjdPbae8E+9FB?wkU zJ@jx$;iTEfCMX0bOg#-qnp{%e#UWEM7As;12(Q#dr$M^k`yW$qtvK|~hIv`^8(JGH z_j!+576OZx(ltd+8f2?Kr21ke*8fDd^B7R~c-n~-8sk2Sv^0np+0#Z36$Ay&GRd*t zLTJ10aDt8P&gZ0YH`eKM%~7QLM9Jet+1t2Zk1nl&Vz@P@B=HAdrc|a*)=(aa=^q7 zaO*Zw-~9p3u!5*&XupHUhgVFJEG*U393YvO_ed+4s54JbWlfbtmSs)*(>|!vR9h9_ z{@RkiNkcTNs8?ELimqp9mMwc)++?^QdNPZ-CCTwx*B4C^Q z;Z3bZCWxZX6p^?dz->{#9>t27uQwam=KQC>goPvV#6FVo>nbldX2Q>D+Mx|6XM^o$ zbVjDf_%P`NN0dNydZ0B{S>hOAPF`&xkL&2SVX6goWwYihnDJ}=#IODLvQY7`W)TpD z5GxcaniQ=!v;K7ojNe~A2^gza7*pI)&T;~stu0sNs!M`WrsG{kY|3a3W_e3J=b0-N zpKx~EqTsX?`sBd`0#aYJy})KCHmk6O^I?kcHsbRZ+6v;Jo0*JjY40e4sSYYFh@>l>ERS`(!5xJl2#^RcnR|nhrv_T=#|fccz&N%sUmr(n zHynQ^TGsKPS|FShs*5SO=3M;Bp)r0QV7Us5%2$_7` zSY5GpA4ciH-$_Jxo{f2UkUhV2RctGrn@yJ`@OirqyQz5GNq8{2Brw4UFUvF#j4@xwzsrqWU+zLs@0a_@$JA4lK2%mo4JJQ zIDK>C=CME4m=Xg#B*->4_R~*MXA35LG$&)Rwhre?%)oO zobLyg?zCxK=xc;ME4=Q&*nI}ri;cRNOx;1JH&91#Q)Uku?vr)V8- z!eP>Qm~ufbVs#GZCa7mMqazGMj)%;v3m9kJ2LlQ1n;t-zjxAQ36@ z3qM^5_}zhju2W;iA=vb0oT!YfZ~5qkiE>on&?y5p_nE>T>n6#{oAv*Ih=0U=yRUF}^! zRry#2{fIaPameg}~M|7q-4+ZvaWbN%mYslf>L303Bmw?X=f`dVBS*xOTAeg+@ ziynTpP0l;o$UELj7}e&CJY{GwIqmKJriJ?yuNGw%&>$!{fSOo9_nj08c$H`QG4IP6 zWTQ66Xdla$(if&)W2Ic{TGtr>cQ9>4+e__uGj#oQL$i$NNn!xgkr^SqRe^XQHqMhP z`_0Ttj-zSUdN5U0mG9}?T*ajns%sfg@ia*p`%P6&4Of+Z_LZnqFa(#bHf-NZlU^kX z^zw?dq21!kPz#n3(MV_}U#d3>-9Vy*i#J_F@K(X`ZR9!OYsr9plgtNR^b2<9=PRFe z!2M}ww>v($!AeuF8+!OPmF7=={?gIEuPq<0 z&KkDUr$DRk41@GiNqX$(p_H+KV~P)|6)J=wG1|ENP&?i^Xrld3mS$=e+z3&RG>~h6 zH$rIY?T8YZD4P1?413@ zY(HN3UkaIy0APj?m`)#v2HXwem>op>6do(7zGTvk-Ufff??Y&IhWJGUxa4Qu;RCjr z-GG*sek3-}99VRGNSm8CU403-78Id|+|Ff*1p>F!@*O<5-0iWac(13fzJJX8 zs&bmTj@+XiaWKyXdvsW~eqaPOt{fZazneWZf0BDYmDCn+Ksg$xmvWfpufoS=pZ7vj z;)jwX%30ovDr1X4;I_U=zk_9vecZoioOYaQxqk-x@xfTQ8(Vs3`;a+X_p`h( z8CI6oOYaLvj%bPirMeaEB;3mMOI=cJZ-Esqi~!l4LRIx<%1We1-go+8N;?@?cQD@N zO#(t$MH=H9jLvMJq$}5_lc;btb`Se_kaO>o{PFyhN(*5$V<7hRtqZ^q;vaq{liyL2 zv-dU4?*#0F=7Zj^;HJE0PiGS3`~nhEBT4U6?Wblcc2)&zeRGr1WFSQEX#Ma%2;;nx zHP;{qICxZ@J{Oi3pM+k2d>d{~XZBc&Fo0-b`n=MkNecw3n({+pl|dEIAjHF)T|J0K z-g7_Y7s^OlfXjD2Btu5A1~Ww4^g5DX#3p)t=Ekn!6G4i@>^QiBG5_q zdpmjUhkMHqB*q-TDTe5jesLkZGEf$XK4}a_b3g+E%ri?f++SNJkeI1TDVCdq>#16C z!Ei3Evv)U_0X61J*BRnncyKFfr4KX0KEdx3)Ag!gkeCRUEW%Mo-jj6ML0*Ri+&|?T z90>V7>6G74z6(K0Bz%NmHkg^N`N5yw*%KWES(7_`F^eBFKGFE<{Z+y7BbGUc%G{iu z!S?(;yj^=SL6oxC(d$LOPM z;`S+2^B5y63}caZ=W1l%%%>Mdi$U+daLK$kRNdh`9~1+^pk~n}#zJNqv}&YFoXG6Ys``men)74f-)f z*cE$&6Rwr%|MUF5XMNB1`oiI6f#l}%Qkxgo@=wqMO-|#xjn)QGiTt;j-$jRa-vz%P z=N$_NfNYStA^W(>drFh-fsDfARohj7{EGw%))3sgvuY86G8t+t1!k25a*NJN+sY`xM$LINNG>Akzn z2(eSJGWXkw(Zta0EROIYI0&F;J;x*P`bCiTmm%`Z$J|0S^{20kC^XFam{E`u@AL3b zV^Nnc46hX*K~gT}agQo<`Y(ZZU^jsqk)<%{glGZ2lfM~>yk+#`N+D%LZB{l8g7|R+ z0!Tj=s_Ph})xENQQ9*fG9sm22*lDO7%Mad_wm9jYmQ@;iq5*||Ov7jNf?buI6OX-CipxY?TB4c0oknhu3Q3yC++8QTTy zU<1aj57U8aaHsOYKP9jGN-Ao(dA6Wbd8_$OlewygNMs5Dk;8r)eorAvb>JCf{=v32 zn#BNW+upeA`(tW1W17+GQe9;S#sOpe6Uf*Bpnw#-NTWHIMXgh;;UoW^zXvHscB6CM zv&&0CAw4FUGYO82QO{l8dp7uXJPF}bfZYf%4k7F!RQ-V`WojCdJvVJLw}o4ZI@r=Q zhGH9h2M$lX8}zLY!`}J`+wQk66F{m6OfbOsu#W^gI^>z3=GwrDr;mD$c%#u6J+Hnx z*)KFL;d4mW7v^V_oGP(rMo=qY6aXF5#Kl6Yy z$$teP-%>n^zeQ%&A|PLAB9K>SKr`f>RdV>=U7u_Gu9KA*ckXDdPNl-AvjBgRgT|La9Fi*> z8u3!cRLu5GY`p{+Re5Oy7kSgDtgI}$#v%MjuQ_=L4uba!jzdk$1N#=1#`|A^Mt2o$ zcIyk&!p4cPzAfa_8?g-#)nohm?uZX(alIf0g6I|bFH_pZS*~!J*mpFB{x)0cHE8({ zBMA@+A-e=+^kOwQc6YM~3lkGMh3wYd&d6-m(YG)4xZ@+*Ik`5J9=<)JR34=v<`Dsv zdUxniFcaRD_VmB=F<&nO7)|=dgNK?XbQU-NW(BYu{hjt*0dZ=jceRXsGxp!w@73*f*?Igp@o5< zF7ZTq=ycgzYx74tN6~Q!F=PBU%(-^*%rTjXf8uDNskEcZ^x*BYIz@o76qlkFT0%ZR z{yVNSXd3k}oiCL%m4FB0cpwt6u9CQIUhCJE^#b%8Md;rQbd#>wBN@GE$Vb1vC=`DX zz5QY_`2F4p=0i-i@IpyPuty(Vtt;QZl#V$I@HX!FavQ2QEzld(LjX*JNE$~DgBzRQ zhb-o*n&BW`BGY?nbv3e3qr#$! z9z}R4Smt1sduCu;n?qRgTUwjiU7U&^*rQt?yfy;_!|V=}^Cv znFyfyYJBnh-4{PUVP^ivoii-DPR_ESmA08ug<2x4Y&Au9J*k_y*s()qnjmvDhb-^~ zd}GESc>6K$@=S4PB0YWO+GzU3k}@Z=4)0bMK+}@V^y>U~a0I0aEo^X|9m(fDWM*Pe zq||LwwEdk3*6y}DGK3VO%6%jqb;~DW`+Dybl!(hd%1=WlY}Ed;Xf>YiLid`$DHE_Hoo7LQIZBCo*^Zx5azQXcyXlPdSS?K`x;Br}$%I>uz)L zu~XxVPhRYgJ3H3%iYH~$qBJLTdWE{e9iJ#T2`6J~=-RUtmkU@A(IGaZZ$YWz`Dk+PJmZuoNe zfce8Xzf=PzfKH7^U$fK$OE2&_{`%2(D2GL&P@2#(K>iB!IrtW~ZEwLX>kN9k zW=vHBtZ7BmWS<<2^MfTo{8&ek4a+ra1K-pCHmoKJs4C~9_-}w;PQ(hbhV*GgEiy<0+R5&T z!eNPr<*!Ygx}AoJO2wCgJimBpovW~%pcGLktYaI~SwQ&MKiz-5s@M0yb4U9kC9Ss& z+wPF6%-PJ|U?z-TGQL_zd#59a0U??g>ei+~VQ&P)SuY@C)lUBH0G7a=-h1CV;E)I* z+@XaH>cw4m7cE$PJKt}%fDL6#ttlzS83~hG<_b-;Wu5?e(^-t(GT;pI@(YOj0 zKvIm6>oqQjBL2R+F+c5lB*Q#uO2DkE4;mE|f4GSuY(XF(p!uPPqfj|r{mC$cwZtF6 zgSvcNy*twupmkIjMDT{2#MH!z=Kt+OyZR1&+H#`yfoDouJdvyY=FCO#eYlJW!UaAU zkN$FED+!i$xGkzm!zz*8sx)ZSqGhowz*6{g{l`|pgsn`hw!op|h{fDPx+nH&s44S+ ziw`1^xt`zPgTYW&e&CWOVy*&!uIA`83n)+MDxFEn%i78p=Wf+eE8pS#v}3>b#^Tg0O;K z?35%OK7HnKYag?llwf36QCpi3@*i3NDU$dP5d#fIfiNY?=(*3yzdL2OjXV)wMxHdR z6e%7)h&GmdVGxQSzHD8=J3XU4nPBKdy_VGLx!;CXFwQ?8D*k?&iFjdf`}p|k@_F57 z-WA^O%?Ok`a^3j%@9#$L*?3&?oOo)XJQebGbg@}pth0bu7n_%s6Hi*_ga__jqL*qu zS`ahcf8tq;2-^%wZ2B}18FVyCqIolq0@V7*)s3Qnk|6D)Sd8w}a?Y8{* zcHG>YB^+ZiT1)0kr|v9zJ-b)m))vE2Wj6{jBC+R`%7k3{Wx_}LSFJmP7T9VFgX@%v zY6e+_BBk1tS=1Ys9+QsonXSneQeERY8Y(Vk*9^!5jXzaw-2F>e@mEtj_L9zLn06*P zA`=$HH<7x63>s6I%Z#wZ?=8GnH5O9*BJ}5zPqVsSkcC6MCYu;zg7Db!XVhH!uB+bd zJ@*BXDYq53KkTCggx^X>@yRGD!Urkw-pV`MElC>|7hh)RYa}xGEj3ltb)m0$(KNR& z5C;BvzoB$Ka24W%`%mu?R`wqje3BK*4Mx3#R~%FE*wt?vZE@A21I->r{e?rw5$f(UXr1vFQ z7f`&s*7hnftH{>r!hb&4wRfa(ko1Y%7p86{xg|s$nHSkbfX5=PnjJxc3;-8@W?N29 zzOC+g{`mN(X0hp8KyPeH;YB;e`ojZu@}RGb7lDsPe^3Hv*MGaTaF?I^s{CI?5iqqNRgdJrBV+=o_Y-Tkmh|_qyv1DcGtRpXp=Deif zJ34JPdXtdFXSWfz?q7!eiZ=OlfsNws2;}kfCcj8O$ zO!6#v&AQ$-`Euk^C?w5~E1a(}wlP)=E$Ujyhay0?Y2bLkU;V@j=VWK8`_q^ChqEei z=3ZZQ1|BVo30z=~crrM((^lO={x6qvPhGFaCy*1(4e9&L5FDZaqci zh$CnUTlKm@EK(`>S8#!%)<=f= zQ{R^IoLnUyM}J^mujA%~(fI`IlT?(o7c#p9R&N!11SlkJoACs(WmbZBPR{1%_BE8beX3#HhKGco<9+N^-)D#}rMdO0jMO@cdwF(RhAk(ep*s@5`;nm=}tlSk=3-1su z`duWErSXx2wK}ui@xIXqJj>sYwsIXzYw_!r?QD$m%|2*;TN3lIjJC3S;q;MIJ6T4S zdWf3J0mXMU+CySo$Qybwz8Q~fPCw07ya1itI4a~A0ik_S<_kkUREsJ9lY^- z+i6KV99GDknQ@l%Bhmc^9{uj_gwWE#GU8zEdeZUy(Yy6n>s2#`4@9uXZ6>g`Ix3y& z`a_k*Z)dWm_#awMkCLa}Dra4|#W80s=D*abbWIBX4AYq4$`E8cjQ+C81g3;FjQUm7 zc6jrV*Qt@0Xz{}sT7g5ur zHS=6;_p1@k>6TVX2uc3*w{J9!=^~G=WN};}xJ+`B2?4E%04c5~`r4ho?_*Y($m{UA zF}~<3%8#xnU1e}lmQzXOp0kMhfvm%muo~N8WULw_$YV3ME5D(%e-L111LrGw%ZUE0 z^LTsqGwoV6N4n$*Wm1Ckp=3NYN{iq5l7d%v>5kbn;|x_6wVYeFYK~XT!NA$Y@9@AS z-WQd#<*&3Npu2hJSUF4>Te>eiYPOeh4NWb`&1^{hxGj>l(Z~uIp{9-8I(v z+(Y#rYYl`^JSMngwWDw(=}o4RusDs^WY9LqsuOA3fSu(OgK`)Y`a$$z?|t+p^fd9R zy-CiYGn2j5cZ5;zY@2Z8d-MXOP=NyfX<1d2*+ALUuO^e;<-YwdZUP^wi-UajXYx<8 zHRmdO#qE7UpMK1(6z$tU?L7z{SwKYhY#>RvdQcQrOW>2TjZr^y{D;G1FGJ+|uNw4_z%bnNCMtUIY3UmaQfr+oAk_P}pO4x9~DqM`+Q zJpLwU_k@#Eo}3`1R8htClw*o=iSluCi_~^xqMR=o#?v&jKaI|~l6Zqx)VY$HCa%<| z6e3_GbzHrR+UlYo#X-ax+Zbk(4H7u<%^dPGMM5SfdA4s+-Sg2RtPB8FrFgJU(tK&@ z*jL|=gztzaGB+gf-$~3oRVtQHMa3%M|~Y4%mUMW-5D)EzpnSA9_IbR zj`c|`Z4Hm0KVd{)k0~km=Ex0xiR01kM(sY87fNVPz%|z=)Ok-wVjx*LGMlRB1ewCJ zy)(AAGam=B`Cu2LtyX5tR{l zB_7eyA$U|xaL9#CbRosjK<0^xA1WEmc%b5SqT=Sc^Y;s4cW>|R<%w68s#V^R<$)H6 zVXAsv$W4X1cVH&czSi0uvG45BE=#g|yEb8+_{)UFe_3mYQ8g3Rrv#NP$Ve3$bzLKi zN~VTEpZ-&lj}@2MA8uAal$jxZ=#d$+qVcQbxCq=HUPn@$AM0qs%-?v&Soo|D)+E!?Ikuwzr~mcjrxqbcb|zw{&;6bhmT~2uODe zNJ+PJNq2)Ze#846&mZ@pZh`x{X4X1u%~VJDa0Pc?byRP6r?IN=^W8ImR}Pk4&FbQ= z@JaX2h@Y-ZkffX}xF+BypGk>f(OTK-aWnxEy3F>5ssc~EC0rmr-*Bic?MXQrZkH_l{!8gW-{}vWZY@4_acm&L6 z>Vt!>QhlP0%OmJYgQ(9QeZC8oRn)EN?d|NO-E&#IjCB?t4)t?y{ur!FjM z$y1?YWRK?b-RNuJ(^oXkx9GRY&!0N8`+U)<23b{z-M7-e>qOR zzqSGw@KqOoACnH&+0Ow0p1(gy;V1d@6Q?_(PJ}6&f=Ho$S_`emMck~lRc^+*fS&h2 z%lpp)&ip3uGKhZ@pDzrWJdP_!V~+`gr->YyofPcK#aJ#bhx5j>llr^5koE)Id{Z?V zLjNRYY}HKBmaCRcm9j04m-S|8_kZN*QIqaV6&&;XK7KOh(%U}1-%(04IEV@SjuWfI z*Rgn;!i6<&gq_>S>7ioPIkR^{DL$MZ9+r>JhlINPff=kDJy@~o6u3W8ED9*NH$GwXIh(G|q4OH~~(iUfqz}K(s)x=wd#(QvP#K>_P7ld353DKG*IYaWluux0(YL zE*_4m+g~z}7xv$&=9vi}=iuf;Eafjx_svDaq5t-Kp|?>DX#o%T(Qu7kY{Hs~E2_#4 zFv0@U<@BcP)8Au<07{L}E-A3kMXW9Vm;_96l97zN*zd1==<7Kj`DAYqm!@ezg&xJ6 zoGF~T(`{O5*LeR@dv=z!EqK_VswqY_O3j88lMpzImGwDTuUBvV8C(GUV4nwih~5VS z3xhlW(TsIs7DpKhS%kX}bXFzT%8qsXmvSAk@nd6&wf+;}x*)8s{PD}!FLCOQro_3V zMYCf-!$&q`Od6I>salRHi9m_p*VlF(JM(j+=6x_mK#k({vo?1kUm!WHYxa2OV+|YHc>g7ZLReS22HrDX6FhpzPU^r!V%)aDTkUlokCQ4RE=J>F}kZpFEDe*2nZx7 zZ2SWE?9_GCj{L$bk9++Ay8sh97dt{zm^%8&PJVS)4V%CmpKNRct*3M19cfi`kVk!o zw216+yFEHO97VUUU9NXmCp8MJpiGQn_>7u27Fg790>Uzi%FTzb6%mZ1J4&(dyQJ_` z*&7z^{T&Q-0T?tMK)5|G*GeX0;v|UjiMmxf(p%b3+?;Z9(MB+v*+g+j7_$YK1@HOS zw+wcO?f)2iVHew6-ra5e=)B|wKYt=h5-tVo+cNVMm>rnk?QSbSiPFVsl6pYjDxuEx zw=_9^zv*Uwwo+`?3~yGPSQzMukR0#-`yvM6%MtXr#UvH9E}F5Wm&&X(TB3dL%3Tfx@ji)i({vkBgE z~2cu5Y5ZcpPU7a@A&3!C4ce_RgJcVUx+klX>JQe@+C8xm&~^~=>dGi4Y4 z%&wEVxV&roDRLrMk9)w>IH~9XU2;b97E{OIk1`8AKhNK7uFiYVir3ct^DJrFN)kX# z$@q;3UX9?w{b!uGALp(A?DS_d#zrs4clo}70~Ykc^&kT`l}B<^RJT*~?j=QeuKV|_ z3w||B^Jzn3tlYVxOHwm+I(qa5y-W)L+|__0){2qG)8P|v>S_H{ z>i7Og$~YvzV`Kfo!zDm+wxVDN-@@5~J5x|*{?PcoK=|q+)b21`El;Ic43w(rb4mct zD>yY!T>Bo_vqy8cFQx{({7&2wTZp3mz;vF+&4;R64ojWn|2!!Gy97@ByDJ@He>k*m zGC&|Z_S&{X(-`0DhLubsD*s{&89cCnmyNEo`7^9x%HdB&kDtXn)!kLkjXpL$f@yCL zC-~EdgfSFaSUieecaJQ-Sw3*g1JF6h)5JBD&D2{Y+@gN8{-uIr>{fD(2yi!7ifOVixyLT7RdzylrGLavh!22~*rWh|OP&u_ zLG(M%@?J|{%y}0lq_m7{#9R8?(D$|wNf}uqFKmKc=p=^3x#_z=#lm$`j3H)1lHwy* z@UTsLwHfBgamJk(Tw?B*_-75&*_ERlPurUOV!QnRRbRY~S8Y`dE>KN^fVButn+edm zgUQYDOfAeP6hXP%_zZB>T?a;2^O?Xy;KY$lwM(UE?04cK6OR_v&R%QPg?_3VNa4j) zpo^+rv?{CYV8n(b6~n$M!s%P2`tHZ9GYT@6r*1I_sV z;38}97B-6aYu@nm35Ofks{4ND_T=Urb+^dM)b@cO^g6%;Wo~!@3ryEt&3eI4y(Oaz zIfx3Mld}$sroidCI4fMCSLHf_u|{-9NC3KAs)b*E&fmf|M zX7^_jg9%|MjF$A&AsgN5S|H+ZbB;Rtrbmn7;6=v+&;yX9OP4o^J{s+Hd-V=9Q`9#{ zuWeSYW{0}fRbnL>EKF1F5P0GV`1~jPLH&=PcXWb#5Z(!Vz!_oz+<`$56l%h6?Xpt8 zAKg?WqFS(lE&`Lcu~Rz&xD+5!iIL>=>8WsU#D2q?)Up7q9=7<2pG84LcCu+1P|L8b zXy%c?PFmEqM%^M^O!D`?d)6fPm>4C+#U&&}3eIk5o1%Vua|qJF8T}>6d)X3b8jNlf zf31N}OF7d-K!U}i5S_8z^hBp7Tl`bY+q%5-EeogT{pL+wG60;S_b{vG#NEF2dlwA#~V&ug*%s*iPbvj zbJHp~glf8$Pbx`_8*{g3@_pGeon3n@IjyZ*)AuYlAWMZX1<@sMK&&WY57No$`woO2 z{?H|D=@zbU-ZakF@<-cpN0Za9l&@?p&2fxljyt}Jr^M0(RvKC5KWbl~LoGM*ksfti zVu7TUzf_KVIt%KM3!e*r0JuRoN!8b5w_RjFrS)}(0)Ea`if3NO=7S3xW{s*M!tfir zvk6*E(-kZlpyMOkPTD-@D6#4M!RzBd*kPWF%bo`o6EG%1*f6 z{rA|g^_CNpVDoXHYXaz}pd%c#>4V2PA;;f)zj5_wDY-7TkSqW3T*)q~*s`ILv&kkP z9~zQReRpEg^-4A(3%$M7`Y#AAv#c$p?Yk2lG0`v}1l zR%O4O;#Z6j=(aXV0Wt_0YmGow{e3+@*UbtsZ!pQ7nvc4-LVN-`IU&4Dho?R_gWqvC zEg1_s2@q3;VJOMqpS~4sUK~3CEfK6Sz;cWGp@q#9V+6Z>-TZ&nPlVOSP)P_m&nDho zo1QCzzMdW6v%7w|`;Y}%O(OLNX&@`G6@uLC-R7tI`o*z$;sX|mAd17C zBq%asji%8HYVEH54wGHEyc8S@a3SPg5K|1y5@MYyJ(0AN4wm#;H)6i#lD0hBj5P}5 zdoJ4*(&DqSVhq6@niHvO)Cy#&afenN7D%D^{`hGEHg2yi5UNYt)D^ZBj_(cJvXOzB zhWhUJL!$sD(cPrc=xL-atYM4r>PoBhY(>=7&+z$q!;-mbmYhs;at;7%FTP%WN+<%X zv1H425)yke*Y;JLhv-W#=ssKCOqA_n(^8wzn=d*Jm7rqdW_Ir+j(oeuyt?tS_G4+; z=hgRbyH+(a%jW40O++9kF_ntg$03M@^6T|>$tj-Qw%uSbVjNY}2ngEIwv3{>3|nCm zO(X-IKGxsFF|RFGwp15Aa&`mLuS5}a9d^GjmNY==dd0W-oj<_}_9?#AFOmI7%C3~R zaBPU*DW-+wVt0h!?~b;9tL;$b!r&7#Ao15m8n9ZRC%&FaICe~e*;s)sWO&b`-`?&Z z+6MUWUb)a7isBQQw7^g@hN83o9e;IYXIRyKHi=-s*Ep7fD4Pqn&7Sl3bGkklv|ioC7gs+_G*h-5XKO11ydk>T-(3#O@IAGWlst-Rsh58ES!$wuW zD*OG}@FJEN#N|f>azq~L(-nCs_5JC!N3CA;$r>k45)N)0GKN%-@}R4{!k&T)zfZOt z_thZWe07!~xQua=fcuCsC%rTHOwbbY8#Poa(7S6~%{K~W7G{NM zovI=%^2m7Ez0os8GtE#uiPCwBa6+Dc05Dy^jw_lpocz*CM=_HiwMx3E@+oIC&N{zG z@qs2qPLCV4fR4G`-~HQr{$#{eKF%zTB{BW0RTQJ06x<0Oc>|--8-bi$b9tRYm2$)$ z0hr|i6k66m%&&BGE;~Hd&r2WKW)GXS4yu_oGq-lf<$)`MF-5*ox}RS1)_^B zuUCkL4DMMzRCkU_`G$bdvxH4>1ild+N9Y#MYl|v%jM`W@|7vwZvB_In7X_{;OQN*< zrfpS~Fp2)OcCk)i>karPDB)H8!1zLhmL=l>Cnc%1rF7ru029Jxub3GI);CEa3DkWc zArWrZ9aHH}n46boxiQRdN+Jl6SA?Q846Tm+cfh*})rCSIizU;6KEO7BLMX`pUEot` zQ(sY{Y%p5@JB!Q@bfKF2|3Eu$c(`dZ!YX+Gs_J{%Y%v18m3$BKIh`p?3E))VqDqa} zC$c$zCrgQ2-LNPZ!oU-gG<;GKxhI8f>2%2f+%^B~Z{&A0!u1XCD9zdG`GuaJG+!8a z`;4HRBMeE=b%H>lZU9fN0WZ=$jTH5%K_b-4 zzgFD20^`raen8legHVS&Tl@h+ZF==MTTc4RbivbiY=H!W-8*C<-4{H-MT=EuT(glE zrBX#2ekynXVYP+ZHxZDE=gmj(eH{JLHWru#1&PXgfiQh=&0fdg0&#n{j*~%!GK>9%4jx6T>Ts-^j z?7FqpCAo#T#E2u}$f-Da=K2RQ!5C6QL|8t)SOe_LfmPG;a!UkN!3sT_W+sIdB#{y= z%!|$=3S8cy-;TiH^ud=f%zCmmbgUXPqH<2jRVsVy4Je}^D#_1t0hu+x(oV#Sj6c5| z2J_eGSv@kcUdJ8&wDb(f47R^HC32G$>id$2a{@%;aw z)Tx5R>MNHAhCEyH#PMR-G4h+YZ;f>jN9qNObawOm-CH#!G;g4q7m^?Vhe%yl zji|u~(D-!bPirS?fDq6@=3kyN~rao$sN;kk;;y44EK7)OYhgU)$^2 zKsI?Ym7lP9*EugANgwVOw!+DxyC8t_0kI666bPU{s|u)L4%J=qdhu7!TkHQ+!k?H@ zvqor=oImZWkg5C;z6q2P{FlkUZ&6>*z>yka@sFB#8z{~#*z3tk0VaFU%d2*AX7NZg z^z9p;U5a?@)9jN`_HN}FmQx2=J=5DqdI4?l^ndU&(DzBXKjcrfsnx;>^atbv;Glrh zXA*@yMHjQDVa-Fwx@j$=(%L>b@2~`NcvDdhN2oMValk1zQQBlhC9vT=a#YlSWpr}< zWh7Q32J$>8)9#etE4bYA%ApwaJ2r$(QT|Gd{ z)X1d&UCG;I0(zA1+5YWa@=QRTq$Ku?@$2tebbbsQ`zb3W#9;0i;E8hJM!`idd`ZMN z{ne1e3Fbq?Hbp`IEnzKzj#V15p7MAE?wf;Mr?_6Mi6wN^S<<9Cc9Fj{X0;6LNPUaJ4}~J# zjm<%E5NiPdNJ#q$4hWxTrd`1yKw$ggO-Y5349uxN!P78+Zb^rSM)rWM-KI_riKg|F zLf()S)Z`MEkZIM$9*f5}Zmk^!LMA9kKtRTgL_lkX$O4}hM}ap`QbZQE{;h607Vu(% zQ2s5iqI2d@71>9c9GFb)pXiV9N~Yoqp>G4}jys76 z(IRjoVkaY?;1XRnAAvCfc<@YPd&4ny;f1n+t`E{kBW%!Tm1@BH%&9min&_j(FGii@ z2DVpYJy=Ab`BsU%-Q!!QS3YeK&lrObs$UX)_TZT-$&|aLb&5NoAQ%mateM;^$=lPA zwsq87Co+w5&8b@G11&!z_nZBkm(P|R;w)}Ns|RC~{J?e|@e@X7*+t(z#^XsyB9QNf zvj`lB(=&cE6M$kAy3n2P%gUOEopic&Mqhw1^)^j{>0);&i@Q_w*C6Q#D{vIS2V6Wp zw#anyRcBTcW%ncrFknvw9}49%R1jHzHWH8JRQ=4!eg7Dz_;4I>#TAC~x?wTnpwNf6 zIBhtcDr{dw2{}o_@7_~jfLplhyLy40{2F4oUD}Tt58Xh}BW`^{KoI2ZGq_$Abg1f* zhG1^IvPWmX4Cm^YO?t%szArBPf-foDUbABlB~+aFaa345f)bQmYeLhcg;NP4L@N7(F!zMK8zOiC;Hrd!t zt~7C?e41jF!T956p@~NgRF+B!#1$h~lqrdVWJvY!O9<0XYk*XD>@#G0)6!)WSTeFr z3%CNec!7sgpFEKiYpM(pSK6!qihGnXHQUI9X23Ymh3r%8flRqMfmSoM_Q%2DnGvL- z@(iD@1n`*Q1iDjd>A^sP`x0N@H7*)QPyv1Lu8F3UZXd3ietL1v& zDFM|FWWpw~a!gsJ*G~}a(qfluN(u}W5%8|SJCTdcr=!dLkcmElkrm#w3bHH0J9WA-)S*Mdt*XDAh~y@|S!;ym zZi?#n1C=-(n*u)y1RoYG?Lg2XvP>D&APO{PhRmuV4U1@B$OPDkYm2@XUmY%>YI9`q zXswGUJEZFRwoKx;w$6r%@T24NM|hJM(9{dB?GiCSmBg(R9ymx~Rk3a01nrq{gs{-Y zW6{>G?zdh~gFHmKz%I9FgZV+O z>!X95>6;MI4Mj#Nl#3ga@_O-7-A&-_0)@`$j=afY%M-b+O!YKX+n(tPn7f8LsKis` zzekru1BA|lt8W5J%6Wke9QZAD+y6um+}i?t=Ryll_sd0r$l6pJBOgv_w}6P`kUp>o zG!E%OSOM1N#rjJ?K0ltd&91vZS#WNLW%dAmc$O zKQ)P^@7NFss0R4vBF+(?KLZJcNTG0WSQ2C9<9>K zx9LqdQosMVok0T!X5M)I9fjSu$gqO%QM|D83{BA>pY{o~YXGEeC#Xn{`Fd%;yS`FRMQLK4a)Fd}_@ zgGj$x+?=ZcpRUi{mVp6CrMFRMwQG77rL`e+r7@HPxRG(Fvjt!R)~Ej#1SLzTa+j`F zV?ZUw+sVpnFeop~MLFl*m_5Vqxf{JALQG}et>!{b+xl$W13tyyF8-zEo z;l%f~h#2M{rpLMyx6yX#uUb0W6&0tOmT}2~MZTRkcCOdp?=F^Fv~oKqHmyoXP+<%m zXGw&K8X0B(Nr&M?Yb$dxzeBWuw*X%TWcxwxH{q+X#@#?@0Hm@6#`tKWm#j%3D-GKa zxM;t&NVH9;ZoVz3u+I&Oy8xsJmK6aXmsV-@r$=LSPheUB{pR*Pd0Xd5IeoQry=$@@ zcdwM~yX9uDuDjPR9mz1n&-Q{yR3bWY0DLf_lHe`4;mlOD?oVU>sv%n`ySS0@q_TCe z%?SJ;PAH?vZP<9id2gAEQ*8JZgb98<5Hy@{9*wy*@hyvC8u>d~-JyeS2h2;r8Ub%5 zt*4d*(kTcfzKRD3Y#&gO!~wU<>FRpCU8!EPAZH1rvH^_*>|hKyaj8&MpeKP<3`#QS zkq~KP8bPsj?5wVf-`pOu9^x$MQkGF+A!0Mu(+phV3FcDaf>7b@GR;A;HP3E-nwX0u z&Ud{!=`!^qV-;w#g`i5>waYIlsvcv){H7YI|9(veTAGq?gdTVJEI9qEdTV3q;I;ZN z3>eR%XQr-NbwtZ@W@Cw)R1Z6wWTaB!r;1ek1Unxh-t*T^`2BC=h6-$O0O$->w|A=} zGGxO$HP+nAd(&#zJOiXg2kHmlXvu(dqFz62sQ*k4Y9>g{Pnybao2IM7iv2v+@B$-cdsxB!G(@_~O}WB~U*v}qOuIzj3OSl-~65OY>G zJ;Js@zJ3pIg$W?nLz0(J%l6cc%*+di_D*Gv@ZiB3Pn<-)Ro8$E`j7D&+H66PPMBhm zu5hX;h+)L7=7ZGrsXYp-sJrsfyc90nMXOI!izGz4CD+eWfr%X(gbjlA(&J{jl@JSb zz5pXZpj~oUiUpg*god{dPzsO*J1uKjPR39*gwqDP%S{l0qg zz1agj;+CBhNaUStH#v%ayAqB2IQXf)IbeXGud!v)#gF_Q7wOlvY8SKPVVpHo031Pm z3w`Jb+$Gj;kIu(69KPGS+I$#yThj?ZSjX9Y@BhaItl9owm^%9MmJHvM=h6`Wzw*EH5kU_$^b9u&(j;fR6 zzTHm!2mEb0$`Vhf2XTgpO_H;J6valYiP@xt@EGsjfaI*EhG91XKU2Kk%kR7rv&Myk z<4-=ESoJ+RHnHhwg+R&1@^gGH)cF#(Y*f-AI$Oc2iEi)$Hbew={@JzoxRgcodggPb zK$Q!SbnG?l*)p>Gl#l>6XfJAiz4rzzUAML;(|hXR(L`TJ{K<09j!f)pG9t~Fa6TWE z5%HJ~>g}OkCCG1?W+v zux|khLgNsTTYOx^jSAfJ;-?V;nKWLF@LSIH-oLhW8^?eA%F1N8F^f$+U{QM

i4f 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 Tkdk1b{!>aq?qPx0bKn0DWs_gq literal 35123 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 I7r*84Ke$_^MF0Q* diff --git a/docs/source/_static/img/examples/gp.png b/docs/source/_static/img/examples/gp.png index 4c11cbaef5a0533e41468dce7f3528e2edbdb6f3..94428bdb33fa57b98d935e943bf12d3491723361 100644 GIT binary patch literal 49485 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

xth{VwX+hSB%(o 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 literal 25617 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 kiEwT&Fplin~Kd(>zh^$6u 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

  • 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 diff --git a/docs/source/_static/img/examples/neutra.png b/docs/source/_static/img/examples/neutra.png index 626a7b6e408a68874a676c862f5d5e43e536fd80..b2d4871935c71c753c2ad71d836d3dbf9e56c5a7 100644 GIT binary patch literal 674216 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 z

    HDg7nY<1RFG~@-JLGehhsM!$jm}nC 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 z≀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 L1r&v)yuwlhp-cd}W633{jhdc0+Us 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 WPy3yXjHxc)D)~%KwD`%3SN{(Sx#<1? literal 116283 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 CXSy>0 diff --git a/docs/source/_static/img/examples/ode.png b/docs/source/_static/img/examples/ode.png index 096de0e01f3c37846e4e66c97865e34afe384a3b..58131c9544deca4418f9125aea07e3d5ad0efa1f 100644 GIT binary patch literal 184479 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 z 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 diff --git a/docs/source/_static/img/examples/stochastic_volatility.png b/docs/source/_static/img/examples/stochastic_volatility.png index da60ea4218fc48bd36ec1822bb83b826e8c7ebe5..e660bb9a44503ae6bc0ad0570dfb096a00a392d7 100644 GIT binary patch literal 81059 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 literal 44446 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 literal 20132 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�$q;89WMTCgo}k>$<)D{ZJ5Dw~WWM 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 J=52##{|BVi-QNHJ literal 0 HcmV?d00001 diff --git a/docs/source/_static/img/tutorials/discrete_imputation.png b/docs/source/_static/img/tutorials/discrete_imputation.png new file mode 100644 index 0000000000000000000000000000000000000000..a3e8f409942a99057becf9395d8585043e664608 GIT binary patch literal 7216 zcma)>byQSc`}YTFhEza6(jf(e5hP^*=}|z2E@42ryM``lrKN@xZ@Oz}l%YYSyOC}g z`iJ*#z3+OSKi;+8waz(voqe6}-q+r1$7f$B;+={D2@xF;001CSQj~?=r(ySZGda%v zQvs_p{yxF6kXDuk04n2v*KpkXcV<&Xm@)w1%?Xs-=G(j0R76H45I6lI1ktY z2&@~&v_29<2E3z8${TaW$f%LmMt;i0hs}SBJWksUuaJA^My8R5D_txdytHEK*vgeZkGp7ujepgZ99dx( z4$sr$eCtCRrV`-(gc)Oxs(y(K;Ew)v1#eu680x;vw)8wy_`N`|9T%Q$%19$g@Q*%R z;XyMk(Gw$np0?Yy%w!K#!FAJBG69o{#G3Iek$A@Vur`bDV7H9K+Ch7>S6$^m)BXpmWIxyA zVAoivJn+Yqv2_C7p>^k=crpro^I8fPbp!!QD z$>2fYFRg)awI?a7V1p{51K+uiLw|V>(Sa#`;`V6KPtoL^ljkjGa z-{uz#n2t!6FEtd)iE||N)8jZWh)n@=M!_O1J7rs5gUSNJ=B!nNyHmWAs0Z15N(6Bs zWZ}B$afKKJoF^s#-4zfyaiRDoSQ?3?5Pjx^y;K)WEeZ^yHR`NFmGq;D5w{u-DRHje z2dVrjJ#kv~ntDH|Q+AG(?;7-JW8z}A{*jnR_*^}UXN{ZRtBy^5;sCsa(rO9530+En zPgMyoQNW>Lx5uBoiOVCLHqL092_4h(r3aoS=`OyS+?H#hpoaJ^bb{dR3hhlT3%y%!alavfn>d;+t5x4MD#Qa;K2^~SKpMI&M51y> zZAGTY_1c!_jP?X;Zm6|dZ2TaFMF2_Z_2B?N>WB>%h!Ks1e#a!)>+gOpdyHjU2CWz# z)+UTFA>qW@={W1}3p|`FOSJ%|4Cw7NzPUzV!V_?93sgFG>Ht!Y!epEp>Ggk zcwa)4=X>@lh>23(`{|fHi4#Ni-ujhFzgM*!PdVag0SZN0uE4pohW#3EQ0byD*XcZF3(qyreRo!?m$ z!@mT`*tYc$ELa^Qkyk768#|ABaGn37VE~lQEJhStAGYl`=6p>_sGPgJ;Im93=@r>u zP6RslZpeE={}0~PVu;@KzvEk9s?cj>1B78Eef_po&4TK_iyPl6(tjTd8`@+(eZYD< zxc_l3A(b!(&74d7Jp`kw2Dm-4G=d+?D+dz(ziB0wb z*ReCaY#cMCA)+{M;Rfty*jD>Eo8$rC`bIDL^3~Jxn@zK(hjv&B@ZLP>Eco_Qg~`Ps z5w81I>Qnz3hGbxbW3Gn@{FkyehdKCvzjFGA<6^pjs>t&xPj zQSH2#_$2f|Wh@x`oR$pe;6kiY)P%*TPby;+=8j^SLNo31l3?l6T=aU8JtGa?42CjCdA4=I^zHx=53L10e=fV#HC&F%|*s_79UNjoR0pf2Nf4D2i zb?qPXqXcSV1NKa>4akbJLWk*IFH)ZDIS_{X6)qtRzd3jB+YWLV>qoau1RfUVIJnvD zo|oEB-4*``F5P>|3|uX==Vv3Ga9#1oPEy|d2=|9(Ec1;J^mOWIJkfIqU3e)`zaG2r zl0-7fdN#B20>^*}BtuS3Jo_uh=iAw>`v<8we#PP75$5~dA}+uN{Js>|FgM4Ce_N&>#V5$!)@;>6K_50sJ$FXCnDdrvxSCWkFH zQX67TOSea+O~!P{9;JvOm>~{%q&8yNGGF8=FGbm%3U|B})49r>|J*Jiki8Ao zvF`}sUif}+MYHIO<$=W{PE%vSG67g+>}7q3qg$gg3s$ob4Yi zUi*U}{y!XmtFu&xN+8dfe&OoK{$IQ?m{!C4dJ4K6fTkv#Z*8zhlBXCVZ0LBvE9t*O znT|`^`L1ZL%0h>@9RJk6apHovoQBGhBfGH;BBNmJ?I9v^;~T8B^^sGvWT-{&JpZ)f&<=2lM% z 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

    IqBsYY|1-I%YYny`d41G0vEy(GIIv4H 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 OL-EyHxiVR!&;JM0_MO%M literal 0 HcmV?d00001 diff --git a/examples/bnn.py b/examples/bnn.py index 679570352..dd2b806dd 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -7,6 +7,9 @@ We demonstrate how to use NUTS to do inference on a simple (small) Bayesian neural network with two hidden layers. + +.. image:: ../_static/img/examples/bnn.png + :align: center """ import argparse @@ -121,7 +124,7 @@ def main(args): percentiles = np.percentile(predictions, [5.0, 95.0], axis=0) # make plots - fig, ax = plt.subplots(1, 1) + fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) # plot training data ax.plot(X[:, 1], Y[:, 0], 'kx') @@ -132,7 +135,6 @@ def main(args): ax.set(xlabel="X", ylabel="Y", title="Mean predictions with 90% CI") plt.savefig('bnn_plot.pdf') - plt.tight_layout() if __name__ == "__main__": diff --git a/examples/funnel.py b/examples/funnel.py index 7636e061f..860950f34 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -21,6 +21,9 @@ 1. *Stan User's Guide*, https://mc-stan.org/docs/2_19/stan-users-guide/reparameterization-section.html 2. Maria I. Gorinova, Dave Moore, Matthew D. Hoffman (2019), "Automatic Reparameterisation of Probabilistic Programs", (https://arxiv.org/abs/1906.03028) + +.. image:: ../_static/img/examples/funnel.png + :align: center """ import argparse @@ -70,7 +73,7 @@ def main(args): random.PRNGKey(1)) # make plots - fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 8)) + fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 8), constrained_layout=True) ax1.plot(samples['x'][:, 0], samples['y'], "go", alpha=0.3) ax1.set(xlim=(-20, 20), ylim=(-9, 9), ylabel='y', @@ -81,7 +84,6 @@ def main(args): title='Funnel samples with non-centered parameterization') plt.savefig('funnel_plot.pdf') - plt.tight_layout() if __name__ == "__main__": diff --git a/examples/gp.py b/examples/gp.py index 250bcb709..a9c32c021 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -7,6 +7,9 @@ In this example we show how to use NUTS to sample from the posterior over the hyperparameters of a gaussian process. + +.. image:: ../_static/img/examples/gp.png + :align: center """ import argparse @@ -125,7 +128,7 @@ def main(args): percentiles = np.percentile(predictions, [5.0, 95.0], axis=0) # make plots - fig, ax = plt.subplots(1, 1) + fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) # plot training data ax.plot(X, Y, 'kx') @@ -136,7 +139,6 @@ def main(args): ax.set(xlabel="X", ylabel="Y", title="Mean predictions with 90% CI") plt.savefig("gp_plot.pdf") - plt.tight_layout() if __name__ == "__main__": diff --git a/examples/hmm.py b/examples/hmm.py index d3d09356d..b51708f22 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -24,6 +24,9 @@ 2. http://pyro.ai/examples/hmm.html 3. https://en.wikipedia.org/wiki/Forward_algorithm 4. https://discourse.pymc.io/t/how-to-marginalized-markov-chain-with-categorical/2230 + +.. image:: ../_static/img/examples/hmm.png + :align: center """ import argparse @@ -172,7 +175,7 @@ def main(args): print('\nMCMC elapsed time:', time.time() - start) # make plots - fig, ax = plt.subplots(1, 1) + fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) x = np.linspace(0, 1, 101) for i in range(transition_prob.shape[0]): @@ -185,7 +188,6 @@ def main(args): ax.legend() plt.savefig("hmm_plot.pdf") - plt.tight_layout() if __name__ == '__main__': diff --git a/examples/neutra.py b/examples/neutra.py index 1b01d863e..fc90c0a82 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -12,6 +12,9 @@ 1. Hoffman, M. et al. (2019), "NeuTra-lizing Bad Geometry in Hamiltonian Monte Carlo Using Neural Transport", (https://arxiv.org/abs/1903.03704) + +.. image:: ../_static/img/examples/neutra.png + :align: center """ import argparse diff --git a/examples/ode.py b/examples/ode.py index c402e3585..f927311bf 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -13,6 +13,9 @@ `_. 2. https://en.wikipedia.org/wiki/Lotka-Volterra_equations 3. http://people.whitman.edu/~hundledr/courses/M250F03/M250.html + +.. image:: ../_static/img/examples/ode.png + :align: center """ import argparse @@ -52,20 +55,20 @@ def model(N, y=None): :param numpy.ndarray y: measured populations with shape (N, 2) """ # initial population - z_init = numpyro.sample("z_init", dist.LogNormal(jnp.log(10), 1), sample_shape=(2,)) + z_init = numpyro.sample("z_init", dist.LogNormal(jnp.log(10), 1).expand([2])) # measurement times ts = jnp.arange(float(N)) # parameters alpha, beta, gamma, delta of dz_dt theta = numpyro.sample( "theta", - dist.TruncatedNormal(low=0., loc=jnp.array([0.5, 0.05, 1.5, 0.05]), + dist.TruncatedNormal(low=0., loc=jnp.array([1.0, 0.05, 1.0, 0.05]), scale=jnp.array([0.5, 0.05, 0.5, 0.05]))) # integrate dz/dt, the result will have shape N x 2 - z = odeint(dz_dt, z_init, ts, theta, rtol=1e-5, atol=1e-3, mxstep=500) - # measurement errors, we expect that measured hare has larger error than measured lynx - sigma = numpyro.sample("sigma", dist.Exponential(jnp.array([1, 2]))) - # measured populations (in log scale) - numpyro.sample("y", dist.Normal(jnp.log(z), sigma), obs=y) + z = odeint(dz_dt, z_init, ts, theta, rtol=1e-6, atol=1e-5, mxstep=1000) + # measurement errors + sigma = numpyro.sample("sigma", dist.LogNormal(-1, 1).expand([2])) + # measured populations + numpyro.sample("y", dist.LogNormal(jnp.log(z), sigma), obs=y) def main(args): @@ -76,13 +79,13 @@ def main(args): mcmc = MCMC(NUTS(model, dense_mass=True), args.num_warmup, args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) - mcmc.run(PRNGKey(1), N=data.shape[0], y=jnp.log(data)) + mcmc.run(PRNGKey(1), N=data.shape[0], y=data) mcmc.print_summary() # predict populations - y_pred = Predictive(model, mcmc.get_samples())(PRNGKey(2), data.shape[0])["y"] - pop_pred = jnp.exp(y_pred) + pop_pred = Predictive(model, mcmc.get_samples())(PRNGKey(2), data.shape[0])["y"] mu, pi = jnp.mean(pop_pred, 0), jnp.percentile(pop_pred, (10, 90), 0) + plt.figure(figsize=(8, 6), constrained_layout=True) plt.plot(year, data[:, 0], "ko", mfc="none", ms=4, label="true hare", alpha=0.67) plt.plot(year, data[:, 1], "bx", label="true lynx") plt.plot(year, mu[:, 0], "k-.", label="pred hare", lw=1, alpha=0.67) @@ -94,7 +97,6 @@ def main(args): plt.legend() plt.savefig("ode_plot.pdf") - plt.tight_layout() if __name__ == '__main__': diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index d4a2bc94c..95315d273 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -29,6 +29,9 @@ 2. *The No-U-Turn Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo*, https://arxiv.org/pdf/1111.4246.pdf 3. Pyro forum discussion, https://forum.pyro.ai/t/problems-transforming-a-pymc3-model-to-pyro-mcmc/208/14 + +.. image:: ../_static/img/examples/stochastic_volatility.png + :align: center """ import argparse @@ -92,7 +95,7 @@ def main(args): progbar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) print_results(hmc_states, dates) - fig, ax = plt.subplots(1, 1) + fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) dates = mdates.num2date(mdates.datestr2num(dates)) ax.plot(dates, returns, lw=0.5) # format the ticks @@ -106,7 +109,6 @@ def main(args): ax.set(xlabel='time', ylabel='returns', title='Volatility of S&P500 over time') plt.savefig("stochastic_volatility_plot.pdf") - plt.tight_layout() if __name__ == "__main__": diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index ae2938ef7..3daa72da8 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -48,6 +48,9 @@ 2. McElreath, R. (2018), "Statistical Rethinking: A Bayesian Course with Examples in R and Stan", Chapman and Hall/CRC. 3. https://github.com/rmcelreath/rethinking/tree/Experimental#multilevel-model-formulas + +.. image:: ../_static/img/examples/ucbadmit.png + :align: center """ import argparse @@ -114,7 +117,7 @@ def main(args): print_results(header, pred_probs, dept, male, admit / applications) # make plots - fig, ax = plt.subplots(1, 1) + fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) ax.plot(range(1, 13), admit / applications, "o", ms=7, label="actual rate") ax.errorbar(range(1, 13), jnp.mean(pred_probs, 0), jnp.std(pred_probs, 0), @@ -125,7 +128,6 @@ def main(args): ax.legend() plt.savefig("ucbadmit_plot.pdf") - plt.tight_layout() if __name__ == '__main__': diff --git a/test/test_einstein_kernels.py b/test/test_einstein_kernels.py index ed07013e3..b90557d1f 100644 --- a/test/test_einstein_kernels.py +++ b/test/test_einstein_kernels.py @@ -81,4 +81,4 @@ def test_kernel_forward(kernel, particles, particle_info, loss_fn, tparticles, m kernel_fn = kernel(mode=mode).compute(particles, particle_info(d), loss_fn) value = kernel_fn(*tparticles) - assert_allclose(value, kval[mode]) + assert_allclose(value, kval[mode], atol=1e-9) From 0af61a641cac3f86914de02d0b5d0224764fb047 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 18 Dec 2020 15:58:46 -0600 Subject: [PATCH 014/222] Add has_rsample / rsample attribute to distributions (#844) --- docs/source/distributions.rst | 16 ++--- numpyro/distributions/__init__.py | 2 +- numpyro/distributions/continuous.py | 30 ++++++--- numpyro/distributions/directional.py | 2 +- numpyro/distributions/discrete.py | 50 -------------- numpyro/distributions/distribution.py | 96 +++++++++++++++++++++++++-- numpyro/distributions/kl.py | 4 +- test/test_distributions.py | 67 ++++++++++++++++--- 8 files changed, 183 insertions(+), 84 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 15cef004f..5ab0222ef 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -49,6 +49,14 @@ TransformedDistribution :show-inheritance: :member-order: bysource +Delta +----- +.. autoclass:: numpyro.distributions.distribution.Delta + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + Unit ---- .. autoclass:: numpyro.distributions.distribution.Unit @@ -333,14 +341,6 @@ CategoricalProbs :show-inheritance: :member-order: bysource -Delta ------ -.. autoclass:: numpyro.distributions.discrete.Delta - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - DirichletMultinomial -------------------- .. autoclass:: numpyro.distributions.conjugate.DirichletMultinomial diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 22ea03399..c095690cc 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -42,7 +42,6 @@ Categorical, CategoricalLogits, CategoricalProbs, - Delta, Geometric, GeometricLogits, GeometricProbs, @@ -55,6 +54,7 @@ ZeroInflatedPoisson ) from numpyro.distributions.distribution import ( + Delta, Distribution, ExpandedDistribution, ImproperUniform, diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 2ceaa487e..1724ce5aa 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -52,6 +52,7 @@ class Beta(Distribution): arg_constraints = {'concentration1': constraints.positive, 'concentration0': constraints.positive} + reparametrized_params = ['concentration1', 'concentration0'] support = constraints.unit_interval def __init__(self, concentration1, concentration0, validate_args=None): @@ -111,6 +112,7 @@ def variance(self): class Dirichlet(Distribution): arg_constraints = {'concentration': constraints.positive} + reparametrized_params = ['concentration'] support = constraints.simplex def __init__(self, concentration, validate_args=None): @@ -175,7 +177,7 @@ class Gamma(Distribution): arg_constraints = {'concentration': constraints.positive, 'rate': constraints.positive} support = constraints.positive - reparametrized_params = ['rate'] + reparametrized_params = ['concentration', 'rate'] def __init__(self, concentration, rate=1., validate_args=None): self.concentration, self.rate = promote_shapes(concentration, rate) @@ -205,6 +207,7 @@ def variance(self): class Chi2(Gamma): arg_constraints = {'df': constraints.positive} + reparametrized_params = ['df'] def __init__(self, df, validate_args=None): self.df = df @@ -212,12 +215,13 @@ def __init__(self, df, validate_args=None): class GaussianRandomWalk(Distribution): - arg_constraints = {'scale': constraints.positive, 'num_steps': constraints.positive_integer} + arg_constraints = {'scale': constraints.positive} support = constraints.real_vector reparametrized_params = ['scale'] def __init__(self, scale=1., num_steps=1, validate_args=None): - assert jnp.shape(num_steps) == () + assert isinstance(num_steps, int) and num_steps > 0, \ + "`num_steps` argument should be an positive integer." self.scale = scale self.num_steps = num_steps batch_shape, event_shape = jnp.shape(scale), (num_steps,) @@ -314,8 +318,8 @@ class InverseGamma(TransformedDistribution): (e.g. wikipedia: https://en.wikipedia.org/wiki/Inverse-gamma_distribution) """ arg_constraints = {'concentration': constraints.positive, 'rate': constraints.positive} + reparametrized_params = ["concentration", "rate"] support = constraints.positive - reparametrized_params = ['rate'] def __init__(self, concentration, rate=1., validate_args=None): base_dist = Gamma(concentration, rate) @@ -429,6 +433,7 @@ class LKJ(TransformedDistribution): Daniel Lewandowski, Dorota Kurowicka, Harry Joe """ arg_constraints = {'concentration': constraints.positive} + reparametrized_params = ["concentration"] support = constraints.corr_matrix def __init__(self, dimension, concentration=1., sample_method='onion', validate_args=None): @@ -480,6 +485,7 @@ class LKJCholesky(Distribution): Daniel Lewandowski, Dorota Kurowicka, Harry Joe """ arg_constraints = {'concentration': constraints.positive} + reparametrized_params = ['concentration'] support = constraints.corr_cholesky def __init__(self, dimension, concentration=1., sample_method='onion', validate_args=None): @@ -813,8 +819,9 @@ class LowRankMultivariateNormal(Distribution): "loc": constraints.real_vector, "cov_factor": constraints.real, "cov_diag": constraints.positive - } + } support = constraints.real_vector + reparametrized_params = ['loc', 'cov_factor', 'cov_diag'] def __init__(self, loc, cov_factor, cov_diag, validate_args=None): if jnp.ndim(loc) < 1: @@ -951,6 +958,7 @@ def variance(self): class Pareto(TransformedDistribution): arg_constraints = {'scale': constraints.positive, 'alpha': constraints.positive} + reparametrized_params = ["scale", "alpha"] def __init__(self, scale, alpha, validate_args=None): self.scale, self.alpha = promote_shapes(scale, alpha) @@ -984,7 +992,7 @@ def tree_flatten(self): class StudentT(Distribution): arg_constraints = {'df': constraints.positive, 'loc': constraints.real, 'scale': constraints.positive} support = constraints.real - reparametrized_params = ['loc', 'scale'] + reparametrized_params = ['df', 'loc', 'scale'] def __init__(self, df, loc=0., scale=1., validate_args=None): batch_shape = lax.broadcast_shapes(jnp.shape(df), jnp.shape(loc), jnp.shape(scale)) @@ -1022,6 +1030,8 @@ def variance(self): class _BaseTruncatedCauchy(Distribution): # NB: this is a truncated cauchy with low=0, scale=1 + arg_constraints = {"base_loc": constraints.real} + reparametrized_params = ["base_loc"] support = constraints.positive def __init__(self, base_loc): @@ -1049,7 +1059,7 @@ def log_prob(self, value): class TruncatedCauchy(TransformedDistribution): arg_constraints = {'low': constraints.real, 'loc': constraints.real, 'scale': constraints.positive} - reparametrized_params = ['low', 'loc', 'scale'] + reparametrized_params = ["low", "loc", "scale"] def __init__(self, low=0., loc=0., scale=1., validate_args=None): self.low, self.loc, self.scale = promote_shapes(low, loc, scale) @@ -1089,6 +1099,8 @@ def tree_unflatten(cls, aux_data, params): class _BaseTruncatedNormal(Distribution): # NB: this is a truncated normal with low=0, scale=1 + arg_constraints = {"base_loc": constraints.real} + reparametrized_params = ["base_loc"] support = constraints.positive def __init__(self, base_loc): @@ -1116,7 +1128,7 @@ def log_prob(self, value): class TruncatedNormal(TransformedDistribution): arg_constraints = {'low': constraints.real, 'loc': constraints.real, 'scale': constraints.positive} - reparametrized_params = ['low', 'loc', 'scale'] + reparametrized_params = ["low", "loc", "scale"] # TODO: support `high` arg def __init__(self, low=0., loc=0., scale=1., validate_args=None): @@ -1215,7 +1227,7 @@ def tree_unflatten(cls, aux_data, params): class Logistic(Distribution): arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} support = constraints.real - reparametrized_params = ['loc', 'real'] + reparametrized_params = ['loc', 'scale'] def __init__(self, loc=0., scale=1., validate_args=None): self.loc, self.scale = promote_shapes(loc, scale) diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index a1cba2b70..3e5242d32 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -13,7 +13,7 @@ class VonMises(Distribution): arg_constraints = {'loc': constraints.real, 'concentration': constraints.positive} - + reparametrized_params = ['loc'] support = constraints.interval(-math.pi, math.pi) def __init__(self, loc, concentration, validate_args=None): diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 31032c8ee..b362b65ec 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -30,7 +30,6 @@ import numpy as np from jax import device_put, lax -from jax.dtypes import canonicalize_dtype from jax.nn import softmax, softplus import jax.numpy as jnp import jax.random as random @@ -48,7 +47,6 @@ lazy_property, multinomial, promote_shapes, - sum_rightmost, validate_sample ) from numpyro.util import not_jax_tracer @@ -356,54 +354,6 @@ def Categorical(probs=None, logits=None, validate_args=None): raise ValueError('One of `probs` or `logits` must be specified.') -class Delta(Distribution): - arg_constraints = {'v': constraints.real, 'log_density': constraints.real} - support = constraints.real - is_discrete = True - - def __init__(self, v=0., log_density=0., event_dim=0, validate_args=None, value=None): - if value is not None: - v = value - warnings.warn("`value` argument has been deprecated in favor of `v` argument.", - FutureWarning) - - if event_dim > jnp.ndim(v): - raise ValueError('Expected event_dim <= v.dim(), actual {} vs {}' - .format(event_dim, jnp.ndim(v))) - batch_dim = jnp.ndim(v) - event_dim - batch_shape = jnp.shape(v)[:batch_dim] - event_shape = jnp.shape(v)[batch_dim:] - self.v = lax.convert_element_type(v, canonicalize_dtype(jnp.float64)) - # NB: following Pyro implementation, log_density should be broadcasted to batch_shape - self.log_density = promote_shapes(log_density, shape=batch_shape)[0] - super(Delta, self).__init__(batch_shape, event_shape, validate_args=validate_args) - - def sample(self, key, sample_shape=()): - shape = sample_shape + self.batch_shape + self.event_shape - return jnp.broadcast_to(device_put(self.v), shape) - - @validate_sample - def log_prob(self, value): - log_prob = jnp.log(value == self.v) - log_prob = sum_rightmost(log_prob, len(self.event_shape)) - return log_prob + self.log_density - - @property - def mean(self): - return self.v - - @property - def variance(self): - return jnp.zeros(self.batch_shape + self.event_shape) - - def tree_flatten(self): - return (self.v, self.log_density), self.event_dim - - @classmethod - def tree_unflatten(cls, aux_data, params): - return cls(*params, event_dim=aux_data) - - class OrderedLogistic(CategoricalProbs): """ A categorical distribution with ordered outcomes. diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 5bba2a52f..77e3a6cb0 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -193,6 +193,16 @@ def event_dim(self): """ return len(self.event_shape) + @property + def has_rsample(self): + return set(self.reparametrized_params) == set(self.arg_constraints) + + def rsample(self, key, sample_shape=()): + if self.has_rsample: + return self.sample(key, sample_shape=sample_shape) + + raise NotImplementedError + def shape(self, sample_shape=()): """ The tensor shape of samples from this distribution. @@ -390,23 +400,33 @@ def is_discrete(self): return self.base_dist.is_discrete @property - def support(self): - return self.base_dist.support + def has_rsample(self): + return self.base_dist.has_rsample - def sample(self, key, sample_shape=()): + def _sample(self, sample_fn, key, sample_shape=()): interstitial_dims = tuple(self._interstitial_sizes.keys()) event_dim = len(self.event_shape) interstitial_dims = tuple(i - event_dim for i in interstitial_dims) interstitial_sizes = tuple(self._interstitial_sizes.values()) expanded_sizes = tuple(self._expanded_sizes.values()) batch_shape = expanded_sizes + interstitial_sizes - samples = self.base_dist(rng_key=key, sample_shape=sample_shape + batch_shape) + samples = sample_fn(key, sample_shape=sample_shape + batch_shape) interstitial_idx = len(sample_shape) + len(expanded_sizes) interstitial_sample_dims = tuple(range(interstitial_idx, interstitial_idx + len(interstitial_sizes))) for dim1, dim2 in zip(interstitial_dims, interstitial_sample_dims): samples = jnp.swapaxes(samples, dim1, dim2) return samples.reshape(sample_shape + self.batch_shape + self.event_shape) + def rsample(self, key, sample_shape=()): + return self._sample(self.base_dist.rsample, key, sample_shape) + + @property + def support(self): + return self.base_dist.support + + def sample(self, key, sample_shape=()): + return self._sample(self.base_dist.sample, key, sample_shape) + def log_prob(self, value): shape = lax.broadcast_shapes(self.batch_shape, jnp.shape(value)[:max(jnp.ndim(value) - self.event_dim, 0)]) @@ -584,6 +604,13 @@ def mean(self): def variance(self): return self.base_dist.variance + @property + def has_rsample(self): + return self.base_dist.has_rsample + + def rsample(self, key, sample_shape=()): + return self.base_dist.rsample(key, sample_shape=sample_shape) + def sample(self, key, sample_shape=()): return self.base_dist(rng_key=key, sample_shape=sample_shape) @@ -639,6 +666,13 @@ def has_enumerate_support(self): def is_discrete(self): return self.base_dist.is_discrete + @property + def has_rsample(self): + return self.base_dist.has_rsample + + def rsample(self, key, sample_shape=()): + return self.base_dist.rsample(key, sample_shape=sample_shape) + @property def support(self): return self.base_dist.support @@ -744,6 +778,16 @@ def __init__(self, base_distribution, transforms, validate_args=None): batch_shape = () super(TransformedDistribution, self).__init__(batch_shape, event_shape, validate_args=validate_args) + @property + def has_rsample(self): + return self.base_dist.has_rsample + + def rsample(self, key, sample_shape=()): + x = self.base_dist.rsample(key, sample_shape=sample_shape) + for transform in self.transforms: + x = transform(x) + return x + @property def support(self): domain = self.base_dist.support @@ -805,6 +849,50 @@ def tree_flatten(self): " your usage cases.") +class Delta(Distribution): + arg_constraints = {'v': real, 'log_density': real} + reparameterized_params = ['v', 'log_density'] + support = real + is_discrete = True + + def __init__(self, v=0., log_density=0., event_dim=0, validate_args=None): + if event_dim > jnp.ndim(v): + raise ValueError('Expected event_dim <= v.dim(), actual {} vs {}' + .format(event_dim, jnp.ndim(v))) + batch_dim = jnp.ndim(v) - event_dim + batch_shape = jnp.shape(v)[:batch_dim] + event_shape = jnp.shape(v)[batch_dim:] + self.v = v + # NB: following Pyro implementation, log_density should be broadcasted to batch_shape + self.log_density = promote_shapes(log_density, shape=batch_shape)[0] + super(Delta, self).__init__(batch_shape, event_shape, validate_args=validate_args) + + def sample(self, key, sample_shape=()): + shape = sample_shape + self.batch_shape + self.event_shape + return jnp.broadcast_to(self.v, shape) + + @validate_sample + def log_prob(self, value): + log_prob = jnp.log(value == self.v) + log_prob = sum_rightmost(log_prob, len(self.event_shape)) + return log_prob + self.log_density + + @property + def mean(self): + return self.v + + @property + def variance(self): + return jnp.zeros(self.batch_shape + self.event_shape) + + def tree_flatten(self): + return (self.v, self.log_density), self.event_dim + + @classmethod + def tree_unflatten(cls, aux_data, params): + return cls(*params, event_dim=aux_data) + + class Unit(Distribution): """ Trivial nonnormalized distribution representing the unit type. diff --git a/numpyro/distributions/kl.py b/numpyro/distributions/kl.py index d54d361d6..6e97c1fea 100644 --- a/numpyro/distributions/kl.py +++ b/numpyro/distributions/kl.py @@ -32,8 +32,8 @@ import jax.numpy as jnp from numpyro.distributions.continuous import Normal -from numpyro.distributions.discrete import Delta -from numpyro.distributions.distribution import Distribution, ExpandedDistribution, Independent, MaskedDistribution +from numpyro.distributions.distribution import (Delta, Distribution, ExpandedDistribution, + Independent, MaskedDistribution) from numpyro.distributions.util import scale_and_mask, sum_rightmost diff --git a/test/test_distributions.py b/test/test_distributions.py index d9734b47a..83a3ba378 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -99,7 +99,7 @@ def sample(self, key, sample_shape=()): } CONTINUOUS = [ - T(dist.Beta, 1., 2.), + T(dist.Beta, 0.2, 1.1), T(dist.Beta, 1., jnp.array([2., 2.])), T(dist.Beta, 1., jnp.array([[1., 1.], [2., 2.]])), T(dist.Chi2, 2.), @@ -152,9 +152,9 @@ def sample(self, key, sample_shape=()): T(dist.MultivariateNormal, jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), None, None, jnp.array([[1., 0.], [0., 1.]])), T(dist.MultivariateNormal, 0., None, jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), None), - T(dist.LowRankMultivariateNormal, jnp.zeros(2), jnp.array([[1], [0]]), jnp.array([1, 1])), + T(dist.LowRankMultivariateNormal, jnp.zeros(2), jnp.array([[1.], [0.]]), jnp.array([1., 1.])), T(dist.LowRankMultivariateNormal, jnp.arange(6, dtype=jnp.float32).reshape((2, 3)), - jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), jnp.array([1, 2, 3])), + jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), jnp.array([1., 2., 3.])), T(dist.Normal, 0., 1.), T(dist.Normal, 1., jnp.array([1., 2.])), T(dist.Normal, jnp.array([0., 1.]), jnp.array([[1.], [2.]])), @@ -163,7 +163,7 @@ def sample(self, key, sample_shape=()): T(dist.Pareto, jnp.array([[1.], [3.]]), jnp.array([1., 0.5])), T(dist.StudentT, 1., 1., 0.5), T(dist.StudentT, 2., jnp.array([1., 2.]), 2.), - T(dist.StudentT, jnp.array([3, 5]), jnp.array([[1.], [2.]]), 2.), + T(dist.StudentT, jnp.array([3., 5.]), jnp.array([[1.], [2.]]), 2.), T(dist.TruncatedCauchy, -1., 0., 1.), T(dist.TruncatedCauchy, 1., 0., jnp.array([1., 2.])), T(dist.TruncatedCauchy, jnp.array([-2., 2.]), jnp.array([0., 1.]), jnp.array([[1.], [2.]])), @@ -326,10 +326,42 @@ def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): assert_allclose(jax_dist.precision_matrix, jnp.linalg.inv(jax_dist.covariance_matrix), rtol=1e-6) +@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) +def test_has_rsample(jax_dist, sp_dist, params): + jax_dist = jax_dist(*params) + masked_dist = jax_dist.mask(False) + indept_dist = jax_dist.expand_by([2]).to_event(1) + transf_dist = dist.TransformedDistribution(jax_dist, biject_to(constraints.real)) + assert masked_dist.has_rsample == jax_dist.has_rsample + assert indept_dist.has_rsample == jax_dist.has_rsample + assert transf_dist.has_rsample == jax_dist.has_rsample + + if jax_dist.has_rsample: + assert isinstance(jax_dist, dist.Delta) or not jax_dist.is_discrete + if isinstance(jax_dist, dist.TransformedDistribution): + assert jax_dist.base_dist.has_rsample + else: + assert set(jax_dist.arg_constraints) == set(jax_dist.reparametrized_params) + jax_dist.rsample(random.PRNGKey(0)) + if isinstance(jax_dist, dist.Normal): + masked_dist.rsample(random.PRNGKey(0)) + indept_dist.rsample(random.PRNGKey(0)) + transf_dist.rsample(random.PRNGKey(0)) + else: + with pytest.raises(NotImplementedError): + jax_dist.rsample(random.PRNGKey(0)) + if isinstance(jax_dist, dist.BernoulliProbs): + with pytest.raises(NotImplementedError): + masked_dist.rsample(random.PRNGKey(0)) + with pytest.raises(NotImplementedError): + indept_dist.rsample(random.PRNGKey(0)) + with pytest.raises(NotImplementedError): + transf_dist.rsample(random.PRNGKey(0)) + + @pytest.mark.parametrize('batch_shape', [(), (4,), (3, 2)]) def test_unit(batch_shape): log_factor = random.normal(random.PRNGKey(0), batch_shape) - d = dist.Unit(log_factor=log_factor) x = d.sample(random.PRNGKey(1)) assert x.shape == batch_shape + (0,) @@ -338,20 +370,32 @@ def test_unit(batch_shape): @pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) def test_sample_gradient(jax_dist, sp_dist, params): - if not jax_dist.reparametrized_params: + # we have pathwise gradient for gamma sampler + gamma_derived_params = { + "Gamma": ["concentration"], + "Beta": ["concentration1", "concentration0"], + "Chi2": ["df"], + "InverseGamma": ["concentration"], + "LKJ": ["concentration"], + "LKJCholesky": ["concentration"], + "StudentT": ["df"] + }.get(jax_dist.__name__, []) + reparameterized_params = [p for p in jax_dist.reparametrized_params + if p not in gamma_derived_params] + if not reparameterized_params: pytest.skip('{} not reparametrized.'.format(jax_dist.__name__)) dist_args = [p for p in inspect.getfullargspec(jax_dist.__init__)[0][1:]] params_dict = dict(zip(dist_args[:len(params)], params)) nonrepara_params_dict = {k: v for k, v in params_dict.items() - if k not in jax_dist.reparametrized_params} + if k not in reparameterized_params} repara_params = tuple(v for k, v in params_dict.items() - if k in jax_dist.reparametrized_params) + if k in reparameterized_params) rng_key = random.PRNGKey(0) def fn(args): - args_dict = dict(zip(jax_dist.reparametrized_params, args)) + args_dict = dict(zip(reparameterized_params, args)) return jnp.sum(jax_dist(**args_dict, **nonrepara_params_dict).sample(key=rng_key)) actual_grad = jax.grad(fn)(repara_params) @@ -375,6 +419,9 @@ def fn(args): (dist.Gamma, osp.gamma, (1.,)), (dist.Gamma, osp.gamma, (0.1,)), (dist.Gamma, osp.gamma, (10.,)), + (dist.Chi2, osp.chi2, (1.,)), + (dist.Chi2, osp.chi2, (0.1,)), + (dist.Chi2, osp.chi2, (10.,)), # TODO: add more test cases for Beta/StudentT (and Dirichlet too) when # their pathwise grad (independent of standard_gamma grad) is implemented. pytest.param(dist.Beta, osp.beta, (1., 1.), marks=pytest.mark.xfail( @@ -712,6 +759,8 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): for i in range(len(params)): if jax_dist in (_ImproperWrapper, dist.LKJ, dist.LKJCholesky) and dist_args[i] != "concentration": continue + if jax_dist is dist.GaussianRandomWalk and dist_args[i] == "num_steps": + continue if params[i] is None: oob_params[i] = None valid_params[i] = None From c0991a683e9cc3d3528f295d5d3ad149d335948f Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 20 Dec 2020 22:40:51 -0600 Subject: [PATCH 015/222] expose logits in Probs distributions (#849) --- numpyro/distributions/discrete.py | 22 +++++++++++++++++++++- 1 file changed, 21 insertions(+), 1 deletion(-) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index b362b65ec..043541bcd 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -89,6 +89,10 @@ def sample(self, key, sample_shape=()): def log_prob(self, value): return xlogy(value, self.probs) + xlog1py(1 - value, -self.probs) + @lazy_property + def logits(self): + return _to_logits_bernoulli(self.probs) + @property def mean(self): return self.probs @@ -174,6 +178,10 @@ def log_prob(self, value): return (log_factorial_n - log_factorial_k - log_factorial_nmk + xlogy(value, self.probs) + xlog1py(self.total_count - value, -self.probs)) + @lazy_property + def logits(self): + return _to_logits_bernoulli(self.probs) + @property def mean(self): return jnp.broadcast_to(self.total_count * self.probs, self.batch_shape) @@ -274,10 +282,14 @@ def log_prob(self, value): batch_shape = lax.broadcast_shapes(jnp.shape(value), self.batch_shape) value = jnp.expand_dims(value, axis=-1) value = jnp.broadcast_to(value, batch_shape + (1,)) - logits = _to_logits_multinom(self.probs) + logits = self.logits log_pmf = jnp.broadcast_to(logits, batch_shape + jnp.shape(logits)[-1:]) return jnp.take_along_axis(log_pmf, value, axis=-1)[..., 0] + @lazy_property + def logits(self): + return _to_logits_multinom(self.probs) + @property def mean(self): return jnp.full(self.batch_shape, jnp.nan, dtype=get_dtype(self.probs)) @@ -430,6 +442,10 @@ def log_prob(self, value): return gammaln(self.total_count + 1) \ + jnp.sum(xlogy(value, self.probs) - gammaln(value + 1), axis=-1) + @lazy_property + def logits(self): + return _to_logits_multinom(self.probs) + @property def mean(self): return self.probs * jnp.expand_dims(self.total_count, -1) @@ -585,6 +601,10 @@ def log_prob(self, value): probs = jnp.where((self.probs == 1) & (value == 0), 0, self.probs) return value * jnp.log1p(-probs) + jnp.log(probs) + @lazy_property + def logits(self): + return _to_logits_bernoulli(self.probs) + @property def mean(self): return 1. / self.probs - 1. From a4c40fa96ef0212f0a9811a63d6e6c50146310f4 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Wed, 23 Dec 2020 09:44:45 -0600 Subject: [PATCH 016/222] add thinning support to fori_collect (#851) * initial commit * fl8 * nit * expand test * nit * add thinning to mcmc * nit * nit * fixtest * address comments * nit * relax assert --- examples/gp.py | 7 ++++--- numpyro/infer/mcmc.py | 13 +++++++++++-- numpyro/util.py | 36 +++++++++++++++++++++++------------- test/test_util.py | 21 +++++++++++++++++++++ 4 files changed, 59 insertions(+), 18 deletions(-) diff --git a/examples/gp.py b/examples/gp.py index a9c32c021..0279b9762 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -70,7 +70,7 @@ def run_inference(model, args, rng_key, X, Y): elif args.init_strategy == "uniform": init_strategy = init_to_uniform(radius=1) kernel = NUTS(model, init_strategy=init_strategy) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, + mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, thinning=args.thinning, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) mcmc.run(rng_key, X, Y) mcmc.print_summary() @@ -119,8 +119,8 @@ def main(args): samples = run_inference(model, args, rng_key, X, Y) # do prediction - vmap_args = (random.split(rng_key_predict, args.num_samples * args.num_chains), samples['kernel_var'], - samples['kernel_length'], samples['kernel_noise']) + vmap_args = (random.split(rng_key_predict, samples['kernel_var'].shape[0]), + samples['kernel_var'], samples['kernel_length'], samples['kernel_noise']) means, predictions = vmap(lambda rng_key, var, length, noise: predict(rng_key, X, Y, X_test, var, length, noise))(*vmap_args) @@ -147,6 +147,7 @@ def main(args): parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) parser.add_argument("--num-chains", nargs='?', default=1, type=int) + parser.add_argument("--thinning", nargs='?', default=2, type=int) parser.add_argument("--num-data", nargs='?', default=25, type=int) parser.add_argument("--device", default='cpu', type=str, help='use "cpu" or "gpu".') parser.add_argument("--init-strategy", default='median', type=str, diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 9470ec966..3d8e144ac 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -208,6 +208,9 @@ class MCMC(object): and :class:`~numpyro.infer.mcmc.NUTS` are available. :param int num_warmup: Number of warmup steps. :param int num_samples: Number of samples to generate from the Markov chain. + :param int thinning: Positive integer that controls the fraction of post-warmup samples that are + retained. For example if thinning is 2 then every other sample is retained. + Defaults to 1, i.e. no thinning. :param int num_chains: Number of Number of MCMC chains to run. By default, chains will be run in parallel using :func:`jax.pmap`, failing which, chains will be run in sequence. @@ -231,6 +234,7 @@ def __init__(self, num_warmup, num_samples, num_chains=1, + thinning=1, postprocess_fn=None, chain_method='parallel', progress_bar=True, @@ -241,6 +245,9 @@ def __init__(self, self.num_warmup = num_warmup self.num_samples = num_samples self.num_chains = num_chains + if not isinstance(thinning, int) or thinning < 1: + raise ValueError('thinning must be a positive integer') + self.thinning = thinning self.postprocess_fn = postprocess_fn if chain_method not in ['parallel', 'vectorized', 'sequential']: raise ValueError('Only supporting the following methods to draw chains:' @@ -312,7 +319,8 @@ def _single_chain_mcmc(self, init, args, kwargs, collect_fields): lower_idx = self._collection_params["lower"] upper_idx = self._collection_params["upper"] phase = self._collection_params["phase"] - + collection_size = self._collection_params["collection_size"] + collection_size = collection_size if collection_size is None else collection_size // self.thinning collect_vals = fori_collect(lower_idx, upper_idx, self._get_cached_fn(), @@ -320,7 +328,8 @@ def _single_chain_mcmc(self, init, args, kwargs, collect_fields): transform=_collect_fn(collect_fields), progbar=self.progress_bar, return_last_val=True, - collection_size=self._collection_params["collection_size"], + thinning=self.thinning, + collection_size=collection_size, progbar_desc=partial(_get_progbar_desc_str, lower_idx, phase), diagnostics_fn=diagnostics) states, last_val = collect_vals diff --git a/numpyro/util.py b/numpyro/util.py index 6f89c2568..d8d6a6d54 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -165,7 +165,8 @@ def _wrapped(fn): def fori_collect(lower, upper, body_fun, init_val, transform=identity, - progbar=True, return_last_val=False, collection_size=None, **progbar_opts): + progbar=True, return_last_val=False, collection_size=None, + thinning=1, **progbar_opts): """ This looping construct works like :func:`~jax.lax.fori_loop` but with the additional effect of collecting values from the loop body. In addition, this allows for @@ -185,9 +186,12 @@ def fori_collect(lower, upper, body_fun, init_val, transform=identity, :param progbar: whether to post progress bar updates. :param bool return_last_val: If `True`, the last value is also returned. This has the same type as `init_val`. - :param int collection_size: Size of the returned collection. If not specified, - the size will be ``upper - lower``. If the size is larger than - ``upper - lower``, only the top ``upper - lower`` entries will be non-zero. + :param thinning: Positive integer that controls the thinning ratio for retained + values. Defaults to 1, i.e. no thinning. + :param int collection_size: Size of the returned collection. If not + specified, the size will be ``(upper - lower) // thinning``. If the + size is larger than ``(upper - lower) // thinning``, only the top + ``(upper - lower) // thinning`` entries will be non-zero. :param `**progbar_opts`: optional additional progress bar arguments. A `diagnostics_fn` can be supplied which when passed the current value from `body_fun` returns a string that is used to update the progress @@ -197,26 +201,32 @@ def fori_collect(lower, upper, body_fun, init_val, transform=identity, collected along the leading axis of `np.ndarray` objects. """ assert lower <= upper - collection_size = upper - lower if collection_size is None else collection_size - assert collection_size >= upper - lower + assert thinning >= 1 + collection_size = (upper - lower) // thinning if collection_size is None else collection_size + assert collection_size >= (upper - lower) // thinning init_val_flat, unravel_fn = ravel_pytree(transform(init_val)) + start_idx = lower + (upper - lower) % thinning @cached_by(fori_collect, body_fun, transform) def _body_fn(i, vals): - val, collection, lower_idx = vals + val, collection, start_idx, thinning = vals val = body_fun(val) - i = jnp.where(i >= lower_idx, i - lower_idx, 0) - collection = ops.index_update(collection, i, ravel_pytree(transform(val))[0]) - return val, collection, lower_idx + idx = (i - start_idx) // thinning + collection = cond(idx >= 0, + collection, + lambda x: ops.index_update(x, idx, ravel_pytree(transform(val))[0]), + collection, + identity) + return val, collection, start_idx, thinning collection = jnp.zeros((collection_size,) + init_val_flat.shape) if not progbar: - last_val, collection, _ = fori_loop(0, upper, _body_fn, (init_val, collection, lower)) + last_val, collection, _, _ = fori_loop(0, upper, _body_fn, (init_val, collection, start_idx, thinning)) else: diagnostics_fn = progbar_opts.pop('diagnostics_fn', None) progbar_desc = progbar_opts.pop('progbar_desc', lambda x: '') - vals = (init_val, collection, device_put(lower)) + vals = (init_val, collection, device_put(start_idx), device_put(thinning)) if upper == 0: # special case, only compiling jit(_body_fn)(0, vals) @@ -228,7 +238,7 @@ def _body_fn(i, vals): if diagnostics_fn: t.set_postfix_str(diagnostics_fn(vals[0]), refresh=False) - last_val, collection, _ = vals + last_val, collection, _, _ = vals unravel_collection = vmap(unravel_fn)(collection) return (unravel_collection, last_val) if return_last_val else unravel_collection diff --git a/test/test_util.py b/test/test_util.py index 61f752e2b..3bf38a832 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -13,6 +13,27 @@ from numpyro.util import fori_collect, ravel_pytree, soft_vmap +def test_fori_collect_thinning(): + def f(x): + return x + 1.0 + + actual2 = fori_collect(0, 9, f, jnp.array([-1]), thinning=2) + expected2 = jnp.array([[2], [4], [6], [8]]) + check_eq(actual2, expected2) + + actual3 = fori_collect(0, 9, f, jnp.array([-1]), thinning=3) + expected3 = jnp.array([[2], [5], [8]]) + check_eq(actual3, expected3) + + actual4 = fori_collect(0, 9, f, jnp.array([-1]), thinning=4) + expected4 = jnp.array([[4], [8]]) + check_eq(actual4, expected4) + + actual5 = fori_collect(12, 37, f, jnp.array([-1]), thinning=5) + expected5 = jnp.array([[16], [21], [26], [31], [36]]) + check_eq(actual5, expected5) + + def test_fori_collect(): def f(x): return {'i': x['i'] + x['j'], 'j': x['i'] - x['j']} From f687efa761415b3c4f0c03123afef30749be1646 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 23 Dec 2020 15:12:09 -0600 Subject: [PATCH 017/222] Add discrete and subsample gibbs_fn (#850) * discrete gibbs * temp save * implement discrete_gibbs_fn * add subsample gibbs fn * add tests for discrete gibb and subsample gibbs * move tests to docs * use gibbs sampling directly * fix lint in notebook * use isfinite for safe * address comments --- docs/source/mcmc.rst | 4 + ...esian_hierarchical_linear_regression.ipynb | 1 + numpyro/infer/__init__.py | 4 +- numpyro/infer/hmc_gibbs.py | 190 +++++++++++++++++- 4 files changed, 196 insertions(+), 3 deletions(-) diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index 782ce93f3..0b56761b9 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -40,6 +40,10 @@ MCMC Kernels :show-inheritance: :member-order: bysource +.. autofunction:: numpyro.infer.hmc_gibbs.discrete_gibbs_fn + +.. autofunction:: numpyro.infer.hmc_gibbs.subsample_gibbs_fn + .. autofunction:: numpyro.infer.hmc.hmc .. autofunction:: numpyro.infer.hmc.hmc.init_kernel diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index db6c14dd2..1e50bdcb8 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -579,6 +579,7 @@ "metadata": {}, "source": [ "The results are exactly what we expected to see! Highlight observations:\n", + "\n", "- The model adequately learned Bayesian Linear Regressions! The orange line (learned predicted FVC mean) is very inline with the red line (deterministic linear regression). But most important: it learned to predict uncertainty, showed in the light orange region (one sigma above and below the mean FVC line)\n", "- The model predicts a higher uncertainty where the data points are more disperse (1st and 3rd patients). Conversely, where the points are closely grouped together (2nd patient), the model predicts a higher confidence (narrower light orange region)\n", "- Finally, in all patients, we can see that the uncertainty grows as the look more into the future: the light orange region widens as the # of weeks grow!\n", diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 041e50801..4a2b69993 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -3,7 +3,7 @@ from numpyro.infer.elbo import ELBO, RenyiELBO, Trace_ELBO, TraceMeanField_ELBO from numpyro.infer.hmc import HMC, NUTS -from numpyro.infer.hmc_gibbs import HMCGibbs +from numpyro.infer.hmc_gibbs import HMCGibbs, discrete_gibbs_fn, subsample_gibbs_fn from numpyro.infer.initialization import ( init_to_feasible, init_to_median, @@ -17,6 +17,8 @@ from numpyro.infer.util import Predictive, log_likelihood __all__ = [ + 'discrete_gibbs_fn', + 'subsample_gibbs_fn', 'init_to_feasible', 'init_to_median', 'init_to_sample', diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 6c356a8f9..9c7c47147 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -5,11 +5,16 @@ import copy from functools import partial -from jax import device_put, random, value_and_grad +from jax import device_put, ops, random, value_and_grad +import jax.numpy as jnp +from jax.scipy.special import expit +from numpyro.distributions import biject_to from numpyro.handlers import condition, seed, trace, substitute -from numpyro.infer.mcmc import MCMCKernel from numpyro.infer.hmc import HMC +from numpyro.infer.mcmc import MCMCKernel +from numpyro.infer.util import log_likelihood, potential_energy +from numpyro.util import cond, fori_loop, identity, ravel_pytree HMCGibbsState = namedtuple("HMCGibbsState", "z, hmc_state, rng_key") @@ -149,3 +154,184 @@ def potential_fn(z_gibbs, z_hmc): z = {**z_gibbs, **hmc_state.z} return HMCGibbsState(z, hmc_state, rng_key) + + +def _discrete_step(rng_key, z_discrete, pe, potential_fn, idx, support_size): + # idx: current index of `z_discrete_flat` to update + # support_size: support size of z_discrete at the index idx + + # get z proposal + z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) + + # XXX: we can't vmap potential_fn over all proposals and sample from the conditional + # categorical distribution because support_size is a traced value, i.e. its value + # might change across different discrete variables; + # so here we will loop over all proposals and use an online scheme to sample from + # the conditional categorical distribution + def body_fn(i, val): + rng_key, z, pe, weight_logsumexp = val + rng_key, rng_accept = random.split(rng_key) + proposal = jnp.where(i >= z_discrete_flat[idx], i + 1, i) + z_new_flat = ops.index_update(z_discrete_flat, idx, proposal) + z_new = unravel_fn(z_new_flat) + pe_new = potential_fn(z_new) + weight_new = pe - pe_new + # Handles the NaN case... + weight_new = jnp.where(jnp.isfinite(weight_new), weight_new, -jnp.inf) + # transition_prob = e^weight_new / (e^weight_logsumexp + e^weight_new) + transition_prob = expit(weight_new - weight_logsumexp) + z, pe = cond(random.bernoulli(rng_accept, transition_prob), + (z_new, pe_new), identity, + (z, pe), identity) + weight_logsumexp = jnp.logaddexp(weight_new, weight_logsumexp) + return rng_key, z, pe, weight_logsumexp + + init_val = (rng_key, z_discrete, pe, jnp.array(0.)) + rng_key, z, pe, _ = fori_loop(0, support_size - 1, body_fn, init_val) + return rng_key, z, pe + + +def discrete_gibbs_fn(model, *model_args, **model_kwargs): + """ + [EXPERIMENTAL INTERFACE] + + Returns a gibbs_fn to be used in :class:`HMCGibbs`, which works for discrete latent sites + with enumerate support. The site update order is randomly permuted at each step. + + Note that those discrete latent sites that are not specified in the constructor of + :class:`HMCGibbs` will be marginalized out by default (if they have enumerate supports). + + **Example** + + .. doctest:: + + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.infer import MCMC, NUTS, HMCGibbs, discrete_gibbs_fn + ... + >>> def model(probs, locs): + ... c = numpyro.sample("c", dist.Categorical(probs)) + ... numpyro.sample("x", dist.Normal(locs[c], 0.5)) + ... + >>> probs = jnp.array([0.15, 0.3, 0.3, 0.25]) + >>> locs = jnp.array([-2, 0, 2, 4]) + >>> gibbs_fn = discrete_gibbs_fn(model, probs, locs) + >>> kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["c"]) + >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) + >>> mcmc.run(random.PRNGKey(0), probs, locs) + >>> samples = mcmc.get_samples()["x"] + >>> assert abs(jnp.mean(samples) - 1.3) < 0.1 + >>> assert abs(jnp.var(samples) - 4.36) < 0.5 + + """ + # NB: all of the information such as `model`, `model_args`, `model_kwargs` + # can be accessed from HMCGibbs.sample but we require them here to + # simplify the api of `gibbs_fn` + prototype_trace = trace(seed(model, rng_seed=0)).get_trace(*model_args, **model_kwargs) + support_sizes = { + name: jnp.broadcast_to(site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"])) + for name, site in prototype_trace.items() + if site["type"] == "sample" and site["fn"].has_enumerate_support and not site["is_observed"] + } + + def gibbs_fn(rng_key, gibbs_sites, hmc_sites): + # convert to unconstrained values + z_hmc = {k: biject_to(prototype_trace[k]["fn"].support).inv(v) + for k, v in hmc_sites.items() if k in prototype_trace} + enum = len(set(support_sizes) - set(gibbs_sites)) > 0 + + def potential_fn(z_discrete): + model_kwargs["_gibbs_sites"] = z_discrete + return potential_energy(_wrap_model(model), model_args, model_kwargs, z_hmc, enum=enum) + + # get support_sizes of gibbs_sites + support_sizes_flat, _ = ravel_pytree({k: support_sizes[k] for k in gibbs_sites}) + num_discretes = support_sizes_flat.shape[0] + + rng_key, rng_permute = random.split(rng_key) + idxs = random.permutation(rng_key, jnp.arange(num_discretes)) + + def body_fn(i, val): + idx, support_size = idxs[i], support_sizes_flat[i] + return _discrete_step(*val, potential_fn=potential_fn, idx=idx, support_size=support_size) + + init_val = (rng_key, gibbs_sites, potential_fn(gibbs_sites)) + _, gibbs_sites, _ = fori_loop(0, num_discretes, body_fn, init_val) + return gibbs_sites + + return gibbs_fn + + +def subsample_gibbs_fn(model, *model_args, **model_kwargs): + """ + [EXPERIMENTAL INTERFACE] + + Returns a gibbs_fn to be used in :class:`HMCGibbs`, which works for subsampling + statements using :class:`~numpyro.plate` primitive. This implements the Algorithm 1 + of reference [1] but uses a naive estimation (without control variates) of log likelihood, + hence might incur a high variance. + + **References:** + + 1. *Hamiltonian Monte Carlo with energy conserving subsampling*, + Dang, K. D., Quiroz, M., Kohn, R., Minh-Ngoc, T., & Villani, M. (2019) + 2. *Speeding Up MCMC by Efficient Data Subsampling*, + Quiroz, M., Kohn, R., Villani, M., & Tran, M. N. (2018) + + **Example** + + .. doctest:: + + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.infer import MCMC, NUTS, HMCGibbs, subsample_gibbs_fn + ... + >>> def model(data): + ... x = numpyro.sample("x", dist.Normal(0, 1)) + ... with numpyro.plate("N", data.shape[0], subsample_size=100): + ... batch = numpyro.subsample(data, event_dim=0) + ... numpyro.sample("obs", dist.Normal(x, 1), obs=batch) + ... + >>> data = random.normal(random.PRNGKey(0), (10000,)) + 1 + >>> gibbs_fn = subsample_gibbs_fn(model, data) + >>> kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["N"]) + >>> mcmc = MCMC(kernel, 1000, 1000) + >>> mcmc.run(random.PRNGKey(0), data) + >>> samples = mcmc.get_samples()["x"] + >>> assert abs(jnp.mean(samples).copy() - 1.) < 0.1 + + """ + prototype_trace = trace(seed(model, rng_seed=0)).get_trace(*model_args, **model_kwargs) + plate_sizes = { + name: site["args"] + for name, site in prototype_trace.items() + if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size + } + enum = any(site["type"] == "sample" + and not site["is_observed"] + and site["fn"].has_enumerate_support + for name, site in prototype_trace.items()) + assert not enum, "Enumeration is not supported for subsample_gibbs_fn." + + def gibbs_fn(rng_key, gibbs_sites, hmc_sites): + assert set(gibbs_sites) == set(plate_sizes) + u_new = {} + for name in gibbs_sites: + size, subsample_size = plate_sizes[name] + rng_key, subkey = random.split(rng_key) + u_new[name] = random.choice(subkey, size, (subsample_size,), replace=False) + + u_loglik = log_likelihood(_wrap_model(model), hmc_sites, *model_args, batch_ndims=0, + **model_kwargs, _gibbs_sites=gibbs_sites) + u_loglik = sum(v.sum() for v in u_loglik.values()) + u_new_loglik = log_likelihood(_wrap_model(model), hmc_sites, *model_args, batch_ndims=0, + **model_kwargs, _gibbs_sites=u_new) + u_new_loglik = sum(v.sum() for v in u_new_loglik.values()) + accept_prob = jnp.clip(jnp.exp(u_new_loglik - u_loglik), a_max=1.0) + return cond(random.bernoulli(rng_key, accept_prob), u_new, identity, gibbs_sites, identity) + + return gibbs_fn From 4ac5d6fa8014f586c66432b62b24cd027d2128f8 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 23 Dec 2020 15:27:48 -0600 Subject: [PATCH 018/222] Support scan markov with history > 1 (#848) * initialize the implementation * add todo * use sarkka_bilmes_product when history > 1 * add hmm and test * revise docs * mark xfail for test_examples * unroll more steps * fix docs * address bug of carry shape not recycled * add explanation for why we need to delay promoting value shapes * no matter how many unroll steps we need, the result is still correct --- docs/source/svi.rst | 21 ++- examples/hmm_enum.py | 68 +++++++++- numpyro/contrib/control_flow/scan.py | 158 ++++++++++++++--------- numpyro/contrib/funsor/enum_messenger.py | 3 +- numpyro/contrib/funsor/infer_util.py | 34 +++-- numpyro/handlers.py | 14 +- test/contrib/test_funsor.py | 48 ++++++- test/test_examples.py | 1 + 8 files changed, 257 insertions(+), 90 deletions(-) diff --git a/docs/source/svi.rst b/docs/source/svi.rst index 6f176d2c7..7281ef62e 100644 --- a/docs/source/svi.rst +++ b/docs/source/svi.rst @@ -16,19 +16,28 @@ ELBO :show-inheritance: :member-order: bysource -RenyiELBO ---------- +Trace_ELBO +---------- -.. autoclass:: numpyro.infer.elbo.RenyiELBO +.. autoclass:: numpyro.infer.elbo.Trace_ELBO :members: :undoc-members: :show-inheritance: :member-order: bysource -Trace_ELBO ----------- +TraceMeanField_ELBO +------------------- -.. autoclass:: numpyro.infer.elbo.Trace_ELBO +.. autoclass:: numpyro.infer.elbo.TraceMeanField_ELBO + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +RenyiELBO +--------- + +.. autoclass:: numpyro.infer.elbo.RenyiELBO :members: :undoc-members: :show-inheritance: diff --git a/examples/hmm_enum.py b/examples/hmm_enum.py index bd6a114d7..5a52f192a 100644 --- a/examples/hmm_enum.py +++ b/examples/hmm_enum.py @@ -43,6 +43,9 @@ 3. *Modeling Temporal Dependencies in High-Dimensional Sequences: Application to Polyphonic Music Generation and Transcription*, Boulanger-Lewandowski, N., Bengio, Y. and Vincent, P. + 4. *Tensor Variable Elimination for Plated Factor Graphs*, + Fritz Obermeyer, Eli Bingham, Martin Jankowiak, Justin Chiu, + Neeraj Pradhan, Alexander Rush, Noah Goodman (https://arxiv.org/abs/1902.03210) """ import argparse @@ -65,8 +68,9 @@ logger.setLevel(logging.INFO) +# %% # Let's start with a simple Hidden Markov Model. -# + # x[t-1] --> x[t] --> x[t+1] # | | | # V V V @@ -100,8 +104,9 @@ def transition_fn(carry, y): scan(transition_fn, (x_init, 0), jnp.swapaxes(sequences, 0, 1)) +# %% # Next let's add a dependency of y[t] on y[t-1]. -# + # x[t-1] --> x[t] --> x[t+1] # | | | # V V V @@ -137,8 +142,9 @@ def transition_fn(carry, y): scan(transition_fn, (x_init, y_init, 0), jnp.swapaxes(sequences, 0, 1)) +# %% # Next consider a Factorial HMM with two hidden states. -# + # w[t-1] ----> w[t] ---> w[t+1] # \ x[t-1] --\-> x[t] --\-> x[t+1] # \ / \ / \ / @@ -185,9 +191,10 @@ def transition_fn(carry, y): scan(transition_fn, (w_init, x_init, 0), jnp.swapaxes(sequences, 0, 1)) +# %% # By adding a dependency of x on w, we generalize to a # Dynamic Bayesian Network. -# + # w[t-1] ----> w[t] ---> w[t+1] # | \ | \ | \ # | x[t-1] ----> x[t] ----> x[t+1] @@ -230,6 +237,59 @@ def transition_fn(carry, y): scan(transition_fn, (w_init, x_init, 0), jnp.swapaxes(sequences, 0, 1)) +# %% +# Next let's consider a second-order HMM model +# in which x[t+1] depends on both x[t] and x[t-1]. + +# _______>______ +# _____>_____/______ \ +# / / \ \ +# x[t-1] --> x[t] --> x[t+1] --> x[t+2] +# | | | | +# V V V V +# y[t-1] y[t] y[t+1] y[t+2] +# +# Note that in this model (in contrast to the previous model) we treat +# the transition and emission probabilities as parameters (so they have no prior). +# +# Note that this is the "2HMM" model in reference [4]. +def model_6(sequences, lengths, args, include_prior=False): + num_sequences, max_length, data_dim = sequences.shape + + with mask(mask=include_prior): + # Explicitly parameterize the full tensor of transition probabilities, which + # has hidden_dim cubed entries. + probs_x = numpyro.sample("probs_x", + dist.Dirichlet(0.9 * jnp.eye(args.hidden_dim) + 0.1) + .expand([args.hidden_dim, args.hidden_dim]) + .to_event(2)) + + probs_y = numpyro.sample("probs_y", + dist.Beta(0.1, 0.9) + .expand([args.hidden_dim, data_dim]) + .to_event(2)) + + def transition_fn(carry, y): + x_prev, x_curr, t = carry + with numpyro.plate("sequences", num_sequences, dim=-2): + with mask(mask=(t < lengths)[..., None]): + probs_x_t = Vindex(probs_x)[x_prev, x_curr] + x_prev, x_curr = x_curr, numpyro.sample("x", dist.Categorical(probs_x_t)) + with numpyro.plate("tones", data_dim, dim=-1): + probs_y_t = probs_y[x_curr.squeeze(-1)] + numpyro.sample("y", + dist.Bernoulli(probs_y_t), + obs=y) + return (x_prev, x_curr, t + 1), None + + x_prev = jnp.zeros((num_sequences, 1), dtype=jnp.int32) + x_curr = jnp.zeros((num_sequences, 1), dtype=jnp.int32) + scan(transition_fn, (x_prev, x_curr, 0), jnp.swapaxes(sequences, 0, 1), history=2) + + +# %% +# Do inference + models = {name[len('model_'):]: model for name, model in globals().items() if name.startswith('model_')} diff --git a/numpyro/contrib/control_flow/scan.py b/numpyro/contrib/control_flow/scan.py index 7bf4b6b9b..a81083421 100644 --- a/numpyro/contrib/control_flow/scan.py +++ b/numpyro/contrib/control_flow/scan.py @@ -4,7 +4,7 @@ from collections import OrderedDict from functools import partial -from jax import lax, random, tree_flatten, tree_map, tree_multimap, tree_unflatten +from jax import device_put, lax, random, tree_flatten, tree_map, tree_multimap, tree_unflatten import jax.numpy as jnp from jax.tree_util import register_pytree_node_class @@ -87,45 +87,53 @@ def _subs_wrapper(subs_map, i, length, site): " which is currently not supported. Please report the issue to us!") -class promote_shapes(Messenger): - # a helper messenger to promote shapes of `fn` and `value` - # + msg: fn.batch_shape = (2, 3), value.shape = (3,) + fn.event_shape - # process_message(msg): promote value so that value.shape = (1, 3) + fn.event_shape +class _promote_fn_shapes(Messenger): + # a helper messenger to promote shapes of `fn` # + msg: fn.batch_shape = (3,), value.shape = (2, 3) + fn.event_shape # process_message(msg): promote fn so that fn.batch_shape = (1, 3). - def process_message(self, msg): + def postprocess_message(self, msg): if msg["type"] == "sample" and msg["value"] is not None: fn, value = msg["fn"], msg["value"] value_batch_ndims = jnp.ndim(value) - fn.event_dim fn_batch_ndim = len(fn.batch_shape) - prepend_shapes = (1,) * abs(fn_batch_ndim - value_batch_ndims) - if fn_batch_ndim > value_batch_ndims: - msg["value"] = jnp.reshape(value, prepend_shapes + jnp.shape(value)) - elif fn_batch_ndim < value_batch_ndims: + if fn_batch_ndim < value_batch_ndims: + prepend_shapes = (1,) * (value_batch_ndims - fn_batch_ndim) msg["fn"] = tree_map(lambda x: jnp.reshape(x, prepend_shapes + jnp.shape(x)), fn) -def scan_enum(f, init, xs, length, reverse, rng_key=None, substitute_stack=None): +def _promote_scanned_value_shapes(value, fn): + # a helper function to promote shapes of `value` + # + msg: fn.batch_shape = (T, 2, 3), value.shape = (T, 3,) + fn.event_shape + # process_message(msg): promote value so that value.shape = (T, 1, 3) + fn.event_shape + value_batch_ndims = jnp.ndim(value) - fn.event_dim + fn_batch_ndim = len(fn.batch_shape) + if fn_batch_ndim > value_batch_ndims: + prepend_shapes = (1,) * (fn_batch_ndim - value_batch_ndims) + return jnp.reshape(value, jnp.shape(value)[:1] + prepend_shapes + jnp.shape(value)[1:]) + else: + return value + + +def scan_enum(f, init, xs, length, reverse, rng_key=None, substitute_stack=None, history=1, + first_available_dim=None): from numpyro.contrib.funsor import config_enumerate, enum, markov from numpyro.contrib.funsor import trace as packed_trace - # XXX: This implementation only works for history size=1 but can be - # extended to history size > 1 by running `f` `history_size` times - # for initialization. However, `sequential_sum_product` does not - # support history size > 1, so we skip supporting it here. - # Note that `funsor.sum_product.sarkka_bilmes_product` does support history > 1. + # amount number of steps to unroll + history = min(history, length) + unroll_steps = min(2 * history - 1, length) if reverse: - x0 = tree_map(lambda x: x[-1], xs) - xs_ = tree_map(lambda x: x[:-1], xs) + x0 = tree_map(lambda x: x[-unroll_steps:][::-1], xs) + xs_ = tree_map(lambda x: x[:-unroll_steps], xs) else: - x0 = tree_map(lambda x: x[0], xs) - xs_ = tree_map(lambda x: x[1:], xs) + x0 = tree_map(lambda x: x[:unroll_steps], xs) + xs_ = tree_map(lambda x: x[unroll_steps:], xs) - carry_shape_at_t1 = None + carry_shapes = [] def body_fn(wrapped_carry, x, prefix=None): i, rng_key, carry = wrapped_carry - init = True if (not_jax_tracer(i) and i == 0) else False + init = True if (not_jax_tracer(i) and i in range(unroll_steps)) else False rng_key, subkey = random.split(rng_key) if rng_key is not None else (None, None) # we need to tell unconstrained messenger in potential energy computation @@ -141,35 +149,57 @@ def body_fn(wrapped_carry, x, prefix=None): seeded_fn = handlers.substitute(seeded_fn, substitute_fn=subs_fn) if init: - with handlers.scope(prefix="_init"): - new_carry, y = seeded_fn(carry, x) + # handler the name to match the pattern of sakkar_bilmes product + with handlers.scope(prefix='P' * (unroll_steps - i), divider='_'): + new_carry, y = config_enumerate(seeded_fn)(carry, x) trace = {} else: - with handlers.block(), packed_trace() as trace, promote_shapes(), enum(), markov(): - # Like scan_wrapper, we collect the trace of scan's transition function - # `seeded_fn` here. To put time dimension to the correct position, we need to - # promote shapes to make `fn` and `value` - # at each site have the same batch dims (e.g. if `fn.batch_shape = (2, 3)`, - # and value's batch_shape is (3,), then we promote shape of - # value so that its batch shape is (1, 3)). + # Like scan_wrapper, we collect the trace of scan's transition function + # `seeded_fn` here. To put time dimension to the correct position, we need to + # promote shapes to make `fn` and `value` + # at each site have the same batch dims (e.g. if `fn.batch_shape = (2, 3)`, + # and value's batch_shape is (3,), then we promote shape of + # value so that its batch shape is (1, 3)). + # Here we will promote `fn` shape first. `value` shape will be promoted after scanned. + # We don't promote `value` shape here because we need to store carry shape + # at this step. If we reshape the `value` here, output carry might get wrong shape. + with _promote_fn_shapes(), packed_trace() as trace, handlers.scope(divider='_'): new_carry, y = config_enumerate(seeded_fn)(carry, x) # store shape of new_carry at a global variable - nonlocal carry_shape_at_t1 - carry_shape_at_t1 = [jnp.shape(x) for x in tree_flatten(new_carry)[0]] + if len(carry_shapes) < (history + 1): + carry_shapes.append([jnp.shape(x) for x in tree_flatten(new_carry)[0]]) # make new_carry have the same shape as carry # FIXME: is this rigorous? new_carry = tree_multimap(lambda a, b: jnp.reshape(a, jnp.shape(b)), new_carry, carry) - return (i + jnp.array(1), rng_key, new_carry), (PytreeTrace(trace), y) + return (i + 1, rng_key, new_carry), (PytreeTrace(trace), y) - with markov(): + with handlers.block(hide_fn=lambda site: site["name"].startswith("_")), \ + enum(first_available_dim=first_available_dim): wrapped_carry = (0, rng_key, init) - wrapped_carry, (_, y0) = body_fn(wrapped_carry, x0) - if length == 1: - ys = tree_map(lambda x: jnp.expand_dims(x, 0), y0) - return wrapped_carry, (PytreeTrace({}), ys) - wrapped_carry, (pytree_trace, ys) = lax.scan(body_fn, wrapped_carry, xs_, length - 1, reverse) + y0s = [] + # We run unroll_steps + 1 where the last step is used for rolling with `lax.scan` + for i in markov(range(unroll_steps + 1), history=history): + if i < unroll_steps: + wrapped_carry, (_, y0) = body_fn(wrapped_carry, tree_map(lambda z: z[i], x0)) + if i > 0: + # reshape y1, y2,... to have the same shape as y0 + y0 = tree_multimap(lambda z0, z: jnp.reshape(z, jnp.shape(z0)), y0s[0], y0) + y0s.append(y0) + # shapes of the first `history - 1` steps are not useful to interpret the last carry + # shape so we don't need to record them here + if (i >= history - 1) and (len(carry_shapes) < history + 1): + carry_shapes.append(jnp.shape(x) for x in tree_flatten(wrapped_carry[-1])[0]) + else: + # this is the last rolling step + y0s = tree_multimap(lambda *z: jnp.stack(z, axis=0), *y0s) + # return early if length = unroll_steps + if length == unroll_steps: + return wrapped_carry, (PytreeTrace({}), y0s) + wrapped_carry = device_put(wrapped_carry) + wrapped_carry, (pytree_trace, ys) = lax.scan(body_fn, wrapped_carry, xs_, + length - unroll_steps, reverse) first_var = None for name, site in pytree_trace.trace.items(): @@ -181,30 +211,38 @@ def body_fn(wrapped_carry, x, prefix=None): if first_var is None: first_var = name + # we haven't promote shapes of values yet during `lax.scan`, so we do it here + site["value"] = _promote_scanned_value_shapes(site["value"], site["fn"]) + # XXX: site['infer']['dim_to_name'] is not enough to determine leftmost dimension because # we don't record 1-size dimensions in this field time_dim = -min(len(site['fn'].batch_shape), jnp.ndim(site['value']) - site['fn'].event_dim) site['infer']['dim_to_name'][time_dim] = '_time_{}'.format(first_var) # similar to carry, we need to reshape due to shape alternating in markov - ys = tree_multimap(lambda z0, z: jnp.reshape(z, z.shape[:1] + jnp.shape(z0)), y0, ys) + ys = tree_multimap(lambda z0, z: jnp.reshape(z, z.shape[:1] + jnp.shape(z0)[1:]), y0s, ys) + # then join with y0s + ys = tree_multimap(lambda z0, z: jnp.concatenate([z0, z], axis=0), y0s, ys) # we also need to reshape `carry` to match sequential behavior - if length % 2 == 0: - t, rng_key, carry = wrapped_carry - flatten_carry, treedef = tree_flatten(carry) - flatten_carry = [jnp.reshape(x, t1_shape) - for x, t1_shape in zip(flatten_carry, carry_shape_at_t1)] - carry = tree_unflatten(treedef, flatten_carry) - wrapped_carry = (t, rng_key, carry) + i = (length + 1) % (history + 1) + t, rng_key, carry = wrapped_carry + carry_shape = carry_shapes[i] + flatten_carry, treedef = tree_flatten(carry) + flatten_carry = [jnp.reshape(x, t1_shape) + for x, t1_shape in zip(flatten_carry, carry_shape)] + carry = tree_unflatten(treedef, flatten_carry) + wrapped_carry = (t, rng_key, carry) return wrapped_carry, (pytree_trace, ys) -def scan_wrapper(f, init, xs, length, reverse, rng_key=None, substitute_stack=[], enum=False): +def scan_wrapper(f, init, xs, length, reverse, rng_key=None, substitute_stack=[], enum=False, + history=1, first_available_dim=None): if length is None: length = tree_flatten(xs)[0][0].shape[0] - if enum: - return scan_enum(f, init, xs, length, reverse, rng_key, substitute_stack) + if enum and history > 0: + return scan_enum(f, init, xs, length, reverse, rng_key, substitute_stack, history, + first_available_dim) def body_fn(wrapped_carry, x): i, rng_key, carry = wrapped_carry @@ -229,10 +267,11 @@ def body_fn(wrapped_carry, x): return (i + 1, rng_key, carry), (PytreeTrace(trace), y) - return lax.scan(body_fn, (jnp.array(0), rng_key, init), xs, length=length, reverse=reverse) + wrapped_carry = device_put((0, rng_key, init)) + return lax.scan(body_fn, wrapped_carry, xs, length=length, reverse=reverse) -def scan(f, init, xs, length=None, reverse=False): +def scan(f, init, xs, length=None, reverse=False, history=1): """ This primitive scans a function over the leading array axes of `xs` while carrying along state. See :func:`jax.lax.scan` for more @@ -297,13 +336,11 @@ def g(*args, **kwargs): evaluated using parallel-scan (reference [1]) over time dimension, which reduces parallel complexity to `O(log(length))`. - Currently, only the equivalence to - :class:`~numpyro.contrib.funsor.enum_messenger.markov(history_size=1)` - is supported. A :class:`~numpyro.handlers.trace` of `scan` with discrete latent + A :class:`~numpyro.handlers.trace` of `scan` with discrete latent variables will contain the following sites: - + init sites: those sites belong to the first trace of `f`. Each of - them will have name prefixed with `_init/`. + + init sites: those sites belong to the first `history` traces of `f`. + Sites at the `i`-th trace will have name prefixed with `P` * (2 * history - 1 - i). + scanned sites: those sites collect the values of the remaining scan loop over `f`. An addition time dimension `_time_foo` will be added to those sites, where `foo` is the name of the first site @@ -331,6 +368,8 @@ def g(*args, **kwargs): but can be used when `xs` is an empty pytree (e.g. None) :param bool reverse: optional boolean specifying whether to run the scan iteration forward (the default) or in reverse + :param int history: The number of previous contexts visible from the current context. + Defaults to 1. If zero, this is similar to :class:`numpyro.plate`. :return: output of scan, quoted from :func:`jax.lax.scan` docs: "pair of type (c, [b]) where the first element represents the final loop carry value and the second element represents the stacked outputs of the @@ -347,7 +386,8 @@ def g(*args, **kwargs): 'fn': scan_wrapper, 'args': (f, init, xs, length, reverse), 'kwargs': {'rng_key': None, - 'substitute_stack': []}, + 'substitute_stack': [], + 'history': history}, 'value': None, } diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index 6f63948b3..dd241c897 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -494,6 +494,7 @@ def process_message(self, msg): msg["infer"].get("enumerate") != "parallel" or (not msg["fn"].has_enumerate_support): if msg["type"] == "control_flow": msg["kwargs"]["enum"] = True + msg["kwargs"]["first_available_dim"] = self.first_available_dim return super().process_message(msg) if msg["infer"].get("num_samples", None) is not None: @@ -526,7 +527,7 @@ def postprocess_message(self, msg): if msg["type"] == "sample": total_batch_shape = lax.broadcast_shapes( tuple(msg["fn"].batch_shape), - msg["value"].shape[:len(msg["value"].shape) - msg["fn"].event_dim] + jnp.shape(msg["value"])[:jnp.ndim(msg["value"]) - msg["fn"].event_dim] ) msg["infer"]["dim_to_name"] = NamedMessenger._get_dim_to_name(total_batch_shape) if msg["type"] in ("sample", "param"): diff --git a/numpyro/contrib/funsor/infer_util.py b/numpyro/contrib/funsor/infer_util.py index 7ba7dfe56..433a2d2b0 100644 --- a/numpyro/contrib/funsor/infer_util.py +++ b/numpyro/contrib/funsor/infer_util.py @@ -71,7 +71,8 @@ def config_fn(site): return infer_config(fn, config_fn) -def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_dims, sum_vars, prod_vars): +def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_dims, + sum_vars, prod_vars, history): """ :param dict time_to_factors: a map from time variable to the log prob factors. :param dict time_to_init_vars: a map from time variable to init discrete sites. @@ -79,13 +80,13 @@ def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_di (discrete sites that depend on previous steps). :param frozenset sum_vars: all plate and enum dimensions in the trace. :param frozenset prod_vars: all plate dimensions in the trace. + :param int history: The number of previous contexts visible from the current context. :returns: a list of factors after eliminate time dimensions """ markov_factors = [] for time_var, log_factors in time_to_factors.items(): prev_vars = time_to_init_vars[time_var] - # remove `_init/` prefix to convert prev to curr - prev_to_curr = {k: "/".join(k.split("/")[1:]) for k in prev_vars} + # we eliminate all plate and enum dimensions not available at markov sites. eliminate_vars = (sum_vars | prod_vars) - time_to_markov_dims[time_var] with funsor.interpreter.interpretation(funsor.terms.lazy): @@ -93,8 +94,19 @@ def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_di funsor.ops.logaddexp, funsor.ops.add, log_factors, eliminate=eliminate_vars, plates=prod_vars) trans = funsor.optimizer.apply_optimizer(lazy_result) - markov_factors.append(funsor.sum_product.sequential_sum_product( - funsor.ops.logaddexp, funsor.ops.add, trans, time_var, prev_to_curr)) + + if history > 1: + global_vars = frozenset(set(trans.inputs) - {time_var.name} - prev_vars + - {k.lstrip("P") for k in prev_vars}) + markov_factors.append(funsor.sum_product.sarkka_bilmes_product( + funsor.ops.logaddexp, funsor.ops.add, trans, time_var, global_vars + )) + else: + # remove `P` prefix to convert prev to curr + prev_to_curr = {k: k.lstrip("P") for k in prev_vars} + markov_factors.append(funsor.sum_product.sequential_sum_product( + funsor.ops.logaddexp, funsor.ops.add, trans, time_var, prev_to_curr + )) return markov_factors @@ -124,9 +136,10 @@ def model(*args, **kwargs): model_trace = packed_trace(model).get_trace(*model_args, **model_kwargs) log_factors = [] time_to_factors = defaultdict(list) # log prob factors - time_to_init_vars = defaultdict(frozenset) # _init/... variables + time_to_init_vars = defaultdict(frozenset) # PP... variables time_to_markov_dims = defaultdict(frozenset) # dimensions at markov sites sum_vars, prod_vars = frozenset(), frozenset() + history = 1 for site in model_trace.values(): if site['type'] == 'sample': value = site['value'] @@ -148,8 +161,9 @@ def model(*args, **kwargs): if name.startswith("_time"): time_dim = funsor.Variable(name, funsor.domains.bint(log_prob.shape[dim])) time_to_factors[time_dim].append(log_prob_factor) + history = max(history, max((len(s) - len(s.lstrip("P"))) for s in dim_to_name.values())) time_to_init_vars[time_dim] |= frozenset( - s for s in dim_to_name.values() if s.startswith("_init")) + s for s in dim_to_name.values() if s.startswith("P")) break if time_dim is None: log_factors.append(log_prob_factor) @@ -160,14 +174,14 @@ def model(*args, **kwargs): for time_dim, init_vars in time_to_init_vars.items(): for var in init_vars: - curr_var = "/".join(var.split("/")[1:]) + curr_var = var.lstrip("P") dim_to_name = model_trace[curr_var]["infer"]["dim_to_name"] - if var in dim_to_name.values(): # i.e. _init (i.e. prev) in dim_to_name + if var in dim_to_name.values(): # i.e. P* (i.e. prev) in dim_to_name time_to_markov_dims[time_dim] |= frozenset(name for name in dim_to_name.values()) if len(time_to_factors) > 0: markov_factors = compute_markov_factors(time_to_factors, time_to_init_vars, - time_to_markov_dims, sum_vars, prod_vars) + time_to_markov_dims, sum_vars, prod_vars, history) log_factors = log_factors + markov_factors with funsor.interpreter.interpretation(funsor.terms.lazy): diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 0fa21767c..b03b6c4f5 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -391,7 +391,7 @@ def __init__(self, fn=None, config_fn=None): self.config_fn = config_fn def process_message(self, msg): - if msg["type"] in ("sample", "param"): + if msg["type"] in ("sample",): msg["infer"].update(self.config_fn(msg)) @@ -565,7 +565,7 @@ def process_message(self, msg): class scope(Messenger): """ - This handler prepend a prefix followed by a ``/`` to the name of sample sites. + This handler prepend a prefix followed by a divider to the name of sample sites. Example:: @@ -577,21 +577,23 @@ class scope(Messenger): >>> >>> def model(): ... with scope(prefix="a"): - ... with scope(prefix="b"): + ... with scope(prefix="b", divider="."): ... return numpyro.sample("x", dist.Bernoulli(0.5)) ... - >>> assert "a/b/x" in trace(seed(model, 0)).get_trace() + >>> assert "a/b.x" in trace(seed(model, 0)).get_trace() :param fn: Python callable with NumPyro primitives. :param str prefix: a string to prepend to sample names + :param str divider: a string to join the prefix and sample name; default to `'/'` """ - def __init__(self, fn=None, prefix=''): + def __init__(self, fn=None, prefix='', divider='/'): self.prefix = prefix + self.divider = divider super().__init__(fn) def process_message(self, msg): if msg.get('name'): - msg['name'] = f"{self.prefix}/{msg['name']}" + msg['name'] = f"{self.prefix}{self.divider}{msg['name']}" class seed(Messenger): diff --git a/test/contrib/test_funsor.py b/test/contrib/test_funsor.py index 4ae1a133d..ea7d54a2a 100644 --- a/test/contrib/test_funsor.py +++ b/test/contrib/test_funsor.py @@ -226,14 +226,14 @@ def transition_fn(x, y): probs = init_probs if x is None else transition_probs[x] x = numpyro.sample("x", dist.Categorical(probs)) numpyro.sample("y", dist.Normal(locs[x], 1), obs=y) - return x, None + return x, 1 x, collections = scan(transition_fn, None, data) - assert collections is None + assert collections.shape == data.shape[:1] return x - actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[0] expected_log_joint = log_density(enum(config_enumerate(model)), (data,), {}, {})[0] + actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[0] assert_allclose(actual_log_joint, expected_log_joint) actual_last_x = enum(config_enumerate(fun_model))(data) @@ -267,8 +267,8 @@ def transition_fn(x, y): scan(transition_fn, None, data) - actual_log_joint = log_density(enum(config_enumerate(fun_model), -2), (data,), {}, {})[0] expected_log_joint = log_density(enum(config_enumerate(model), -2), (data,), {}, {})[0] + actual_log_joint = log_density(enum(config_enumerate(fun_model), -2), (data,), {}, {})[0] assert_allclose(actual_log_joint, expected_log_joint) @@ -433,6 +433,46 @@ def transition_fn(name, probs, locs, x, y): assert_allclose(actual_log_joint, expected_log_joint) +@pytest.mark.parametrize('history', [2, 3]) +@pytest.mark.parametrize('T', [1, 2, 3, 4, 10, 11, 12, 13]) +def test_scan_history(history, T): + def model(): + p = numpyro.param("p", 0.25 * jnp.ones((2, 2, 2))) + q = numpyro.param("q", 0.25 * jnp.ones(2)) + z = numpyro.sample("z", dist.Bernoulli(0.5)) + x_prev = 0 + x_curr = 0 + for t in markov(range(T), history=history): + probs = p[x_prev, x_curr, z] + x_prev, x_curr = x_curr, numpyro.sample("x_{}".format(t), dist.Bernoulli(probs)) + numpyro.sample("y_{}".format(t), dist.Bernoulli(q[x_curr]), obs=0) + return x_prev, x_curr + + def fun_model(): + p = numpyro.param("p", 0.25 * jnp.ones((2, 2, 2))) + q = numpyro.param("q", 0.25 * jnp.ones(2)) + z = numpyro.sample("z", dist.Bernoulli(0.5)) + + def transition_fn(carry, y): + x_prev, x_curr = carry + probs = p[x_prev, x_curr, z] + x_prev, x_curr = x_curr, numpyro.sample("x", dist.Bernoulli(probs)) + numpyro.sample("y", dist.Bernoulli(q[x_curr]), obs=y) + return (x_prev, x_curr), None + + (x_prev, x_curr), _ = scan(transition_fn, (0, 0), jnp.zeros(T), history=history) + return x_prev, x_curr + + expected_log_joint = log_density(enum(config_enumerate(model)), (), {}, {})[0] + actual_log_joint = log_density(enum(config_enumerate(fun_model)), (), {}, {})[0] + assert_allclose(actual_log_joint, expected_log_joint) + + expected_x_prev, expected_x_curr = enum(config_enumerate(model))() + actual_x_prev, actual_x_curr = enum(config_enumerate(fun_model))() + assert_allclose(actual_x_prev, expected_x_prev) + assert_allclose(actual_x_curr, expected_x_curr) + + def test_missing_plate(monkeypatch): K, N = 3, 1000 diff --git a/test/test_examples.py b/test/test_examples.py index de34c86ae..3d0029df5 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -30,6 +30,7 @@ 'hmm_enum.py -m 3 -t 3 -d 3 --num-warmup 1 -n 4', 'hmm_enum.py -m 3 -t 3 -d 4 --num-warmup 1 -n 4', 'hmm_enum.py -m 4 -t 3 -d 4 --num-warmup 1 -n 4', + 'hmm_enum.py -m 6 -t 4 -d 3 --num-warmup 1 -n 4', 'minipyro.py', 'neutra.py --num-samples 100 --num-warmup 100', 'ode.py --num-samples 100 --num-warmup 100 --num-chains 1', From 2f64cf59d2d6a01a8e16ea86407fccadc731cf46 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 24 Dec 2020 07:52:42 -0600 Subject: [PATCH 019/222] Fix bug at support_size and enum of discrete gibbs (#852) * fix bug at support_size * fix bug when using enum --- numpyro/infer/hmc_gibbs.py | 15 +++++++++++---- test/test_hmc_gibbs.py | 29 ++++++++++++++++++++++++++++- 2 files changed, 39 insertions(+), 5 deletions(-) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 9c7c47147..c87733ae0 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -13,7 +13,7 @@ from numpyro.handlers import condition, seed, trace, substitute from numpyro.infer.hmc import HMC from numpyro.infer.mcmc import MCMCKernel -from numpyro.infer.util import log_likelihood, potential_energy +from numpyro.infer.util import log_likelihood, potential_energy, _guess_max_plate_nesting from numpyro.util import cond, fori_loop, identity, ravel_pytree @@ -235,16 +235,22 @@ def discrete_gibbs_fn(model, *model_args, **model_kwargs): for name, site in prototype_trace.items() if site["type"] == "sample" and site["fn"].has_enumerate_support and not site["is_observed"] } + max_plate_nesting = _guess_max_plate_nesting(prototype_trace) def gibbs_fn(rng_key, gibbs_sites, hmc_sites): # convert to unconstrained values z_hmc = {k: biject_to(prototype_trace[k]["fn"].support).inv(v) for k, v in hmc_sites.items() if k in prototype_trace} - enum = len(set(support_sizes) - set(gibbs_sites)) > 0 + use_enum = len(set(support_sizes) - set(gibbs_sites)) > 0 + wrapped_model = _wrap_model(model) + if use_enum: + from numpyro.contrib.funsor import config_enumerate, enum + + wrapped_model = enum(config_enumerate(wrapped_model), -max_plate_nesting - 1) def potential_fn(z_discrete): model_kwargs["_gibbs_sites"] = z_discrete - return potential_energy(_wrap_model(model), model_args, model_kwargs, z_hmc, enum=enum) + return potential_energy(wrapped_model, model_args, model_kwargs, z_hmc, enum=use_enum) # get support_sizes of gibbs_sites support_sizes_flat, _ = ravel_pytree({k: support_sizes[k] for k in gibbs_sites}) @@ -254,7 +260,8 @@ def potential_fn(z_discrete): idxs = random.permutation(rng_key, jnp.arange(num_discretes)) def body_fn(i, val): - idx, support_size = idxs[i], support_sizes_flat[i] + idx = idxs[i] + support_size = support_sizes_flat[idx] return _discrete_step(*val, potential_fn=potential_fn, idx=idx, support_size=support_size) init_val = (rng_key, gibbs_sites, potential_fn(gibbs_sites)) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index 320ecd1df..f45df7bec 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -13,7 +13,7 @@ import numpyro import numpyro.distributions as dist -from numpyro.infer import HMC, MCMC, NUTS, HMCGibbs +from numpyro.infer import HMC, MCMC, NUTS, HMCGibbs, discrete_gibbs_fn def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): @@ -146,3 +146,30 @@ def model(): assert_allclose(x0_std, np.sqrt(np.diagonal(cov00)), rtol=0.05) assert_allclose(x1_std, np.sqrt(np.diagonal(cov11)), rtol=0.1) + + +def test_discrete_gibbs_multiple_sites(): + + def model(): + numpyro.sample("x", dist.Bernoulli(0.7).expand([3])) + numpyro.sample("y", dist.Binomial(10, 0.3)) + + kernel = HMCGibbs(NUTS(model), discrete_gibbs_fn(model), gibbs_sites=["x", "y"]) + mcmc = MCMC(kernel, 1000, 10000, progress_bar=False) + mcmc.run(random.PRNGKey(0)) + samples = mcmc.get_samples() + assert_allclose(jnp.mean(samples["x"], 0), 0.7 * jnp.ones(3), atol=0.01) + assert_allclose(jnp.mean(samples["y"], 0), 0.3 * 10, atol=0.1) + + +def test_discrete_gibbs_enum(): + + def model(): + numpyro.sample("x", dist.Bernoulli(0.7)) + numpyro.sample("y", dist.Binomial(10, 0.3)) + + kernel = HMCGibbs(NUTS(model), discrete_gibbs_fn(model), gibbs_sites=["y"]) + mcmc = MCMC(kernel, 1000, 10000, progress_bar=False) + mcmc.run(random.PRNGKey(0)) + samples = mcmc.get_samples() + assert_allclose(jnp.mean(samples["y"], 0), 0.3 * 10, atol=0.1) From 41594d61a8a8c666c4be07db387ab3f28f781d8d Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 31 Dec 2020 13:47:01 -0600 Subject: [PATCH 020/222] Add various discrete gibbs functions method (#854) * add various discrete gibbs function method * change stay_prob to modified to avoid confusing users * address comments --- numpyro/infer/hmc_gibbs.py | 159 +++++++++++++++++++++++++++++-------- test/test_hmc_gibbs.py | 35 ++++++++ 2 files changed, 161 insertions(+), 33 deletions(-) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index c87733ae0..4eaf6a755 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -156,42 +156,93 @@ def potential_fn(z_gibbs, z_hmc): return HMCGibbsState(z, hmc_state, rng_key) -def _discrete_step(rng_key, z_discrete, pe, potential_fn, idx, support_size): +def _discrete_gibbs_proposal_body_fn(z_init_flat, unravel_fn, pe_init, potential_fn, idx, i, val): + rng_key, z, pe, log_weight_sum = val + rng_key, rng_transition = random.split(rng_key) + proposal = jnp.where(i >= z_init_flat[idx], i + 1, i) + z_new_flat = ops.index_update(z_init_flat, idx, proposal) + z_new = unravel_fn(z_new_flat) + pe_new = potential_fn(z_new) + log_weight_new = pe_init - pe_new + # Handles the NaN case... + log_weight_new = jnp.where(jnp.isfinite(log_weight_new), log_weight_new, -jnp.inf) + # transition_prob = e^weight_new / (e^weight_logsumexp + e^weight_new) + transition_prob = expit(log_weight_new - log_weight_sum) + z, pe = cond(random.bernoulli(rng_transition, transition_prob), + (z_new, pe_new), identity, + (z, pe), identity) + log_weight_sum = jnp.logaddexp(log_weight_new, log_weight_sum) + return rng_key, z, pe, log_weight_sum + + +def _discrete_gibbs_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_size): # idx: current index of `z_discrete_flat` to update # support_size: support size of z_discrete at the index idx - # get z proposal z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) - + # Here we loop over the support of z_flat[idx] to get z_new # XXX: we can't vmap potential_fn over all proposals and sample from the conditional # categorical distribution because support_size is a traced value, i.e. its value # might change across different discrete variables; # so here we will loop over all proposals and use an online scheme to sample from # the conditional categorical distribution - def body_fn(i, val): - rng_key, z, pe, weight_logsumexp = val - rng_key, rng_accept = random.split(rng_key) - proposal = jnp.where(i >= z_discrete_flat[idx], i + 1, i) - z_new_flat = ops.index_update(z_discrete_flat, idx, proposal) - z_new = unravel_fn(z_new_flat) - pe_new = potential_fn(z_new) - weight_new = pe - pe_new - # Handles the NaN case... - weight_new = jnp.where(jnp.isfinite(weight_new), weight_new, -jnp.inf) - # transition_prob = e^weight_new / (e^weight_logsumexp + e^weight_new) - transition_prob = expit(weight_new - weight_logsumexp) - z, pe = cond(random.bernoulli(rng_accept, transition_prob), - (z_new, pe_new), identity, - (z, pe), identity) - weight_logsumexp = jnp.logaddexp(weight_new, weight_logsumexp) - return rng_key, z, pe, weight_logsumexp - + body_fn = partial(_discrete_gibbs_proposal_body_fn, + z_discrete_flat, unravel_fn, pe, potential_fn, idx) init_val = (rng_key, z_discrete, pe, jnp.array(0.)) - rng_key, z, pe, _ = fori_loop(0, support_size - 1, body_fn, init_val) - return rng_key, z, pe + rng_key, z_new, pe_new, _ = fori_loop(0, support_size - 1, body_fn, init_val) + log_accept_ratio = jnp.array(0.) + return rng_key, z_new, pe_new, log_accept_ratio + + +def _discrete_modified_gibbs_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_size, + stay_prob=0.): + assert isinstance(stay_prob, float) and stay_prob >= 0. and stay_prob < 1 + z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) + body_fn = partial(_discrete_gibbs_proposal_body_fn, + z_discrete_flat, unravel_fn, pe, potential_fn, idx) + # like gibbs_step but here, weight of the current value is 0 + init_val = (rng_key, z_discrete, pe, jnp.array(-jnp.inf)) + rng_key, z_new, pe_new, log_weight_sum = fori_loop(0, support_size - 1, body_fn, init_val) + rng_key, rng_stay = random.split(rng_key) + z_new, pe_new = cond(random.bernoulli(rng_stay, stay_prob), + (z_discrete, pe), identity, + (z_new, pe_new), identity) + # here we calculate the MH correction: (1 - P(z)) / (1 - P(z_new)) + # where 1 - P(z) ~ weight_sum + # and 1 - P(z_new) ~ 1 + weight_sum - z_new_weight + log_accept_ratio = log_weight_sum - jnp.log(jnp.exp(log_weight_sum) - jnp.expm1(pe - pe_new)) + return rng_key, z_new, pe_new, log_accept_ratio + + +def _discrete_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_size): + rng_key, rng_proposal = random.split(rng_key, 2) + z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) + + proposal = random.randint(rng_proposal, (), minval=0, maxval=support_size) + z_new_flat = ops.index_update(z_discrete_flat, idx, proposal) + z_new = unravel_fn(z_new_flat) + pe_new = potential_fn(z_new) + log_accept_ratio = pe - pe_new + return rng_key, z_new, pe_new, log_accept_ratio + + +def _discrete_modified_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_size, + stay_prob=0.): + assert isinstance(stay_prob, float) and stay_prob >= 0. and stay_prob < 1 + rng_key, rng_proposal, rng_stay = random.split(rng_key, 3) + z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) + + i = random.randint(rng_proposal, (), minval=0, maxval=support_size - 1) + proposal = jnp.where(i >= z_discrete_flat[idx], i + 1, i) + proposal = jnp.where(random.bernoulli(rng_stay, stay_prob), idx, proposal) + z_new_flat = ops.index_update(z_discrete_flat, idx, proposal) + z_new = unravel_fn(z_new_flat) + pe_new = potential_fn(z_new) + log_accept_ratio = pe - pe_new + return rng_key, z_new, pe_new, log_accept_ratio -def discrete_gibbs_fn(model, *model_args, **model_kwargs): +def discrete_gibbs_fn(model, model_args=(), model_kwargs={}, *, random_walk=False, modified=False): """ [EXPERIMENTAL INTERFACE] @@ -201,6 +252,24 @@ def discrete_gibbs_fn(model, *model_args, **model_kwargs): Note that those discrete latent sites that are not specified in the constructor of :class:`HMCGibbs` will be marginalized out by default (if they have enumerate supports). + :param callable model: a callable with NumPyro primitives. This should be the same model + as the one used in the `inner_kernel` of :class:`HMCGibbs`. + :param tuple model_args: Arguments provided to the model. + :param dict model_kwargs: Keyword arguments provided to the model. + :param bool random_walk: If False, Gibbs sampling will be used to draw a sample from the + conditional `p(gibbs_site | remaining sites)`. Otherwise, a sample will be drawn uniformly + from the domain of `gibbs_site`. + :param bool modified: whether to use a modified proposal, as suggested in reference [1], which + always proposes a new state for the current Gibbs site. + The modified scheme appears in the literature under the name "modified Gibbs sampler" or + "Metropolised Gibbs sampler". + :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs + + **References:** + + 1. *Peskun's theorem and a modified discrete-state Gibbs sampler*, + Liu, J. S. (1996) + **Example** .. doctest:: @@ -217,13 +286,11 @@ def discrete_gibbs_fn(model, *model_args, **model_kwargs): ... >>> probs = jnp.array([0.15, 0.3, 0.3, 0.25]) >>> locs = jnp.array([-2, 0, 2, 4]) - >>> gibbs_fn = discrete_gibbs_fn(model, probs, locs) + >>> gibbs_fn = discrete_gibbs_fn(model, (probs, locs)) >>> kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["c"]) >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) >>> mcmc.run(random.PRNGKey(0), probs, locs) - >>> samples = mcmc.get_samples()["x"] - >>> assert abs(jnp.mean(samples) - 1.3) < 0.1 - >>> assert abs(jnp.var(samples) - 4.36) < 0.5 + >>> mcmc.print_summary() # doctest: +SKIP """ # NB: all of the information such as `model`, `model_args`, `model_kwargs` @@ -236,6 +303,16 @@ def discrete_gibbs_fn(model, *model_args, **model_kwargs): if site["type"] == "sample" and site["fn"].has_enumerate_support and not site["is_observed"] } max_plate_nesting = _guess_max_plate_nesting(prototype_trace) + if random_walk: + if modified: + proposal_fn = partial(_discrete_modified_rw_proposal, stay_prob=0.) + else: + proposal_fn = _discrete_rw_proposal + else: + if modified: + proposal_fn = partial(_discrete_modified_gibbs_proposal, stay_prob=0.) + else: + proposal_fn = _discrete_gibbs_proposal def gibbs_fn(rng_key, gibbs_sites, hmc_sites): # convert to unconstrained values @@ -249,8 +326,9 @@ def gibbs_fn(rng_key, gibbs_sites, hmc_sites): wrapped_model = enum(config_enumerate(wrapped_model), -max_plate_nesting - 1) def potential_fn(z_discrete): - model_kwargs["_gibbs_sites"] = z_discrete - return potential_energy(wrapped_model, model_args, model_kwargs, z_hmc, enum=use_enum) + model_kwargs_ = model_kwargs.copy() + model_kwargs_["_gibbs_sites"] = z_discrete + return potential_energy(wrapped_model, model_args, model_kwargs_, z_hmc, enum=use_enum) # get support_sizes of gibbs_sites support_sizes_flat, _ = ravel_pytree({k: support_sizes[k] for k in gibbs_sites}) @@ -262,7 +340,16 @@ def potential_fn(z_discrete): def body_fn(i, val): idx = idxs[i] support_size = support_sizes_flat[idx] - return _discrete_step(*val, potential_fn=potential_fn, idx=idx, support_size=support_size) + rng_key, z, pe = val + rng_key, z_new, pe_new, log_accept_ratio = proposal_fn( + rng_key, z, pe, potential_fn=potential_fn, idx=idx, support_size=support_size) + rng_key, rng_accept = random.split(rng_key) + # u ~ Uniform(0, 1), u < accept_ratio => -log(u) > -log_accept_ratio + # and -log(u) ~ exponential(1) + z, pe = cond(random.exponential(rng_accept) > -log_accept_ratio, + (z_new, pe_new), identity, + (z, pe), identity) + return rng_key, z, pe init_val = (rng_key, gibbs_sites, potential_fn(gibbs_sites)) _, gibbs_sites, _ = fori_loop(0, num_discretes, body_fn, init_val) @@ -271,7 +358,7 @@ def body_fn(i, val): return gibbs_fn -def subsample_gibbs_fn(model, *model_args, **model_kwargs): +def subsample_gibbs_fn(model, model_args=(), model_kwargs={}): """ [EXPERIMENTAL INTERFACE] @@ -287,6 +374,12 @@ def subsample_gibbs_fn(model, *model_args, **model_kwargs): 2. *Speeding Up MCMC by Efficient Data Subsampling*, Quiroz, M., Kohn, R., Villani, M., & Tran, M. N. (2018) + :param callable model: a callable with NumPyro primitives. This should be the same model + as the one used in the `inner_kernel` of :class:`HMCGibbs`. + :param tuple model_args: Arguments provided to the model. + :param dict model_kwargs: Keyword arguments provided to the model. + :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs + **Example** .. doctest:: @@ -304,7 +397,7 @@ def subsample_gibbs_fn(model, *model_args, **model_kwargs): ... numpyro.sample("obs", dist.Normal(x, 1), obs=batch) ... >>> data = random.normal(random.PRNGKey(0), (10000,)) + 1 - >>> gibbs_fn = subsample_gibbs_fn(model, data) + >>> gibbs_fn = subsample_gibbs_fn(model, (data,)) >>> kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["N"]) >>> mcmc = MCMC(kernel, 1000, 1000) >>> mcmc.run(random.PRNGKey(0), data) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index f45df7bec..65eb26baf 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -173,3 +173,38 @@ def model(): mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["y"], 0), 0.3 * 10, atol=0.1) + + +@pytest.mark.parametrize("random_walk", [False, True]) +@pytest.mark.parametrize("modified", [False, True]) +def test_discrete_gibbs_bernoulli(random_walk, modified): + + def model(): + numpyro.sample("c", dist.Bernoulli(0.8)) + + gibbs_fn = discrete_gibbs_fn(model, random_walk=random_walk, modified=modified) + kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["c"]) + mcmc = MCMC(kernel, 1000, 200000, progress_bar=False) + mcmc.run(random.PRNGKey(0)) + samples = mcmc.get_samples()["c"] + assert_allclose(jnp.mean(samples), 0.8, atol=0.05) + + +@pytest.mark.parametrize("modified", [False, True]) +def test_discrete_gibbs_gmm_1d(modified): + + def model(probs, locs): + c = numpyro.sample("c", dist.Categorical(probs)) + numpyro.sample("x", dist.Normal(locs[c], 0.5)) + + probs = jnp.array([0.15, 0.3, 0.3, 0.25]) + locs = jnp.array([-2, 0, 2, 4]) + gibbs_fn = discrete_gibbs_fn(model, (probs, locs), modified=modified) + kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["c"]) + mcmc = MCMC(kernel, 1000, 200000, progress_bar=False) + mcmc.run(random.PRNGKey(0), probs, locs) + samples = mcmc.get_samples() + assert_allclose(jnp.mean(samples["x"]), 1.3, atol=0.1) + assert_allclose(jnp.var(samples["x"]), 4.36, atol=0.1) + assert_allclose(jnp.mean(samples["c"]), 1.65, atol=0.1) + assert_allclose(jnp.var(samples["c"]), 1.03, atol=0.1) From e93ecd91be011bbf4bd5bd31f462a4c35b1dc282 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 1 Jan 2021 10:34:09 -0600 Subject: [PATCH 021/222] Change prefix P to _PREV_ for scan_enum (#856) * change P to PREV - tests are not passed yet * fix the bug --- numpyro/contrib/control_flow/scan.py | 9 +++++---- numpyro/contrib/funsor/infer_util.py | 27 ++++++++++++++++++++------- 2 files changed, 25 insertions(+), 11 deletions(-) diff --git a/numpyro/contrib/control_flow/scan.py b/numpyro/contrib/control_flow/scan.py index a81083421..1c1e4dc6b 100644 --- a/numpyro/contrib/control_flow/scan.py +++ b/numpyro/contrib/control_flow/scan.py @@ -150,7 +150,7 @@ def body_fn(wrapped_carry, x, prefix=None): if init: # handler the name to match the pattern of sakkar_bilmes product - with handlers.scope(prefix='P' * (unroll_steps - i), divider='_'): + with handlers.scope(prefix='_PREV_' * (unroll_steps - i), divider=''): new_carry, y = config_enumerate(seeded_fn)(carry, x) trace = {} else: @@ -163,7 +163,7 @@ def body_fn(wrapped_carry, x, prefix=None): # Here we will promote `fn` shape first. `value` shape will be promoted after scanned. # We don't promote `value` shape here because we need to store carry shape # at this step. If we reshape the `value` here, output carry might get wrong shape. - with _promote_fn_shapes(), packed_trace() as trace, handlers.scope(divider='_'): + with _promote_fn_shapes(), packed_trace() as trace: new_carry, y = config_enumerate(seeded_fn)(carry, x) # store shape of new_carry at a global variable @@ -175,7 +175,7 @@ def body_fn(wrapped_carry, x, prefix=None): new_carry, carry) return (i + 1, rng_key, new_carry), (PytreeTrace(trace), y) - with handlers.block(hide_fn=lambda site: site["name"].startswith("_")), \ + with handlers.block(hide_fn=lambda site: not site["name"].startswith("_PREV_")), \ enum(first_available_dim=first_available_dim): wrapped_carry = (0, rng_key, init) y0s = [] @@ -340,7 +340,8 @@ def g(*args, **kwargs): variables will contain the following sites: + init sites: those sites belong to the first `history` traces of `f`. - Sites at the `i`-th trace will have name prefixed with `P` * (2 * history - 1 - i). + Sites at the `i`-th trace will have name prefixed with + `'_PREV_' * (2 * history - 1 - i)`. + scanned sites: those sites collect the values of the remaining scan loop over `f`. An addition time dimension `_time_foo` will be added to those sites, where `foo` is the name of the first site diff --git a/numpyro/contrib/funsor/infer_util.py b/numpyro/contrib/funsor/infer_util.py index 433a2d2b0..4a880febe 100644 --- a/numpyro/contrib/funsor/infer_util.py +++ b/numpyro/contrib/funsor/infer_util.py @@ -3,6 +3,7 @@ from collections import defaultdict from contextlib import contextmanager +import re import funsor import numpyro @@ -71,6 +72,18 @@ def config_fn(site): return infer_config(fn, config_fn) +def _get_shift(name): + """helper function used internally in sarkka_bilmes_product""" + return len(re.search(r"^(_PREV_)*", name).group(0)) // 6 + + +def _shift_name(name, t): + """helper function used internally in sarkka_bilmes_product""" + if t >= 0: + return t * "_PREV_" + name + return name.replace("_PREV_" * -t, "", 1) + + def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_dims, sum_vars, prod_vars, history): """ @@ -97,13 +110,13 @@ def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_di if history > 1: global_vars = frozenset(set(trans.inputs) - {time_var.name} - prev_vars - - {k.lstrip("P") for k in prev_vars}) + - {_shift_name(k, -_get_shift(k)) for k in prev_vars}) markov_factors.append(funsor.sum_product.sarkka_bilmes_product( funsor.ops.logaddexp, funsor.ops.add, trans, time_var, global_vars )) else: - # remove `P` prefix to convert prev to curr - prev_to_curr = {k: k.lstrip("P") for k in prev_vars} + # remove `_PREV_` prefix to convert prev to curr + prev_to_curr = {k: _shift_name(k, -_get_shift(k)) for k in prev_vars} markov_factors.append(funsor.sum_product.sequential_sum_product( funsor.ops.logaddexp, funsor.ops.add, trans, time_var, prev_to_curr )) @@ -161,9 +174,9 @@ def model(*args, **kwargs): if name.startswith("_time"): time_dim = funsor.Variable(name, funsor.domains.bint(log_prob.shape[dim])) time_to_factors[time_dim].append(log_prob_factor) - history = max(history, max((len(s) - len(s.lstrip("P"))) for s in dim_to_name.values())) + history = max(history, max(_get_shift(s) for s in dim_to_name.values())) time_to_init_vars[time_dim] |= frozenset( - s for s in dim_to_name.values() if s.startswith("P")) + s for s in dim_to_name.values() if s.startswith("_PREV_")) break if time_dim is None: log_factors.append(log_prob_factor) @@ -174,9 +187,9 @@ def model(*args, **kwargs): for time_dim, init_vars in time_to_init_vars.items(): for var in init_vars: - curr_var = var.lstrip("P") + curr_var = _shift_name(var, -_get_shift(var)) dim_to_name = model_trace[curr_var]["infer"]["dim_to_name"] - if var in dim_to_name.values(): # i.e. P* (i.e. prev) in dim_to_name + if var in dim_to_name.values(): # i.e. _PREV_* (i.e. prev) in dim_to_name time_to_markov_dims[time_dim] |= frozenset(name for name in dim_to_name.values()) if len(time_to_factors) > 0: From 1a1d21ffd2f4d42255a9e6c3a875cf3db687d997 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 2 Jan 2021 16:06:07 -0600 Subject: [PATCH 022/222] Fix discrete_gibbs_fn not compatible with deterministic sites (#858) * fix deterministic in gibbs * add tests * fix docs --- numpyro/infer/hmc_gibbs.py | 7 ++++--- test/test_hmc_gibbs.py | 3 ++- 2 files changed, 6 insertions(+), 4 deletions(-) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 4eaf6a755..0cbab8817 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -263,7 +263,7 @@ def discrete_gibbs_fn(model, model_args=(), model_kwargs={}, *, random_walk=Fals always proposes a new state for the current Gibbs site. The modified scheme appears in the literature under the name "modified Gibbs sampler" or "Metropolised Gibbs sampler". - :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs + :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs` **References:** @@ -317,7 +317,8 @@ def discrete_gibbs_fn(model, model_args=(), model_kwargs={}, *, random_walk=Fals def gibbs_fn(rng_key, gibbs_sites, hmc_sites): # convert to unconstrained values z_hmc = {k: biject_to(prototype_trace[k]["fn"].support).inv(v) - for k, v in hmc_sites.items() if k in prototype_trace} + for k, v in hmc_sites.items() + if k in prototype_trace and prototype_trace[k]["type"] == "sample"} use_enum = len(set(support_sizes) - set(gibbs_sites)) > 0 wrapped_model = _wrap_model(model) if use_enum: @@ -378,7 +379,7 @@ def subsample_gibbs_fn(model, model_args=(), model_kwargs={}): as the one used in the `inner_kernel` of :class:`HMCGibbs`. :param tuple model_args: Arguments provided to the model. :param dict model_kwargs: Keyword arguments provided to the model. - :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs + :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs` **Example** diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index 65eb26baf..a145eb779 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -166,7 +166,8 @@ def test_discrete_gibbs_enum(): def model(): numpyro.sample("x", dist.Bernoulli(0.7)) - numpyro.sample("y", dist.Binomial(10, 0.3)) + y = numpyro.sample("y", dist.Binomial(10, 0.3)) + numpyro.deterministic("y2", y ** 2) kernel = HMCGibbs(NUTS(model), discrete_gibbs_fn(model), gibbs_sites=["y"]) mcmc = MCMC(kernel, 1000, 10000, progress_bar=False) From 956789be0fc09b81d769a647d67e5ec303a50224 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 4 Jan 2021 14:33:27 -0600 Subject: [PATCH 023/222] Address memory leak of postprocess_fn and lax.map (#860) --- numpyro/infer/mcmc.py | 48 ++++++++++++++++++++++++++++--------------- 1 file changed, 31 insertions(+), 17 deletions(-) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 3d8e144ac..19dc40784 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -271,7 +271,7 @@ def __init__(self, self._collection_params = {} self._set_collection_params() - def _get_cached_fn(self): + def _get_cached_fns(self): if self._jit_model_args: args, kwargs = (None,), (None,) else: @@ -279,20 +279,36 @@ def _get_cached_fn(self): kwargs = tree_map(lambda x: _hashable(x), tuple(sorted(self._kwargs.items()))) key = args + kwargs try: - fn = self._cache.get(key, None) + fns = self._cache.get(key, None) # If unhashable arguments are provided, proceed normally # without caching except TypeError: - fn, key = None, None - if fn is None: + fns, key = None, None + if fns is None: + + def laxmap_postprocess_fn(states, args, kwargs): + if self.postprocess_fn is None: + body_fn = self.sampler.postprocess_fn(args, kwargs) + else: + body_fn = self.postprocess_fn + if self.chain_method == "vectorized" and self.num_chains > 1: + body_fn = vmap(body_fn) + + return lax.map(body_fn, states) + if self._jit_model_args: - fn = partial(_sample_fn_jit_args, sampler=self.sampler) + sample_fn = partial(_sample_fn_jit_args, sampler=self.sampler) + postprocess_fn = jit(laxmap_postprocess_fn) else: - fn = partial(_sample_fn_nojit_args, sampler=self.sampler, - args=self._args, kwargs=self._kwargs) + sample_fn = partial(_sample_fn_nojit_args, sampler=self.sampler, + args=self._args, kwargs=self._kwargs) + postprocess_fn = jit(partial(laxmap_postprocess_fn, + args=self._args, kwargs=self._kwargs)) + + fns = sample_fn, postprocess_fn if key is not None: - self._cache[key] = fn - return fn + self._cache[key] = fns + return fns def _get_cached_init_state(self, rng_key, args, kwargs): rng_key = (_hashable(rng_key),) @@ -310,10 +326,7 @@ def _single_chain_mcmc(self, init, args, kwargs, collect_fields): if init_state is None: init_state = self.sampler.init(rng_key, self.num_warmup, init_params, model_args=args, model_kwargs=kwargs) - if self.postprocess_fn is None: - postprocess_fn = self.sampler.postprocess_fn(args, kwargs) - else: - postprocess_fn = self.postprocess_fn + sample_fn, postprocess_fn = self._get_cached_fns() diagnostics = lambda x: self.sampler.get_diagnostics_str(x[0]) if rng_key.ndim == 1 else '' # noqa: E731 init_val = (init_state, args, kwargs) if self._jit_model_args else (init_state,) lower_idx = self._collection_params["lower"] @@ -323,7 +336,7 @@ def _single_chain_mcmc(self, init, args, kwargs, collect_fields): collection_size = collection_size if collection_size is None else collection_size // self.thinning collect_vals = fori_collect(lower_idx, upper_idx, - self._get_cached_fn(), + sample_fn, init_val, transform=_collect_fn(collect_fields), progbar=self.progress_bar, @@ -344,9 +357,10 @@ def _single_chain_mcmc(self, init, args, kwargs, collect_fields): # so we only need to filter out the case site_value.shape[0] == 0 # (which happens when lower_idx==upper_idx) if len(site_values) > 0 and jnp.shape(site_values[0])[0] > 0: - if self.chain_method == "vectorized" and self.num_chains > 1: - postprocess_fn = vmap(postprocess_fn) - states[self._sample_field] = lax.map(postprocess_fn, states[self._sample_field]) + if self._jit_model_args: + states[self._sample_field] = postprocess_fn(states[self._sample_field], args, kwargs) + else: + states[self._sample_field] = postprocess_fn(states[self._sample_field]) return states, last_state def _set_collection_params(self, lower=None, upper=None, collection_size=None, phase=None): From 87258a29188298cc33f34ce478db1a79a891e0dc Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 8 Jan 2021 12:54:30 -0600 Subject: [PATCH 024/222] Expose some mcmc states for sequential sampling strategy (#861) --- numpyro/distributions/discrete.py | 2 +- numpyro/infer/hmc.py | 6 ++--- numpyro/infer/mcmc.py | 37 ++++++++++++++++++++++++++++--- test/test_mcmc.py | 11 +++++++-- 4 files changed, 46 insertions(+), 10 deletions(-) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 043541bcd..90a6f137f 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -53,7 +53,7 @@ def _to_probs_bernoulli(logits): - return 1 / (1 + jnp.exp(-logits)) + return expit(logits) def _to_logits_bernoulli(probs): diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 1db4c93fb..baa0fc12d 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -121,12 +121,10 @@ def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo='NUTS'): >>> true_coefs = jnp.array([1., 2., 3.]) >>> data = random.normal(random.PRNGKey(2), (2000, 3)) - >>> dim = 3 >>> labels = dist.Bernoulli(logits=(true_coefs * data).sum(-1)).sample(random.PRNGKey(3)) >>> >>> def model(data, labels): - ... coefs_mean = jnp.zeros(dim) - ... coefs = numpyro.sample('beta', dist.Normal(coefs_mean, jnp.ones(3))) + ... coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(3), jnp.ones(3))) ... intercept = numpyro.sample('intercept', dist.Normal(0., 10.)) ... return numpyro.sample('y', dist.Bernoulli(logits=(coefs * data + intercept).sum(-1)), obs=labels) >>> @@ -137,7 +135,7 @@ def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo='NUTS'): ... num_warmup=300) >>> samples = fori_collect(0, 500, sample_kernel, hmc_state, ... transform=lambda state: model_info.postprocess_fn(state.z)) - >>> print(jnp.mean(samples['beta'], axis=0)) # doctest: +SKIP + >>> print(jnp.mean(samples['coefs'], axis=0)) # doctest: +SKIP [0.9153987 2.0754058 2.9621222] """ if kinetic_fn is None: diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 19dc40784..47fa55a28 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -382,11 +382,42 @@ def _compile(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): except TypeError: pass + @property + def post_warmup_state(self): + """ + The state before the sampling phase. If this attribute is not None, + :meth:`run` will skip the warmup phase and start with the state + specified in this attribute. + + .. note:: This attribute can be used to sequentially draw MCMC samples. For example, + + .. code-block:: python + + mcmc = MCMC(NUTS(model), 100, 100) + mcmc.run(random.PRNGKey(0)) + first_100_samples = mcmc.get_samples() + mcmc.post_warmup_state = mcmc.last_state + mcmc.run(mcmc.post_warmup_state.rng_key) # or mcmc.run(random.PRNGKey(1)) + second_100_samples = mcmc.get_samples() + """ + return self._warmup_state + + @post_warmup_state.setter + def post_warmup_state(self, state): + self._warmup_state = state + + @property + def last_state(self): + """ + The final MCMC state at the end of the sampling phase. + """ + return self._last_state + def warmup(self, rng_key, *args, extra_fields=(), collect_warmup=False, init_params=None, **kwargs): """ - Run the MCMC warmup adaptation phase. After this call, the :meth:`run` method - will skip the warmup adaptation phase. To run `warmup` again for the new data, - it is required to run :meth:`warmup` again. + Run the MCMC warmup adaptation phase. After this call, `self.warmup_state` will be set + and the :meth:`run` method will skip the warmup adaptation phase. To run `warmup` again + for the new data, it is required to run :meth:`warmup` again. :param random.PRNGKey rng_key: Random number generator key to be used for the sampling. :param args: Arguments to be provided to the :meth:`numpyro.infer.mcmc.MCMCKernel.init` method. diff --git a/test/test_mcmc.py b/test/test_mcmc.py index c1f5a8751..b6febbf6c 100644 --- a/test/test_mcmc.py +++ b/test/test_mcmc.py @@ -115,6 +115,7 @@ def model(data): kernel = NUTS(model=model) mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.warmup(random.PRNGKey(2), data, collect_warmup=True) + assert mcmc.post_warmup_state is not None warmup_samples = mcmc.get_samples() mcmc.run(random.PRNGKey(3), data) samples = mcmc.get_samples() @@ -122,6 +123,12 @@ def model(data): assert len(samples['loc']) == num_samples assert_allclose(jnp.mean(samples['loc'], 0), true_coef, atol=0.05) + mcmc.post_warmup_state = mcmc.last_state + mcmc.run(random.PRNGKey(3), data) + samples = mcmc.get_samples() + assert len(samples['loc']) == num_samples + assert_allclose(jnp.mean(samples['loc'], 0), true_coef, atol=0.05) + def test_improper_normal(): true_coef = 0.9 @@ -293,7 +300,7 @@ def model(data): mcmc1.warmup(random.PRNGKey(2), data) mcmc1.run(random.PRNGKey(3), data) check_close(mcmc1.get_samples(), mcmc.get_samples(), atol=1e-4, rtol=1e-4) - check_close(mcmc1._warmup_state, mcmc._warmup_state, atol=1e-4, rtol=1e-4) + check_close(mcmc1.post_warmup_state, mcmc.post_warmup_state, atol=1e-4, rtol=1e-4) @pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) @@ -603,7 +610,7 @@ def model(): mcmc._compile(rng_key) # no delay after compiling mcmc.warmup(rng_key) - mcmc.run(mcmc._warmup_state.rng_key) + mcmc.run(mcmc.last_state.rng_key) actual_samples = mcmc.get_samples()["x"] assert_allclose(actual_samples, expected_samples) From 1f7578a66fd55f169b6bdf824f40f17cf26b86d9 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 8 Jan 2021 15:11:53 -0600 Subject: [PATCH 025/222] add note on how to convert num_steps to tree_depth (#866) --- numpyro/infer/hmc.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index baa0fc12d..a89f535d9 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -31,6 +31,8 @@ - **potential_energy** - Potential energy computed at the given value of ``z``. - **energy** - Sum of potential energy and kinetic energy of the current state. - **num_steps** - Number of steps in the Hamiltonian trajectory (for diagnostics). + In NUTS sampler, the tree depth of a trajectory can be computed from this field + with `tree_depth = np.log2(num_steps).astype(int) + 1`. - **accept_prob** - Acceptance probability of the proposal. Note that ``z`` does not correspond to the proposal if it is rejected. - **mean_accept_prob** - Mean acceptance probability until current iteration From 4ebc316b6636e54e36c568205117e46c807297d8 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 8 Jan 2021 21:56:58 -0600 Subject: [PATCH 026/222] Fix a typo in regression notebook (#867) --- notebooks/source/bayesian_regression.ipynb | 23 ++++++++++++++-------- numpyro/__init__.py | 3 +-- numpyro/contrib/funsor/enum_messenger.py | 3 ++- numpyro/distributions/__init__.py | 2 +- numpyro/distributions/kl.py | 10 +++++++--- numpyro/examples/datasets.py | 2 +- numpyro/infer/autoguide.py | 2 +- numpyro/infer/einstein/kernels.py | 9 +++++---- numpyro/infer/hmc_gibbs.py | 5 ++--- numpyro/infer/svi.py | 3 ++- test/test_autoguide.py | 4 ++-- test/test_distributions.py | 9 +++++++-- test/test_einstein_kernels.py | 13 ++++++------ test/test_hmc_gibbs.py | 8 ++++---- test/test_svi.py | 2 +- 15 files changed, 58 insertions(+), 40 deletions(-) diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 543b5be15..2c1af08f8 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -1139,7 +1139,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "

    " ] @@ -1247,7 +1247,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 3000/3000 [00:04<00:00, 669.73it/s, 3 steps of size 7.48e-01. acc. prob=0.91]\n" + "sample: 100%|██████████| 3000/3000 [00:06<00:00, 429.13it/s, 3 steps of size 7.48e-01. acc. prob=0.91] \n" ] }, { @@ -1450,7 +1450,7 @@ "outputs": [], "source": [ "def predict(rng_key, post_samples, model, *args, **kwargs):\n", - " model = handlers.condition(handlers.seed(model, rng_key), post_samples)\n", + " model = handlers.seed(handlers.condition(model, post_samples), rng_key)\n", " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", " return model_trace['obs']['value']\n", "\n", @@ -1552,7 +1552,7 @@ "\n", "mean_pred = jnp.mean(predictions_1, axis=0)\n", "df = dset.filter(['Location'])\n", - "df['Mean Predictions'] = jnp.mean(predictions, axis=0)\n", + "df['Mean Predictions'] = mean_pred\n", "df.head()" ] }, @@ -1563,7 +1563,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] @@ -1667,7 +1667,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 3000/3000 [00:04<00:00, 690.83it/s, 3 steps of size 7.68e-01. acc. prob=0.92] \n" + "sample: 100%|██████████| 3000/3000 [00:07<00:00, 425.30it/s, 3 steps of size 7.68e-01. acc. prob=0.92]" ] }, { @@ -1682,6 +1682,13 @@ "\n", "Number of divergences: 0\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] } ], "source": [ @@ -1789,7 +1796,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 3000/3000 [00:04<00:00, 608.50it/s, 7 steps of size 5.15e-01. acc. prob=0.92] \n" + "sample: 100%|██████████| 3000/3000 [00:07<00:00, 389.02it/s, 7 steps of size 5.15e-01. acc. prob=0.92]\n" ] }, { @@ -1967,7 +1974,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 4000/4000 [00:06<00:00, 650.76it/s, 15 steps of size 3.00e-01. acc. prob=0.91] \n" + "sample: 100%|██████████| 4000/4000 [00:09<00:00, 408.70it/s, 15 steps of size 3.00e-01. acc. prob=0.91] \n" ] }, { diff --git a/numpyro/__init__.py b/numpyro/__init__.py index 4f4c590df..afe7b8070 100644 --- a/numpyro/__init__.py +++ b/numpyro/__init__.py @@ -4,8 +4,7 @@ from numpyro import compat, diagnostics, distributions, handlers, infer, optim from numpyro.distributions.distribution import enable_validation, validation_enabled import numpyro.patch # noqa: F401 -from numpyro.primitives import (deterministic, factor, module, param, plate, plate_stack, - prng_key, sample, subsample) +from numpyro.primitives import deterministic, factor, module, param, plate, plate_stack, prng_key, sample, subsample from numpyro.util import enable_x64, set_host_device_count, set_platform from numpyro.version import __version__ diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index dd241c897..27fced6da 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -9,7 +9,8 @@ import jax.numpy as jnp import funsor -from numpyro.handlers import infer_config, trace as OrigTraceMessenger +from numpyro.handlers import infer_config +from numpyro.handlers import trace as OrigTraceMessenger from numpyro.primitives import Messenger, apply_stack from numpyro.primitives import plate as OrigPlateMessenger diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index c095690cc..cc5fbec9a 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -3,7 +3,6 @@ from numpyro.distributions.conjugate import BetaBinomial, DirichletMultinomial, GammaPoisson import numpyro.distributions.constraints # noqa: F401 -from numpyro.distributions.kl import kl_divergence from numpyro.distributions.continuous import ( LKJ, Beta, @@ -63,6 +62,7 @@ TransformedDistribution, Unit ) +from numpyro.distributions.kl import kl_divergence import numpyro.distributions.transforms # noqa: F401 from numpyro.distributions.transforms import biject_to diff --git a/numpyro/distributions/kl.py b/numpyro/distributions/kl.py index 6e97c1fea..5e5fe2445 100644 --- a/numpyro/distributions/kl.py +++ b/numpyro/distributions/kl.py @@ -32,11 +32,15 @@ import jax.numpy as jnp from numpyro.distributions.continuous import Normal -from numpyro.distributions.distribution import (Delta, Distribution, ExpandedDistribution, - Independent, MaskedDistribution) +from numpyro.distributions.distribution import ( + Delta, + Distribution, + ExpandedDistribution, + Independent, + MaskedDistribution +) from numpyro.distributions.util import scale_and_mask, sum_rightmost - _KL_REGISTRY = {} # Source of truth mapping a few general (type, type) pairs to functions. _KL_MEMOIZE = {} # Memoized version mapping many specific (type, type) pairs to functions. diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index 45ad5ad55..846e93892 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -7,9 +7,9 @@ import os import pickle import struct -import zipfile from urllib.parse import urlparse from urllib.request import urlretrieve +import zipfile import numpy as np diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 40745b8c8..198ee2501 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -4,7 +4,6 @@ # Adapted from pyro.infer.autoguide from abc import ABC, abstractmethod from contextlib import ExitStack -from numpyro.infer.initialization import init_to_median import warnings import numpy as np @@ -29,6 +28,7 @@ ) from numpyro.distributions.util import cholesky_of_inverse, periodic_repeat, sum_rightmost from numpyro.infer.elbo import Trace_ELBO +from numpyro.infer.initialization import init_to_median from numpyro.infer.util import init_to_uniform, initialize_model from numpyro.nn.auto_reg_nn import AutoregressiveNN from numpyro.nn.block_neural_arn import BlockNeuralAutoregressiveNN diff --git a/numpyro/infer/einstein/kernels.py b/numpyro/infer/einstein/kernels.py index b9aad37a6..c1e77c4e0 100644 --- a/numpyro/infer/einstein/kernels.py +++ b/numpyro/infer/einstein/kernels.py @@ -1,14 +1,15 @@ from abc import ABC, abstractmethod -from typing import Callable, List, Dict, Tuple +from typing import Callable, Dict, List, Tuple + +import numpy as np +import numpy.random as npr import jax.numpy as jnp import jax.scipy.linalg import jax.scipy.stats -import numpy as np -import numpy.random as npr import numpyro.distributions as dist -from numpyro.infer.einstein.utils import sqrth, posdef, safe_norm +from numpyro.infer.einstein.utils import posdef, safe_norm, sqrth class PrecondMatrix(ABC): diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 0cbab8817..913a6fdb7 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -10,13 +10,12 @@ from jax.scipy.special import expit from numpyro.distributions import biject_to -from numpyro.handlers import condition, seed, trace, substitute +from numpyro.handlers import condition, seed, substitute, trace from numpyro.infer.hmc import HMC from numpyro.infer.mcmc import MCMCKernel -from numpyro.infer.util import log_likelihood, potential_energy, _guess_max_plate_nesting +from numpyro.infer.util import _guess_max_plate_nesting, log_likelihood, potential_energy from numpyro.util import cond, fori_loop, identity, ravel_pytree - HMCGibbsState = namedtuple("HMCGibbsState", "z, hmc_state, rng_key") """ - **z** - a dict of the current latent values (both HMC and Gibbs sites) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 66970ea4f..bf954b55b 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -3,9 +3,10 @@ from functools import namedtuple, partial +import tqdm + from jax import jit, lax, random import jax.numpy as jnp -import tqdm from numpyro.distributions import constraints from numpyro.distributions.transforms import biject_to diff --git a/test/test_autoguide.py b/test/test_autoguide.py index db9f931e1..8f3612dd2 100644 --- a/test/test_autoguide.py +++ b/test/test_autoguide.py @@ -21,13 +21,13 @@ from numpyro.infer import SVI, Trace_ELBO, TraceMeanField_ELBO from numpyro.infer.autoguide import ( AutoBNAFNormal, + AutoDelta, AutoDiagonalNormal, AutoIAFNormal, AutoLaplaceApproximation, AutoLowRankMultivariateNormal, AutoMultivariateNormal, - AutoNormal, - AutoDelta, + AutoNormal ) from numpyro.infer.initialization import init_to_median from numpyro.infer.reparam import TransformReparam diff --git a/test/test_distributions.py b/test/test_distributions.py index 83a3ba378..276f634a8 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -22,8 +22,13 @@ from numpyro.distributions.discrete import _to_probs_bernoulli, _to_probs_multinom from numpyro.distributions.flows import InverseAutoregressiveTransform from numpyro.distributions.transforms import LowerCholeskyAffine, PermuteTransform, PowerTransform, biject_to -from numpyro.distributions.util import (matrix_to_tril_vec, multinomial, signed_stick_breaking_tril, - sum_rightmost, vec_to_tril_matrix) +from numpyro.distributions.util import ( + matrix_to_tril_vec, + multinomial, + signed_stick_breaking_tril, + sum_rightmost, + vec_to_tril_matrix +) from numpyro.nn import AutoregressiveNN diff --git a/test/test_einstein_kernels.py b/test/test_einstein_kernels.py index b90557d1f..c0f5ed15f 100644 --- a/test/test_einstein_kernels.py +++ b/test/test_einstein_kernels.py @@ -1,18 +1,19 @@ from collections import namedtuple -import jax.numpy as jnp -import pytest from numpy.testing import assert_allclose +import pytest + +import jax.numpy as jnp from numpyro.infer.einstein.kernels import ( - RBFKernel, - RandomFeatureKernel, GraphicalKernel, + HessianPrecondMatrix, IMQKernel, LinearKernel, MixtureKernel, - HessianPrecondMatrix, - PrecondMatrixKernel + PrecondMatrixKernel, + RandomFeatureKernel, + RBFKernel ) jnp.set_printoptions(precision=100) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index a145eb779..429909d96 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -1,15 +1,15 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +from functools import partial + import numpy as np from numpy.testing import assert_allclose import pytest -from functools import partial - -import jax.numpy as jnp from jax import random -from jax.scipy.linalg import cho_factor, cho_solve, solve_triangular, inv +import jax.numpy as jnp +from jax.scipy.linalg import cho_factor, cho_solve, inv, solve_triangular import numpyro import numpyro.distributions as dist diff --git a/test/test_svi.py b/test/test_svi.py index 34912a781..d265fd617 100644 --- a/test/test_svi.py +++ b/test/test_svi.py @@ -14,7 +14,7 @@ from numpyro.distributions import constraints from numpyro.distributions.transforms import AffineTransform, SigmoidTransform from numpyro.handlers import substitute -from numpyro.infer import RenyiELBO, SVI, Trace_ELBO +from numpyro.infer import SVI, RenyiELBO, Trace_ELBO from numpyro.util import fori_loop From 5845358c666696278b2c8520f81592bbd397576c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Thu, 14 Jan 2021 00:44:42 +0100 Subject: [PATCH 027/222] Block updates for gibbs subsampling (#870) * Added block_updates to subsample_gibbs_fn. * Added test case for no block_update and fixed bugs. * Fixed num_blocks and block_size mix up and added test case for using block updates. * Cleaned imports. * Updated comments with reference and added test for num_blocks={} (there was a bug). * Changed num_blocks in subsample_gibbs_fn to integer. Co-authored-by: Ola --- numpyro/infer/hmc_gibbs.py | 28 ++++++++++++++++++++++------ setup.py | 4 ++-- test/test_hmc_gibbs.py | 32 ++++++++++++++++++++++++-------- 3 files changed, 48 insertions(+), 16 deletions(-) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 913a6fdb7..b3549b0bb 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -29,6 +29,7 @@ def fn(*args, **kwargs): gibbs_values = kwargs.pop("_gibbs_sites", {}) with condition(data=gibbs_values), substitute(data=gibbs_values): model(*args, **kwargs) + return fn @@ -358,7 +359,7 @@ def body_fn(i, val): return gibbs_fn -def subsample_gibbs_fn(model, model_args=(), model_kwargs={}): +def subsample_gibbs_fn(model, model_args=(), model_kwargs={}, *, num_blocks=1): """ [EXPERIMENTAL INTERFACE] @@ -367,18 +368,26 @@ def subsample_gibbs_fn(model, model_args=(), model_kwargs={}): of reference [1] but uses a naive estimation (without control variates) of log likelihood, hence might incur a high variance. + The function can partition named subsample statements and update only one block in the parition + to improve acceptance rate of proposed subsamples as detailed in [3]. + .. note:: New subsample indices are proposed randomly with replacement at each MCMC step. + **References:** 1. *Hamiltonian Monte Carlo with energy conserving subsampling*, Dang, K. D., Quiroz, M., Kohn, R., Minh-Ngoc, T., & Villani, M. (2019) 2. *Speeding Up MCMC by Efficient Data Subsampling*, Quiroz, M., Kohn, R., Villani, M., & Tran, M. N. (2018) + 3. *The Block Pseudo-Margional Sampler*, + Tran, M.-N., Kohn, R., Quiroz, M. Villani, M. (2017) - :param callable model: a callable with NumPyro primitives. This should be the same model + :param callable model: A callable with NumPyro primitives. This should be the same model as the one used in the `inner_kernel` of :class:`HMCGibbs`. + :param tuple model_args: Arguments provided to the model. :param dict model_kwargs: Keyword arguments provided to the model. - :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs` + :param int num_blocks: Number of blocks to partition subsample into. + :return: A callable `gibbs_fn` to be used in :class:`HMCGibbs` **Example** @@ -397,7 +406,7 @@ def subsample_gibbs_fn(model, model_args=(), model_kwargs={}): ... numpyro.sample("obs", dist.Normal(x, 1), obs=batch) ... >>> data = random.normal(random.PRNGKey(0), (10000,)) + 1 - >>> gibbs_fn = subsample_gibbs_fn(model, (data,)) + >>> gibbs_fn = subsample_gibbs_fn(model, (data,), num_blocks={'N': 10}) >>> kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["N"]) >>> mcmc = MCMC(kernel, 1000, 1000) >>> mcmc.run(random.PRNGKey(0), data) @@ -411,6 +420,7 @@ def subsample_gibbs_fn(model, model_args=(), model_kwargs={}): for name, site in prototype_trace.items() if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size } + enum = any(site["type"] == "sample" and not site["is_observed"] and site["fn"].has_enumerate_support @@ -422,8 +432,14 @@ def gibbs_fn(rng_key, gibbs_sites, hmc_sites): u_new = {} for name in gibbs_sites: size, subsample_size = plate_sizes[name] - rng_key, subkey = random.split(rng_key) - u_new[name] = random.choice(subkey, size, (subsample_size,), replace=False) + rng_key, subkey, block_key = random.split(rng_key, 3) + block_size = subsample_size // num_blocks + + chosen_block = random.randint(block_key, shape=(), minval=0, maxval=num_blocks) + new_idx = random.randint(subkey, minval=0, maxval=size, shape=(subsample_size,)) + block_mask = jnp.arange(subsample_size) // block_size == chosen_block + + u_new[name] = jnp.where(block_mask, new_idx, gibbs_sites[name]) u_loglik = log_likelihood(_wrap_model(model), hmc_sites, *model_args, batch_ndims=0, **model_kwargs, _gibbs_sites=gibbs_sites) diff --git a/setup.py b/setup.py index b0441999e..c26d572e3 100644 --- a/setup.py +++ b/setup.py @@ -34,9 +34,9 @@ author_email='npradhan@uber.com', install_requires=[ # TODO: pin to a specific version for the release (until JAX's API becomes stable) - 'jax>=0.2.3', + 'jax==0.2.7', # check min version here: https://github.com/google/jax/blob/master/jax/lib/__init__.py#L26 - 'jaxlib>=0.1.56', + 'jaxlib==0.1.56', 'tqdm', ], extras_require={ diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index 429909d96..badf638a4 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -3,17 +3,17 @@ from functools import partial +import jax.numpy as jnp import numpy as np -from numpy.testing import assert_allclose import pytest - from jax import random -import jax.numpy as jnp from jax.scipy.linalg import cho_factor, cho_solve, inv, solve_triangular +from numpy.testing import assert_allclose import numpyro import numpyro.distributions as dist -from numpyro.infer import HMC, MCMC, NUTS, HMCGibbs, discrete_gibbs_fn +from numpyro.handlers import plate +from numpyro.infer import HMC, MCMC, NUTS, HMCGibbs, discrete_gibbs_fn, subsample_gibbs_fn def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): @@ -99,6 +99,26 @@ def model(X, Y): assert_allclose(sigma_mean, sigma, atol=0.25) +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +@pytest.mark.parametrize('num_blocks', [1, 2, 50, 100]) +def test_subsample_gibbs_partitioning(kernel_cls, num_blocks): + def model(obs): + with plate('N', obs.shape[0], subsample_size=100) as idx: + numpyro.sample('x', dist.Normal(0, 1), obs=obs[idx]) + + obs = random.normal(random.PRNGKey(0), (10000,)) / 100 + kernel = kernel_cls(model) + hmc_state = kernel.init(random.PRNGKey(1), 10, model_args=(obs,)) + gibbs_sites = {'N': jnp.arange(100)} + + gibbs_fn = subsample_gibbs_fn(model, (obs,), {}, num_blocks=num_blocks) + + new_gibbs_sites = gibbs_fn(random.PRNGKey(2), gibbs_sites, hmc_state.z) # accept_prob > .999 + block_size = 100 // num_blocks + for name in gibbs_sites: + assert block_size == jnp.not_equal(gibbs_sites[name], new_gibbs_sites[name]).sum() + + @pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) def test_gaussian_model(kernel_cls, D=2, warmup_steps=3000, num_samples=5000): np.random.seed(0) @@ -149,7 +169,6 @@ def model(): def test_discrete_gibbs_multiple_sites(): - def model(): numpyro.sample("x", dist.Bernoulli(0.7).expand([3])) numpyro.sample("y", dist.Binomial(10, 0.3)) @@ -163,7 +182,6 @@ def model(): def test_discrete_gibbs_enum(): - def model(): numpyro.sample("x", dist.Bernoulli(0.7)) y = numpyro.sample("y", dist.Binomial(10, 0.3)) @@ -179,7 +197,6 @@ def model(): @pytest.mark.parametrize("random_walk", [False, True]) @pytest.mark.parametrize("modified", [False, True]) def test_discrete_gibbs_bernoulli(random_walk, modified): - def model(): numpyro.sample("c", dist.Bernoulli(0.8)) @@ -193,7 +210,6 @@ def model(): @pytest.mark.parametrize("modified", [False, True]) def test_discrete_gibbs_gmm_1d(modified): - def model(probs, locs): c = numpyro.sample("c", dist.Categorical(probs)) numpyro.sample("x", dist.Normal(locs[c], 0.5)) From edf32615d508f4d33382f9a3b6ed97214b98491e Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 13 Jan 2021 23:32:39 -0600 Subject: [PATCH 028/222] warn instead of raising ValueError when substituting an incorrect subsample_size (#868) --- numpyro/primitives.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index acc94fd39..19a33c1a6 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -4,6 +4,7 @@ from collections import namedtuple from contextlib import ExitStack, contextmanager import functools +import warnings from jax import lax, random import jax.numpy as jnp @@ -289,7 +290,7 @@ def _subsample(name, size, subsample_size, dim): apply_stack(msg) subsample = msg['value'] if subsample_size is not None and subsample_size != subsample.shape[0]: - raise ValueError("subsample_size does not match len(subsample), {} vs {}.".format( + warnings.warn("subsample_size does not match len(subsample), {} vs {}.".format( subsample_size, len(subsample)) + " Did you accidentally use different subsample_size in the model and guide?") cond_indep_stack = msg['cond_indep_stack'] From 85289efdd0a0b0c436085befaeac3b2802b0530a Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 14 Jan 2021 16:28:56 -0600 Subject: [PATCH 029/222] Add default values to constraints to make grad propogate properly (#872) --- numpyro/distributions/constraints.py | 53 +++++++++++++++++++++++++++ numpyro/distributions/distribution.py | 9 ++++- test/test_distributions.py | 25 +++++++++++++ 3 files changed, 86 insertions(+), 1 deletion(-) diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 35d50bfd1..8f630ca12 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -73,11 +73,20 @@ def check(self, value): """ return self(value) + def feasible_like(self, prototype): + """ + Get a feasible value which has the same shape as dtype as `prototype`. + """ + raise NotImplementedError + class _Boolean(Constraint): def __call__(self, x): return (x == 0) | (x == 1) + def feasible_like(self, prototype): + return jax.numpy.zeros_like(prototype) + class _CorrCholesky(Constraint): def __call__(self, x): @@ -89,6 +98,9 @@ def __call__(self, x): unit_norm_row = jnp.all((x_norm <= 1) & (x_norm > 1 - 1e-6), axis=-1) return lower_triangular & positive_diagonal & unit_norm_row + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + class _CorrMatrix(Constraint): def __call__(self, x): @@ -101,6 +113,9 @@ def __call__(self, x): unit_variance = jnp.all(jnp.abs(jnp.diagonal(x, axis1=-2, axis2=-1) - 1) < 1e-6, axis=-1) return symmetric & positive & unit_variance + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + class _Dependent(Constraint): def __call__(self, x): @@ -118,6 +133,9 @@ def __init__(self, lower_bound): def __call__(self, x): return x > self.lower_bound + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(self.lower_bound + 1, jax.numpy.shape(prototype)) + class _LessThan(Constraint): def __init__(self, upper_bound): @@ -126,6 +144,9 @@ def __init__(self, upper_bound): def __call__(self, x): return x < self.upper_bound + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(self.upper_bound - 1, jax.numpy.shape(prototype)) + class _IntegerInterval(Constraint): def __init__(self, lower_bound, upper_bound): @@ -135,6 +156,9 @@ def __init__(self, lower_bound, upper_bound): def __call__(self, x): return (x >= self.lower_bound) & (x <= self.upper_bound) & (x % 1 == 0) + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(self.lower_bound, jax.numpy.shape(prototype)) + class _IntegerGreaterThan(Constraint): def __init__(self, lower_bound): @@ -143,6 +167,9 @@ def __init__(self, lower_bound): def __call__(self, x): return (x % 1 == 0) & (x >= self.lower_bound) + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(self.lower_bound, jax.numpy.shape(prototype)) + class _Interval(Constraint): def __init__(self, lower_bound, upper_bound): @@ -152,6 +179,9 @@ def __init__(self, lower_bound, upper_bound): def __call__(self, x): return (x >= self.lower_bound) & (x <= self.upper_bound) + def feasible_like(self, prototype): + return jax.numpy.broadcast_to((self.lower_bound + self.upper_bound) / 2, jax.numpy.shape(prototype)) + class _LowerCholesky(Constraint): def __call__(self, x): @@ -161,6 +191,9 @@ def __call__(self, x): positive_diagonal = jnp.all(jnp.diagonal(x, axis1=-2, axis2=-1) > 0, axis=-1) return lower_triangular & positive_diagonal + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + class _Multinomial(Constraint): def __init__(self, upper_bound): @@ -169,11 +202,19 @@ def __init__(self, upper_bound): def __call__(self, x): return (x >= 0).all(axis=-1) & (x.sum(axis=-1) == self.upper_bound) + def feasible_like(self, prototype): + pad_width = ((0, 0),) * jax.numpy.ndim(self.upper_bound) + ((0, prototype.shape[-1] - 1),) + value = jax.numpy.pad(jax.numpy.expand_dims(self.upper_bound, -1), pad_width) + return jax.numpy.broadcast_to(value, prototype.shape) + class _OrderedVector(Constraint): def __call__(self, x): return (x[..., 1:] > x[..., :-1]).all(axis=-1) + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(jax.numpy.arange(float(prototype.shape[-1])), prototype.shape) + class _PositiveDefinite(Constraint): def __call__(self, x): @@ -184,23 +225,35 @@ def __call__(self, x): positive = jnp.linalg.eigh(x)[0][..., 0] > 0 return symmetric & positive + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + class _Real(Constraint): def __call__(self, x): # XXX: consider to relax this condition to [-inf, inf] interval return (x == x) & (x != float('inf')) & (x != float('-inf')) + def feasible_like(self, prototype): + return jax.numpy.zeros_like(prototype) + class _RealVector(Constraint): def __call__(self, x): return ((x == x) & (x != float('inf')) & (x != float('-inf'))).all(axis=-1) + def feasible_like(self, prototype): + return jax.numpy.zeros_like(prototype) + class _Simplex(Constraint): def __call__(self, x): x_sum = x.sum(axis=-1) return (x >= 0).all(axis=-1) & (x_sum < 1 + 1e-6) & (x_sum > 1 - 1e-6) + def feasible_like(self, prototype): + return jax.numpy.full_like(prototype, 1 / prototype.shape[-1]) + # TODO: Make types consistent diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 77e3a6cb0..53e86bb74 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -296,7 +296,7 @@ def to_event(self, reinterpreted_batch_ndims=None): """ if reinterpreted_batch_ndims is None: reinterpreted_batch_ndims = len(self.batch_shape) - elif reinterpreted_batch_ndims == 0: + if reinterpreted_batch_ndims == 0: return self return Independent(self, reinterpreted_batch_ndims) @@ -687,6 +687,13 @@ def log_prob(self, value): return jnp.zeros(shape) if self._mask is True: return self.base_dist.log_prob(value) + try: + default_value = self.base_dist.support.feasible_like(value) + except NotImplementedError: + pass + else: + mask = jnp.reshape(self._mask, jnp.shape(self._mask) + (1,) * self.event_dim) + value = jnp.where(mask, value, default_value) return jnp.where(self._mask, self.base_dist.log_prob(value), 0.) def enumerate_support(self, expand=True): diff --git a/test/test_distributions.py b/test/test_distributions.py index 276f634a8..0b7433185 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -910,6 +910,17 @@ def g(x): def test_constraints(constraint, x, expected): assert_array_equal(constraint(x), expected) + feasible_value = constraint.feasible_like(x) + assert jnp.shape(feasible_value) == jnp.shape(x) + assert_allclose(constraint(feasible_value), jnp.full(jnp.shape(expected), True)) + + try: + inverse = biject_to(constraint).inv(feasible_value) + except NotImplementedError: + pass + else: + assert_allclose(inverse, jnp.zeros_like(inverse), atol=2e-7) + @pytest.mark.parametrize('constraint', [ constraints.corr_cholesky, @@ -1302,6 +1313,20 @@ def test_mask(batch_shape, event_shape, mask_shape): assert_allclose(actual != 0, jnp.broadcast_to(mask, lax.broadcast_shapes(batch_shape, mask_shape))) +@pytest.mark.parametrize('event_shape', [(), (4,), (2, 4)]) +def test_mask_grad(event_shape): + def f(x, data): + base_dist = dist.Beta(jnp.exp(x), jnp.ones(event_shape)).to_event() + mask = jnp.all(jnp.isfinite(data), tuple(-i-1 for i in range(len(event_shape)))) + log_prob = base_dist.mask(mask).log_prob(data) + assert log_prob.shape == data.shape[:len(data.shape) - len(event_shape)] + return log_prob.sum() + + data = jnp.array([[0.4, jnp.nan, 0.2, jnp.nan], [0.5, 0.5, 0.5, 0.5]]) + log_prob, grad = jax.value_and_grad(f)(1., data) + assert jnp.isfinite(grad) and jnp.isfinite(log_prob) + + @pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) def test_dist_pytree(jax_dist, sp_dist, params): def f(x): From c8e9d67c74e599f80318476b92aab0d681632d2f Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 15 Jan 2021 00:13:06 -0600 Subject: [PATCH 030/222] Add _InverseTransform (#875) * add inverse transform * also use _inverse in TFP --- numpyro/contrib/tfp/distributions.py | 2 +- numpyro/distributions/transforms.py | 73 ++++++++++++++++++++++------ test/test_distributions.py | 4 ++ 3 files changed, 62 insertions(+), 17 deletions(-) diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index 3d198328d..9fce79498 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -80,7 +80,7 @@ def codomain(self): def __call__(self, x): return self.bijector.forward(x) - def inv(self, y): + def _inverse(self, y): return self.bijector.inverse(y) def log_abs_det_jacobian(self, x, y, intermediates=None): diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 11228465a..23efb2494 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -62,10 +62,14 @@ def input_event_dim(self): def output_event_dim(self): return self.event_dim + @property + def inv(self): + return _InverseTransform(self) + def __call__(self, x): return NotImplementedError - def inv(self, y): + def _inverse(self, y): raise NotImplementedError def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -75,6 +79,43 @@ def call_with_intermediates(self, x): return self(x), None +class _InverseTransform(Transform): + def __init__(self, transform): + super().__init__() + self._inv = transform + + @property + def domain(self): + return self._inv.codomain + + @property + def codomain(self): + return self._inv.domain + + @property + def input_event_dim(self): + return self._inv.output_event_dim + + @property + def output_event_dim(self): + return self._inv.input_event_dim + + @property + def event_dim(self): + return self._inv.event_dim + + @property + def inv(self): + return self._inv + + def __call__(self, x): + return self._inv._inverse(x) + + def log_abs_det_jacobian(self, x, y, intermediates=None): + # NB: we don't use intermediates for inverse transform + return -self._inv.log_abs_det_jacobian(y, x, None) + + class AbsTransform(Transform): domain = constraints.real codomain = constraints.positive @@ -85,7 +126,7 @@ def __eq__(self, other): def __call__(self, x): return jnp.abs(x) - def inv(self, y): + def _inverse(self, y): return y @@ -134,7 +175,7 @@ def event_dim(self): def __call__(self, x): return self.loc + self.scale * x - def inv(self, y): + def _inverse(self, y): return (y - self.loc) / self.scale def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -176,7 +217,7 @@ def __call__(self, x): x = part(x) return x - def inv(self, y): + def _inverse(self, y): for part in self.parts[::-1]: y = part.inv(y) return y @@ -255,7 +296,7 @@ def __call__(self, x): t = jnp.tanh(x) return signed_stick_breaking_tril(t) - def inv(self, y): + def _inverse(self, y): # inverse stick-breaking z1m_cumprod = 1 - jnp.cumsum(y * y, axis=-1) pad_width = [(0, 0)] * y.ndim @@ -306,7 +347,7 @@ def __call__(self, x): # XXX consider to clamp from below for stability if necessary return jnp.exp(x) - def inv(self, y): + def _inverse(self, y): return jnp.log(y) def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -321,7 +362,7 @@ def __init__(self, event_dim=0): def __call__(self, x): return x - def inv(self, y): + def _inverse(self, y): return y def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -349,7 +390,7 @@ def codomain(self): def __call__(self, x): return jnp.matmul(x, jnp.swapaxes(x, -2, -1)) - def inv(self, y): + def _inverse(self, y): return jnp.linalg.cholesky(y) def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -387,7 +428,7 @@ def __init__(self, loc, scale_tril): def __call__(self, x): return self.loc + jnp.squeeze(jnp.matmul(self.scale_tril, x[..., jnp.newaxis]), axis=-1) - def inv(self, y): + def _inverse(self, y): y = y - self.loc original_shape = jnp.shape(y) yt = jnp.reshape(y, (-1, original_shape[-1])).T @@ -415,7 +456,7 @@ def __call__(self, x): diag = jnp.exp(x[..., -n:]) return z + jnp.expand_dims(diag, axis=-1) * jnp.identity(n) - def inv(self, y): + def _inverse(self, y): z = matrix_to_tril_vec(y, diagonal=-1) return jnp.concatenate([z, jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1))], axis=-1) @@ -442,7 +483,7 @@ def __call__(self, x): z = jnp.concatenate([x[..., :1], jnp.exp(x[..., 1:])], axis=-1) return jnp.cumsum(z, axis=-1) - def inv(self, y): + def _inverse(self, y): x = jnp.log(y[..., 1:] - y[..., :-1]) return jnp.concatenate([y[..., :1], x], axis=-1) @@ -461,7 +502,7 @@ def __init__(self, permutation): def __call__(self, x): return x[..., self.permutation] - def inv(self, y): + def _inverse(self, y): size = self.permutation.size permutation_inv = ops.index_update(jnp.zeros(size, dtype=canonicalize_dtype(jnp.int64)), self.permutation, @@ -482,7 +523,7 @@ def __init__(self, exponent): def __call__(self, x): return jnp.power(x, self.exponent) - def inv(self, y): + def _inverse(self, y): return jnp.power(y, 1 / self.exponent) def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -495,7 +536,7 @@ class SigmoidTransform(Transform): def __call__(self, x): return _clipped_expit(x) - def inv(self, y): + def _inverse(self, y): return logit(y) def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -522,7 +563,7 @@ def __call__(self, x): z1m_cumprod_shifted = jnp.pad(z1m_cumprod, pad_width, mode="constant", constant_values=1.) return z_padded * z1m_cumprod_shifted - def inv(self, y): + def _inverse(self, y): y_crop = y[..., :-1] z1m_cumprod = jnp.clip(1 - jnp.cumsum(y_crop, axis=-1), a_min=jnp.finfo(y.dtype).tiny) # hence x = logit(z) = log(z / (1 - z)) = y[::-1] / z1m_cumprod @@ -559,7 +600,7 @@ def __call__(self, x): else: return self.unpack_fn(x) - def inv(self, y): + def _inverse(self, y): leading_dims = [v.shape[0] if jnp.ndim(v) > 0 else 0 for v in tree_flatten(y)[0]] d0 = leading_dims[0] diff --git a/test/test_distributions.py b/test/test_distributions.py index 0b7433185..a480b4715 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1031,12 +1031,16 @@ def test_bijective_transforms(transform, event_shape, batch_shape): # test inv z = transform.inv(y) assert_allclose(x, z, atol=1e-6, rtol=1e-6) + assert transform.inv.inv is transform + assert transform.domain is transform.inv.codomain + assert transform.codomain is transform.inv.domain # test domain assert_array_equal(transform.domain(z), jnp.ones(batch_shape)) # test log_abs_det_jacobian actual = transform.log_abs_det_jacobian(x, y) + assert_allclose(actual, -transform.inv.log_abs_det_jacobian(y, x)) assert jnp.shape(actual) == batch_shape if len(shape) == transform.event_dim: if len(event_shape) == 1: From e1d34dc5273f13f07fe0553e953096dee344eb0a Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 16 Jan 2021 16:49:13 -0600 Subject: [PATCH 031/222] Revise API of gibbs functions (#873) * warn instead of raising ValueError when substituting an incorrect subsample_size * add new api for discrete and subsample gibbs * merge upstream * addresses reviewer's comments --- docs/source/mcmc.rst | 20 ++- examples/capture_recapture.py | 1 - examples/gp.py | 2 +- numpyro/infer/__init__.py | 12 +- numpyro/infer/hmc_gibbs.py | 263 +++++++++++++++++++--------------- setup.py | 4 +- test/test_hmc_gibbs.py | 28 ++-- 7 files changed, 185 insertions(+), 145 deletions(-) diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index 0b56761b9..16734f154 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -22,27 +22,35 @@ MCMC Kernels :show-inheritance: :member-order: bysource -.. autoclass:: numpyro.infer.hmc_gibbs.HMCGibbs +.. autoclass:: numpyro.infer.hmc.NUTS :members: :undoc-members: :show-inheritance: :member-order: bysource -.. autoclass:: numpyro.infer.hmc.NUTS +.. autoclass:: numpyro.infer.hmc_gibbs.HMCGibbs :members: :undoc-members: :show-inheritance: :member-order: bysource -.. autoclass:: numpyro.infer.sa.SA +.. autoclass:: numpyro.infer.hmc_gibbs.DiscreteHMCGibbs :members: :undoc-members: :show-inheritance: :member-order: bysource -.. autofunction:: numpyro.infer.hmc_gibbs.discrete_gibbs_fn +.. autoclass:: numpyro.infer.hmc_gibbs.HMCECS + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource -.. autofunction:: numpyro.infer.hmc_gibbs.subsample_gibbs_fn +.. autoclass:: numpyro.infer.sa.SA + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource .. autofunction:: numpyro.infer.hmc.hmc @@ -52,6 +60,8 @@ MCMC Kernels .. autodata:: numpyro.infer.hmc.HMCState +.. autodata:: numpyro.infer.hmc_gibbs.HMCGibbsState + .. autodata:: numpyro.infer.sa.SAState diff --git a/examples/capture_recapture.py b/examples/capture_recapture.py index 4b7a369ed..fd16f5fbb 100644 --- a/examples/capture_recapture.py +++ b/examples/capture_recapture.py @@ -54,7 +54,6 @@ from numpyro.infer import HMC, MCMC, NUTS from numpyro.infer.reparam import LocScaleReparam - # %% # Our first and simplest CJS model variant only has two continuous # (scalar) latent random variables: i) the survival probability phi; diff --git a/examples/gp.py b/examples/gp.py index 0279b9762..f7c897bcb 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -27,7 +27,7 @@ import numpyro import numpyro.distributions as dist -from numpyro.infer import MCMC, NUTS, init_to_value, init_to_median, init_to_feasible, init_to_sample, init_to_uniform +from numpyro.infer import MCMC, NUTS, init_to_feasible, init_to_median, init_to_sample, init_to_uniform, init_to_value matplotlib.use('Agg') # noqa: E402 diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 4a2b69993..789a250bd 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -3,7 +3,7 @@ from numpyro.infer.elbo import ELBO, RenyiELBO, Trace_ELBO, TraceMeanField_ELBO from numpyro.infer.hmc import HMC, NUTS -from numpyro.infer.hmc_gibbs import HMCGibbs, discrete_gibbs_fn, subsample_gibbs_fn +from numpyro.infer.hmc_gibbs import HMCECS, DiscreteHMCGibbs, HMCGibbs from numpyro.infer.initialization import ( init_to_feasible, init_to_median, @@ -17,23 +17,23 @@ from numpyro.infer.util import Predictive, log_likelihood __all__ = [ - 'discrete_gibbs_fn', - 'subsample_gibbs_fn', 'init_to_feasible', 'init_to_median', 'init_to_sample', 'init_to_uniform', 'init_to_value', 'log_likelihood', + 'DiscreteHMCGibbs', 'ELBO', - 'RenyiELBO', - 'Trace_ELBO', - 'TraceMeanField_ELBO', 'HMC', + 'HMCECS', 'HMCGibbs', 'MCMC', 'NUTS', 'Predictive', + 'RenyiELBO', 'SA', 'SVI', + 'Trace_ELBO', + 'TraceMeanField_ELBO', ] diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index b3549b0bb..c8429ed71 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -9,7 +9,6 @@ import jax.numpy as jnp from jax.scipy.special import expit -from numpyro.distributions import biject_to from numpyro.handlers import condition, seed, substitute, trace from numpyro.infer.hmc import HMC from numpyro.infer.mcmc import MCMCKernel @@ -50,7 +49,7 @@ class HMCGibbs(MCMCKernel): Must also include arguments `hmc_sites` and `gibbs_sites`, each of which is a dictionary with keys that are site names and values that are sample values. Note that a given `gibbs_fn` may not need make use of all these sample values. - :param gibbs_sites: a list of site names for the latent variables that are covered by the Gibbs sampler. + :param list gibbs_sites: a list of site names for the latent variables that are covered by the Gibbs sampler. **Example** @@ -93,6 +92,8 @@ def __init__(self, inner_kernel, gibbs_fn, gibbs_sites): self.inner_kernel._model = _wrap_model(inner_kernel.model) self._gibbs_sites = gibbs_sites self._gibbs_fn = gibbs_fn + self._use_constrained_gibbs_fn = True + self._prototype_trace = None @property def model(self): @@ -117,10 +118,12 @@ def fn(z): def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() - rng_key, key_u, key_z = random.split(rng_key, 3) - prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) + if self._prototype_trace is None: + rng_key, key_u = random.split(rng_key) + self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) - gibbs_sites = {name: site["value"] for name, site in prototype_trace.items() if name in self._gibbs_sites} + rng_key, key_z = random.split(rng_key) + gibbs_sites = {name: site["value"] for name, site in self._prototype_trace.items() if name in self._gibbs_sites} model_kwargs["_gibbs_sites"] = gibbs_sites hmc_state = self.inner_kernel.init(key_z, num_warmup, init_params, model_args, model_kwargs) @@ -140,8 +143,8 @@ def potential_fn(z_gibbs, z_hmc): z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} model_kwargs_ = model_kwargs.copy() model_kwargs_["_gibbs_sites"] = z_gibbs - # TODO: give the user more control over which sites are transformed from unconstrained to constrained space - z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs_)(z_hmc) + if self._use_constrained_gibbs_fn: + z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs_)(z_hmc) z_gibbs = self._gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc) @@ -242,61 +245,8 @@ def _discrete_modified_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, s return rng_key, z_new, pe_new, log_accept_ratio -def discrete_gibbs_fn(model, model_args=(), model_kwargs={}, *, random_walk=False, modified=False): - """ - [EXPERIMENTAL INTERFACE] - - Returns a gibbs_fn to be used in :class:`HMCGibbs`, which works for discrete latent sites - with enumerate support. The site update order is randomly permuted at each step. - - Note that those discrete latent sites that are not specified in the constructor of - :class:`HMCGibbs` will be marginalized out by default (if they have enumerate supports). - - :param callable model: a callable with NumPyro primitives. This should be the same model - as the one used in the `inner_kernel` of :class:`HMCGibbs`. - :param tuple model_args: Arguments provided to the model. - :param dict model_kwargs: Keyword arguments provided to the model. - :param bool random_walk: If False, Gibbs sampling will be used to draw a sample from the - conditional `p(gibbs_site | remaining sites)`. Otherwise, a sample will be drawn uniformly - from the domain of `gibbs_site`. - :param bool modified: whether to use a modified proposal, as suggested in reference [1], which - always proposes a new state for the current Gibbs site. - The modified scheme appears in the literature under the name "modified Gibbs sampler" or - "Metropolised Gibbs sampler". - :return: a callable `gibbs_fn` to be used in :class:`HMCGibbs` - - **References:** - - 1. *Peskun's theorem and a modified discrete-state Gibbs sampler*, - Liu, J. S. (1996) - - **Example** - - .. doctest:: - - >>> from jax import random - >>> import jax.numpy as jnp - >>> import numpyro - >>> import numpyro.distributions as dist - >>> from numpyro.infer import MCMC, NUTS, HMCGibbs, discrete_gibbs_fn - ... - >>> def model(probs, locs): - ... c = numpyro.sample("c", dist.Categorical(probs)) - ... numpyro.sample("x", dist.Normal(locs[c], 0.5)) - ... - >>> probs = jnp.array([0.15, 0.3, 0.3, 0.25]) - >>> locs = jnp.array([-2, 0, 2, 4]) - >>> gibbs_fn = discrete_gibbs_fn(model, (probs, locs)) - >>> kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["c"]) - >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) - >>> mcmc.run(random.PRNGKey(0), probs, locs) - >>> mcmc.print_summary() # doctest: +SKIP - - """ - # NB: all of the information such as `model`, `model_args`, `model_kwargs` - # can be accessed from HMCGibbs.sample but we require them here to - # simplify the api of `gibbs_fn` - prototype_trace = trace(seed(model, rng_seed=0)).get_trace(*model_args, **model_kwargs) +def _discrete_gibbs_fn(wrapped_model, model_args, model_kwargs, prototype_trace, + random_walk=False, modified=False): support_sizes = { name: jnp.broadcast_to(site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"])) for name, site in prototype_trace.items() @@ -315,21 +265,19 @@ def discrete_gibbs_fn(model, model_args=(), model_kwargs={}, *, random_walk=Fals proposal_fn = _discrete_gibbs_proposal def gibbs_fn(rng_key, gibbs_sites, hmc_sites): - # convert to unconstrained values - z_hmc = {k: biject_to(prototype_trace[k]["fn"].support).inv(v) - for k, v in hmc_sites.items() - if k in prototype_trace and prototype_trace[k]["type"] == "sample"} + z_hmc = hmc_sites use_enum = len(set(support_sizes) - set(gibbs_sites)) > 0 - wrapped_model = _wrap_model(model) if use_enum: from numpyro.contrib.funsor import config_enumerate, enum - wrapped_model = enum(config_enumerate(wrapped_model), -max_plate_nesting - 1) + wrapped_model_ = enum(config_enumerate(wrapped_model), -max_plate_nesting - 1) + else: + wrapped_model_ = wrapped_model def potential_fn(z_discrete): model_kwargs_ = model_kwargs.copy() model_kwargs_["_gibbs_sites"] = z_discrete - return potential_energy(wrapped_model, model_args, model_kwargs_, z_hmc, enum=use_enum) + return potential_energy(wrapped_model_, model_args, model_kwargs_, z_hmc, enum=use_enum) # get support_sizes of gibbs_sites support_sizes_flat, _ = ravel_pytree({k: support_sizes[k] for k in gibbs_sites}) @@ -359,35 +307,33 @@ def body_fn(i, val): return gibbs_fn -def subsample_gibbs_fn(model, model_args=(), model_kwargs={}, *, num_blocks=1): +class DiscreteHMCGibbs(HMCGibbs): """ [EXPERIMENTAL INTERFACE] - Returns a gibbs_fn to be used in :class:`HMCGibbs`, which works for subsampling - statements using :class:`~numpyro.plate` primitive. This implements the Algorithm 1 - of reference [1] but uses a naive estimation (without control variates) of log likelihood, - hence might incur a high variance. + A subclass of :class:`HMCGibbs` which performs Metropolis updates for discrete latent sites. - The function can partition named subsample statements and update only one block in the parition - to improve acceptance rate of proposed subsamples as detailed in [3]. - .. note:: New subsample indices are proposed randomly with replacement at each MCMC step. + .. note:: The site update order is randomly permuted at each step. - **References:** + .. note:: This class supports enumeration of discrete latent variables. To marginalize out a + discrete latent site, we can specify `infer={'enumerate': 'parallel'}` keyword in its + corresponding :func:`~numpyro.primitives.sample` statement. - 1. *Hamiltonian Monte Carlo with energy conserving subsampling*, - Dang, K. D., Quiroz, M., Kohn, R., Minh-Ngoc, T., & Villani, M. (2019) - 2. *Speeding Up MCMC by Efficient Data Subsampling*, - Quiroz, M., Kohn, R., Villani, M., & Tran, M. N. (2018) - 3. *The Block Pseudo-Margional Sampler*, - Tran, M.-N., Kohn, R., Quiroz, M. Villani, M. (2017) + :param inner_kernel: One of :class:`~numpyro.infer.hmc.HMC` or :class:`~numpyro.infer.hmc.NUTS`. + :param list discrete_sites: a list of site names for the discrete latent variables + that are covered by the Gibbs sampler. + :param bool random_walk: If False, Gibbs sampling will be used to draw a sample from the + conditional `p(gibbs_site | remaining sites)`. Otherwise, a sample will be drawn uniformly + from the domain of `gibbs_site`. + :param bool modified: whether to use a modified proposal, as suggested in reference [1], which + always proposes a new state for the current Gibbs site. + The modified scheme appears in the literature under the name "modified Gibbs sampler" or + "Metropolised Gibbs sampler". - :param callable model: A callable with NumPyro primitives. This should be the same model - as the one used in the `inner_kernel` of :class:`HMCGibbs`. + **References:** - :param tuple model_args: Arguments provided to the model. - :param dict model_kwargs: Keyword arguments provided to the model. - :param int num_blocks: Number of blocks to partition subsample into. - :return: A callable `gibbs_fn` to be used in :class:`HMCGibbs` + 1. *Peskun's theorem and a modified discrete-state Gibbs sampler*, + Liu, J. S. (1996) **Example** @@ -397,35 +343,45 @@ def subsample_gibbs_fn(model, model_args=(), model_kwargs={}, *, num_blocks=1): >>> import jax.numpy as jnp >>> import numpyro >>> import numpyro.distributions as dist - >>> from numpyro.infer import MCMC, NUTS, HMCGibbs, subsample_gibbs_fn + >>> from numpyro.infer import DiscreteHMCGibbs, MCMC, NUTS ... - >>> def model(data): - ... x = numpyro.sample("x", dist.Normal(0, 1)) - ... with numpyro.plate("N", data.shape[0], subsample_size=100): - ... batch = numpyro.subsample(data, event_dim=0) - ... numpyro.sample("obs", dist.Normal(x, 1), obs=batch) + >>> def model(probs, locs): + ... c = numpyro.sample("c", dist.Categorical(probs)) + ... numpyro.sample("x", dist.Normal(locs[c], 0.5)) ... - >>> data = random.normal(random.PRNGKey(0), (10000,)) + 1 - >>> gibbs_fn = subsample_gibbs_fn(model, (data,), num_blocks={'N': 10}) - >>> kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["N"]) - >>> mcmc = MCMC(kernel, 1000, 1000) - >>> mcmc.run(random.PRNGKey(0), data) + >>> probs = jnp.array([0.15, 0.3, 0.3, 0.25]) + >>> locs = jnp.array([-2, 0, 2, 4]) + >>> kernel = DiscreteHMCGibbs(NUTS(model), modified=True) + >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) + >>> mcmc.run(random.PRNGKey(0), probs, locs) + >>> mcmc.print_summary() >>> samples = mcmc.get_samples()["x"] - >>> assert abs(jnp.mean(samples).copy() - 1.) < 0.1 + >>> assert abs(jnp.mean(samples) - 1.3) < 0.1 + >>> assert abs(jnp.var(samples) - 4.36) < 0.5 """ - prototype_trace = trace(seed(model, rng_seed=0)).get_trace(*model_args, **model_kwargs) - plate_sizes = { - name: site["args"] - for name, site in prototype_trace.items() - if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size - } - enum = any(site["type"] == "sample" - and not site["is_observed"] - and site["fn"].has_enumerate_support - for name, site in prototype_trace.items()) - assert not enum, "Enumeration is not supported for subsample_gibbs_fn." + def __init__(self, inner_kernel, *, random_walk=False, modified=False): + super().__init__(inner_kernel, lambda *args: None, None) + self._random_walk = random_walk + self._modified = modified + self._use_unconstrained_gibbs_fn = True + + def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): + model_kwargs = {} if model_kwargs is None else model_kwargs.copy() + rng_key, key_u = random.split(rng_key) + self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) + self._gibbs_fn = _discrete_gibbs_fn(self.model, model_args, model_kwargs, self._prototype_trace, + random_walk=self._random_walk, modified=self._modified) + self._gibbs_sites = [name for name, site in self._prototype_trace.items() + if site["type"] == "sample" + and site["fn"].has_enumerate_support + and not site["is_observed"] + and site["infer"].get("enumerate", "") != "parallel"] + return super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) + + +def _subsample_gibbs_fn(wrapped_model, model_args, model_kwargs, plate_sizes, num_blocks=1): def gibbs_fn(rng_key, gibbs_sites, hmc_sites): assert set(gibbs_sites) == set(plate_sizes) @@ -441,13 +397,90 @@ def gibbs_fn(rng_key, gibbs_sites, hmc_sites): u_new[name] = jnp.where(block_mask, new_idx, gibbs_sites[name]) - u_loglik = log_likelihood(_wrap_model(model), hmc_sites, *model_args, batch_ndims=0, + u_loglik = log_likelihood(wrapped_model, hmc_sites, *model_args, batch_ndims=0, **model_kwargs, _gibbs_sites=gibbs_sites) u_loglik = sum(v.sum() for v in u_loglik.values()) - u_new_loglik = log_likelihood(_wrap_model(model), hmc_sites, *model_args, batch_ndims=0, + u_new_loglik = log_likelihood(wrapped_model, hmc_sites, *model_args, batch_ndims=0, **model_kwargs, _gibbs_sites=u_new) u_new_loglik = sum(v.sum() for v in u_new_loglik.values()) accept_prob = jnp.clip(jnp.exp(u_new_loglik - u_loglik), a_max=1.0) return cond(random.bernoulli(rng_key, accept_prob), u_new, identity, gibbs_sites, identity) return gibbs_fn + + +class HMCECS(HMCGibbs): + """ + [EXPERIMENTAL INTERFACE] + + HMC with Energy Conserving Subsampling. + + A subclass of :class:`HMCGibbs` for performing HMC-within-Gibbs for models with subsample + statements using the :class:`~numpyro.plate` primitive. This implements Algorithm 1 + of reference [1] but uses a naive estimation (without control variates) of log likelihood, + hence might incur a high variance. + + The function can divide subsample indices into blocks and update only one block at each + MCMC step to improve the acceptance rate of proposed subsamples as detailed in [3]. + + .. note:: New subsample indices are proposed randomly with replacement at each MCMC step. + + **References:** + + 1. *Hamiltonian Monte Carlo with energy conserving subsampling*, + Dang, K. D., Quiroz, M., Kohn, R., Minh-Ngoc, T., & Villani, M. (2019) + 2. *Speeding Up MCMC by Efficient Data Subsampling*, + Quiroz, M., Kohn, R., Villani, M., & Tran, M. N. (2018) + 3. *The Block Pseudo-Margional Sampler*, + Tran, M.-N., Kohn, R., Quiroz, M. Villani, M. (2017) + + :param inner_kernel: One of :class:`~numpyro.infer.hmc.HMC` or :class:`~numpyro.infer.hmc.NUTS`. + :param int num_blocks: Number of blocks to partition subsample into. + + **Example** + + .. doctest:: + + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.infer import HMCECS, MCMC, NUTS + ... + >>> def model(data): + ... x = numpyro.sample("x", dist.Normal(0, 1)) + ... with numpyro.plate("N", data.shape[0], subsample_size=100): + ... batch = numpyro.subsample(data, event_dim=0) + ... numpyro.sample("obs", dist.Normal(x, 1), obs=batch) + ... + >>> data = random.normal(random.PRNGKey(0), (10000,)) + 1 + >>> kernel = HMCECS(NUTS(model), num_blocks=10) + >>> mcmc = MCMC(kernel, 1000, 1000) + >>> mcmc.run(random.PRNGKey(0), data) + >>> samples = mcmc.get_samples()["x"] + >>> assert abs(jnp.mean(samples) - 1.) < 0.1 + + """ + def __init__(self, inner_kernel, *, num_blocks=1): + super().__init__(inner_kernel, lambda *args: None, None) + self._num_blocks = num_blocks + + def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): + model_kwargs = {} if model_kwargs is None else model_kwargs.copy() + rng_key, key_u = random.split(rng_key) + self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) + plate_sizes = { + name: site["args"] + for name, site in self._prototype_trace.items() + if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size + } + self._gibbs_sites = list(plate_sizes.keys()) + + enum = any(site["type"] == "sample" + and not site["is_observed"] + and site["fn"].has_enumerate_support + for name, site in self._prototype_trace.items()) + assert not enum, "Enumeration is not supported for subsample_gibbs_fn." + self._gibbs_fn = _subsample_gibbs_fn(self.model, model_args, model_kwargs, plate_sizes, + num_blocks=self._num_blocks) + return super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) diff --git a/setup.py b/setup.py index c26d572e3..e6cafaf60 100644 --- a/setup.py +++ b/setup.py @@ -34,9 +34,9 @@ author_email='npradhan@uber.com', install_requires=[ # TODO: pin to a specific version for the release (until JAX's API becomes stable) - 'jax==0.2.7', + 'jax>=0.2.7', # check min version here: https://github.com/google/jax/blob/master/jax/lib/__init__.py#L26 - 'jaxlib==0.1.56', + 'jaxlib>=0.1.56', 'tqdm', ], extras_require={ diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index badf638a4..1a3490d69 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -3,17 +3,18 @@ from functools import partial -import jax.numpy as jnp import numpy as np +from numpy.testing import assert_allclose import pytest + from jax import random +import jax.numpy as jnp from jax.scipy.linalg import cho_factor, cho_solve, inv, solve_triangular -from numpy.testing import assert_allclose import numpyro import numpyro.distributions as dist from numpyro.handlers import plate -from numpyro.infer import HMC, MCMC, NUTS, HMCGibbs, discrete_gibbs_fn, subsample_gibbs_fn +from numpyro.infer import HMC, HMCECS, MCMC, NUTS, DiscreteHMCGibbs, HMCGibbs def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): @@ -107,12 +108,11 @@ def model(obs): numpyro.sample('x', dist.Normal(0, 1), obs=obs[idx]) obs = random.normal(random.PRNGKey(0), (10000,)) / 100 - kernel = kernel_cls(model) - hmc_state = kernel.init(random.PRNGKey(1), 10, model_args=(obs,)) + kernel = HMCECS(kernel_cls(model), num_blocks=num_blocks) + hmc_state = kernel.init(random.PRNGKey(1), 10, None, model_args=(obs,), model_kwargs=None) gibbs_sites = {'N': jnp.arange(100)} - gibbs_fn = subsample_gibbs_fn(model, (obs,), {}, num_blocks=num_blocks) - + gibbs_fn = kernel._gibbs_fn new_gibbs_sites = gibbs_fn(random.PRNGKey(2), gibbs_sites, hmc_state.z) # accept_prob > .999 block_size = 100 // num_blocks for name in gibbs_sites: @@ -161,7 +161,7 @@ def model(): x0_std = np.std(mcmc.get_samples()['x0'], axis=0) x1_std = np.std(mcmc.get_samples()['x1'], axis=0) - assert_allclose(x0_mean, np.zeros(D), atol=0.15) + assert_allclose(x0_mean, np.zeros(D), atol=0.2) assert_allclose(x1_mean, np.zeros(D), atol=0.2) assert_allclose(x0_std, np.sqrt(np.diagonal(cov00)), rtol=0.05) @@ -173,7 +173,7 @@ def model(): numpyro.sample("x", dist.Bernoulli(0.7).expand([3])) numpyro.sample("y", dist.Binomial(10, 0.3)) - kernel = HMCGibbs(NUTS(model), discrete_gibbs_fn(model), gibbs_sites=["x", "y"]) + kernel = DiscreteHMCGibbs(NUTS(model)) mcmc = MCMC(kernel, 1000, 10000, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples() @@ -183,11 +183,11 @@ def model(): def test_discrete_gibbs_enum(): def model(): - numpyro.sample("x", dist.Bernoulli(0.7)) + numpyro.sample("x", dist.Bernoulli(0.7), infer={"enumerate": "parallel"}) y = numpyro.sample("y", dist.Binomial(10, 0.3)) numpyro.deterministic("y2", y ** 2) - kernel = HMCGibbs(NUTS(model), discrete_gibbs_fn(model), gibbs_sites=["y"]) + kernel = DiscreteHMCGibbs(NUTS(model)) mcmc = MCMC(kernel, 1000, 10000, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples() @@ -200,8 +200,7 @@ def test_discrete_gibbs_bernoulli(random_walk, modified): def model(): numpyro.sample("c", dist.Bernoulli(0.8)) - gibbs_fn = discrete_gibbs_fn(model, random_walk=random_walk, modified=modified) - kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["c"]) + kernel = DiscreteHMCGibbs(NUTS(model), random_walk=random_walk, modified=modified) mcmc = MCMC(kernel, 1000, 200000, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples()["c"] @@ -216,8 +215,7 @@ def model(probs, locs): probs = jnp.array([0.15, 0.3, 0.3, 0.25]) locs = jnp.array([-2, 0, 2, 4]) - gibbs_fn = discrete_gibbs_fn(model, (probs, locs), modified=modified) - kernel = HMCGibbs(NUTS(model), gibbs_fn, gibbs_sites=["c"]) + kernel = DiscreteHMCGibbs(NUTS(model), modified=modified) mcmc = MCMC(kernel, 1000, 200000, progress_bar=False) mcmc.run(random.PRNGKey(0), probs, locs) samples = mcmc.get_samples() From b26c71ef224cb94e47e304952af1475c674bffb2 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 17 Jan 2021 10:24:58 -0600 Subject: [PATCH 032/222] Add constraint event_dim (#876) --- numpyro/contrib/tfp/distributions.py | 10 +- numpyro/distributions/constraints.py | 60 +++++++-- numpyro/distributions/continuous.py | 4 +- numpyro/distributions/distribution.py | 25 ++-- numpyro/distributions/flows.py | 4 +- numpyro/distributions/transforms.py | 167 ++++++++++++++------------ numpyro/infer/autoguide.py | 5 +- numpyro/infer/initialization.py | 1 + numpyro/infer/util.py | 2 +- test/test_distributions.py | 72 ++++++----- 10 files changed, 206 insertions(+), 144 deletions(-) diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index 9fce79498..16706806a 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -47,6 +47,10 @@ class BijectorConstraint(constraints.Constraint): def __init__(self, bijector): self.bijector = bijector + @property + def event_dim(self): + return self.bijector.forward_min_event_ndims + def __call__(self, x): return self.codomain(x) @@ -65,10 +69,6 @@ class BijectorTransform(Transform): def __init__(self, bijector): self.bijector = bijector - @property - def event_dim(self): - return self.bijector.forward_min_event_ndims - @property def domain(self): return BijectorConstraint(tfb.Invert(self.bijector)) @@ -84,7 +84,7 @@ def _inverse(self, y): return self.bijector.inverse(y) def log_abs_det_jacobian(self, x, y, intermediates=None): - return self.bijector.forward_log_det_jacobian(x, self.event_dim) + return self.bijector.forward_log_det_jacobian(x, self.domain.event_dim) @biject_to.register(BijectorConstraint) diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 8f630ca12..aa46f28a4 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -62,6 +62,7 @@ class Constraint(object): A constraint object represents a region over which a variable is valid, e.g. within which a variable can be optimized. """ + event_dim = 0 def __call__(self, x): raise NotImplementedError @@ -89,6 +90,8 @@ def feasible_like(self, prototype): class _CorrCholesky(Constraint): + event_dim = 2 + def __call__(self, x): jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy tril = jnp.tril(x) @@ -103,6 +106,8 @@ def feasible_like(self, prototype): class _CorrMatrix(Constraint): + event_dim = 2 + def __call__(self, x): jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy # check for symmetric @@ -137,6 +142,40 @@ def feasible_like(self, prototype): return jax.numpy.broadcast_to(self.lower_bound + 1, jax.numpy.shape(prototype)) +class _IndependentConstraint(Constraint): + """ + Wraps a constraint by aggregating over ``reinterpreted_batch_ndims``-many + dims in :meth:`check`, so that an event is valid only if all its + independent entries are valid. + """ + def __init__(self, base_constraint, reinterpreted_batch_ndims): + assert isinstance(base_constraint, Constraint) + assert isinstance(reinterpreted_batch_ndims, int) + assert reinterpreted_batch_ndims >= 0 + self.base_constraint = base_constraint + self.reinterpreted_batch_ndims = reinterpreted_batch_ndims + super().__init__() + + @property + def event_dim(self): + return self.base_constraint.event_dim + self.reinterpreted_batch_ndims + + def __call__(self, value): + result = self.base_constraint(value) + if self.reinterpreted_batch_ndims == 0: + return result + elif jax.numpy.ndim(result) < self.reinterpreted_batch_ndims: + expected = self.event_dim + raise ValueError(f"Expected value.dim() >= {expected} but got {jax.numpy.ndim(value)}") + result = result.reshape( + jax.numpy.shape(result)[:jax.numpy.ndim(result) - self.reinterpreted_batch_ndims] + (-1,)) + result = result.all(-1) + return result + + def feasible_like(self, prototype): + return self.base_constraint.feasible_like(prototype) + + class _LessThan(Constraint): def __init__(self, upper_bound): self.upper_bound = upper_bound @@ -184,6 +223,8 @@ def feasible_like(self, prototype): class _LowerCholesky(Constraint): + event_dim = 2 + def __call__(self, x): jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy tril = jnp.tril(x) @@ -196,6 +237,8 @@ def feasible_like(self, prototype): class _Multinomial(Constraint): + event_dim = 1 + def __init__(self, upper_bound): self.upper_bound = upper_bound @@ -209,6 +252,8 @@ def feasible_like(self, prototype): class _OrderedVector(Constraint): + event_dim = 1 + def __call__(self, x): return (x[..., 1:] > x[..., :-1]).all(axis=-1) @@ -217,6 +262,8 @@ def feasible_like(self, prototype): class _PositiveDefinite(Constraint): + event_dim = 2 + def __call__(self, x): jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy # check for symmetric @@ -238,15 +285,9 @@ def feasible_like(self, prototype): return jax.numpy.zeros_like(prototype) -class _RealVector(Constraint): - def __call__(self, x): - return ((x == x) & (x != float('inf')) & (x != float('-inf'))).all(axis=-1) - - def feasible_like(self, prototype): - return jax.numpy.zeros_like(prototype) - - class _Simplex(Constraint): + event_dim = 1 + def __call__(self, x): x_sum = x.sum(axis=-1) return (x >= 0).all(axis=-1) & (x_sum < 1 + 1e-6) & (x_sum > 1 - 1e-6) @@ -263,6 +304,7 @@ def feasible_like(self, prototype): dependent = _Dependent() greater_than = _GreaterThan less_than = _LessThan +independent = _IndependentConstraint integer_interval = _IntegerInterval integer_greater_than = _IntegerGreaterThan interval = _Interval @@ -274,6 +316,6 @@ def feasible_like(self, prototype): positive_definite = _PositiveDefinite() positive_integer = _IntegerGreaterThan(1) real = _Real() -real_vector = _RealVector() +real_vector = independent(real, 1) simplex = _Simplex() unit_interval = _Interval(0., 1.) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 1724ce5aa..c08a89cde 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -817,8 +817,8 @@ def _batch_lowrank_mahalanobis(W, D, x, capacitance_tril): class LowRankMultivariateNormal(Distribution): arg_constraints = { "loc": constraints.real_vector, - "cov_factor": constraints.real, - "cov_diag": constraints.positive + "cov_factor": constraints.independent(constraints.real, 2), + "cov_diag": constraints.independent(constraints.positive, 1) } support = constraints.real_vector reparametrized_params = ['loc', 'cov_factor', 'cov_diag'] diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 53e86bb74..2a4bf475c 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -35,7 +35,7 @@ from jax import lax, tree_util import jax.numpy as jnp -from numpyro.distributions.constraints import is_dependent, real +from numpyro.distributions.constraints import independent, is_dependent, real from numpyro.distributions.transforms import ComposeTransform, Transform from numpyro.distributions.util import lazy_property, promote_shapes, sum_rightmost, validate_sample from numpyro.util import not_jax_tracer @@ -582,7 +582,7 @@ def __init__(self, base_dist, reinterpreted_batch_ndims, validate_args=None): @property def support(self): - return self.base_dist.support + return independent(self.base_dist.support, self.reinterpreted_batch_ndims) @property def has_enumerate_support(self): @@ -765,14 +765,15 @@ def __init__(self, base_distribution, transforms, validate_args=None): # this is just an edge case, we might skip this issue but need # to pay attention to any inference function that inspects # transformed distribution's shape. + # TODO: address this and the comment below when infer_shapes is available shape = base_distribution.batch_shape + base_distribution.event_shape base_ndim = len(shape) transform = ComposeTransform(self.transforms) - transform_input_event_dim = transform.input_event_dim + transform_input_event_dim = transform.domain.event_dim if base_ndim < transform_input_event_dim: raise ValueError("Base distribution needs to have shape with size at least {}, but got {}." .format(transform_input_event_dim, base_ndim)) - event_dim = transform.output_event_dim + max(self.base_dist.event_dim - transform_input_event_dim, 0) + event_dim = transform.codomain.event_dim + max(self.base_dist.event_dim - transform_input_event_dim, 0) # See the above note. Currently, there is no way to interpret the shape of output after # transforming. To solve this issue, we need something like Bijector.forward_event_shape # as in TFP. For now, we will prepend singleton dimensions to compromise, so that @@ -797,11 +798,13 @@ def rsample(self, key, sample_shape=()): @property def support(self): - domain = self.base_dist.support - for t in self.transforms: - t.domain = domain - domain = t.codomain - return domain + codomain = self.transforms[-1].codomain + codomain_event_dim = codomain.event_dim + assert self.event_dim >= codomain_event_dim + if self.event_dim == codomain_event_dim: + return codomain + else: + return independent(codomain, self.event_dim - codomain_event_dim) def sample(self, key, sample_shape=()): x = self.base_dist(rng_key=key, sample_shape=sample_shape) @@ -831,9 +834,9 @@ def log_prob(self, value, intermediates=None): x = transform.inv(y) if intermediates is None else intermediates[-i - 1][0] t_inter = None if intermediates is None else intermediates[-i - 1][1] t_log_det = transform.log_abs_det_jacobian(x, y, t_inter) - batch_ndim = event_dim - transform.output_event_dim + batch_ndim = event_dim - transform.codomain.event_dim log_prob = log_prob - sum_rightmost(t_log_det, batch_ndim) - event_dim = transform.input_event_dim + batch_ndim + event_dim = transform.domain.event_dim + batch_ndim y = x log_prob = log_prob + sum_rightmost(self.base_dist.log_prob(y), diff --git a/numpyro/distributions/flows.py b/numpyro/distributions/flows.py index f2abf1580..91e6a43d6 100644 --- a/numpyro/distributions/flows.py +++ b/numpyro/distributions/flows.py @@ -53,7 +53,7 @@ def call_with_intermediates(self, x): scale = jnp.exp(log_scale) return scale * x + mean, log_scale - def inv(self, y): + def _inverse(self, y): """ :param numpy.ndarray y: the output of the transform to be inverted """ @@ -108,7 +108,7 @@ def call_with_intermediates(self, x): y, logdet = self.bn_arn(x) return y, logdet - def inv(self, y): + def _inverse(self, y): raise NotImplementedError("Block neural autoregressive transform does not have an analytic" " inverse implemented.") diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 23efb2494..d2e332bdc 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -52,15 +52,13 @@ def _clipped_expit(x): class Transform(object): domain = constraints.real codomain = constraints.real - event_dim = 0 @property - def input_event_dim(self): - return self.event_dim - - @property - def output_event_dim(self): - return self.event_dim + def event_dim(self): + warnings.warn("transform.event_dim is deprecated. Please use Transform.domain.event_dim to " + "get input event dim or Transform.codomain.event_dim to get output event dim.", + FutureWarning) + return self.domain.event_dim @property def inv(self): @@ -92,18 +90,6 @@ def domain(self): def codomain(self): return self._inv.domain - @property - def input_event_dim(self): - return self._inv.output_event_dim - - @property - def output_event_dim(self): - return self._inv.input_event_dim - - @property - def event_dim(self): - return self._inv.event_dim - @property def inv(self): return self._inv @@ -144,8 +130,6 @@ def __init__(self, loc, scale, domain=constraints.real): def codomain(self): if self.domain is constraints.real: return constraints.real - elif self.domain is constraints.real_vector: - return constraints.real_vector elif isinstance(self.domain, constraints.greater_than): if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)): return constraints.less_than(self(self.domain.lower_bound)) @@ -168,10 +152,6 @@ def codomain(self): else: raise NotImplementedError - @property - def event_dim(self): - return 1 if self.domain is constraints.real_vector else 0 - def __call__(self, x): return self.loc + self.scale * x @@ -179,7 +159,21 @@ def _inverse(self, y): return (y - self.loc) / self.scale def log_abs_det_jacobian(self, x, y, intermediates=None): - return sum_rightmost(jnp.broadcast_to(jnp.log(jnp.abs(self.scale)), jnp.shape(x)), self.event_dim) + return jnp.broadcast_to(jnp.log(jnp.abs(self.scale)), jnp.shape(x)) + + +def _get_compose_transform_input_event_dim(parts): + input_event_dim = parts[-1].domain.event_dim + for part in parts[len(parts) - 1::-1]: + input_event_dim = part.domain.event_dim + max(input_event_dim - part.codomain.event_dim, 0) + return input_event_dim + + +def _get_compose_transform_output_event_dim(parts): + output_event_dim = parts[0].codomain.event_dim + for part in parts[1:]: + output_event_dim = part.codomain.event_dim + max(output_event_dim - part.domain.event_dim, 0) + return output_event_dim class ComposeTransform(Transform): @@ -188,29 +182,23 @@ def __init__(self, parts): @property def domain(self): - return self.parts[0].domain + input_event_dim = _get_compose_transform_input_event_dim(self.parts) + first_input_event_dim = self.parts[0].domain.event_dim + assert input_event_dim >= first_input_event_dim + if input_event_dim == first_input_event_dim: + return self.parts[0].domain + else: + return constraints.independent(self.parts[0].domain, input_event_dim - first_input_event_dim) @property def codomain(self): - return self.parts[-1].codomain - - @property - def event_dim(self): - raise ValueError("Please use `.input_event_dim` or `.output_event_dim` instead.") - - @property - def input_event_dim(self): - input_event_dim = self.parts[-1].input_event_dim - for part in self.parts[len(self.parts) - 1::-1]: - input_event_dim = part.input_event_dim + max(input_event_dim - part.output_event_dim, 0) - return input_event_dim - - @property - def output_event_dim(self): - output_event_dim = self.parts[0].output_event_dim - for part in self.parts[1:]: - output_event_dim = part.output_event_dim + max(output_event_dim - part.input_event_dim, 0) - return output_event_dim + output_event_dim = _get_compose_transform_output_event_dim(self.parts) + last_output_event_dim = self.parts[-1].codomain.event_dim + assert output_event_dim >= last_output_event_dim + if output_event_dim == last_output_event_dim: + return self.parts[-1].codomain + else: + return constraints.independent(self.parts[-1].codomain, output_event_dim - last_output_event_dim) def __call__(self, x): for part in self.parts: @@ -229,20 +217,20 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): .format(len(intermediates), len(self.parts))) result = 0. - input_event_dim = self.input_event_dim + input_event_dim = self.domain.event_dim for i, part in enumerate(self.parts[:-1]): y_tmp = part(x) if intermediates is None else intermediates[i][0] inter = None if intermediates is None else intermediates[i][1] logdet = part.log_abs_det_jacobian(x, y_tmp, intermediates=inter) - batch_ndim = input_event_dim - part.input_event_dim + batch_ndim = input_event_dim - part.domain.event_dim result = result + sum_rightmost(logdet, batch_ndim) - input_event_dim = part.output_event_dim + batch_ndim + input_event_dim = part.codomain.event_dim + batch_ndim x = y_tmp # account the the last transform, where y is available inter = None if intermediates is None else intermediates[-1] part = self.parts[-1] logdet = part.log_abs_det_jacobian(x, y, intermediates=inter) - result = result + sum_rightmost(logdet, input_event_dim - part.input_event_dim) + result = result + sum_rightmost(logdet, input_event_dim - part.domain.event_dim) return result def call_with_intermediates(self, x): @@ -284,12 +272,6 @@ class :class:`StickBreakingTransform` to transform :math:`X_i` into a """ domain = constraints.real_vector codomain = constraints.corr_cholesky - input_event_dim = 1 - output_event_dim = 2 - - @property - def event_dim(self): - raise ValueError("Please use `.input_event_dim` or `.output_event_dim` instead.") def __call__(self, x): # we interchange step 1 and step 2.a for a better performance @@ -356,9 +338,6 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): class IdentityTransform(Transform): - def __init__(self, event_dim=0): - self.event_dim = event_dim - def __call__(self, x): return x @@ -366,7 +345,46 @@ def _inverse(self, y): return y def log_abs_det_jacobian(self, x, y, intermediates=None): - return jnp.full(jnp.shape(x) if self.event_dim == 0 else jnp.shape(x)[:-1], 0.) + return jnp.zeros_like(x) + + +class IndependentTransform(Transform): + """ + Wraps a transform by aggregating over ``reinterpreted_batch_ndims``-many + dims in :meth:`check`, so that an event is valid only if all its + independent entries are valid. + """ + def __init__(self, base_transform, reinterpreted_batch_ndims): + assert isinstance(base_transform, Transform) + assert isinstance(reinterpreted_batch_ndims, int) + assert reinterpreted_batch_ndims >= 0 + self.base_transform = base_transform + self.reinterpreted_batch_ndims = reinterpreted_batch_ndims + super().__init__() + + @property + def domain(self): + return constraints.independent(self.base_transform.domain, self.reinterpreted_batch_ndims) + + @property + def codomain(self): + return constraints.independent(self.base_transform.codomain, self.reinterpreted_batch_ndims) + + def __call__(self, x): + return self.base_transform(x) + + def _inverse(self, y): + return self.base_transform._inverse(y) + + def log_abs_det_jacobian(self, x, y, intermediates=None): + result = self.base_transform.log_abs_det_jacobian(x, y, intermediates=intermediates) + if jnp.ndim(result) < self.reinterpreted_batch_ndims: + expected = self.domain.event_dim + raise ValueError(f"Expected x.dim() >= {expected} but got {jnp.ndim(x)}") + return sum_rightmost(result, self.reinterpreted_batch_ndims) + + def call_with_intermediates(self, x): + return self.base_transform.call_with_intermediates(x) class InvCholeskyTransform(Transform): @@ -374,7 +392,6 @@ class InvCholeskyTransform(Transform): Transform via the mapping :math:`y = x @ x.T`, where `x` is a lower triangular matrix with positive diagonal. """ - event_dim = 2 def __init__(self, domain=constraints.lower_cholesky): assert domain in [constraints.lower_cholesky, constraints.corr_cholesky] @@ -384,7 +401,7 @@ def __init__(self, domain=constraints.lower_cholesky): def codomain(self): if self.domain is constraints.lower_cholesky: return constraints.positive_definite - elif self.domain: + elif self.domain is constraints.corr_cholesky: return constraints.corr_matrix def __call__(self, x): @@ -415,7 +432,6 @@ class LowerCholeskyAffine(Transform): """ domain = constraints.real_vector codomain = constraints.real_vector - event_dim = 1 def __init__(self, loc, scale_tril): if jnp.ndim(scale_tril) != 2: @@ -443,12 +459,6 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): class LowerCholeskyTransform(Transform): domain = constraints.real_vector codomain = constraints.lower_cholesky - input_event_dim = 1 - output_event_dim = 2 - - @property - def event_dim(self): - raise ValueError("Please use `.input_event_dim` or `.output_event_dim` instead.") def __call__(self, x): n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) @@ -477,7 +487,6 @@ class OrderedTransform(Transform): """ domain = constraints.real_vector codomain = constraints.ordered_vector - event_dim = 1 def __call__(self, x): z = jnp.concatenate([x[..., :1], jnp.exp(x[..., 1:])], axis=-1) @@ -494,7 +503,6 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): class PermuteTransform(Transform): domain = constraints.real_vector codomain = constraints.real_vector - event_dim = 1 def __init__(self, permutation): self.permutation = permutation @@ -547,7 +555,6 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): class StickBreakingTransform(Transform): domain = constraints.real_vector codomain = constraints.simplex - event_dim = 1 def __call__(self, x): # we shift x to obtain a balanced mapping (0, 0, ..., 0) -> (1/K, 1/K, ..., 1/K) @@ -587,7 +594,7 @@ class UnpackTransform(Transform): :param unpack_fn: callable used to unpack a contiguous array. """ domain = constraints.real_vector - event_dim = 1 + codomain = constraints.dependent def __init__(self, unpack_fn): self.unpack_fn = unpack_fn @@ -650,7 +657,8 @@ def _transform_to_corr_cholesky(constraint): @biject_to.register(constraints.corr_matrix) def _transform_to_corr_matrix(constraint): - return ComposeTransform([CorrCholeskyTransform(), InvCholeskyTransform(domain=constraints.corr_cholesky)]) + return ComposeTransform([CorrCholeskyTransform(), + InvCholeskyTransform(domain=constraints.corr_cholesky)]) @biject_to.register(constraints.greater_than) @@ -669,6 +677,12 @@ def _transform_to_less_than(constraint): domain=constraints.positive)]) +@biject_to.register(constraints.independent) +def _biject_to_independent(constraint): + return IndependentTransform(biject_to(constraint.base_constraint), + constraint.reinterpreted_batch_ndims) + + @biject_to.register(constraints.interval) def _transform_to_interval(constraint): if constraint is constraints.unit_interval: @@ -699,11 +713,6 @@ def _transform_to_real(constraint): return IdentityTransform() -@biject_to.register(constraints.real_vector) -def _transform_to_real_vector(constraint): - return IdentityTransform(event_dim=1) - - @biject_to.register(constraints.simplex) def _transform_to_simplex(constraint): return StickBreakingTransform() diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 198ee2501..c42bb3098 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -21,6 +21,7 @@ from numpyro.distributions.transforms import ( AffineTransform, ComposeTransform, + IndependentTransform, LowerCholeskyAffine, PermuteTransform, UnpackTransform, @@ -563,13 +564,13 @@ def get_base_dist(self): def get_transform(self, params): loc = params['{}_loc'.format(self.prefix)] scale = params['{}_scale'.format(self.prefix)] - return AffineTransform(loc, scale, domain=constraints.real_vector) + return IndependentTransform(AffineTransform(loc, scale), 1) def get_posterior(self, params): """ Returns a diagonal Normal posterior distribution. """ - transform = self.get_transform(params) + transform = self.get_transform(params).base_transform return dist.Normal(transform.loc, transform.scale) def median(self, params): diff --git a/numpyro/infer/initialization.py b/numpyro/infer/initialization.py index adbb7e047..6a5d68d8f 100644 --- a/numpyro/infer/initialization.py +++ b/numpyro/infer/initialization.py @@ -61,6 +61,7 @@ def init_to_uniform(site=None, radius=2): # we can't use this logic for general priors # because some distributions such as TransformedDistribution might # have wrong event_shape. + # TODO: address this when infer_shapes is available prototype_value = jnp.full(site['fn'].shape(), jnp.nan) transform = biject_to(site['fn'].support) diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 6f8aa7bcf..68b7226f1 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -122,7 +122,7 @@ def _unconstrain_reparam(params, site): # in scan, we might only want to substitute an item at index i, rather than the whole sequence i = site['infer'].get('_scan_current_index', None) if i is not None: - event_dim_shift = t.output_event_dim - t.input_event_dim + event_dim_shift = t.codomain.event_dim - t.domain.event_dim expected_unconstrained_dim = len(site["fn"].shape()) - event_dim_shift # check if p has additional time dimension if jnp.ndim(p) > expected_unconstrained_dim: diff --git a/test/test_distributions.py b/test/test_distributions.py index a480b4715..5533e7287 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -230,81 +230,85 @@ def _is_batched_multivariate(jax_dist): def gen_values_within_bounds(constraint, size, key=random.PRNGKey(11)): eps = 1e-6 - if isinstance(constraint, constraints._Boolean): + if constraint is constraints.boolean: return random.bernoulli(key, shape=size) - elif isinstance(constraint, constraints._GreaterThan): + elif isinstance(constraint, constraints.greater_than): return jnp.exp(random.normal(key, size)) + constraint.lower_bound + eps - elif isinstance(constraint, constraints._IntegerInterval): + elif isinstance(constraint, constraints.integer_interval): lower_bound = jnp.broadcast_to(constraint.lower_bound, size) upper_bound = jnp.broadcast_to(constraint.upper_bound, size) return random.randint(key, size, lower_bound, upper_bound + 1) - elif isinstance(constraint, constraints._IntegerGreaterThan): + elif isinstance(constraint, constraints.integer_greater_than): return constraint.lower_bound + random.poisson(key, np.array(5), shape=size) - elif isinstance(constraint, constraints._Interval): + elif isinstance(constraint, constraints.interval): lower_bound = jnp.broadcast_to(constraint.lower_bound, size) upper_bound = jnp.broadcast_to(constraint.upper_bound, size) return random.uniform(key, size, minval=lower_bound, maxval=upper_bound) - elif isinstance(constraint, (constraints._Real, constraints._RealVector)): + elif constraint in (constraints.real, constraints.real_vector): return random.normal(key, size) - elif isinstance(constraint, constraints._Simplex): + elif constraint is constraints.simplex: return osp.dirichlet.rvs(alpha=jnp.ones((size[-1],)), size=size[:-1]) - elif isinstance(constraint, constraints._Multinomial): + elif isinstance(constraint, constraints.multinomial): n = size[-1] return multinomial(key, p=jnp.ones((n,)) / n, n=constraint.upper_bound, shape=size[:-1]) - elif isinstance(constraint, constraints._CorrCholesky): + elif constraint is constraints.corr_cholesky: return signed_stick_breaking_tril( random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1)) - elif isinstance(constraint, constraints._CorrMatrix): + elif constraint is constraints.corr_matrix: cholesky = signed_stick_breaking_tril( random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1)) return jnp.matmul(cholesky, jnp.swapaxes(cholesky, -2, -1)) - elif isinstance(constraint, constraints._LowerCholesky): + elif constraint is constraints.lower_cholesky: return jnp.tril(random.uniform(key, size)) - elif isinstance(constraint, constraints._PositiveDefinite): + elif constraint is constraints.positive_definite: x = random.normal(key, size) return jnp.matmul(x, jnp.swapaxes(x, -2, -1)) - elif isinstance(constraint, constraints._OrderedVector): + elif constraint is constraints.ordered_vector: x = jnp.cumsum(random.exponential(key, size), -1) return x - random.normal(key, size[:-1]) + elif isinstance(constraint, constraints.independent): + return gen_values_within_bounds(constraint.base_constraint, size, key) else: raise NotImplementedError('{} not implemented.'.format(constraint)) def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)): - if isinstance(constraint, constraints._Boolean): + if constraint is constraints.boolean: return random.bernoulli(key, shape=size) - 2 - elif isinstance(constraint, constraints._GreaterThan): + elif isinstance(constraint, constraints.greater_than): return constraint.lower_bound - jnp.exp(random.normal(key, size)) - elif isinstance(constraint, constraints._IntegerInterval): + elif isinstance(constraint, constraints.integer_interval): lower_bound = jnp.broadcast_to(constraint.lower_bound, size) return random.randint(key, size, lower_bound - 1, lower_bound) - elif isinstance(constraint, constraints._IntegerGreaterThan): + elif isinstance(constraint, constraints.integer_greater_than): return constraint.lower_bound - random.poisson(key, np.array(5), shape=size) - elif isinstance(constraint, constraints._Interval): + elif isinstance(constraint, constraints.interval): upper_bound = jnp.broadcast_to(constraint.upper_bound, size) return random.uniform(key, size, minval=upper_bound, maxval=upper_bound + 1.) - elif isinstance(constraint, (constraints._Real, constraints._RealVector)): + elif constraint in [constraints.real, constraints.real_vector]: return lax.full(size, jnp.nan) - elif isinstance(constraint, constraints._Simplex): + elif constraint is constraints.simplex: return osp.dirichlet.rvs(alpha=jnp.ones((size[-1],)), size=size[:-1]) + 1e-2 - elif isinstance(constraint, constraints._Multinomial): + elif isinstance(constraint, constraints.multinomial): n = size[-1] return multinomial(key, p=jnp.ones((n,)) / n, n=constraint.upper_bound, shape=size[:-1]) + 1 - elif isinstance(constraint, constraints._CorrCholesky): + elif constraint is constraints.corr_cholesky: return signed_stick_breaking_tril( random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1)) + 1e-2 - elif isinstance(constraint, constraints._CorrMatrix): + elif constraint is constraints.corr_matrix: cholesky = 1e-2 + signed_stick_breaking_tril( random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1)) return jnp.matmul(cholesky, jnp.swapaxes(cholesky, -2, -1)) - elif isinstance(constraint, constraints._LowerCholesky): + elif constraint is constraints.lower_cholesky: return random.uniform(key, size) - elif isinstance(constraint, constraints._PositiveDefinite): + elif constraint is constraints.positive_definite: return random.normal(key, size) - elif isinstance(constraint, constraints._OrderedVector): + elif constraint is constraints.ordered_vector: x = jnp.cumsum(random.exponential(key, size), -1) return x[..., ::-1] + elif isinstance(constraint, constraints.independent): + return gen_values_outside_bounds(constraint.base_constraint, size, key) else: raise NotImplementedError('{} not implemented.'.format(constraint)) @@ -933,13 +937,15 @@ def test_constraints(constraint, x, expected): constraints.positive, constraints.positive_definite, constraints.real, + constraints.real_vector, constraints.simplex, constraints.unit_interval, ], ids=lambda x: x.__class__) @pytest.mark.parametrize('shape', [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) def test_biject_to(constraint, shape): + transform = biject_to(constraint) - event_dim = transform.input_event_dim + event_dim = transform.domain.event_dim if isinstance(constraint, constraints._Interval): assert transform.codomain.upper_bound == constraint.upper_bound assert transform.codomain.lower_bound == constraint.lower_bound @@ -975,7 +981,7 @@ def test_biject_to(constraint, shape): if constraint is constraints.simplex: expected = np.linalg.slogdet(jax.jacobian(transform)(x)[:-1, :])[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y)[:, :-1])[1] - elif constraint is constraints.ordered_vector: + elif constraint in [constraints.real_vector, constraints.ordered_vector]: expected = np.linalg.slogdet(jax.jacobian(transform)(x))[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y))[1] elif constraint in [constraints.corr_cholesky, constraints.corr_matrix]: @@ -1042,7 +1048,7 @@ def test_bijective_transforms(transform, event_shape, batch_shape): actual = transform.log_abs_det_jacobian(x, y) assert_allclose(actual, -transform.inv.log_abs_det_jacobian(y, x)) assert jnp.shape(actual) == batch_shape - if len(shape) == transform.event_dim: + if len(shape) == transform.domain.event_dim: if len(event_shape) == 1: expected = np.linalg.slogdet(jax.jacobian(transform)(x))[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y))[1] @@ -1059,8 +1065,8 @@ def test_composed_transform(batch_shape): t1 = transforms.AffineTransform(0, 2) t2 = transforms.LowerCholeskyTransform() t = transforms.ComposeTransform([t1, t2, t1]) - assert t.input_event_dim == 1 - assert t.output_event_dim == 2 + assert t.domain.event_dim == 1 + assert t.codomain.event_dim == 2 x = np.random.normal(size=batch_shape + (6,)) y = t(x) @@ -1075,8 +1081,8 @@ def test_composed_transform_1(batch_shape): t1 = transforms.AffineTransform(0, 2) t2 = transforms.LowerCholeskyTransform() t = transforms.ComposeTransform([t1, t2, t2]) - assert t.input_event_dim == 1 - assert t.output_event_dim == 3 + assert t.domain.event_dim == 1 + assert t.codomain.event_dim == 3 x = np.random.normal(size=batch_shape + (6,)) y = t(x) From 4f0f4992a5eddee9671b7b614fecd5c7efe6f2c5 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 17 Jan 2021 11:50:40 -0600 Subject: [PATCH 033/222] Make subsample faster in CPU (#865) --- numpyro/primitives.py | 19 +++++++++++++++++-- test/test_handlers.py | 19 +++++++++++++++++++ 2 files changed, 36 insertions(+), 2 deletions(-) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 19a33c1a6..1092abf4a 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -6,7 +6,8 @@ import functools import warnings -from jax import lax, random +from jax import lax, ops, random +from jax.lib import xla_bridge import jax.numpy as jnp import numpyro @@ -235,7 +236,21 @@ def module(name, nn, input_shape=None): def _subsample_fn(size, subsample_size, rng_key=None): assert rng_key is not None, "Missing random key to generate subsample indices." - return random.permutation(rng_key, size)[:subsample_size] + if xla_bridge.get_backend().platform == 'cpu': + # ref: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm + rng_keys = random.split(rng_key, subsample_size) + + def body_fn(val, idx): + i_p1 = size - idx + i = i_p1 - 1 + j = random.randint(rng_keys[idx], (), 0, i_p1) + val = ops.index_update(val, ops.index[[i, j], ], val[ops.index[[j, i], ]]) + return val, None + + val, _ = lax.scan(body_fn, jnp.arange(size), jnp.arange(subsample_size)) + return val[-subsample_size:] + else: + return random.choice(rng_key, size, (subsample_size,), replace=False) class plate(Messenger): diff --git a/test/test_handlers.py b/test/test_handlers.py index c4a232fb0..0423b8bd8 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -612,3 +612,22 @@ def model(x=None): z0 = handlers.seed(model, 0)() assert (z[1:] != z0).all() assert (z[0] == z0).all() + + +def test_subsample_fn(): + size = 20 + subsample_size = 11 + num_samples = 1000000 + + @jit + def subsample_fn(rng_key): + return numpyro.primitives._subsample_fn(size, subsample_size, rng_key) + + rng_keys = random.split(random.PRNGKey(0), num_samples) + subsamples = vmap(subsample_fn)(rng_keys) + for k in range(1, 11): + i = random.randint(random.PRNGKey(k), (), 0, size) + assert_allclose(jnp.mean(subsamples == i, axis=0), jnp.full(subsample_size, 1 / size), atol=1e-3) + + # test that values are not duplicated + assert len(set(subsamples[k])) == subsample_size From acc9d992aa795f84504870ce03fd42f1a34de7b3 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 19 Jan 2021 15:04:59 -0600 Subject: [PATCH 034/222] Relax jax jaxlib versions (#882) * relax jax jaxlib versions * run isort and update headers * merge master and fix some rendering issues --- examples/ode.py | 3 +++ examples/proportion_test.py | 3 +++ numpyro/contrib/tfp/__init__.py | 5 ++--- numpyro/distributions/directional.py | 1 + numpyro/distributions/util.py | 1 + numpyro/infer/einstein/kernels.py | 3 +++ numpyro/infer/einstein/utils.py | 3 +++ numpyro/infer/hmc.py | 3 +++ numpyro/infer/hmc_gibbs.py | 2 +- numpyro/infer/mcmc.py | 10 +++++----- numpyro/infer/sa.py | 3 +++ setup.py | 9 +++++---- test/test_einstein_kernels.py | 3 +++ 13 files changed, 36 insertions(+), 13 deletions(-) diff --git a/examples/ode.py b/examples/ode.py index f927311bf..8f7c35477 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -1,3 +1,6 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + """ Example: Predator-Prey Model ============================ diff --git a/examples/proportion_test.py b/examples/proportion_test.py index 2e9ce6205..6964bc1b2 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -1,3 +1,6 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + """ Example: Proportion Test ======================== diff --git a/numpyro/contrib/tfp/__init__.py b/numpyro/contrib/tfp/__init__.py index 87e269656..2d4993ea3 100644 --- a/numpyro/contrib/tfp/__init__.py +++ b/numpyro/contrib/tfp/__init__.py @@ -4,6 +4,5 @@ try: import tensorflow_probability.substrates.jax as tfp # noqa: F401 except ImportError as e: - raise ImportError("Looking like your installed tensorflow_probability does not" - " support JAX backend. You might try to install the nightly" - " version with: `pip install tfp-nightly`") from e + raise ImportError("To use this module, please install TensorFlow Probability. It can be" + " installed with `pip install tensorflow_probability`") from e diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index 3e5242d32..de7eb95ce 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -1,5 +1,6 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 + import math from jax import lax diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index ed08e972a..07329e631 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -1,5 +1,6 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 + from collections import namedtuple from functools import update_wrapper import math diff --git a/numpyro/infer/einstein/kernels.py b/numpyro/infer/einstein/kernels.py index c1e77c4e0..9eec29fac 100644 --- a/numpyro/infer/einstein/kernels.py +++ b/numpyro/infer/einstein/kernels.py @@ -1,3 +1,6 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + from abc import ABC, abstractmethod from typing import Callable, Dict, List, Tuple diff --git a/numpyro/infer/einstein/utils.py b/numpyro/infer/einstein/utils.py index ad57a8570..24f7c22e7 100644 --- a/numpyro/infer/einstein/utils.py +++ b/numpyro/infer/einstein/utils.py @@ -1,3 +1,6 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + import jax import jax.numpy as jnp diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index a89f535d9..4d18ee419 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -1,3 +1,6 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + from collections import namedtuple import math import os diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index c8429ed71..040180101 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -432,7 +432,7 @@ class HMCECS(HMCGibbs): 2. *Speeding Up MCMC by Efficient Data Subsampling*, Quiroz, M., Kohn, R., Villani, M., & Tran, M. N. (2018) 3. *The Block Pseudo-Margional Sampler*, - Tran, M.-N., Kohn, R., Quiroz, M. Villani, M. (2017) + Tran, M.-N., Kohn, R., Quiroz, M. Villani, M. (2017) :param inner_kernel: One of :class:`~numpyro.infer.hmc.HMC` or :class:`~numpyro.infer.hmc.NUTS`. :param int num_blocks: Number of blocks to partition subsample into. diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 47fa55a28..9d8beda50 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -26,7 +26,7 @@ class MCMCKernel(ABC): """ Defines the interface for the Markov transition kernel that is - used for :class:`~numpyro.infer.MCMC` inference. + used for :class:`~numpyro.infer.mcmc.MCMC` inference. **Example:** @@ -204,8 +204,8 @@ class MCMC(object): .. note:: Setting `progress_bar=False` will improve the speed for many cases. :param MCMCKernel sampler: an instance of :class:`~numpyro.infer.mcmc.MCMCKernel` that - determines the sampler for running MCMC. Currently, only :class:`~numpyro.infer.mcmc.HMC` - and :class:`~numpyro.infer.mcmc.NUTS` are available. + determines the sampler for running MCMC. Currently, only :class:`~numpyro.infer.hmc.HMC` + and :class:`~numpyro.infer.hmc.NUTS` are available. :param int num_warmup: Number of warmup steps. :param int num_samples: Number of samples to generate from the Markov chain. :param int thinning: Positive integer that controls the fraction of post-warmup samples that are @@ -422,8 +422,8 @@ def warmup(self, rng_key, *args, extra_fields=(), collect_warmup=False, init_par :param random.PRNGKey rng_key: Random number generator key to be used for the sampling. :param args: Arguments to be provided to the :meth:`numpyro.infer.mcmc.MCMCKernel.init` method. These are typically the arguments needed by the `model`. - :param extra_fields: Extra fields (aside from :meth:`~numpyro.infer.MCMCKernel.default_fields`) - from the state object (e.g. :data:`numpyro.infer.mcmc.HMCState` for HMC) to collect during + :param extra_fields: Extra fields (aside from :meth:`~numpyro.infer.mcmc.MCMCKernel.default_fields`) + from the state object (e.g. :data:`numpyro.infer.hmc.HMCState` for HMC) to collect during the MCMC run. :type extra_fields: tuple or list :param bool collect_warmup: Whether to collect samples from the warmup phase. Defaults diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index b229089ab..aadb0e2df 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -1,3 +1,6 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + from collections import namedtuple from jax import device_put, lax, random, vmap diff --git a/setup.py b/setup.py index e6cafaf60..4f19b3179 100644 --- a/setup.py +++ b/setup.py @@ -31,7 +31,6 @@ packages=find_packages(include=['numpyro', 'numpyro.*']), url='https://github.com/pyro-ppl/numpyro', author='Uber AI Labs', - author_email='npradhan@uber.com', install_requires=[ # TODO: pin to a specific version for the release (until JAX's API becomes stable) 'jax>=0.2.7', @@ -47,12 +46,12 @@ 'pyro-api>=0.1.1' ], 'dev': [ + 'dm-haiku', + 'flax', 'funsor', 'ipython', 'isort', - 'flax', - 'dm-haiku', - 'tfp-nightly', # TODO: change this to stable release or a specific nightly release + 'tensorflow_probability', ], 'examples': ['matplotlib', 'seaborn', 'graphviz', 'arviz'], }, @@ -69,5 +68,7 @@ 'Operating System :: MacOS :: MacOS X', 'Programming Language :: Python :: 3.6', 'Programming Language :: Python :: 3.7', + 'Programming Language :: Python :: 3.8', + 'Programming Language :: Python :: 3.9', ], ) diff --git a/test/test_einstein_kernels.py b/test/test_einstein_kernels.py index c0f5ed15f..4c3641202 100644 --- a/test/test_einstein_kernels.py +++ b/test/test_einstein_kernels.py @@ -1,3 +1,6 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + from collections import namedtuple from numpy.testing import assert_allclose From dc3076e13b6787ee918de44348c201d837d519c1 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 19 Jan 2021 15:07:50 -0600 Subject: [PATCH 035/222] improve kinetic grad for eucleadian kinetic energy (#883) --- numpyro/infer/hmc_util.py | 23 ++++++++++++++++++++++- 1 file changed, 22 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 8a7785512..7edb5b236 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -170,6 +170,13 @@ def final_fn(state, regularize=False): return init_fn, update_fn, final_fn +def _kinetic_grad(kinetic_fn, inverse_mass_matrix, r): + if hasattr(kinetic_fn, "_kinetic_grad"): + return kinetic_fn._kinetic_grad(inverse_mass_matrix, r) + else: + return grad(kinetic_fn, argnums=1)(inverse_mass_matrix, r) + + def velocity_verlet(potential_fn, kinetic_fn): r""" Second order symplectic integrator that uses the velocity verlet algorithm @@ -204,7 +211,7 @@ def update_fn(step_size, inverse_mass_matrix, state): """ z, r, _, z_grad = state r = tree_multimap(lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad) # r(n+1/2) - r_grad = grad(kinetic_fn, argnums=1)(inverse_mass_matrix, r) + r_grad = _kinetic_grad(kinetic_fn, inverse_mass_matrix, r) z = tree_multimap(lambda z, r_grad: z + step_size * r_grad, z, r_grad) # z(n+1) potential_energy, z_grad = value_and_grad(potential_fn)(z) r = tree_multimap(lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad) # r(n+1) @@ -727,6 +734,20 @@ def euclidean_kinetic_energy(inverse_mass_matrix, r): return 0.5 * jnp.dot(v, r) +def _euclidean_kinetic_energy_grad(inverse_mass_matrix, r): + r, unravel_fn = ravel_pytree(r) + + if inverse_mass_matrix.ndim == 2: + v = jnp.matmul(inverse_mass_matrix, r) + elif inverse_mass_matrix.ndim == 1: + v = jnp.multiply(inverse_mass_matrix, r) + + return unravel_fn(v) + + +euclidean_kinetic_energy._kinetic_grad = _euclidean_kinetic_energy_grad + + def consensus(subposteriors, num_draws=None, diagonal=False, rng_key=None): """ Merges subposteriors following consensus Monte Carlo algorithm. From 6add2229d4feca299f9e93695cf2daca94e38d4c Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 19 Jan 2021 19:55:12 -0600 Subject: [PATCH 036/222] support forward-mode differentiation (#878) --- numpyro/infer/hmc.py | 43 ++++++++++++++++++++++++++++++--------- numpyro/infer/hmc_util.py | 15 ++++++++++---- numpyro/infer/util.py | 35 ++++++++++++++++++++++--------- test/test_mcmc.py | 18 +++++++++++++--- 4 files changed, 84 insertions(+), 27 deletions(-) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 4d18ee419..8e9d9302b 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -150,6 +150,7 @@ def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo='NUTS'): max_treedepth = None wa_update = None wa_steps = None + forward_mode_ad = False max_delta_energy = 1000. if algo not in {'HMC', 'NUTS'}: raise ValueError('`algo` must be one of `HMC` or `NUTS`.') @@ -165,6 +166,7 @@ def init_kernel(init_params, trajectory_length=2*math.pi, max_tree_depth=10, find_heuristic_step_size=False, + forward_mode_differentiation=False, model_args=(), model_kwargs=None, rng_key=random.PRNGKey(0)): @@ -203,7 +205,8 @@ def init_kernel(init_params, """ step_size = lax.convert_element_type(step_size, canonicalize_dtype(jnp.float64)) - nonlocal wa_update, trajectory_len, max_treedepth, vv_update, wa_steps + nonlocal wa_update, trajectory_len, max_treedepth, vv_update, wa_steps, forward_mode_ad + forward_mode_ad = forward_mode_differentiation wa_steps = num_warmup trajectory_len = trajectory_length max_treedepth = max_tree_depth @@ -239,7 +242,7 @@ def init_kernel(init_params, inverse_mass_matrix=inverse_mass_matrix, mass_matrix_size=jnp.size(ravel_pytree(z)[0])) r = momentum_generator(z, wa_state.mass_matrix_sqrt, rng_key_momentum) - vv_init, vv_update = velocity_verlet(pe_fn, kinetic_fn) + vv_init, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) vv_state = vv_init(z, r, potential_energy=pe, z_grad=z_grad) energy = kinetic_fn(wa_state.inverse_mass_matrix, vv_state.r) hmc_state = HMCState(0, vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, @@ -249,9 +252,9 @@ def init_kernel(init_params, def _hmc_next(step_size, inverse_mass_matrix, vv_state, model_args, model_kwargs, rng_key): if potential_fn_gen: - nonlocal vv_update + nonlocal vv_update, forward_mode_ad pe_fn = potential_fn_gen(*model_args, **model_kwargs) - _, vv_update = velocity_verlet(pe_fn, kinetic_fn) + _, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) num_steps = _get_num_steps(step_size, trajectory_len) vv_state_new = fori_loop(0, num_steps, @@ -272,9 +275,9 @@ def _hmc_next(step_size, inverse_mass_matrix, vv_state, def _nuts_next(step_size, inverse_mass_matrix, vv_state, model_args, model_kwargs, rng_key): if potential_fn_gen: - nonlocal vv_update + nonlocal vv_update, forward_mode_ad pe_fn = potential_fn_gen(*model_args, **model_kwargs) - _, vv_update = velocity_verlet(pe_fn, kinetic_fn) + _, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) binary_tree = build_tree(vv_update, kinetic_fn, vv_state, inverse_mass_matrix, step_size, rng_key, @@ -372,6 +375,13 @@ class HMC(MCMCKernel): See :ref:`init_strategy` section for available functions. :param bool find_heuristic_step_size: whether to a heuristic function to adjust the step size at the beginning of each adaptation window. Defaults to False. + :param bool forward_mode_differentiation: whether to use forward-mode differentiation + or reverse-mode differentiation. By default, we use reverse mode but the forward + mode can be useful in some cases to improve the performance. In addition, some + control flow utility on JAX such as `jax.lax.while_loop` or `jax.lax.fori_loop` + only supports forward-mode differentiation. See + `JAX's The Autodiff Cookbook `_ + for more information. """ def __init__(self, model=None, @@ -384,7 +394,8 @@ def __init__(self, target_accept_prob=0.8, trajectory_length=2 * math.pi, init_strategy=init_to_uniform, - find_heuristic_step_size=False): + find_heuristic_step_size=False, + forward_mode_differentiation=False): if not (model is None) ^ (potential_fn is None): raise ValueError('Only one of `model` or `potential_fn` must be specified.') self._model = model @@ -400,6 +411,7 @@ def __init__(self, self._max_tree_depth = 10 self._init_strategy = init_strategy self._find_heuristic_step_size = find_heuristic_step_size + self._forward_mode_differentiation = forward_mode_differentiation # Set on first call to init self._init_fn = None self._potential_fn_gen = None @@ -414,7 +426,8 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): dynamic_args=True, init_strategy=self._init_strategy, model_args=model_args, - model_kwargs=model_kwargs) + model_kwargs=model_kwargs, + forward_mode_differentiation=self._forward_mode_differentiation) if self._init_fn is None: self._init_fn, self._sample_fn = hmc(potential_fn_gen=potential_fn, kinetic_fn=self._kinetic_fn, @@ -468,6 +481,7 @@ def init(self, rng_key, num_warmup, init_params=None, model_args=(), model_kwarg trajectory_length=self._trajectory_length, max_tree_depth=self._max_tree_depth, find_heuristic_step_size=self._find_heuristic_step_size, + forward_mode_differentiation=self._forward_mode_differentiation, model_args=model_args, model_kwargs=model_kwargs, rng_key=rng_key, @@ -544,6 +558,13 @@ class NUTS(HMC): See :ref:`init_strategy` section for available functions. :param bool find_heuristic_step_size: whether to a heuristic function to adjust the step size at the beginning of each adaptation window. Defaults to False. + :param bool forward_mode_differentiation: whether to use forward-mode differentiation + or reverse-mode differentiation. By default, we use reverse mode but the forward + mode can be useful in some cases to improve the performance. In addition, some + control flow utility on JAX such as `jax.lax.while_loop` or `jax.lax.fori_loop` + only supports forward-mode differentiation. See + `JAX's The Autodiff Cookbook `_ + for more information. """ def __init__(self, model=None, @@ -557,13 +578,15 @@ def __init__(self, trajectory_length=None, max_tree_depth=10, init_strategy=init_to_uniform, - find_heuristic_step_size=False): + find_heuristic_step_size=False, + forward_mode_differentiation=False): super(NUTS, self).__init__(potential_fn=potential_fn, model=model, kinetic_fn=kinetic_fn, step_size=step_size, adapt_step_size=adapt_step_size, adapt_mass_matrix=adapt_mass_matrix, dense_mass=dense_mass, target_accept_prob=target_accept_prob, trajectory_length=trajectory_length, init_strategy=init_strategy, - find_heuristic_step_size=find_heuristic_step_size) + find_heuristic_step_size=find_heuristic_step_size, + forward_mode_differentiation=forward_mode_differentiation) self._max_tree_depth = max_tree_depth self._algo = 'NUTS' diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 7edb5b236..315cf3f65 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -3,7 +3,7 @@ from collections import namedtuple -from jax import grad, random, value_and_grad, vmap +from jax import jacfwd, grad, random, value_and_grad, vmap from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.ops import index_update @@ -170,6 +170,13 @@ def final_fn(state, regularize=False): return init_fn, update_fn, final_fn +def _value_and_grad(f, x, forward_mode_differentiation=False): + if forward_mode_differentiation: + return f(x), jacfwd(f)(x) + else: + return value_and_grad(f)(x) + + def _kinetic_grad(kinetic_fn, inverse_mass_matrix, r): if hasattr(kinetic_fn, "_kinetic_grad"): return kinetic_fn._kinetic_grad(inverse_mass_matrix, r) @@ -177,7 +184,7 @@ def _kinetic_grad(kinetic_fn, inverse_mass_matrix, r): return grad(kinetic_fn, argnums=1)(inverse_mass_matrix, r) -def velocity_verlet(potential_fn, kinetic_fn): +def velocity_verlet(potential_fn, kinetic_fn, forward_mode_differentiation=False): r""" Second order symplectic integrator that uses the velocity verlet algorithm for position `z` and momentum `r`. @@ -198,7 +205,7 @@ def init_fn(z, r, potential_energy=None, z_grad=None): :return: initial state for the integrator. """ if potential_energy is None or z_grad is None: - potential_energy, z_grad = value_and_grad(potential_fn)(z) + potential_energy, z_grad = _value_and_grad(potential_fn, z, forward_mode_differentiation) return IntegratorState(z, r, potential_energy, z_grad) def update_fn(step_size, inverse_mass_matrix, state): @@ -213,7 +220,7 @@ def update_fn(step_size, inverse_mass_matrix, state): r = tree_multimap(lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad) # r(n+1/2) r_grad = _kinetic_grad(kinetic_fn, inverse_mass_matrix, r) z = tree_multimap(lambda z, r_grad: z + step_size * r_grad, z, r_grad) # z(n+1) - potential_energy, z_grad = value_and_grad(potential_fn)(z) + potential_energy, z_grad = _value_and_grad(potential_fn, z, forward_mode_differentiation) r = tree_multimap(lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad) # r(n+1) return IntegratorState(z, r, potential_energy, z_grad) diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 68b7226f1..d71c50a5c 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -7,7 +7,7 @@ import numpy as np -from jax import device_get, lax, random, value_and_grad +from jax import device_get, jacfwd, lax, random, value_and_grad from jax.flatten_util import ravel_pytree import jax.numpy as jnp @@ -176,7 +176,8 @@ def find_valid_initial_params(rng_key, model, enum=False, model_args=(), model_kwargs=None, - prototype_params=None): + prototype_params=None, + forward_mode_differentiation=False): """ (EXPERIMENTAL INTERFACE) Given a model with Pyro primitives, returns an initial valid unconstrained value for all the parameters. This function also returns @@ -240,7 +241,11 @@ def body_fn(state): key, subkey = random.split(key) potential_fn = partial(potential_energy, model, model_args, model_kwargs, enum=enum) - pe, z_grad = value_and_grad(potential_fn)(params) + if forward_mode_differentiation: + pe = potential_fn(params) + z_grad = jacfwd(potential_fn)(params) + else: + pe, z_grad = value_and_grad(potential_fn)(params) z_grad_flat = ravel_pytree(z_grad)[0] is_valid = jnp.isfinite(pe) & jnp.all(jnp.isfinite(z_grad_flat)) return i + 1, key, (params, pe, z_grad), is_valid @@ -384,7 +389,8 @@ def initialize_model(rng_key, model, init_strategy=init_to_uniform, dynamic_args=False, model_args=(), - model_kwargs=None): + model_kwargs=None, + forward_mode_differentiation=False): """ (EXPERIMENTAL INTERFACE) Helper function that calls :func:`~numpyro.infer.util.get_potential_fn` and :func:`~numpyro.infer.util.find_valid_initial_params` under the hood @@ -402,6 +408,13 @@ def initialize_model(rng_key, model, `potential_fn` and `constraints_fn` callables, respectively. :param tuple model_args: args provided to the model. :param dict model_kwargs: kwargs provided to the model. + :param bool forward_mode_differentiation: whether to use forward-mode differentiation + or reverse-mode differentiation. By default, we use reverse mode but the forward + mode can be useful in some cases to improve the performance. In addition, some + control flow utility on JAX such as `jax.lax.while_loop` or `jax.lax.fori_loop` + only supports forward-mode differentiation. See + `JAX's The Autodiff Cookbook `_ + for more information. :return: a namedtupe `ModelInfo` which contains the fields (`param_info`, `potential_fn`, `postprocess_fn`, `model_trace`), where `param_info` is a namedtuple `ParamInfo` containing values from the prior @@ -446,12 +459,14 @@ def initialize_model(rng_key, model, unconstrained_values = transform_fn(inv_transforms, init_values, invert=True) init_strategy = _init_to_unconstrained_value(values=unconstrained_values) prototype_params = transform_fn(inv_transforms, constrained_values, invert=True) - (init_params, pe, grad), is_valid = find_valid_initial_params(rng_key, model, - init_strategy=init_strategy, - enum=has_enumerate_support, - model_args=model_args, - model_kwargs=model_kwargs, - prototype_params=prototype_params) + (init_params, pe, grad), is_valid = find_valid_initial_params( + rng_key, model, + init_strategy=init_strategy, + enum=has_enumerate_support, + model_args=model_args, + model_kwargs=model_kwargs, + prototype_params=prototype_params, + forward_mode_differentiation=forward_mode_differentiation) if not_jax_tracer(is_valid): if device_get(~jnp.all(is_valid)): diff --git a/test/test_mcmc.py b/test/test_mcmc.py index b6febbf6c..0e8aaf730 100644 --- a/test/test_mcmc.py +++ b/test/test_mcmc.py @@ -7,7 +7,7 @@ from numpy.testing import assert_allclose import pytest -from jax import device_get, jit, pmap, random, vmap +from jax import device_get, jit, lax, pmap, random, vmap from jax.lib import xla_bridge import jax.numpy as jnp from jax.scipy.special import logit @@ -101,7 +101,8 @@ def model(labels): assert samples['coefs'].dtype == jnp.float64 -def test_uniform_normal(): +@pytest.mark.parametrize("forward_mode_differentiation", [True, False]) +def test_uniform_normal(forward_mode_differentiation): true_coef = 0.9 num_warmup, num_samples = 1000, 1000 @@ -112,7 +113,7 @@ def model(data): numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) - kernel = NUTS(model=model) + kernel = NUTS(model=model, forward_mode_differentiation=forward_mode_differentiation) mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.warmup(random.PRNGKey(2), data, collect_warmup=True) assert mcmc.post_warmup_state is not None @@ -669,3 +670,14 @@ def model(): mcmc.run(random.PRNGKey(0)) # because event_shape of x is (1,), x should only take value 1 assert_allclose(mcmc.get_samples()["x"], jnp.ones((num_samples,) + batch_shape + (1,))) + + +def test_forward_mode_differentiation(): + def model(): + x = numpyro.sample("x", dist.Normal(0, 1)) + y = lax.while_loop(lambda x: x < 10, lambda x: x + 1, x) + numpyro.sample("obs", dist.Normal(y, 1), obs=1.) + + # this fails in reverse mode + mcmc = MCMC(NUTS(model, forward_mode_differentiation=True), 10, 10) + mcmc.run(random.PRNGKey(0)) From ee5bf1046c6fc27de2c868ca9147dc6392724835 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 19 Jan 2021 19:55:35 -0600 Subject: [PATCH 037/222] move einstein to contrib (#880) --- numpyro/{infer => contrib}/einstein/__init__.py | 0 numpyro/{infer => contrib}/einstein/kernels.py | 2 +- numpyro/{infer => contrib}/einstein/utils.py | 0 test/{ => contrib/einstein}/test_einstein_kernels.py | 2 +- 4 files changed, 2 insertions(+), 2 deletions(-) rename numpyro/{infer => contrib}/einstein/__init__.py (100%) rename numpyro/{infer => contrib}/einstein/kernels.py (99%) rename numpyro/{infer => contrib}/einstein/utils.py (100%) rename test/{ => contrib/einstein}/test_einstein_kernels.py (98%) diff --git a/numpyro/infer/einstein/__init__.py b/numpyro/contrib/einstein/__init__.py similarity index 100% rename from numpyro/infer/einstein/__init__.py rename to numpyro/contrib/einstein/__init__.py diff --git a/numpyro/infer/einstein/kernels.py b/numpyro/contrib/einstein/kernels.py similarity index 99% rename from numpyro/infer/einstein/kernels.py rename to numpyro/contrib/einstein/kernels.py index 9eec29fac..a0b002aa1 100644 --- a/numpyro/infer/einstein/kernels.py +++ b/numpyro/contrib/einstein/kernels.py @@ -12,7 +12,7 @@ import jax.scipy.stats import numpyro.distributions as dist -from numpyro.infer.einstein.utils import posdef, safe_norm, sqrth +from numpyro.contrib.einstein.utils import posdef, safe_norm, sqrth class PrecondMatrix(ABC): diff --git a/numpyro/infer/einstein/utils.py b/numpyro/contrib/einstein/utils.py similarity index 100% rename from numpyro/infer/einstein/utils.py rename to numpyro/contrib/einstein/utils.py diff --git a/test/test_einstein_kernels.py b/test/contrib/einstein/test_einstein_kernels.py similarity index 98% rename from test/test_einstein_kernels.py rename to test/contrib/einstein/test_einstein_kernels.py index 4c3641202..2b1837edc 100644 --- a/test/test_einstein_kernels.py +++ b/test/contrib/einstein/test_einstein_kernels.py @@ -8,7 +8,7 @@ import jax.numpy as jnp -from numpyro.infer.einstein.kernels import ( +from numpyro.contrib.einstein.kernels import ( GraphicalKernel, HessianPrecondMatrix, IMQKernel, From 7e48b74b12a13d63b809dbf7ba0c6086c807cb7d Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Thu, 21 Jan 2021 15:26:34 -0500 Subject: [PATCH 038/222] Memoize Transform.inv (#885) --- numpyro/distributions/transforms.py | 10 +++++++++- test/test_distributions.py | 1 + 2 files changed, 10 insertions(+), 1 deletion(-) diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index d2e332bdc..0835d6a77 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -3,6 +3,7 @@ import math import warnings +import weakref import numpy as np @@ -52,6 +53,7 @@ def _clipped_expit(x): class Transform(object): domain = constraints.real codomain = constraints.real + _inv = None @property def event_dim(self): @@ -62,7 +64,13 @@ def event_dim(self): @property def inv(self): - return _InverseTransform(self) + inv = None + if self._inv is not None: + inv = self._inv() + if inv is None: + inv = _InverseTransform(self) + self._inv = weakref.ref(inv) + return inv def __call__(self, x): return NotImplementedError diff --git a/test/test_distributions.py b/test/test_distributions.py index 5533e7287..cd6cb9c42 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1038,6 +1038,7 @@ def test_bijective_transforms(transform, event_shape, batch_shape): z = transform.inv(y) assert_allclose(x, z, atol=1e-6, rtol=1e-6) assert transform.inv.inv is transform + assert transform.inv is transform.inv assert transform.domain is transform.inv.codomain assert transform.codomain is transform.inv.domain From 90b74eb7b6b6c93023f7dc043e54a2970d31f17b Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 23 Jan 2021 18:06:07 -0600 Subject: [PATCH 039/222] Add transforms' forward_shape and inverse_shape (#887) --- numpyro/contrib/tfp/distributions.py | 12 +++ numpyro/distributions/constraints.py | 3 + numpyro/distributions/distribution.py | 60 +++++++------- numpyro/distributions/flows.py | 4 +- numpyro/distributions/transforms.py | 115 +++++++++++++++++++++++++- numpyro/infer/initialization.py | 14 +--- test/test_distributions.py | 3 + 7 files changed, 163 insertions(+), 48 deletions(-) diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index 16706806a..5714099a3 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -86,6 +86,18 @@ def _inverse(self, y): def log_abs_det_jacobian(self, x, y, intermediates=None): return self.bijector.forward_log_det_jacobian(x, self.domain.event_dim) + def forward_shape(self, shape): + out_shape = self.bijector.forward_event_shape(shape) + in_event_shape = self.bijector.inverse_event_shape(out_shape) + batch_shape = shape[:len(shape) - len(in_event_shape)] + return batch_shape + out_shape + + def inverse_shape(self, shape): + in_shape = self.bijector.inverse_event_shape(shape) + out_event_shape = self.bijector.forward_event_shape(in_shape) + batch_shape = shape[:len(shape) - len(out_event_shape)] + return batch_shape + in_shape + @biject_to.register(BijectorConstraint) def _transform_to_bijector_constraint(constraint): diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index aa46f28a4..6f3138d17 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -152,6 +152,9 @@ def __init__(self, base_constraint, reinterpreted_batch_ndims): assert isinstance(base_constraint, Constraint) assert isinstance(reinterpreted_batch_ndims, int) assert reinterpreted_batch_ndims >= 0 + if isinstance(base_constraint, _IndependentConstraint): + reinterpreted_batch_ndims = reinterpreted_batch_ndims + base_constraint.reinterpreted_batch_ndims + base_constraint = base_constraint.base_constraint self.base_constraint = base_constraint self.reinterpreted_batch_ndims = reinterpreted_batch_ndims super().__init__() diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 2a4bf475c..b59920454 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -518,7 +518,7 @@ class ImproperUniform(Distribution): arg_constraints = {} def __init__(self, support, batch_shape, event_shape, validate_args=None): - self.support = support + self.support = independent(support, len(event_shape) - support.event_dim) super().__init__(batch_shape, event_shape, validate_args=validate_args) @validate_sample @@ -748,42 +748,35 @@ def __init__(self, base_distribution, transforms, validate_args=None): raise ValueError("transforms must be a Transform or a list of Transforms") else: raise ValueError("transforms must be a Transform or list, but was {}".format(transforms)) - # XXX: this logic will not be valid when IndependentDistribution is support; - # in that case, it is more involved to support Transform(Indep(Transform)); - # however, we might not need to support such kind of distribution - # and should raise an error if base_distribution is an Indep one if isinstance(base_distribution, TransformedDistribution): - self.base_dist = base_distribution.base_dist + base_dist = base_distribution.base_dist self.transforms = base_distribution.transforms + transforms else: - self.base_dist = base_distribution + base_dist = base_distribution self.transforms = transforms - # NB: here we assume that base_dist.shape == transformed_dist.shape - # but that might not be True for some transforms such as StickBreakingTransform - # because the event dimension is transformed from (n - 1,) to (n,). - # Currently, we have no mechanism to fix this issue. Given that - # this is just an edge case, we might skip this issue but need - # to pay attention to any inference function that inspects - # transformed distribution's shape. - # TODO: address this and the comment below when infer_shapes is available - shape = base_distribution.batch_shape + base_distribution.event_shape - base_ndim = len(shape) + base_shape = base_dist.shape() + base_event_dim = base_dist.event_dim transform = ComposeTransform(self.transforms) - transform_input_event_dim = transform.domain.event_dim - if base_ndim < transform_input_event_dim: + domain_event_dim = transform.domain.event_dim + if len(base_shape) < domain_event_dim: raise ValueError("Base distribution needs to have shape with size at least {}, but got {}." - .format(transform_input_event_dim, base_ndim)) - event_dim = transform.codomain.event_dim + max(self.base_dist.event_dim - transform_input_event_dim, 0) - # See the above note. Currently, there is no way to interpret the shape of output after - # transforming. To solve this issue, we need something like Bijector.forward_event_shape - # as in TFP. For now, we will prepend singleton dimensions to compromise, so that - # event_dim, len(batch_shape) are still correct. - if event_dim <= base_ndim: - batch_shape = shape[:base_ndim - event_dim] - event_shape = shape[base_ndim - event_dim:] - else: - event_shape = (-1,) * event_dim - batch_shape = () + .format(domain_event_dim, base_shape)) + shape = transform.forward_shape(base_shape) + expanded_base_shape = transform.inverse_shape(shape) + if base_shape != expanded_base_shape: + base_batch_shape = expanded_base_shape[:len(expanded_base_shape) - base_event_dim] + base_dist = base_dist.expand(base_batch_shape) + reinterpreted_batch_ndims = domain_event_dim - base_event_dim + if reinterpreted_batch_ndims > 0: + base_dist = base_dist.to_event(reinterpreted_batch_ndims) + self.base_dist = base_dist + + # Compute shapes. + event_dim = transform.codomain.event_dim + max(base_event_dim - domain_event_dim, 0) + assert len(shape) >= event_dim + cut = len(shape) - event_dim + batch_shape = shape[:cut] + event_shape = shape[cut:] super(TransformedDistribution, self).__init__(batch_shape, event_shape, validate_args=validate_args) @property @@ -862,7 +855,6 @@ def tree_flatten(self): class Delta(Distribution): arg_constraints = {'v': real, 'log_density': real} reparameterized_params = ['v', 'log_density'] - support = real is_discrete = True def __init__(self, v=0., log_density=0., event_dim=0, validate_args=None): @@ -877,6 +869,10 @@ def __init__(self, v=0., log_density=0., event_dim=0, validate_args=None): self.log_density = promote_shapes(log_density, shape=batch_shape)[0] super(Delta, self).__init__(batch_shape, event_shape, validate_args=validate_args) + @property + def support(self): + return independent(real, self.event_dim) + def sample(self, key, sample_shape=()): shape = sample_shape + self.batch_shape + self.event_shape return jnp.broadcast_to(self.v, shape) diff --git a/numpyro/distributions/flows.py b/numpyro/distributions/flows.py index 91e6a43d6..68ee26574 100644 --- a/numpyro/distributions/flows.py +++ b/numpyro/distributions/flows.py @@ -30,7 +30,6 @@ class InverseAutoregressiveTransform(Transform): """ domain = real_vector codomain = real_vector - event_dim = 1 def __init__(self, autoregressive_nn, log_scale_min_clip=-5., log_scale_max_clip=3.): """ @@ -93,7 +92,8 @@ class BlockNeuralAutoregressiveTransform(Transform): 1. *Block Neural Autoregressive Flow*, Nicola De Cao, Ivan Titov, Wilker Aziz """ - event_dim = 1 + domain = real_vector + codomain = real_vector def __init__(self, bn_arn): self.bn_arn = bn_arn diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 0835d6a77..e6981f32c 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -7,7 +7,7 @@ import numpy as np -from jax import ops, tree_flatten, tree_map, vmap +from jax import lax, ops, tree_flatten, tree_map, vmap from jax.dtypes import canonicalize_dtype from jax.flatten_util import ravel_pytree from jax.nn import softplus @@ -84,6 +84,20 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): def call_with_intermediates(self, x): return self(x), None + def forward_shape(self, shape): + """ + Infers the shape of the forward computation, given the input shape. + Defaults to preserving shape. + """ + return shape + + def inverse_shape(self, shape): + """ + Infers the shapes of the inverse computation, given the output shape. + Defaults to preserving shape. + """ + return shape + class _InverseTransform(Transform): def __init__(self, transform): @@ -109,6 +123,12 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): # NB: we don't use intermediates for inverse transform return -self._inv.log_abs_det_jacobian(y, x, None) + def forward_shape(self, shape): + return self._inv.inverse_shape(shape) + + def inverse_shape(self, shape): + return self._inv.forward_shape(shape) + class AbsTransform(Transform): domain = constraints.real @@ -169,6 +189,16 @@ def _inverse(self, y): def log_abs_det_jacobian(self, x, y, intermediates=None): return jnp.broadcast_to(jnp.log(jnp.abs(self.scale)), jnp.shape(x)) + def forward_shape(self, shape): + return lax.broadcast_shapes(shape, + getattr(self.loc, "shape", ()), + getattr(self.scale, "shape", ())) + + def inverse_shape(self, shape): + return lax.broadcast_shapes(shape, + getattr(self.loc, "shape", ()), + getattr(self.scale, "shape", ())) + def _get_compose_transform_input_event_dim(parts): input_event_dim = parts[-1].domain.event_dim @@ -251,6 +281,39 @@ def call_with_intermediates(self, x): intermediates.append(inter) return x, intermediates + def forward_shape(self, shape): + for part in self.parts: + shape = part.forward_shape(shape) + return shape + + def inverse_shape(self, shape): + for part in reversed(self.parts): + shape = part.inverse_shape(shape) + return shape + + +def _matrix_forward_shape(shape, offset=0): + # Reshape from (..., N) to (..., D, D). + if len(shape) < 1: + raise ValueError("Too few dimensions in input") + N = shape[-1] + D = round((0.25 + 2 * N) ** 0.5 - 0.5) + if D * (D + 1) // 2 != N: + raise ValueError("Input is not a flattend lower-diagonal number") + D = D - offset + return shape[:-1] + (D, D) + + +def _matrix_inverse_shape(shape, offset=0): + # Reshape from (..., D, D) to (..., N). + if len(shape) < 2: + raise ValueError("Too few dimensions on input") + if shape[-2] != shape[-1]: + raise ValueError("Input is not square") + D = shape[-1] + offset + N = D * (D + 1) // 2 + return shape[:-2] + (N,) + class CorrCholeskyTransform(Transform): r""" @@ -314,6 +377,12 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): tanh_logdet = -2 * jnp.sum(x + softplus(-2 * x) - jnp.log(2.), axis=-1) return stick_breaking_logdet + tanh_logdet + def forward_shape(self, shape): + return _matrix_forward_shape(shape, offset=-1) + + def inverse_shape(self, shape): + return _matrix_inverse_shape(shape, offset=-1) + class ExpTransform(Transform): # TODO: refine domain/codomain logic through setters, especially when @@ -394,6 +463,12 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): def call_with_intermediates(self, x): return self.base_transform.call_with_intermediates(x) + def forward_shape(self, shape): + return self.base_transform.forward_shape(shape) + + def inverse_shape(self, shape): + return self.base_transform.inverse_shape(shape) + class InvCholeskyTransform(Transform): r""" @@ -463,6 +538,16 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): return jnp.broadcast_to(jnp.log(jnp.diagonal(self.scale_tril, axis1=-2, axis2=-1)).sum(-1), jnp.shape(x)[:-1]) + def forward_shape(self, shape): + if len(shape) < 1: + raise ValueError("Too few dimensions on input") + return lax.broadcast_shapes(shape, self.loc.shape, self.scale_tril.shape[:-1]) + + def inverse_shape(self, shape): + if len(shape) < 1: + raise ValueError("Too few dimensions on input") + return lax.broadcast_shapes(shape, self.loc.shape, self.scale_tril.shape[:-1]) + class LowerCholeskyTransform(Transform): domain = constraints.real_vector @@ -483,6 +568,12 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) return x[..., -n:].sum(-1) + def forward_shape(self, shape): + return _matrix_forward_shape(shape) + + def inverse_shape(self, shape): + return _matrix_inverse_shape(shape) + class OrderedTransform(Transform): """ @@ -545,6 +636,12 @@ def _inverse(self, y): def log_abs_det_jacobian(self, x, y, intermediates=None): return jnp.log(jnp.abs(self.exponent * y / x)) + def forward_shape(self, shape): + return lax.broadcast_shapes(shape, getattr(self.exponent, "shape", ())) + + def inverse_shape(self, shape): + return lax.broadcast_shapes(shape, getattr(self.exponent, "shape", ())) + class SigmoidTransform(Transform): codomain = constraints.unit_interval @@ -594,6 +691,16 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): # the case z ~ 1 return jnp.sum(jnp.log(y[..., :-1] * z) - x, axis=-1) + def forward_shape(self, shape): + if len(shape) < 1: + raise ValueError("Too few dimensions on input") + return shape[:-1] + (shape[-1] + 1,) + + def inverse_shape(self, shape): + if len(shape) < 1: + raise ValueError("Too few dimensions on input") + return shape[:-1] + (shape[-1] - 1,) + class UnpackTransform(Transform): """ @@ -628,6 +735,12 @@ def _inverse(self, y): def log_abs_det_jacobian(self, x, y, intermediates=None): return jnp.zeros(jnp.shape(x)[:-1]) + def forward_shape(self, shape): + raise NotImplementedError + + def inverse_shape(self, shape): + raise NotImplementedError + ########################################################## # CONSTRAINT_REGISTRY diff --git a/numpyro/infer/initialization.py b/numpyro/infer/initialization.py index 6a5d68d8f..48271ef69 100644 --- a/numpyro/infer/initialization.py +++ b/numpyro/infer/initialization.py @@ -52,20 +52,8 @@ def init_to_uniform(site=None, radius=2): sample_shape = site['kwargs'].get('sample_shape') rng_key, subkey = random.split(rng_key) - # this is used to interpret the changes of event_shape in - # domain and codomain spaces - try: - prototype_value = site['fn'](rng_key=subkey, sample_shape=()) - except NotImplementedError: - # XXX: this works for ImproperUniform prior, - # we can't use this logic for general priors - # because some distributions such as TransformedDistribution might - # have wrong event_shape. - # TODO: address this when infer_shapes is available - prototype_value = jnp.full(site['fn'].shape(), jnp.nan) - transform = biject_to(site['fn'].support) - unconstrained_shape = jnp.shape(transform.inv(prototype_value)) + unconstrained_shape = transform.inverse_shape(site["fn"].shape()) unconstrained_samples = dist.Uniform(-radius, radius)( rng_key=rng_key, sample_shape=sample_shape + unconstrained_shape) return transform(unconstrained_samples) diff --git a/test/test_distributions.py b/test/test_distributions.py index cd6cb9c42..4e40d27d7 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -959,6 +959,9 @@ def test_biject_to(constraint, shape): x = random.normal(rng_key, shape) y = transform(x) + assert transform.forward_shape(x.shape) == y.shape + assert transform.inverse_shape(y.shape) == x.shape + # test inv work for NaN arrays: x_nan = transform.inv(jnp.full(jnp.shape(y), jnp.nan)) assert (x_nan.shape == x.shape) From 7892f2bc0eba68f238228198bd2bcfcbcba2207b Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Sat, 23 Jan 2021 21:00:31 -0500 Subject: [PATCH 040/222] Make TransformReparam compatible with .to_event() (#886) * Support .to_event() in TransformReparam * Strengthen test * Address review comment --- numpyro/infer/reparam.py | 45 ++++++++++++++++++++-------------------- test/test_reparam.py | 22 +++++++++++--------- 2 files changed, 35 insertions(+), 32 deletions(-) diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index c17d80289..c5623696b 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -4,6 +4,7 @@ from abc import ABC, abstractmethod import jax.numpy as jnp +from jax import lax import numpyro import numpyro.distributions as dist @@ -28,31 +29,31 @@ def __call__(self, name, fn, obs): def _unwrap(self, fn): """ - Unwrap Independent(...) distributions. + Unwrap Independent(...) and ExpandedDistribution(...) distributions. """ + batch_shape = fn.batch_shape event_dim = fn.event_dim - while isinstance(fn, dist.Independent): + while isinstance(fn, (dist.Independent, dist.ExpandedDistribution)): fn = fn.base_dist - return fn, event_dim + return fn, batch_shape, event_dim - def _wrap(self, fn, event_dim): + def _wrap(self, fn, batch_shape, event_dim): """ - Wrap in Independent distributions. + Wrap in Independent and ExpandedDistribution distributions. """ + # Match batch_shape. + assert fn.event_dim <= event_dim + fn_batch_shape = batch_shape + (1,) * (event_dim - fn.event_dim) + fn_batch_shape = lax.broadcast_shapes(fn_batch_shape, fn.batch_shape) + if fn.batch_shape != fn_batch_shape: + fn = fn.expand(fn_batch_shape) + + # Match event_dim. if fn.event_dim < event_dim: fn = fn.to_event(event_dim - fn.event_dim) assert fn.event_dim == event_dim return fn - def _unexpand(self, fn): - """ - Unexpand ExpandedDistribution(...) distributions. - """ - batch_shape = fn.batch_shape - if isinstance(fn, dist.ExpandedDistribution): - fn = fn.base_dist - return fn, batch_shape - class LocScaleReparam(Reparam): """ @@ -89,8 +90,7 @@ def __call__(self, name, fn, obs): if is_identically_one(centered): return name, fn, obs event_shape = fn.event_shape - fn, event_dim = self._unwrap(fn) - fn, batch_shape = self._unexpand(fn) + fn, batch_shape, event_dim = self._unwrap(fn) # Apply a partial decentering transform. params = {key: getattr(fn, key) for key in self.shape_params} @@ -100,11 +100,11 @@ def __call__(self, name, fn, obs): constraint=constraints.unit_interval) params["loc"] = fn.loc * centered params["scale"] = fn.scale ** centered - decentered_fn = type(fn)(**params).expand(batch_shape) + decentered_fn = self._wrap(type(fn)(**params), batch_shape, event_dim) # Draw decentered noise. decentered_value = numpyro.sample("{}_decentered".format(name), - self._wrap(decentered_fn, event_dim)) + decentered_fn) # Differentiably transform. delta = decentered_value - centered * fn.loc @@ -127,14 +127,15 @@ class TransformReparam(Reparam): """ def __call__(self, name, fn, obs): assert obs is None, "TransformReparam does not support observe statements" - fn, batch_shape = self._unexpand(fn) + fn, batch_shape, event_dim = self._unwrap(fn) assert isinstance(fn, dist.TransformedDistribution) # Draw noise from the base distribution. - # We need to make sure that we have the same batch_shape - reinterpreted_batch_ndims = fn.event_dim - fn.base_dist.event_dim + base_event_dim = event_dim + for t in reversed(fn.transforms): + base_event_dim += t.domain.event_dim - t.codomain.event_dim x = numpyro.sample("{}_base".format(name), - fn.base_dist.to_event(reinterpreted_batch_ndims).expand(batch_shape)) + self._wrap(fn.base_dist, batch_shape, base_event_dim)) # Differentiably transform. for t in fn.transforms: diff --git a/test/test_reparam.py b/test/test_reparam.py index a48be7898..5aaae6bb9 100644 --- a/test/test_reparam.py +++ b/test/test_reparam.py @@ -32,20 +32,22 @@ def get_moments(x): return jnp.stack([m1, m2, m3, m4]) -@pytest.mark.parametrize("shape", [(), (4,), (2, 3)], ids=str) -def test_log_normal(shape): +@pytest.mark.parametrize("batch_shape", [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("event_shape", [(), (5,)], ids=str) +def test_log_normal(batch_shape, event_shape): + shape = batch_shape + event_shape loc = np.random.rand(*shape) * 2 - 1 scale = np.random.rand(*shape) + 0.5 def model(): - with numpyro.plate_stack("plates", shape): + fn = dist.TransformedDistribution( + dist.Normal(jnp.zeros_like(loc), jnp.ones_like(scale)), + [AffineTransform(loc, scale), ExpTransform()]) + if event_shape: + fn = fn.to_event(len(event_shape)).expand_by([100000]) + with numpyro.plate_stack("plates", batch_shape): with numpyro.plate("particles", 100000): - return numpyro.sample("x", - dist.TransformedDistribution( - dist.Normal(jnp.zeros_like(loc), - jnp.ones_like(scale)), - [AffineTransform(loc, scale), - ExpTransform()]).expand_by([100000])) + return numpyro.sample("x", fn) with handlers.trace() as tr: value = handlers.seed(model, 0)() @@ -56,7 +58,7 @@ def model(): value = handlers.seed(model, 0)() assert tr["x"]["type"] == "deterministic" actual_moments = get_moments(jnp.log(value)) - assert_allclose(actual_moments, expected_moments, atol=0.05) + assert_allclose(actual_moments, expected_moments, atol=0.05, rtol=0.01) def neals_funnel(dim): From 2aabe8f38d5a9fee3913fa8d06d5086a685c6dde Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 24 Jan 2021 10:44:11 -0600 Subject: [PATCH 041/222] Enhance DiscreteHMCGibbs and HMCECS (#884) * support forward-mode differentiation * move einstein to contrib * revise Gibbs api * fix some bugs * also enable forward mode differentiation in HMCGibbs * fix failing tests --- numpyro/contrib/funsor/enum_messenger.py | 22 ++- numpyro/infer/hmc_gibbs.py | 169 ++++++++++++++--------- test/test_hmc_gibbs.py | 55 +++++--- 3 files changed, 160 insertions(+), 86 deletions(-) diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index 27fced6da..aa9eb900c 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -475,7 +475,27 @@ def process_message(self, msg): def postprocess_message(self, msg): if msg["type"] in ["to_funsor", "to_data"]: return super().postprocess_message(msg) - return OrigPlateMessenger.postprocess_message(self, msg) + # NB: copied literally from original plate messenger, with self._indices is replaced + # by self.indices + if msg["type"] in ("subsample", "param") and self.dim is not None: + event_dim = msg["kwargs"].get("event_dim") + if event_dim is not None: + assert event_dim >= 0 + dim = self.dim - event_dim + shape = jnp.shape(msg["value"]) + if len(shape) >= -dim and shape[dim] != 1: + if shape[dim] != self.size: + if msg["type"] == "param": + statement = "numpyro.param({}, ..., event_dim={})".format(msg["name"], event_dim) + else: + statement = "numpyro.subsample(..., event_dim={})".format(event_dim) + raise ValueError( + "Inside numpyro.plate({}, {}, dim={}) invalid shape of {}: {}" + .format(self.name, self.size, self.dim, statement, shape)) + if self.subsample_size < self.size: + value = msg["value"] + new_value = jnp.take(value, self.indices, dim) + msg["value"] = new_value class enum(BaseEnumMessenger): diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 040180101..69e2b917f 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -5,14 +5,13 @@ import copy from functools import partial -from jax import device_put, ops, random, value_and_grad +from jax import device_put, jacfwd, grad, ops, random, value_and_grad import jax.numpy as jnp from jax.scipy.special import expit from numpyro.handlers import condition, seed, substitute, trace from numpyro.infer.hmc import HMC from numpyro.infer.mcmc import MCMCKernel -from numpyro.infer.util import _guess_max_plate_nesting, log_likelihood, potential_energy from numpyro.util import cond, fori_loop, identity, ravel_pytree HMCGibbsState = namedtuple("HMCGibbsState", "z, hmc_state, rng_key") @@ -92,7 +91,6 @@ def __init__(self, inner_kernel, gibbs_fn, gibbs_sites): self.inner_kernel._model = _wrap_model(inner_kernel.model) self._gibbs_sites = gibbs_sites self._gibbs_fn = gibbs_fn - self._use_constrained_gibbs_fn = True self._prototype_trace = None @property @@ -143,12 +141,15 @@ def potential_fn(z_gibbs, z_hmc): z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} model_kwargs_ = model_kwargs.copy() model_kwargs_["_gibbs_sites"] = z_gibbs - if self._use_constrained_gibbs_fn: - z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs_)(z_hmc) + z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs_)(z_hmc) z_gibbs = self._gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc) - pe, z_grad = value_and_grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) + if self.inner_kernel._forward_mode_differentiation: + pe = potential_fn(z_gibbs, state.hmc_state.z) + z_grad = jacfwd(partial(potential_fn, z_gibbs))(state.hmc_state.z) + else: + pe, z_grad = value_and_grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) model_kwargs_["_gibbs_sites"] = z_gibbs @@ -245,40 +246,9 @@ def _discrete_modified_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, s return rng_key, z_new, pe_new, log_accept_ratio -def _discrete_gibbs_fn(wrapped_model, model_args, model_kwargs, prototype_trace, - random_walk=False, modified=False): - support_sizes = { - name: jnp.broadcast_to(site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"])) - for name, site in prototype_trace.items() - if site["type"] == "sample" and site["fn"].has_enumerate_support and not site["is_observed"] - } - max_plate_nesting = _guess_max_plate_nesting(prototype_trace) - if random_walk: - if modified: - proposal_fn = partial(_discrete_modified_rw_proposal, stay_prob=0.) - else: - proposal_fn = _discrete_rw_proposal - else: - if modified: - proposal_fn = partial(_discrete_modified_gibbs_proposal, stay_prob=0.) - else: - proposal_fn = _discrete_gibbs_proposal - - def gibbs_fn(rng_key, gibbs_sites, hmc_sites): - z_hmc = hmc_sites - use_enum = len(set(support_sizes) - set(gibbs_sites)) > 0 - if use_enum: - from numpyro.contrib.funsor import config_enumerate, enum - - wrapped_model_ = enum(config_enumerate(wrapped_model), -max_plate_nesting - 1) - else: - wrapped_model_ = wrapped_model - - def potential_fn(z_discrete): - model_kwargs_ = model_kwargs.copy() - model_kwargs_["_gibbs_sites"] = z_discrete - return potential_energy(wrapped_model_, model_args, model_kwargs_, z_hmc, enum=use_enum) +def _discrete_gibbs_fn(potential_fn, support_sizes, proposal_fn): + def gibbs_fn(rng_key, gibbs_sites, hmc_sites, pe): # get support_sizes of gibbs_sites support_sizes_flat, _ = ravel_pytree({k: support_sizes[k] for k in gibbs_sites}) num_discretes = support_sizes_flat.shape[0] @@ -291,7 +261,8 @@ def body_fn(i, val): support_size = support_sizes_flat[idx] rng_key, z, pe = val rng_key, z_new, pe_new, log_accept_ratio = proposal_fn( - rng_key, z, pe, potential_fn=potential_fn, idx=idx, support_size=support_size) + rng_key, z, pe, potential_fn=partial(potential_fn, z_hmc=hmc_sites), + idx=idx, support_size=support_size) rng_key, rng_accept = random.split(rng_key) # u ~ Uniform(0, 1), u < accept_ratio => -log(u) > -log_accept_ratio # and -log(u) ~ exponential(1) @@ -300,9 +271,9 @@ def body_fn(i, val): (z, pe), identity) return rng_key, z, pe - init_val = (rng_key, gibbs_sites, potential_fn(gibbs_sites)) - _, gibbs_sites, _ = fori_loop(0, num_discretes, body_fn, init_val) - return gibbs_sites + init_val = (rng_key, gibbs_sites, pe) + _, gibbs_sites, pe = fori_loop(0, num_discretes, body_fn, init_val) + return gibbs_sites, pe return gibbs_fn @@ -365,14 +336,27 @@ def __init__(self, inner_kernel, *, random_walk=False, modified=False): super().__init__(inner_kernel, lambda *args: None, None) self._random_walk = random_walk self._modified = modified - self._use_unconstrained_gibbs_fn = True + if random_walk: + if modified: + self._discrete_proposal_fn = partial(_discrete_modified_rw_proposal, stay_prob=0.) + else: + self._discrete_proposal_fn = _discrete_rw_proposal + else: + if modified: + self._discrete_proposal_fn = partial(_discrete_modified_gibbs_proposal, stay_prob=0.) + else: + self._discrete_proposal_fn = _discrete_gibbs_proposal def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() rng_key, key_u = random.split(rng_key) self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) - self._gibbs_fn = _discrete_gibbs_fn(self.model, model_args, model_kwargs, self._prototype_trace, - random_walk=self._random_walk, modified=self._modified) + + self._support_sizes = { + name: jnp.broadcast_to(site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"])) + for name, site in self._prototype_trace.items() + if site["type"] == "sample" and site["fn"].has_enumerate_support and not site["is_observed"] + } self._gibbs_sites = [name for name, site in self._prototype_trace.items() if site["type"] == "sample" and site["fn"].has_enumerate_support @@ -380,10 +364,42 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): and site["infer"].get("enumerate", "") != "parallel"] return super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) + def sample(self, state, model_args, model_kwargs): + model_kwargs = {} if model_kwargs is None else model_kwargs + rng_key, rng_gibbs = random.split(state.rng_key) + + def potential_fn(z_gibbs, z_hmc): + return self.inner_kernel._potential_fn_gen( + *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + + z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} + z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} + model_kwargs_ = model_kwargs.copy() + model_kwargs_["_gibbs_sites"] = z_gibbs -def _subsample_gibbs_fn(wrapped_model, model_args, model_kwargs, plate_sizes, num_blocks=1): + # different from the implementation in HMCGibbs.sample, we feed the current potential energy + # and get new potential energy from gibbs_fn + gibbs_fn = _discrete_gibbs_fn(potential_fn, self._support_sizes, self._discrete_proposal_fn) + z_gibbs, pe = gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc, + pe=state.hmc_state.potential_energy) - def gibbs_fn(rng_key, gibbs_sites, hmc_sites): + if self.inner_kernel._forward_mode_differentiation: + z_grad = jacfwd(partial(potential_fn, z_gibbs))(state.hmc_state.z) + else: + z_grad = grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) + hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) + + model_kwargs_["_gibbs_sites"] = z_gibbs + hmc_state = self.inner_kernel.sample(hmc_state, model_args, model_kwargs_) + + z = {**z_gibbs, **hmc_state.z} + + return HMCGibbsState(z, hmc_state, rng_key) + + +def _subsample_gibbs_fn(potential_fn, plate_sizes, num_blocks=1): + + def gibbs_fn(rng_key, gibbs_sites, hmc_sites, pe): assert set(gibbs_sites) == set(plate_sizes) u_new = {} for name in gibbs_sites: @@ -397,14 +413,13 @@ def gibbs_fn(rng_key, gibbs_sites, hmc_sites): u_new[name] = jnp.where(block_mask, new_idx, gibbs_sites[name]) - u_loglik = log_likelihood(wrapped_model, hmc_sites, *model_args, batch_ndims=0, - **model_kwargs, _gibbs_sites=gibbs_sites) - u_loglik = sum(v.sum() for v in u_loglik.values()) - u_new_loglik = log_likelihood(wrapped_model, hmc_sites, *model_args, batch_ndims=0, - **model_kwargs, _gibbs_sites=u_new) - u_new_loglik = sum(v.sum() for v in u_new_loglik.values()) - accept_prob = jnp.clip(jnp.exp(u_new_loglik - u_loglik), a_max=1.0) - return cond(random.bernoulli(rng_key, accept_prob), u_new, identity, gibbs_sites, identity) + # given a fixed hmc_sites, pe_new - pe_curr = loglik_new - loglik_curr + pe_new = potential_fn(u_new, hmc_sites) + accept_prob = jnp.clip(jnp.exp(pe - pe_new), a_max=1.0) + gibbs_sites, pe = cond(random.bernoulli(rng_key, accept_prob), + (u_new, pe_new), identity, + (gibbs_sites, pe), identity) + return gibbs_sites, pe return gibbs_fn @@ -469,18 +484,40 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() rng_key, key_u = random.split(rng_key) self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) - plate_sizes = { + self._plate_sizes = { name: site["args"] for name, site in self._prototype_trace.items() if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size } - self._gibbs_sites = list(plate_sizes.keys()) - - enum = any(site["type"] == "sample" - and not site["is_observed"] - and site["fn"].has_enumerate_support - for name, site in self._prototype_trace.items()) - assert not enum, "Enumeration is not supported for subsample_gibbs_fn." - self._gibbs_fn = _subsample_gibbs_fn(self.model, model_args, model_kwargs, plate_sizes, - num_blocks=self._num_blocks) + self._gibbs_sites = list(self._plate_sizes.keys()) return super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) + + def sample(self, state, model_args, model_kwargs): + model_kwargs = {} if model_kwargs is None else model_kwargs + rng_key, rng_gibbs = random.split(state.rng_key) + + def potential_fn(z_gibbs, z_hmc): + return self.inner_kernel._potential_fn_gen( + *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + + z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} + z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} + model_kwargs_ = model_kwargs.copy() + model_kwargs_["_gibbs_sites"] = z_gibbs + + gibbs_fn = _subsample_gibbs_fn(potential_fn, self._plate_sizes, self._num_blocks) + z_gibbs, pe = gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc, + pe=state.hmc_state.potential_energy) + + if self.inner_kernel._forward_mode_differentiation: + z_grad = jacfwd(partial(potential_fn, z_gibbs))(state.hmc_state.z) + else: + z_grad = grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) + hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) + + model_kwargs_["_gibbs_sites"] = z_gibbs + hmc_state = self.inner_kernel.sample(hmc_state, model_args, model_kwargs_) + + z = {**z_gibbs, **hmc_state.z} + + return HMCGibbsState(z, hmc_state, rng_key) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index 1a3490d69..9b0737599 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -100,25 +100,6 @@ def model(X, Y): assert_allclose(sigma_mean, sigma, atol=0.25) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) -@pytest.mark.parametrize('num_blocks', [1, 2, 50, 100]) -def test_subsample_gibbs_partitioning(kernel_cls, num_blocks): - def model(obs): - with plate('N', obs.shape[0], subsample_size=100) as idx: - numpyro.sample('x', dist.Normal(0, 1), obs=obs[idx]) - - obs = random.normal(random.PRNGKey(0), (10000,)) / 100 - kernel = HMCECS(kernel_cls(model), num_blocks=num_blocks) - hmc_state = kernel.init(random.PRNGKey(1), 10, None, model_args=(obs,), model_kwargs=None) - gibbs_sites = {'N': jnp.arange(100)} - - gibbs_fn = kernel._gibbs_fn - new_gibbs_sites = gibbs_fn(random.PRNGKey(2), gibbs_sites, hmc_state.z) # accept_prob > .999 - block_size = 100 // num_blocks - for name in gibbs_sites: - assert block_size == jnp.not_equal(gibbs_sites[name], new_gibbs_sites[name]).sum() - - @pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) def test_gaussian_model(kernel_cls, D=2, warmup_steps=3000, num_samples=5000): np.random.seed(0) @@ -223,3 +204,39 @@ def model(probs, locs): assert_allclose(jnp.var(samples["x"]), 4.36, atol=0.1) assert_allclose(jnp.mean(samples["c"]), 1.65, atol=0.1) assert_allclose(jnp.var(samples["c"]), 1.03, atol=0.1) + + +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +@pytest.mark.parametrize('num_blocks', [1, 2, 50, 100]) +def test_subsample_gibbs_partitioning(kernel_cls, num_blocks): + def model(obs): + with plate('N', obs.shape[0], subsample_size=100) as idx: + numpyro.sample('x', dist.Normal(0, 1), obs=obs[idx]) + + obs = random.normal(random.PRNGKey(0), (10000,)) / 100 + kernel = HMCECS(kernel_cls(model), num_blocks=num_blocks) + state = kernel.init(random.PRNGKey(1), 10, None, model_args=(obs,), model_kwargs=None) + gibbs_sites = {'N': jnp.arange(100)} + + def potential_fn(z_gibbs, z_hmc): + return kernel.inner_kernel._potential_fn_gen(obs, _gibbs_sites=z_gibbs)(z_hmc) + + gibbs_fn = numpyro.infer.hmc_gibbs._subsample_gibbs_fn(potential_fn, kernel._plate_sizes, num_blocks) + new_gibbs_sites, _ = gibbs_fn(random.PRNGKey(2), gibbs_sites, state.hmc_state.z, + state.hmc_state.potential_energy) # accept_prob > .999 + block_size = 100 // num_blocks + for name in gibbs_sites: + assert block_size == jnp.not_equal(gibbs_sites[name], new_gibbs_sites[name]).sum() + + +def test_enum_subsample_smoke(): + def model(data): + x = numpyro.sample("x", dist.Bernoulli(0.5)) + with numpyro.plate("N", data.shape[0], subsample_size=100, dim=-1): + batch = numpyro.subsample(data, event_dim=0) + numpyro.sample("obs", dist.Normal(x, 1), obs=batch) + + data = random.normal(random.PRNGKey(0), (10000,)) + 1 + kernel = HMCECS(NUTS(model), num_blocks=10) + mcmc = MCMC(kernel, 10, 10) + mcmc.run(random.PRNGKey(0), data) From f052ea67700b23cdf4c919f3120bfdc3e8e6172b Mon Sep 17 00:00:00 2001 From: loopylangur <43548542+loopylangur@users.noreply.github.com> Date: Sun, 24 Jan 2021 10:59:09 -0600 Subject: [PATCH 042/222] optimized test (#890) --- test/test_mcmc.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_mcmc.py b/test/test_mcmc.py index 0e8aaf730..1a667337c 100644 --- a/test/test_mcmc.py +++ b/test/test_mcmc.py @@ -484,7 +484,7 @@ def model(): @pytest.mark.parametrize('algo', ['HMC', 'NUTS']) def test_functional_beta_bernoulli_x64(algo): - warmup_steps, num_samples = 500, 20000 + warmup_steps, num_samples = 410, 100 def model(data): alpha = jnp.array([1.1, 1.1]) From 6a1f5226f180aa708aaf842de777b153a3f99bea Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 24 Jan 2021 14:31:24 -0600 Subject: [PATCH 043/222] Bump to version 0.5.0 (#888) * Support .to_event() in TransformReparam * Strengthen test * add forward shape for transforms * add forward shapes and tests * simplify nested independent Constraint * shape check for affine transform * add missing commit * Bump to version 0.5.0 * fix tests, addresses comments * port some fixes from hmcgibbs PR * pin to specific version * run isort Co-authored-by: Fritz Obermeyer --- examples/annotation.py | 2 +- examples/baseball.py | 2 +- examples/bnn.py | 2 +- examples/covtype.py | 2 +- examples/funnel.py | 2 +- examples/gp.py | 2 +- examples/hmm.py | 2 +- examples/minipyro.py | 2 +- examples/neutra.py | 2 +- examples/ode.py | 2 +- examples/proportion_test.py | 2 +- examples/sparse_regression.py | 2 +- examples/stochastic_volatility.py | 2 +- examples/ucbadmit.py | 2 +- examples/vae.py | 2 +- notebooks/source/bayesian_imputation.ipynb | 2 +- notebooks/source/bayesian_regression.ipynb | 2 +- notebooks/source/logistic_regression.ipynb | 2 +- notebooks/source/ordinal_regression.ipynb | 2 +- notebooks/source/time_series_forecasting.ipynb | 2 +- numpyro/contrib/einstein/kernels.py | 2 +- numpyro/infer/hmc_gibbs.py | 2 +- numpyro/infer/hmc_util.py | 2 +- numpyro/infer/reparam.py | 2 +- numpyro/version.py | 2 +- setup.py | 4 ++-- 26 files changed, 27 insertions(+), 27 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index f820dd8a4..7c9cd6ef4 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -266,7 +266,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.4.1") + assert numpyro.__version__.startswith("0.5.0") parser = argparse.ArgumentParser(description="Bayesian Models of Annotation") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/baseball.py b/examples/baseball.py index de6a52293..9be4206c6 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -196,7 +196,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="Baseball batting average using MCMC") parser.add_argument("-n", "--num-samples", nargs="?", default=3000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1500, type=int) diff --git a/examples/bnn.py b/examples/bnn.py index dd2b806dd..08b68407c 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -138,7 +138,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="Bayesian neural network example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) diff --git a/examples/covtype.py b/examples/covtype.py index fdac66a04..1dcff36e7 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -58,7 +58,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="parse args") parser.add_argument('-n', '--num-samples', default=100, type=int, help='number of samples') parser.add_argument('--num-steps', default=10, type=int, help='number of steps (for "HMC")') diff --git a/examples/funnel.py b/examples/funnel.py index 860950f34..16305aa7c 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -87,7 +87,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="Non-centered reparameterization example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) diff --git a/examples/gp.py b/examples/gp.py index f7c897bcb..bccf22a3d 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -142,7 +142,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) diff --git a/examples/hmm.py b/examples/hmm.py index b51708f22..c07e15fcf 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -191,7 +191,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description='Semi-supervised Hidden Markov Model') parser.add_argument('--num-categories', default=3, type=int) parser.add_argument('--num-words', default=10, type=int) diff --git a/examples/minipyro.py b/examples/minipyro.py index d6652ce06..f59abd2c8 100644 --- a/examples/minipyro.py +++ b/examples/minipyro.py @@ -58,7 +58,7 @@ def body_fn(i, val): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="Mini Pyro demo") parser.add_argument("-f", "--full-pyro", action="store_true", default=False) parser.add_argument("-n", "--num-steps", default=1001, type=int) diff --git a/examples/neutra.py b/examples/neutra.py index fc90c0a82..54d76d644 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -146,7 +146,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="NeuTra HMC") parser.add_argument('-n', '--num-samples', nargs='?', default=4000, type=int) parser.add_argument('--num-warmup', nargs='?', default=1000, type=int) diff --git a/examples/ode.py b/examples/ode.py index 8f7c35477..df06a84a7 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -103,7 +103,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description='Predator-Prey Model') parser.add_argument('-n', '--num-samples', nargs='?', default=1000, type=int) parser.add_argument('--num-warmup', nargs='?', default=1000, type=int) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index 6964bc1b2..3e6e0f5a7 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -128,7 +128,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description='Testing whether ') parser.add_argument('-n', '--num-samples', nargs='?', default=500, type=int) parser.add_argument('--num-warmup', nargs='?', default=1500, type=int) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index a7bd8563d..a91c27297 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -320,7 +320,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs='?', default=500, type=int) diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index 95315d273..fb480c325 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -112,7 +112,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="Stochastic Volatility Model") parser.add_argument('-n', '--num-samples', nargs='?', default=600, type=int) parser.add_argument('--num-warmup', nargs='?', default=600, type=int) diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index 3daa72da8..a7fdff6ec 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -131,7 +131,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description='UCBadmit gender discrimination using HMC') parser.add_argument('-n', '--num-samples', nargs='?', default=2000, type=int) parser.add_argument('--num-warmup', nargs='?', default=500, type=int) diff --git a/examples/vae.py b/examples/vae.py index 37d5d3e29..3935fbf3e 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -131,7 +131,7 @@ def reconstruct_img(epoch, rng_key): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.4.1') + assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="parse args") parser.add_argument('-n', '--num-epochs', default=15, type=int, help='number of training epochs') parser.add_argument('-lr', '--learning-rate', default=1.0e-3, type=float, help='learning rate') diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index 498af5b80..3498618ec 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -46,7 +46,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith(\"0.4.1\")" + "assert numpyro.__version__.startswith(\"0.5.0\")" ] }, { diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 2c1af08f8..329fa6801 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -66,7 +66,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats('svg')\n", "\n", - "assert numpyro.__version__.startswith('0.4.1')" + "assert numpyro.__version__.startswith('0.5.0')" ] }, { diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index 042034459..901a0da06 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -31,7 +31,7 @@ "import numpyro.distributions as dist\n", "from numpyro.examples.datasets import COVTYPE, load_dataset\n", "from numpyro.infer import HMC, MCMC, NUTS\n", - "assert numpyro.__version__.startswith('0.4.1')\n", + "assert numpyro.__version__.startswith('0.5.0')\n", "\n", "# NB: replace gpu by cpu to run this notebook in cpu\n", "numpyro.set_platform(\"gpu\")" diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 9aacc7049..8b1ac5b74 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -30,7 +30,7 @@ "from numpyro.infer import MCMC, NUTS\n", "import pandas as pd\n", "import seaborn as sns\n", - "assert numpyro.__version__.startswith('0.4.1')" + "assert numpyro.__version__.startswith('0.5.0')" ] }, { diff --git a/notebooks/source/time_series_forecasting.ipynb b/notebooks/source/time_series_forecasting.ipynb index 589daf4be..5fd18d541 100644 --- a/notebooks/source/time_series_forecasting.ipynb +++ b/notebooks/source/time_series_forecasting.ipynb @@ -39,7 +39,7 @@ " set_matplotlib_formats(\"svg\")\n", "\n", "numpyro.set_host_device_count(4)\n", - "assert numpyro.__version__.startswith(\"0.4.1\")" + "assert numpyro.__version__.startswith(\"0.5.0\")" ] }, { diff --git a/numpyro/contrib/einstein/kernels.py b/numpyro/contrib/einstein/kernels.py index a0b002aa1..d14261fe2 100644 --- a/numpyro/contrib/einstein/kernels.py +++ b/numpyro/contrib/einstein/kernels.py @@ -11,8 +11,8 @@ import jax.scipy.linalg import jax.scipy.stats -import numpyro.distributions as dist from numpyro.contrib.einstein.utils import posdef, safe_norm, sqrth +import numpyro.distributions as dist class PrecondMatrix(ABC): diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 69e2b917f..89f1c89d3 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -5,7 +5,7 @@ import copy from functools import partial -from jax import device_put, jacfwd, grad, ops, random, value_and_grad +from jax import device_put, grad, jacfwd, ops, random, value_and_grad import jax.numpy as jnp from jax.scipy.special import expit diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 315cf3f65..a97b33fc6 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -3,7 +3,7 @@ from collections import namedtuple -from jax import jacfwd, grad, random, value_and_grad, vmap +from jax import grad, jacfwd, random, value_and_grad, vmap from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.ops import index_update diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index c5623696b..05c5573d8 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -3,8 +3,8 @@ from abc import ABC, abstractmethod -import jax.numpy as jnp from jax import lax +import jax.numpy as jnp import numpyro import numpyro.distributions as dist diff --git a/numpyro/version.py b/numpyro/version.py index c8e4064aa..f86a79a48 100644 --- a/numpyro/version.py +++ b/numpyro/version.py @@ -1,4 +1,4 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -__version__ = '0.4.1' +__version__ = '0.5.0' diff --git a/setup.py b/setup.py index 4f19b3179..bd20fd1b0 100644 --- a/setup.py +++ b/setup.py @@ -33,9 +33,9 @@ author='Uber AI Labs', install_requires=[ # TODO: pin to a specific version for the release (until JAX's API becomes stable) - 'jax>=0.2.7', + 'jax==0.2.8', # check min version here: https://github.com/google/jax/blob/master/jax/lib/__init__.py#L26 - 'jaxlib>=0.1.56', + 'jaxlib==0.1.59', 'tqdm', ], extras_require={ From c3f2d86ad674136c020e784edf0a61faaa5c7039 Mon Sep 17 00:00:00 2001 From: Dominik Straub Date: Mon, 25 Jan 2021 21:44:33 +0100 Subject: [PATCH 044/222] Fix missing infer key in handlers.lift (#892) * Fix missing infer key * Add test for lifted model * Add test for lifted model * Add test for lifted model * Add test for lifted model * Fix commits Co-authored-by: Dominik Straub --- numpyro/handlers.py | 1 + test/test_mcmc.py | 11 +++++++++++ 2 files changed, 12 insertions(+) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index b03b6c4f5..d97c96f95 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -447,6 +447,7 @@ def process_message(self, msg): msg["kwargs"] = {"rng_key": msg["kwargs"].get("rng_key", None), "sample_shape": msg["kwargs"].get("sample_shape", ())} msg["intermediates"] = [] + msg["infer"] = msg.get("infer", {}) else: # otherwise leave as is return diff --git a/test/test_mcmc.py b/test/test_mcmc.py index 1a667337c..ea955b705 100644 --- a/test/test_mcmc.py +++ b/test/test_mcmc.py @@ -681,3 +681,14 @@ def model(): # this fails in reverse mode mcmc = MCMC(NUTS(model, forward_mode_differentiation=True), 10, 10) mcmc.run(random.PRNGKey(0)) + + +def test_model_with_lift_handler(): + def model(data): + c = numpyro.param("c", jnp.array(1.), constraint=dist.constraints.positive) + x = numpyro.sample("x", dist.LogNormal(c, 1.), obs=data) + return x + + nuts_kernel = NUTS(numpyro.handlers.lift(model, prior={"c": dist.Gamma(0.01, 0.01)})) + mcmc = MCMC(nuts_kernel, num_warmup=10, num_samples=10) + mcmc.run(random.PRNGKey(1), jnp.exp(random.normal(random.PRNGKey(0), (1000,)))) From 16edc9f6e5bdfe36c8e2d3b9ff0571186b537e02 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 26 Jan 2021 17:25:58 -0600 Subject: [PATCH 045/222] Move the warning of using the sequential chain method to the constructor (#893) --- numpyro/infer/mcmc.py | 39 ++++++++++++++++----------------------- 1 file changed, 16 insertions(+), 23 deletions(-) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 9d8beda50..836b1c6d4 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -7,10 +7,9 @@ import os import warnings -from jax import device_put, jit, lax, pmap, random, vmap +from jax import jit, lax, local_device_count, pmap, random, vmap from jax.core import Tracer from jax.interpreters.xla import DeviceArray -from jax.lib import xla_bridge import jax.numpy as jnp from jax.tree_util import tree_flatten, tree_map, tree_multimap @@ -211,9 +210,9 @@ class MCMC(object): :param int thinning: Positive integer that controls the fraction of post-warmup samples that are retained. For example if thinning is 2 then every other sample is retained. Defaults to 1, i.e. no thinning. - :param int num_chains: Number of Number of MCMC chains to run. By default, - chains will be run in parallel using :func:`jax.pmap`, failing which, - chains will be run in sequence. + :param int num_chains: Number of MCMC chains to run. By default, chains will be + run in parallel using :func:`jax.pmap`. If there are not enough devices + available, chains will be run in sequence. :param postprocess_fn: Post-processing callable - used to convert a collection of unconstrained sample values returned from the sampler to constrained values that lie within the support of the sample sites. Additionally, this is used to return values at deterministic sites in @@ -252,6 +251,14 @@ def __init__(self, if chain_method not in ['parallel', 'vectorized', 'sequential']: raise ValueError('Only supporting the following methods to draw chains:' ' "sequential", "parallel", or "vectorized"') + if chain_method == 'parallel' and local_device_count() < self.num_chains: + chain_method = 'sequential' + warnings.warn('There are not enough devices to run parallel chains: expected {} but got {}.' + ' Chains will be drawn sequentially. If you are running MCMC in CPU,' + ' consider using `numpyro.set_host_device_count({})` at the beginning' + ' of your program. You can double-check how many devices are available in' + ' your system using `jax.local_device_count()`.' + .format(self.num_chains, local_device_count(), self.num_chains)) self.chain_method = chain_method self.progress_bar = progress_bar # TODO: We should have progress bars (maybe without diagnostics) for num_chains > 1 @@ -473,15 +480,6 @@ def run(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): self._set_collection_params(0, self.num_samples, self.num_samples, "sample") init_state = self._warmup_state._replace(rng_key=rng_key) - chain_method = self.chain_method - if chain_method == 'parallel' and xla_bridge.device_count() < self.num_chains: - chain_method = 'sequential' - warnings.warn('There are not enough devices to run parallel chains: expected {} but got {}.' - ' Chains will be drawn sequentially. If you are running MCMC in CPU,' - ' consider to use `numpyro.set_host_device_count({})` at the beginning' - ' of your program.' - .format(self.num_chains, xla_bridge.device_count(), self.num_chains)) - if init_params is not None and self.num_chains > 1: prototype_init_val = tree_flatten(init_params)[0][0] if jnp.shape(prototype_init_val)[0] != self.num_chains: @@ -499,17 +497,12 @@ def run(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): states_flat, last_state = partial_map_fn(map_args) states = tree_map(lambda x: x[jnp.newaxis, ...], states_flat) else: - if chain_method == 'sequential': - if self.progress_bar: - states, last_state = _laxmap(partial_map_fn, map_args) - else: - states, last_state = lax.map(partial_map_fn, map_args) - elif chain_method == 'parallel': + if self.chain_method == 'sequential': + states, last_state = _laxmap(partial_map_fn, map_args) + elif self.chain_method == 'parallel': states, last_state = pmap(partial_map_fn)(map_args) - # TODO: remove when https://github.com/google/jax/issues/3597 is resolved - states = device_put(states) else: - assert chain_method == 'vectorized' + assert self.chain_method == 'vectorized' states, last_state = partial_map_fn(map_args) # swap num_samples x num_chains to num_chains x num_samples states = tree_map(lambda x: jnp.swapaxes(x, 0, 1), states) From 13c76dcedf9689507b23228b6bbe92a62bdb3a91 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Tue, 2 Feb 2021 11:10:52 -0500 Subject: [PATCH 046/222] Add Distribution.infer_shapes() for static shape analysis (#901) * Add Distribution.infer_shapes() for static shape analysis * Attempt to fix lint * Fix Dirichlet.arg_constraints * Fix LogNormal.support * Remove FIXMEs about expansion * Fix Uniform and OrderedLogistic * Avoid deprecation warning * Reorder pytest params --- Makefile | 3 ++ numpyro/distributions/conjugate.py | 12 ++++-- numpyro/distributions/constraints.py | 56 +++++++++++++++++++++++- numpyro/distributions/continuous.py | 38 +++++++++++++--- numpyro/distributions/discrete.py | 38 +++++++++++----- numpyro/distributions/distribution.py | 62 ++++++++++++++++++++++----- test/test_distributions.py | 17 ++++++++ 7 files changed, 197 insertions(+), 29 deletions(-) diff --git a/Makefile b/Makefile index d7367fe3b..af7088bf5 100644 --- a/Makefile +++ b/Makefile @@ -6,6 +6,9 @@ lint: FORCE format: FORCE isort -rc . +install: FORCE + pip install -e .[dev,doc,test,examples] + doctest: FORCE $(MAKE) -C docs doctest diff --git a/numpyro/distributions/conjugate.py b/numpyro/distributions/conjugate.py index ef9645da4..6771942d9 100644 --- a/numpyro/distributions/conjugate.py +++ b/numpyro/distributions/conjugate.py @@ -67,7 +67,7 @@ def mean(self): def variance(self): return self._beta.variance * self.total_count * (self.concentration0 + self.concentration1 + self.total_count) - @property + @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): return constraints.integer_interval(0, self.total_count) @@ -84,7 +84,7 @@ class DirichletMultinomial(Distribution): Dirichlet distribution. :param numpy.ndarray total_count: number of Categorical trials. """ - arg_constraints = {'concentration': constraints.positive, + arg_constraints = {'concentration': constraints.independent(constraints.positive, 1), 'total_count': constraints.nonnegative_integer} is_discrete = True @@ -125,10 +125,16 @@ def variance(self): alpha_ratio = alpha / alpha_sum return n * alpha_ratio * (1 - alpha_ratio) * (n + alpha_sum) / (1 + alpha_sum) - @property + @constraints.dependent_property(is_discrete=True, event_dim=1) def support(self): return constraints.multinomial(self.total_count) + @staticmethod + def infer_shapes(concentration, total_count=()): + batch_shape = lax.broadcast_shapes(concentration[:-1], total_count) + event_shape = concentration[-1:] + return batch_shape, event_shape + class GammaPoisson(Distribution): r""" diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 6f3138d17..5f9314a25 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -123,8 +123,62 @@ def feasible_like(self, prototype): class _Dependent(Constraint): + """ + Placeholder for variables whose support depends on other variables. + These variables obey no simple coordinate-wise constraints. + + :param bool is_discrete: Optional value of ``.is_discrete`` in case this + can be computed statically. If not provided, access to the + ``.is_discrete`` attribute will raise a NotImplementedError. + :param int event_dim: Optional value of ``.event_dim`` in case this can be + computed statically. If not provided, access to the ``.event_dim`` + attribute will raise a NotImplementedError. + """ + def __init__(self, *, is_discrete=NotImplemented, event_dim=NotImplemented): + self._is_discrete = is_discrete + self._event_dim = event_dim + super().__init__() + + @property + def is_discrete(self): + if self._is_discrete is NotImplemented: + raise NotImplementedError(".is_discrete cannot be determined statically") + return self._is_discrete + + @property + def event_dim(self): + if self._event_dim is NotImplemented: + raise NotImplementedError(".event_dim cannot be determined statically") + return self._event_dim + + def __call__(self, x=None, *, is_discrete=NotImplemented, event_dim=NotImplemented): + if x is not None: + raise ValueError('Cannot determine validity of dependent constraint') + + # Support for syntax to customize static attributes:: + # constraints.dependent(is_discrete=True, event_dim=1) + if is_discrete is NotImplemented: + is_discrete = self._is_discrete + if event_dim is NotImplemented: + event_dim = self._event_dim + return _Dependent(is_discrete=is_discrete, event_dim=event_dim) + + +class dependent_property(property, _Dependent): + def __init__(self, fn=None, *, is_discrete=NotImplemented, event_dim=NotImplemented): + super().__init__(fn) + self._is_discrete = is_discrete + self._event_dim = event_dim + def __call__(self, x): - raise ValueError('Cannot determine validity of dependent constraint') + if not callable(x): + return super().__call__(x) + + # Support for syntax to customize static attributes:: + # @constraints.dependent_property(is_discrete=True, event_dim=1) + # def support(self): + # ... + return dependent_property(x, is_discrete=self._is_discrete, event_dim=self._event_dim) def is_dependent(constraint): diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index c08a89cde..3f6dbc5dc 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -111,7 +111,7 @@ def variance(self): class Dirichlet(Distribution): - arg_constraints = {'concentration': constraints.positive} + arg_constraints = {'concentration': constraints.independent(constraints.positive, 1)} reparametrized_params = ['concentration'] support = constraints.simplex @@ -146,6 +146,12 @@ def variance(self): con0 = jnp.sum(self.concentration, axis=-1, keepdims=True) return self.concentration * (con0 - self.concentration) / (con0 ** 2 * (con0 + 1)) + @staticmethod + def infer_shapes(concentration): + batch_shape = concentration[:-1] + event_shape = concentration[-1:] + return batch_shape, event_shape + class Exponential(Distribution): reparametrized_params = ['rate'] @@ -633,6 +639,7 @@ def tree_unflatten(cls, aux_data, params): class LogNormal(TransformedDistribution): arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + support = constraints.positive reparametrized_params = ['loc', 'scale'] def __init__(self, loc=0., scale=1., validate_args=None): @@ -766,6 +773,15 @@ def tree_unflatten(cls, aux_data, params): loc, scale_tril = params return cls(loc, scale_tril=scale_tril) + @staticmethod + def infer_shapes(loc=(), covariance_matrix=None, precision_matrix=None, scale_tril=None): + batch_shape, event_shape = loc[:-1], loc[-1:] + for matrix in [covariance_matrix, precision_matrix, scale_tril]: + if matrix is not None: + batch_shape = lax.broadcast_shapes(batch_shape, matrix[:-2]) + event_shape = lax.broadcast_shapes(event_shape, matrix[-1:]) + return batch_shape, event_shape + def _batch_mv(bmat, bvec): r""" @@ -922,6 +938,12 @@ def entropy(self): H = 0.5 * (self.loc.shape[-1] * (1.0 + jnp.log(2 * jnp.pi)) + log_det) return jnp.broadcast_to(H, self.batch_shape) + @staticmethod + def infer_shapes(loc, cov_factor, cov_diag): + event_shape = loc[-1:] + batch_shape = lax.broadcast_shapes(loc[:-1], cov_factor[:-2], cov_diag[:-1]) + return batch_shape, event_shape + class Normal(Distribution): arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} @@ -981,7 +1003,7 @@ def variance(self): return jnp.where(self.alpha <= 2, jnp.inf, a) # override the default behaviour to save computations - @property + @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return constraints.greater_than(self.scale) @@ -1069,7 +1091,7 @@ def __init__(self, low=0., loc=0., scale=1., validate_args=None): super(TruncatedCauchy, self).__init__(base_dist, AffineTransform(low, scale), validate_args=validate_args) - @property + @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return self._support @@ -1139,7 +1161,7 @@ def __init__(self, low=0., loc=0., scale=1., validate_args=None): super(TruncatedNormal, self).__init__(base_dist, AffineTransform(low, scale), validate_args=validate_args) - @property + @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return self._support @@ -1196,7 +1218,7 @@ def __init__(self, low=0., high=1., validate_args=None): self._support = constraints.interval(low, high) super(Uniform, self).__init__(base_dist, AffineTransform(low, high - low), validate_args=validate_args) - @property + @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return self._support @@ -1223,6 +1245,12 @@ def tree_unflatten(cls, aux_data, params): d._support = constraints.interval(*aux_data) return d + @staticmethod + def infer_shapes(low=(), high=()): + batch_shape = lax.broadcast_shapes(low, high) + event_shape = () + return batch_shape, event_shape + class Logistic(Distribution): arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 90a6f137f..50790c14f 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -190,7 +190,7 @@ def mean(self): def variance(self): return jnp.broadcast_to(self.total_count * self.probs * (1 - self.probs), self.batch_shape) - @property + @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): return constraints.integer_interval(0, self.total_count) @@ -247,7 +247,7 @@ def mean(self): def variance(self): return jnp.broadcast_to(self.total_count * self.probs * (1 - self.probs), self.batch_shape) - @property + @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): return constraints.integer_interval(0, self.total_count) @@ -298,7 +298,7 @@ def mean(self): def variance(self): return jnp.full(self.batch_shape, jnp.nan, dtype=get_dtype(self.probs)) - @property + @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): return constraints.integer_interval(0, jnp.shape(self.probs)[-1] - 1) @@ -346,7 +346,7 @@ def mean(self): def variance(self): return jnp.full(self.batch_shape, jnp.nan, dtype=get_dtype(self.logits)) - @property + @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): return constraints.integer_interval(0, jnp.shape(self.logits)[-1] - 1) @@ -396,6 +396,12 @@ def __init__(self, predictor, cutpoints, validate_args=None): probs = cumulative_probs[..., 1:] - cumulative_probs[..., :-1] super(OrderedLogistic, self).__init__(probs, validate_args=validate_args) + @staticmethod + def infer_shapes(predictor, cutpoints): + batch_shape = lax.broadcast_shapes(predictor, cutpoints[:-1]) + event_shape = () + return batch_shape, event_shape + class PRNGIdentity(Distribution): """ @@ -424,11 +430,11 @@ class MultinomialProbs(Distribution): def __init__(self, probs, total_count=1, validate_args=None): if jnp.ndim(probs) < 1: raise ValueError("`probs` parameter must be at least one-dimensional.") - batch_shape = lax.broadcast_shapes(jnp.shape(probs)[:-1], jnp.shape(total_count)) + batch_shape, event_shape = self.infer_shapes(jnp.shape(probs), jnp.shape(total_count)) self.probs = promote_shapes(probs, shape=batch_shape + jnp.shape(probs)[-1:])[0] self.total_count = promote_shapes(total_count, shape=batch_shape)[0] super(MultinomialProbs, self).__init__(batch_shape=batch_shape, - event_shape=jnp.shape(self.probs)[-1:], + event_shape=event_shape, validate_args=validate_args) def sample(self, key, sample_shape=()): @@ -454,10 +460,16 @@ def mean(self): def variance(self): return jnp.expand_dims(self.total_count, -1) * self.probs * (1 - self.probs) - @property + @constraints.dependent_property(is_discrete=True, event_dim=1) def support(self): return constraints.multinomial(self.total_count) + @staticmethod + def infer_shapes(probs, total_count): + batch_shape = lax.broadcast_shapes(probs[:-1], total_count) + event_shape = probs[-1:] + return batch_shape, event_shape + class MultinomialLogits(Distribution): arg_constraints = {'logits': constraints.real_vector, @@ -467,11 +479,11 @@ class MultinomialLogits(Distribution): def __init__(self, logits, total_count=1, validate_args=None): if jnp.ndim(logits) < 1: raise ValueError("`logits` parameter must be at least one-dimensional.") - batch_shape = lax.broadcast_shapes(jnp.shape(logits)[:-1], jnp.shape(total_count)) + batch_shape, event_shape = self.infer_shapes(jnp.shape(logits), jnp.shape(total_count)) self.logits = promote_shapes(logits, shape=batch_shape + jnp.shape(logits)[-1:])[0] self.total_count = promote_shapes(total_count, shape=batch_shape)[0] super(MultinomialLogits, self).__init__(batch_shape=batch_shape, - event_shape=jnp.shape(self.logits)[-1:], + event_shape=event_shape, validate_args=validate_args) def sample(self, key, sample_shape=()): @@ -498,10 +510,16 @@ def mean(self): def variance(self): return jnp.expand_dims(self.total_count, -1) * self.probs * (1 - self.probs) - @property + @constraints.dependent_property(is_discrete=True, event_dim=1) def support(self): return constraints.multinomial(self.total_count) + @staticmethod + def infer_shapes(logits, total_count): + batch_shape = lax.broadcast_shapes(logits[:-1], total_count) + event_shape = logits[-1:] + return batch_shape, event_shape + def Multinomial(total_count=1, probs=None, logits=None, validate_args=None): if probs is not None: diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index b59920454..4ab863576 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -28,6 +28,7 @@ from collections import OrderedDict from contextlib import contextmanager import functools +import inspect import warnings import numpy as np @@ -35,11 +36,12 @@ from jax import lax, tree_util import jax.numpy as jnp -from numpyro.distributions.constraints import independent, is_dependent, real from numpyro.distributions.transforms import ComposeTransform, Transform from numpyro.distributions.util import lazy_property, promote_shapes, sum_rightmost, validate_sample from numpyro.util import not_jax_tracer +from . import constraints + _VALIDATION_ENABLED = False @@ -155,7 +157,7 @@ def __init__(self, batch_shape=(), event_shape=(), validate_args=None): for param, constraint in self.arg_constraints.items(): if param not in self.__dict__ and isinstance(getattr(type(self), param), lazy_property): continue - if is_dependent(constraint): + if constraints.is_dependent(constraint): continue # skip constraints that cannot be checked is_valid = constraint(getattr(self, param)) if not_jax_tracer(is_valid): @@ -351,6 +353,44 @@ def mask(self, mask): return self return MaskedDistribution(self, mask) + @classmethod + def infer_shapes(cls, *args, **kwargs): + r""" + Infers ``batch_shape`` and ``event_shape`` given shapes of args to + :meth:`__init__`. + + .. note:: This assumes distribution shape depends only on the shapes + of tensor inputs, not in the data contained in those inputs. + + :param \*args: Positional args replacing each input arg with a + tuple representing the sizes of each tensor input. + :param \*\*kwargs: Keywords mapping name of input arg to tuple + representing the sizes of each tensor input. + :returns: A pair ``(batch_shape, event_shape)`` of the shapes of a + distribution that would be created with input args of the given + shapes. + :rtype: tuple + """ + if cls.support.event_dim > 0: + raise NotImplementedError + + # Convert args to kwargs. + try: + arg_names = cls._arg_names + except AttributeError: + sig = inspect.signature(cls.__init__) + arg_names = cls._arg_names = tuple(sig.parameters)[1:] + kwargs.update(zip(arg_names, args)) + + # Assumes distribution is univariate. + batch_shapes = [] + for name, shape in kwargs.items(): + event_dim = cls.arg_constraints.get(name, constraints.real).event_dim + batch_shapes.append(shape[:len(shape) - event_dim]) + batch_shape = lax.broadcast_shapes(*batch_shapes) if batch_shapes else () + event_shape = () + return batch_shape, event_shape + class ExpandedDistribution(Distribution): arg_constraints = {} @@ -516,9 +556,10 @@ class ImproperUniform(Distribution): :param tuple event_shape: event shape of this distribution. """ arg_constraints = {} + support = constraints.dependent def __init__(self, support, batch_shape, event_shape, validate_args=None): - self.support = independent(support, len(event_shape) - support.event_dim) + self.support = constraints.independent(support, len(event_shape) - support.event_dim) super().__init__(batch_shape, event_shape, validate_args=validate_args) @validate_sample @@ -582,7 +623,7 @@ def __init__(self, base_dist, reinterpreted_batch_ndims, validate_args=None): @property def support(self): - return independent(self.base_dist.support, self.reinterpreted_batch_ndims) + return constraints.independent(self.base_dist.support, self.reinterpreted_batch_ndims) @property def has_enumerate_support(self): @@ -797,7 +838,7 @@ def support(self): if self.event_dim == codomain_event_dim: return codomain else: - return independent(codomain, self.event_dim - codomain_event_dim) + return constraints.independent(codomain, self.event_dim - codomain_event_dim) def sample(self, key, sample_shape=()): x = self.base_dist(rng_key=key, sample_shape=sample_shape) @@ -853,7 +894,8 @@ def tree_flatten(self): class Delta(Distribution): - arg_constraints = {'v': real, 'log_density': real} + # FIXME v and log_density should be constraints.independent(constraints.real, ???) + arg_constraints = {'v': constraints.real, 'log_density': constraints.real} reparameterized_params = ['v', 'log_density'] is_discrete = True @@ -869,9 +911,9 @@ def __init__(self, v=0., log_density=0., event_dim=0, validate_args=None): self.log_density = promote_shapes(log_density, shape=batch_shape)[0] super(Delta, self).__init__(batch_shape, event_shape, validate_args=validate_args) - @property + @constraints.dependent_property(is_discrete=True) def support(self): - return independent(real, self.event_dim) + return constraints.independent(constraints.real, self.event_dim) def sample(self, key, sample_shape=()): shape = sample_shape + self.batch_shape + self.event_shape @@ -907,8 +949,8 @@ class Unit(Distribution): This is used for :func:`numpyro.factor` statements. """ - arg_constraints = {'log_factor': real} - support = real + arg_constraints = {'log_factor': constraints.real} + support = constraints.real def __init__(self, log_factor, validate_args=None): batch_shape = jnp.shape(log_factor) diff --git a/test/test_distributions.py b/test/test_distributions.py index 4e40d27d7..d29a8a167 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -335,6 +335,23 @@ def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): assert_allclose(jax_dist.precision_matrix, jnp.linalg.inv(jax_dist.covariance_matrix), rtol=1e-6) +@pytest.mark.parametrize('prepend_shape', [ + (), + (2,), + (2, 3), +], ids=str) +@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) +def test_infer_shapes(jax_dist, sp_dist, params, prepend_shape): + shapes = tuple(getattr(p, "shape", ()) for p in params) + try: + expected_batch_shape, expected_event_shape = jax_dist.infer_shapes(*shapes) + except NotImplementedError: + pytest.skip(f'{jax_dist.__name__}.infer_shapes() is not implemented') + jax_dist = jax_dist(*params) + assert jax_dist.batch_shape == expected_batch_shape + assert jax_dist.event_shape == expected_event_shape + + @pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) def test_has_rsample(jax_dist, sp_dist, params): jax_dist = jax_dist(*params) From 08ae3816f841c1255e3e7072d41738aab295bcba Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 2 Feb 2021 23:52:42 -0600 Subject: [PATCH 047/222] Fix Delta.arg_constraints["v"] (#902) Co-authored-by: Fritz Obermeyer --- numpyro/distributions/distribution.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 4ab863576..333e2f240 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -894,8 +894,8 @@ def tree_flatten(self): class Delta(Distribution): - # FIXME v and log_density should be constraints.independent(constraints.real, ???) - arg_constraints = {'v': constraints.real, 'log_density': constraints.real} + arg_constraints = {'v': constraints.dependent(is_discrete=False), + 'log_density': constraints.real} reparameterized_params = ['v', 'log_density'] is_discrete = True From aee945895dff9ffb6a12637a9bfbddb1d8c20363 Mon Sep 17 00:00:00 2001 From: Lukas Prediger Date: Thu, 11 Feb 2021 08:48:15 +0200 Subject: [PATCH 048/222] Enabling sampling with intermediates for `ExpandedDistribution` (#909) * Simplifying ExpandedDistribution._sample It involved some elaborate shuffling in sample/batch dimensions that is unneccessary (due to independence in these dimensions) and didn't mitigate the need for a reshape in the end, which achieves the same results all on its own. * Added sample_with_intermediates for ExpandedDistribution Assuming that intermediates are batched similarly to direct samples. --- numpyro/distributions/distribution.py | 35 ++++++++++++++++++--------- 1 file changed, 24 insertions(+), 11 deletions(-) diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 333e2f240..599424af0 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -444,28 +444,41 @@ def has_rsample(self): return self.base_dist.has_rsample def _sample(self, sample_fn, key, sample_shape=()): - interstitial_dims = tuple(self._interstitial_sizes.keys()) - event_dim = len(self.event_shape) - interstitial_dims = tuple(i - event_dim for i in interstitial_dims) interstitial_sizes = tuple(self._interstitial_sizes.values()) expanded_sizes = tuple(self._expanded_sizes.values()) batch_shape = expanded_sizes + interstitial_sizes - samples = sample_fn(key, sample_shape=sample_shape + batch_shape) - interstitial_idx = len(sample_shape) + len(expanded_sizes) - interstitial_sample_dims = tuple(range(interstitial_idx, interstitial_idx + len(interstitial_sizes))) - for dim1, dim2 in zip(interstitial_dims, interstitial_sample_dims): - samples = jnp.swapaxes(samples, dim1, dim2) - return samples.reshape(sample_shape + self.batch_shape + self.event_shape) + samples, intermediates = sample_fn(key, sample_shape=sample_shape + batch_shape) + + def reshape_sample(x): + """ Reshapes samples and intermediates to ensure that the output + shape is correct: This implicitly replaces the interstitial dims + of size 1 in the original batch_shape of base_dist with those + in the expanded dims. While it somewhat 'shuffles' over batch + dimensions, we don't care because they are considered independent.""" + subshape = x.shape[len(sample_shape) + len(batch_shape):] + # subshape == base_dist.batch_shape + event_shape of x (latter unknown for intermediates) + event_shape = subshape[len(self.base_dist.batch_shape):] + return x.reshape(sample_shape + self.batch_shape + event_shape) + + intermediates = tree_util.tree_map(reshape_sample, intermediates) + samples = reshape_sample(samples) + return samples, intermediates def rsample(self, key, sample_shape=()): - return self._sample(self.base_dist.rsample, key, sample_shape) + return self._sample( + lambda *args, **kwargs: (self.base_dist.rsample(*args, **kwargs), []), + key, sample_shape + ) @property def support(self): return self.base_dist.support + def sample_with_intermediates(self, key, sample_shape=()): + return self._sample(self.base_dist.sample_with_intermediates, key, sample_shape) + def sample(self, key, sample_shape=()): - return self._sample(self.base_dist.sample, key, sample_shape) + return self.sample_with_intermediates(key, sample_shape)[0] def log_prob(self, value): shape = lax.broadcast_shapes(self.batch_shape, From e5cd8db99c69ca6dfcb5f9b2da9d413584ff0d71 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Thu, 11 Feb 2021 08:41:13 +0100 Subject: [PATCH 049/222] Hamiltonian Monte Carlo with Energy Conserving Subsampling (#905) * start * start hmcecs two * structuring * small fix * ADDED: verlet, new log density * FIXED: initialization model parameters * FIXED: Arguments potential function * FIXED: Arguments mess * FIXED? shapes error new problem stuff being 1D (precision) * Sampling working Added dataset * Seems to be working * Added: Plotting and save samples to example * ADDED: Assertion errors working with hierarchical priors * working on more than 1 chain * ADDED: more plotting * ADDED: More tests and proxies * Small state fix * Fixed : Proxies and init * Working examples * Maybe working * Started adding Block-Poisson * small stuff * Started adding poisson stuff Lots of things to do * Working on documentation and poisson * Added: Poisson stuff (missing initialization) * BlockPoissonRunning * FIXED: potential estimator * FINISHED: Block-poisson missing tests * MISSING: Postprocessing * FIXED: sign * More debugging * Fixed style. * HMCECS working, fixed problems with SVI MAP and factored code. * Added MNIST BNN example using flax. * Working potential with algebraic effect handlers. * Potential estimator integrated with ECS class. * ECS wrapper working on toy example. * cleaned code. * renamed hmcecs_utils to ecs_utils and added todos. * debugging taylor expansion. * Updated comments with reference and added test for num_blocks={} (there was a bug). * Added pystan * Added components for variational proxy. * Added variational_proxy, todo: fix estimator. * Integrated variational proxy into ecs. * checkpoint: before redoing estimator. * Variational proxy running! * Fixed minor bugs and example of hmcecs with variational proxy on logistic regression. * merging * Refactored taylor_estimator into taylor_proxy and a difference estimator. * Sketched variational proxy in hmc_gibbs. * Variational proxy running. * Examples. * Moved estimate_likelihood * Added two moons * add gibbs_state and fix bugs * Integrated taylor proxy and updated API. * Bugs fixed and taylor working! * Updated variational proxy to new API. * Variational proxy running on breast cancer! * Working regression * Fixed problems in variational; todo rethink dummy_sample ([] doesn't work). Rethink post(theta), prior(theta). * add covtype example * fix some bugs to substitute empty subsample indices and add some FIXME * FIXED ELBO computation and changed the weight scheme in variational proxy to w_i = softmax(E_{z~Q}[l(x_i,z)]). * fixed proxy_sum and added equations. * VECS working with AutoNormal on BreastCancer. * Using Likelihood as weight. * factored out VECS * Added simple test case. * Cleaned. * Removed old HMCECS logistic examples. * removed old autoguide * Fixed linting. * fixed lint. * Remove Poisson, factored out pandas for loading HIGGs dataset, added SA to covtype. * Fixed _block_update refactor. Missing new test cases, 2 more TODOs. * fixed isort * Fixed comments, some 3 TODOs left. * Conditioned gradient computation and moved to unconstraint sapce for ref. params. * Fixed test for HMCECS and bumped jaxlib version. * Fixed test. * Fixed lint. * Corrected taylor_proxy works in unconstraint space. Added docstring and changed Norm-Norm to 3-dim latent param. * Flipped syntax for geq in setup.py * Made default device for covtype example cpu. * Added taylor proxy test. * Added test for variance. * Fixed lint. * Added all log_density computation to test_estimate_likelihood and assert variance on difference between sub and all. * Fixed typo and isort. * isort not included in previous commit. * Fixed shadowing log_prob. Co-authored-by: Lys Co-authored-by: Ola Co-authored-by: Du Phan --- docs/source/conf.py | 2 +- examples/covtype.py | 89 +++++++-- numpyro/diagnostics.py | 1 + numpyro/examples/datasets.py | 32 +++- numpyro/handlers.py | 21 ++- numpyro/infer/autoguide.py | 15 +- numpyro/infer/hmc_gibbs.py | 353 ++++++++++++++++++++++++++++++----- numpyro/infer/util.py | 8 +- numpyro/primitives.py | 9 +- setup.py | 4 +- test/test_hmc_gibbs.py | 138 ++++++++++++-- 11 files changed, 561 insertions(+), 111 deletions(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index 4f0aa83a2..adf47cdd4 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -9,7 +9,6 @@ import nbsphinx import sphinx_rtd_theme - # import pkg_resources # -*- coding: utf-8 -*- @@ -33,6 +32,7 @@ # HACK: This is to ensure that local functions are documented by sphinx. from numpyro.infer.hmc import hmc # noqa: E402 + hmc(None, None) # -- Project information ----------------------------------------------------- diff --git a/examples/covtype.py b/examples/covtype.py index 1dcff36e7..702b0d151 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -4,13 +4,18 @@ import argparse import time +import matplotlib.pyplot as plt + from jax import random import jax.numpy as jnp import numpyro import numpyro.distributions as dist from numpyro.examples.datasets import COVTYPE, load_dataset -from numpyro.infer import MCMC, NUTS +from numpyro.infer import HMC, HMCECS, MCMC, NUTS, SA, SVI, Trace_ELBO, init_to_value +from numpyro.infer.autoguide import AutoBNAFNormal +from numpyro.infer.hmc_gibbs import taylor_proxy +from numpyro.infer.reparam import NeuTraReparam def _load_dataset(): @@ -33,22 +38,76 @@ def _load_dataset(): return features, labels -def model(data, labels): +def model(data, labels, subsample_size=None): dim = data.shape[1] coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) - logits = jnp.dot(data, coefs) - return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) + with numpyro.plate("N", data.shape[0], subsample_size=subsample_size) as idx: + logits = jnp.dot(data[idx], coefs) + return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels[idx]) def benchmark_hmc(args, features, labels): - step_size = jnp.sqrt(0.5 / features.shape[0]) - trajectory_length = step_size * args.num_steps rng_key = random.PRNGKey(1) start = time.time() - kernel = NUTS(model, trajectory_length=trajectory_length) - mcmc = MCMC(kernel, 0, args.num_samples) - mcmc.run(rng_key, features, labels) - mcmc.print_summary() + # a MAP estimate at the following source + # https://github.com/google/edward2/blob/master/examples/no_u_turn_sampler/logistic_regression.py#L117 + ref_params = {"coefs": jnp.array([ + +2.03420663e+00, -3.53567265e-02, -1.49223924e-01, -3.07049364e-01, + -1.00028366e-01, -1.46827862e-01, -1.64167881e-01, -4.20344204e-01, + +9.47479829e-02, -1.12681836e-02, +2.64442056e-01, -1.22087866e-01, + -6.00568838e-02, -3.79419506e-01, -1.06668741e-01, -2.97053963e-01, + -2.05253899e-01, -4.69537191e-02, -2.78072730e-02, -1.43250525e-01, + -6.77954629e-02, -4.34899796e-03, +5.90927452e-02, +7.23133609e-02, + +1.38526391e-02, -1.24497898e-01, -1.50733739e-02, -2.68872194e-02, + -1.80925727e-02, +3.47936489e-02, +4.03552800e-02, -9.98773426e-03, + +6.20188080e-02, +1.15002751e-01, +1.32145107e-01, +2.69109547e-01, + +2.45785132e-01, +1.19035013e-01, -2.59744357e-02, +9.94279515e-04, + +3.39266285e-02, -1.44057125e-02, -6.95222765e-02, -7.52013028e-02, + +1.21171586e-01, +2.29205526e-02, +1.47308692e-01, -8.34354162e-02, + -9.34122875e-02, -2.97472421e-02, -3.03937674e-01, -1.70958012e-01, + -1.59496680e-01, -1.88516974e-01, -1.20889175e+00])} + if args.algo == "HMC": + step_size = jnp.sqrt(0.5 / features.shape[0]) + trajectory_length = step_size * args.num_steps + kernel = HMC(model, step_size=step_size, trajectory_length=trajectory_length, adapt_step_size=False, + dense_mass=args.dense_mass) + subsample_size = None + elif args.algo == "NUTS": + kernel = NUTS(model, dense_mass=args.dense_mass) + subsample_size = None + elif args.algo == "HMCECS": + subsample_size = 1000 + inner_kernel = NUTS(model, init_strategy=init_to_value(values=ref_params), + dense_mass=args.dense_mass) + # note: if num_blocks=100, we'll update 10 index at each MCMC step + # so it took 50000 MCMC steps to iterative the whole dataset + kernel = HMCECS(inner_kernel, num_blocks=100, proxy=taylor_proxy(ref_params)) + elif args.algo == "SA": + # NB: this kernel requires large num_warmup and num_samples + # and running on GPU is much faster than on CPU + kernel = SA(model, adapt_state_size=1000, init_strategy=init_to_value(values=ref_params)) + subsample_size = None + elif args.algo == "FlowHMCECS": + subsample_size = 1000 + guide = AutoBNAFNormal(model, num_flows=1, hidden_factors=[8]) + svi = SVI(model, guide, numpyro.optim.Adam(0.01), Trace_ELBO()) + params, losses = svi.run(random.PRNGKey(2), 2000, features, labels) + plt.plot(losses) + plt.show() + + neutra = NeuTraReparam(guide, params) + neutra_model = neutra.reparam(model) + neutra_ref_params = {"auto_shared_latent": jnp.zeros(55)} + # no need to adapt mass matrix if the flow does a good job + inner_kernel = NUTS(neutra_model, init_strategy=init_to_value(values=neutra_ref_params), + adapt_mass_matrix=False) + kernel = HMCECS(inner_kernel, num_blocks=100, proxy=taylor_proxy(neutra_ref_params)) + else: + raise ValueError("Invalid algorithm, either 'HMC', 'NUTS', or 'HMCECS'.") + mcmc = MCMC(kernel, args.num_warmup, args.num_samples) + mcmc.run(rng_key, features, labels, subsample_size, extra_fields=("accept_prob",)) + print("Mean accept prob:", jnp.mean(mcmc.get_extra_fields()["accept_prob"])) + mcmc.print_summary(exclude_deterministic=False) print('\nMCMC elapsed time:', time.time() - start) @@ -60,14 +119,20 @@ def main(args): if __name__ == '__main__': assert numpyro.__version__.startswith('0.5.0') parser = argparse.ArgumentParser(description="parse args") - parser.add_argument('-n', '--num-samples', default=100, type=int, help='number of samples') + parser.add_argument('-n', '--num-samples', default=1000, type=int, help='number of samples') + parser.add_argument('--num-warmup', default=1000, type=int, help='number of warmup steps') parser.add_argument('--num-steps', default=10, type=int, help='number of steps (for "HMC")') parser.add_argument('--num-chains', nargs='?', default=1, type=int) - parser.add_argument('--algo', default='NUTS', type=str, help='whether to run "HMC" or "NUTS"') + parser.add_argument('--algo', default='HMCECS', type=str, + help='whether to run "HMCECS", "NUTS", "HMCECS", "SA" or "FlowHMCECS"') + parser.add_argument('--dense-mass', action="store_true") + parser.add_argument('--x64', action="store_true") parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) numpyro.set_host_device_count(args.num_chains) + if args.x64: + numpyro.enable_x64() main(args) diff --git a/numpyro/diagnostics.py b/numpyro/diagnostics.py index f85ee471d..ab2b9996d 100644 --- a/numpyro/diagnostics.py +++ b/numpyro/diagnostics.py @@ -161,6 +161,7 @@ def effective_sample_size(x): :return: effective sample size of ``x``. :rtype: numpy.ndarray """ + assert x.ndim >= 2 assert x.shape[1] >= 2 diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index 846e93892..18ace29e3 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -4,11 +4,13 @@ from collections import namedtuple import csv import gzip +import io import os import pickle import struct from urllib.parse import urlparse from urllib.request import urlretrieve +import warnings import zipfile import numpy as np @@ -23,25 +25,20 @@ '.data')) os.makedirs(DATA_DIR, exist_ok=True) - dset = namedtuple('dset', ['name', 'urls']) - BASEBALL = dset('baseball', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/EfronMorrisBB.txt', ]) - COVTYPE = dset('covtype', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/covtype.zip', ]) - DIPPER_VOLE = dset('dipper_vole', [ 'https://github.com/pyro-ppl/datasets/blob/master/dipper_vole.zip?raw=true', ]) - MNIST = dset('mnist', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-images-idx3-ubyte.gz', 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-labels-idx1-ubyte.gz', @@ -49,26 +46,26 @@ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/t10k-labels-idx1-ubyte.gz', ]) - SP500 = dset('SP500', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/SP500.csv', ]) - UCBADMIT = dset('ucbadmit', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/UCBadmit.csv', ]) - LYNXHARE = dset('lynxhare', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/LynxHare.txt', ]) - JSB_CHORALES = dset('jsb_chorales', [ 'https://d2hg8soec8ck9v.cloudfront.net/datasets/polyphonic/jsb_chorales.pickle', ]) +HIGGS = dset("higgs", [ + "https://archive.ics.uci.edu/ml/machine-learning-databases/00280/HIGGS.csv.gz", +]) + def _download(dset): for url in dset.urls: @@ -240,6 +237,21 @@ def _load_jsb_chorales(): return processed_dataset +def _load_higgs(): + warnings.warn("Higgs is a 2.6 GB dataset") + _download(HIGGS) + + file_path = os.path.join(DATA_DIR, 'HIGGS.csv.gz') + with io.TextIOWrapper(gzip.open(file_path, 'rb')) as f: + csv_reader = csv.reader(f, delimiter=',', quoting=csv.QUOTE_NONE) + obs = [] + data = [] + for row in csv_reader: + obs.append(row[0]) + data.append(row[1:]) + return np.stack(obs), np.stack(data) + + def _load(dset): if dset == BASEBALL: return _load_baseball() @@ -257,6 +269,8 @@ def _load(dset): return _load_lynxhare() elif dset == JSB_CHORALES: return _load_jsb_chorales() + elif dset == HIGGS: + return _load_higgs() raise ValueError('Dataset - {} not found.'.format(dset.name)) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index d97c96f95..a40572504 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -1,6 +1,5 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 - """ This provides a small set of effect handlers in NumPyro that are modeled after Pyro's `poutine `_ module. @@ -136,6 +135,7 @@ class trace(Messenger): 'type': 'sample', 'value': DeviceArray(-0.20584235, dtype=float32)})]) """ + def __enter__(self): super(trace, self).__enter__() self.trace = OrderedDict() @@ -146,7 +146,7 @@ def postprocess_message(self, msg): # skip recording helper messages e.g. `control_flow`, `to_data`, `to_funsor` # which has no name return - assert not(msg['type'] == 'sample' and msg['name'] in self.trace), \ + assert not (msg['type'] == 'sample' and msg['name'] in self.trace), \ 'all sites must have unique names but got `{}` duplicated'.format(msg['name']) self.trace[msg['name']] = msg.copy() @@ -191,6 +191,7 @@ class replay(Messenger): -0.20584235 >>> assert replayed_trace['a']['value'] == exec_trace['a']['value'] """ + def __init__(self, fn=None, guide_trace=None): assert guide_trace is not None self.guide_trace = guide_trace @@ -234,6 +235,7 @@ class block(Messenger): >>> assert 'a' not in trace_block_a >>> assert 'b' in trace_block_a """ + def __init__(self, fn=None, hide_fn=None, hide=None): if hide_fn is not None: self.hide_fn = hide_fn @@ -350,6 +352,7 @@ class condition(Messenger): >>> assert exec_trace['a']['value'] == -1 >>> assert exec_trace['a']['is_observed'] """ + def __init__(self, fn=None, data=None, condition_fn=None): self.condition_fn = condition_fn self.data = data @@ -386,6 +389,7 @@ class infer_config(Messenger): :param fn: a stochastic function (callable containing NumPyro primitive calls) :param config_fn: a callable taking a site and returning an infer dict """ + def __init__(self, fn=None, config_fn=None): super().__init__(fn) self.config_fn = config_fn @@ -470,6 +474,7 @@ class mask(Messenger): :param mask: a boolean or a boolean-valued array for masking elementwise log probability of sample sites (`True` includes a site, `False` excludes a site). """ + def __init__(self, fn=None, mask=True): if lax.dtype(mask) != 'bool': raise ValueError("`mask` should be a bool array.") @@ -506,6 +511,7 @@ class reparam(Messenger): :class:`~numpyro.infer.reparam.Reparam` or None. :type config: dict or callable """ + def __init__(self, fn=None, config=None): assert isinstance(config, dict) or callable(config) self.config = config @@ -550,6 +556,7 @@ class scale(Messenger): of log probability. :type scale: float or numpy.ndarray """ + def __init__(self, fn=None, scale=1.): if not_jax_tracer(scale): if np.any(np.less_equal(scale, 0)): @@ -587,6 +594,7 @@ class scope(Messenger): :param str prefix: a string to prepend to sample names :param str divider: a string to join the prefix and sample name; default to `'/'` """ + def __init__(self, fn=None, prefix='', divider='/'): self.prefix = prefix self.divider = divider @@ -638,6 +646,7 @@ class seed(Messenger): >>> y = handlers.seed(model, rng_seed=1)() >>> assert x == y """ + def __init__(self, fn=None, rng_seed=None): if isinstance(rng_seed, int) or (isinstance(rng_seed, jnp.ndarray) and not jnp.shape(rng_seed)): rng_seed = random.PRNGKey(rng_seed) @@ -647,10 +656,10 @@ def __init__(self, fn=None, rng_seed=None): super(seed, self).__init__(fn) def process_message(self, msg): - if (msg['type'] == 'sample' and not msg['is_observed'] and - msg['kwargs']['rng_key'] is None) or msg['type'] in ['prng_key', 'plate', 'control_flow']: - # no need to create a new key when value is available + if (msg['type'] == 'sample' and not msg['is_observed'] and msg['kwargs']['rng_key'] is None) \ + or msg['type'] in ['prng_key', 'plate', 'control_flow']: if msg['value'] is not None: + # no need to create a new key when value is available return self.rng_key, rng_key_sample = random.split(self.rng_key) msg['kwargs']['rng_key'] = rng_key_sample @@ -691,6 +700,7 @@ class substitute(Messenger): >>> exec_trace = trace(substitute(model, {'a': -1})).get_trace() >>> assert exec_trace['a']['value'] == -1 """ + def __init__(self, fn=None, data=None, substitute_fn=None): self.substitute_fn = substitute_fn self.data = data @@ -760,6 +770,7 @@ class do(Messenger): >>> assert not exec_trace['z'].get('stop', None) >>> assert z_square == 1 """ + def __init__(self, fn=None, data=None): self.data = data self._intervener_id = str(id(self)) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index c42bb3098..bd4966bdd 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -214,19 +214,14 @@ def __call__(self, *args, **kwargs): event_dim=event_dim) site_fn = dist.Normal(site_loc, site_scale).to_event(event_dim) - if site["fn"].support in [constraints.real, constraints.real_vector]: + if site["fn"].support is constraints.real \ + or (isinstance(site["fn"].support, constraints.independent) and + site["fn"].support is constraints.real): result[name] = numpyro.sample(name, site_fn) else: - unconstrained_value = numpyro.sample("{}_unconstrained".format(name), site_fn, - infer={"is_auxiliary": True}) - transform = biject_to(site['fn'].support) - value = transform(unconstrained_value) - log_density = - transform.log_abs_det_jacobian(unconstrained_value, value) - log_density = sum_rightmost(log_density, - jnp.ndim(log_density) - jnp.ndim(value) + site["fn"].event_dim) - delta_dist = dist.Delta(value, log_density=log_density, event_dim=site["fn"].event_dim) - result[name] = numpyro.sample(name, delta_dist) + guide_dist = dist.TransformedDistribution(site_fn, transform) + result[name] = numpyro.sample(name, guide_dist) return result diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 89f1c89d3..ef6881123 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -1,17 +1,21 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -from collections import namedtuple +from collections import defaultdict, namedtuple import copy from functools import partial +import warnings -from jax import device_put, grad, jacfwd, ops, random, value_and_grad +from jax import device_put, grad, hessian, jacfwd, jacobian, lax, ops, random, value_and_grad import jax.numpy as jnp from jax.scipy.special import expit -from numpyro.handlers import condition, seed, substitute, trace +import numpyro +from numpyro.distributions.transforms import biject_to +from numpyro.handlers import block, condition, seed, substitute, trace from numpyro.infer.hmc import HMC from numpyro.infer.mcmc import MCMCKernel +from numpyro.infer.util import _unconstrain_reparam from numpyro.util import cond, fori_loop, identity, ravel_pytree HMCGibbsState = namedtuple("HMCGibbsState", "z, hmc_state, rng_key") @@ -247,7 +251,6 @@ def _discrete_modified_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, s def _discrete_gibbs_fn(potential_fn, support_sizes, proposal_fn): - def gibbs_fn(rng_key, gibbs_sites, hmc_sites, pe): # get support_sizes of gibbs_sites support_sizes_flat, _ = ravel_pytree({k: support_sizes[k] for k in gibbs_sites}) @@ -397,31 +400,52 @@ def potential_fn(z_gibbs, z_hmc): return HMCGibbsState(z, hmc_state, rng_key) -def _subsample_gibbs_fn(potential_fn, plate_sizes, num_blocks=1): +def _update_block(rng_key, num_blocks, subsample_idx, plate_size): + size, subsample_size = plate_size + rng_key, subkey, block_key = random.split(rng_key, 3) + block_size = (subsample_size - 1) // num_blocks + 1 + pad = block_size - (subsample_size - 1) % block_size - 1 - def gibbs_fn(rng_key, gibbs_sites, hmc_sites, pe): - assert set(gibbs_sites) == set(plate_sizes) - u_new = {} - for name in gibbs_sites: - size, subsample_size = plate_sizes[name] - rng_key, subkey, block_key = random.split(rng_key, 3) - block_size = subsample_size // num_blocks + chosen_block = random.randint(block_key, shape=(), minval=0, maxval=num_blocks) + new_idx = random.randint(subkey, minval=0, maxval=size, shape=(block_size,)) + subsample_idx_padded = jnp.pad(subsample_idx, (0, pad)) + start = chosen_block * block_size + subsample_idx_padded = lax.dynamic_update_slice_in_dim( + subsample_idx_padded, new_idx, start, 0) + return rng_key, subsample_idx_padded[:subsample_size], pad, new_idx, start - chosen_block = random.randint(block_key, shape=(), minval=0, maxval=num_blocks) - new_idx = random.randint(subkey, minval=0, maxval=size, shape=(subsample_size,)) - block_mask = jnp.arange(subsample_size) // block_size == chosen_block - u_new[name] = jnp.where(block_mask, new_idx, gibbs_sites[name]) +def _block_update(plate_sizes, num_blocks, rng_key, gibbs_sites, gibbs_state): + u_new = {} + for name, subsample_idx in gibbs_sites.items(): + rng_key, u_new[name], *_ = _update_block(rng_key, num_blocks, subsample_idx, plate_sizes[name]) + return u_new, gibbs_state - # given a fixed hmc_sites, pe_new - pe_curr = loglik_new - loglik_curr - pe_new = potential_fn(u_new, hmc_sites) - accept_prob = jnp.clip(jnp.exp(pe - pe_new), a_max=1.0) - gibbs_sites, pe = cond(random.bernoulli(rng_key, accept_prob), - (u_new, pe_new), identity, - (gibbs_sites, pe), identity) - return gibbs_sites, pe - return gibbs_fn +def _block_update_proxy(num_blocks, rng_key, gibbs_sites, plate_sizes): + u_new = {} + pads = {} + new_idxs = {} + starts = {} + for name, subsample_idx in gibbs_sites.items(): + rng_key, u_new[name], pads[name], new_idxs[name], starts[name] = _update_block(rng_key, num_blocks, + subsample_idx, plate_sizes[name]) + return u_new, pads, new_idxs, starts + + +HMCECSState = namedtuple("HMCECSState", "z, hmc_state, rng_key, gibbs_state, accept_prob") +TaylorProxyState = namedtuple("TaylorProxyState", "ref_subsample_log_liks, " + "ref_subsample_log_lik_grads, ref_subsample_log_lik_hessians") + + +def _wrap_gibbs_state(model): + def wrapped_fn(*args, **kwargs): + # this is to let estimate_likelihood handler knows what is the current gibbs_state + msg = {"type": "_gibbs_state", "value": kwargs.pop("_gibbs_state", ())} + numpyro.primitives.apply_stack(msg) + return model(*args, **kwargs) + + return wrapped_fn class HMCECS(HMCGibbs): @@ -448,9 +472,13 @@ class HMCECS(HMCGibbs): Quiroz, M., Kohn, R., Villani, M., & Tran, M. N. (2018) 3. *The Block Pseudo-Margional Sampler*, Tran, M.-N., Kohn, R., Quiroz, M. Villani, M. (2017) + 4. *The Fundamental Incompatibility of Scalable Hamiltonian Monte Carlo and Naive Data Subsampling* + Betancourt, M. (2015) :param inner_kernel: One of :class:`~numpyro.infer.hmc.HMC` or :class:`~numpyro.infer.hmc.NUTS`. :param int num_blocks: Number of blocks to partition subsample into. + :param proxy: Either :function `~numpyro.infer.hmc_gibbs.taylor_proxy` for likelihood estimation, + or, None for naive (in-between trajectory) subsampling as outlined in [4]. **Example** @@ -476,48 +504,285 @@ class HMCECS(HMCGibbs): >>> assert abs(jnp.mean(samples) - 1.) < 0.1 """ - def __init__(self, inner_kernel, *, num_blocks=1): + + def __init__(self, inner_kernel, *, num_blocks=1, proxy=None): super().__init__(inner_kernel, lambda *args: None, None) + + self.inner_kernel._model = _wrap_gibbs_state(self.inner_kernel._model) self._num_blocks = num_blocks + self._proxy = proxy + + def postprocess_fn(self, args, kwargs): + def fn(z): + model_kwargs = {} if kwargs is None else kwargs.copy() + hmc_sites = {k: v for k, v in z.items() if k not in self._gibbs_sites} + gibbs_sites = {k: v for k, v in z.items() if k in self._gibbs_sites} + model_kwargs["_gibbs_sites"] = gibbs_sites + hmc_sites = self.inner_kernel.postprocess_fn(args, model_kwargs)(hmc_sites) + return hmc_sites + + return fn def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() rng_key, key_u = random.split(rng_key) self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) - self._plate_sizes = { + self._subsample_plate_sizes = { name: site["args"] for name, site in self._prototype_trace.items() if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size } - self._gibbs_sites = list(self._plate_sizes.keys()) - return super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) + self._gibbs_sites = list(self._subsample_plate_sizes.keys()) + if self._proxy is not None: + proxy_fn, gibbs_init, self._gibbs_update = self._proxy(self._prototype_trace, + self._subsample_plate_sizes, + self.model, + model_args, + model_kwargs.copy(), + num_blocks=self._num_blocks) + method = perturbed_method(self._subsample_plate_sizes, proxy_fn) + self.inner_kernel._model = estimate_likelihood(self.inner_kernel._model, method) + + z_gibbs = {name: site["value"] for name, site in self._prototype_trace.items() if name in self._gibbs_sites} + rng_key, rng_state = random.split(rng_key) + gibbs_state = gibbs_init(rng_state, z_gibbs) + else: + self._gibbs_update = partial(_block_update, self._subsample_plate_sizes, self._num_blocks) + gibbs_state = () + + model_kwargs["_gibbs_state"] = gibbs_state + state = super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) + return HMCECSState(state.z, state.hmc_state, state.rng_key, gibbs_state, jnp.array(0.)) def sample(self, state, model_args, model_kwargs): - model_kwargs = {} if model_kwargs is None else model_kwargs + model_kwargs = {} if model_kwargs is None else model_kwargs.copy() rng_key, rng_gibbs = random.split(state.rng_key) - def potential_fn(z_gibbs, z_hmc): + def potential_fn(z_gibbs, gibbs_state, z_hmc): return self.inner_kernel._potential_fn_gen( - *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + *model_args, _gibbs_sites=z_gibbs, _gibbs_state=gibbs_state, **model_kwargs)(z_hmc) z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} - z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} - model_kwargs_ = model_kwargs.copy() - model_kwargs_["_gibbs_sites"] = z_gibbs + z_gibbs_new, gibbs_state_new = self._gibbs_update(rng_key, z_gibbs, state.gibbs_state) - gibbs_fn = _subsample_gibbs_fn(potential_fn, self._plate_sizes, self._num_blocks) - z_gibbs, pe = gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc, - pe=state.hmc_state.potential_energy) + # given a fixed hmc_sites, pe_new - pe_curr = loglik_new - loglik_curr + pe = state.hmc_state.potential_energy + pe_new = potential_fn(z_gibbs_new, gibbs_state_new, state.hmc_state.z) + accept_prob = jnp.clip(jnp.exp(pe - pe_new), a_max=1.0) + transition = random.bernoulli(rng_key, accept_prob) + grad_ = jacfwd if self.inner_kernel._forward_mode_differentiation else grad + z_gibbs, gibbs_state, pe, z_grad = cond(transition, + (z_gibbs_new, gibbs_state_new, pe_new), + lambda vals: vals + (grad_(partial(potential_fn, + vals[0], + vals[1]))(state.hmc_state.z),), + (z_gibbs, state.gibbs_state, pe, state.hmc_state.z_grad), identity) - if self.inner_kernel._forward_mode_differentiation: - z_grad = jacfwd(partial(potential_fn, z_gibbs))(state.hmc_state.z) - else: - z_grad = grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) - model_kwargs_["_gibbs_sites"] = z_gibbs - hmc_state = self.inner_kernel.sample(hmc_state, model_args, model_kwargs_) + model_kwargs["_gibbs_sites"] = z_gibbs + model_kwargs["_gibbs_state"] = gibbs_state + hmc_state = self.inner_kernel.sample(hmc_state, model_args, model_kwargs) z = {**z_gibbs, **hmc_state.z} + return HMCECSState(z, hmc_state, rng_key, gibbs_state, accept_prob) - return HMCGibbsState(z, hmc_state, rng_key) + +def perturbed_method(subsample_plate_sizes, proxy_fn): + def estimator(likelihoods, params, gibbs_state): + subsample_log_liks = defaultdict(float) + for (fn, value, name, subsample_dim) in likelihoods.values(): + subsample_log_liks[name] += _sum_all_except_at_dim(fn.log_prob(value), subsample_dim) + + log_lik_sum = 0. + + proxy_value_all, proxy_value_subsample = proxy_fn(params, subsample_log_liks.keys(), gibbs_state) + + for name, subsample_log_lik in subsample_log_liks.items(): # loop over all subsample sites + n, m = subsample_plate_sizes[name] + + diff = subsample_log_lik - proxy_value_subsample[name] + + unbiased_log_lik = proxy_value_all[name] + n * jnp.mean(diff) + variance = n ** 2 / m * jnp.var(diff) + log_lik_sum += unbiased_log_lik - 0.5 * variance + return log_lik_sum + + return estimator + + +def taylor_proxy(reference_params): + """ Control variate for unbiased log likelihood estimation using a Taylor expansion around a reference + parameter. Suggest for subsampling in [1]. + + :param dict reference_params: Model parameterization at MLE or MAP-estimate. + + ** References: ** + + [1] Towards scaling up Markov chainMonte Carlo: an adaptive subsampling approach + Bardenet., R., Doucet, A., Holmes, C. (2014) + """ + + def construct_proxy_fn(prototype_trace, subsample_plate_sizes, model, model_args, model_kwargs, num_blocks=1): + ref_params = {name: biject_to(prototype_trace[name]["fn"].support).inv(value) + for name, value in reference_params.items()} + + ref_params_flat, unravel_fn = ravel_pytree(ref_params) + + def log_likelihood(params_flat, subsample_indices=None): + if subsample_indices is None: + subsample_indices = {k: jnp.arange(v[0]) for k, v in subsample_plate_sizes.items()} + params = unravel_fn(params_flat) + with warnings.catch_warnings(): + warnings.simplefilter("ignore") + params = {name: biject_to(prototype_trace[name]["fn"].support)(value) for name, value in params.items()} + with block(), trace() as tr, substitute(data=subsample_indices), substitute(data=params): + model(*model_args, **model_kwargs) + + log_lik = {} + for site in tr.values(): + if site["type"] == "sample" and site["is_observed"]: + for frame in site["cond_indep_stack"]: + if frame.name in log_lik: + log_lik[frame.name] += _sum_all_except_at_dim( + site["fn"].log_prob(site["value"]), frame.dim) + else: + log_lik[frame.name] = _sum_all_except_at_dim( + site["fn"].log_prob(site["value"]), frame.dim) + return log_lik + + def log_likelihood_sum(params_flat, subsample_indices=None): + return {k: v.sum() for k, v in log_likelihood(params_flat, subsample_indices).items()} + + # those stats are dict keyed by subsample names + ref_log_likelihoods_sum = log_likelihood_sum(ref_params_flat) + ref_log_likelihood_grads_sum = jacobian(log_likelihood_sum)(ref_params_flat) + ref_log_likelihood_hessians_sum = hessian(log_likelihood_sum)(ref_params_flat) + + def gibbs_init(rng_key, gibbs_sites): + ref_subsample_log_liks = log_likelihood(ref_params_flat, gibbs_sites) + ref_subsample_log_lik_grads = jacfwd(log_likelihood)(ref_params_flat, gibbs_sites) + ref_subsample_log_lik_hessians = jacfwd(jacfwd(log_likelihood))(ref_params_flat, gibbs_sites) + return TaylorProxyState(ref_subsample_log_liks, ref_subsample_log_lik_grads, ref_subsample_log_lik_hessians) + + def gibbs_update(rng_key, gibbs_sites, gibbs_state): + u_new, pads, new_idxs, starts = _block_update_proxy(num_blocks, rng_key, gibbs_sites, subsample_plate_sizes) + + new_states = defaultdict(dict) + ref_subsample_log_liks = log_likelihood(ref_params_flat, new_idxs) + ref_subsample_log_lik_grads = jacfwd(log_likelihood)(ref_params_flat, new_idxs) + ref_subsample_log_lik_hessians = jacfwd(jacfwd(log_likelihood))(ref_params_flat, new_idxs) + for stat, new_block_values, last_values in zip( + ["log_liks", "grads", "hessians"], + [ref_subsample_log_liks, + ref_subsample_log_lik_grads, + ref_subsample_log_lik_hessians], + [gibbs_state.ref_subsample_log_liks, + gibbs_state.ref_subsample_log_lik_grads, + gibbs_state.ref_subsample_log_lik_hessians]): + for name, subsample_idx in gibbs_sites.items(): + size, subsample_size = subsample_plate_sizes[name] + pad, start = pads[name], starts[name] + new_value = jnp.pad(last_values[name], [(0, pad)] + [(0, 0)] * (jnp.ndim(last_values[name]) - 1)) + new_value = lax.dynamic_update_slice_in_dim( + new_value, new_block_values[name], start, 0) + new_states[stat][name] = new_value[:subsample_size] + gibbs_state = TaylorProxyState(new_states["log_liks"], new_states["grads"], new_states["hessians"]) + return u_new, gibbs_state + + def proxy_fn(params, subsample_lik_sites, gibbs_state): + params_flat, _ = ravel_pytree(params) + params_diff = params_flat - ref_params_flat + + ref_subsample_log_liks = gibbs_state.ref_subsample_log_liks + ref_subsample_log_lik_grads = gibbs_state.ref_subsample_log_lik_grads + ref_subsample_log_lik_hessians = gibbs_state.ref_subsample_log_lik_hessians + + proxy_sum = defaultdict(float) + proxy_subsample = defaultdict(float) + for name in subsample_lik_sites: + proxy_subsample[name] = (ref_subsample_log_liks[name] + + jnp.dot(ref_subsample_log_lik_grads[name], params_diff) + + 0.5 * jnp.dot(jnp.dot(ref_subsample_log_lik_hessians[name], params_diff), + params_diff)) + + proxy_sum[name] = (ref_log_likelihoods_sum[name] + + jnp.dot(ref_log_likelihood_grads_sum[name], params_diff) + + 0.5 * jnp.dot(jnp.dot(ref_log_likelihood_hessians_sum[name], params_diff), + params_diff)) + return proxy_sum, proxy_subsample + + return proxy_fn, gibbs_init, gibbs_update + + return construct_proxy_fn + + +def _sum_all_except_at_dim(x, dim): + x = x.reshape((-1,) + x.shape[dim:]).sum(0) + return x.reshape(x.shape[:1] + (-1,)).sum(-1) + + +class estimate_likelihood(numpyro.primitives.Messenger): + def __init__(self, fn=None, method=None): + # estimate_likelihood: accept likelihood tuple (fn, value, subsample_name, subsample_dim) + # and current unconstrained params + # and returns log of the bias-corrected likelihood + assert method is not None + super().__init__(fn) + self.method = method + self.params = None + self.likelihoods = {} + self.subsample_plates = {} + self.gibbs_state = None + + def __enter__(self): + for handler in numpyro.primitives._PYRO_STACK[::-1]: + # the potential_fn in HMC makes the PYRO_STACK nested like trace(...); so we can extract the + # unconstrained_params from the _unconstrain_reparam substitute_fn + if isinstance(handler, substitute) and isinstance(handler.substitute_fn, partial) \ + and handler.substitute_fn.func is _unconstrain_reparam: + self.params = handler.substitute_fn.args[0] + break + return super().__enter__() + + def __exit__(self, exc_type, exc_value, traceback): + # make sure exit trackback is nice if an error happens + super().__exit__(exc_type, exc_value, traceback) + if exc_type is not None: + return + + if self.params is None: + return + + # add numpyro.factor; ideally, we will want to skip this computation when making prediction + # see: https://github.com/pyro-ppl/pyro/issues/2744 + numpyro.factor("_biased_corrected_log_likelihood", + self.method(self.likelihoods, self.params, self.gibbs_state)) + + # clean up + self.params = None + self.likelihoods = {} + self.subsample_plates = {} + self.gibbs_state = None + + def process_message(self, msg): + if self.params is None: + return + + if msg["type"] == "_gibbs_state": + self.gibbs_state = msg["value"] + return + + if msg["type"] == "sample" and msg["is_observed"]: + assert msg["name"] not in self.params + # store the likelihood for the estimator + for frame in msg["cond_indep_stack"]: + if frame.name in self.subsample_plates: + if msg["name"] in self.likelihoods: + raise RuntimeError(f"Multiple subsample plates at site {msg['name']} " + "are not allowed. Please reshape your data.") + self.likelihoods[msg["name"]] = (msg["fn"], msg["value"], frame.name, frame.dim) + # mask the current likelihood + msg["fn"] = msg["fn"].mask(False) + elif msg["type"] == "plate" and msg["args"][0] > msg["args"][1]: + self.subsample_plates[msg["name"]] = msg["value"] diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index d71c50a5c..8b4227819 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -432,7 +432,7 @@ def initialize_model(rng_key, model, # substitute param sites from model_trace to model so # we don't need to generate again parameters of `numpyro.module` model = substitute(model, data={k: site["value"] for k, site in model_trace.items() - if site["type"] in ["param", "plate"]}) + if site["type"] in ["param"]}) constrained_values = {k: v['value'] for k, v in model_trace.items() if v['type'] == 'sample' and not v['is_observed'] and not v['fn'].is_discrete} @@ -460,7 +460,8 @@ def initialize_model(rng_key, model, init_strategy = _init_to_unconstrained_value(values=unconstrained_values) prototype_params = transform_fn(inv_transforms, constrained_values, invert=True) (init_params, pe, grad), is_valid = find_valid_initial_params( - rng_key, model, + rng_key, substitute(model, data={k: site["value"] for k, site in model_trace.items() + if site["type"] in ["plate"]}), init_strategy=init_strategy, enum=has_enumerate_support, model_args=model_args, @@ -482,7 +483,7 @@ def initialize_model(rng_key, model, for w in ws: # at site information to the warning message w.message.args = ("Site {}: {}".format(site["name"], w.message.args[0]),) \ - + w.message.args[1:] + + w.message.args[1:] warnings.showwarning(w.message, w.category, w.filename, w.lineno, file=w.file, line=w.line) raise RuntimeError("Cannot find valid initial parameters. Please check your model again.") @@ -491,7 +492,6 @@ def initialize_model(rng_key, model, def _predictive(rng_key, model, posterior_samples, batch_shape, return_sites=None, parallel=True, model_args=(), model_kwargs={}): - def single_prediction(val): rng_key, samples = val model_trace = trace(seed(substitute(model, samples), rng_key)).get_trace( diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 1092abf4a..3353f4966 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -15,7 +15,6 @@ _PYRO_STACK = [] - CondIndepStackFrame = namedtuple('CondIndepStackFrame', ['name', 'dim', 'size']) @@ -38,7 +37,7 @@ def apply_stack(msg): # A Messenger that sets msg["stop"] == True also prevents application # of postprocess_message by Messengers above it on the stack # via the pointer variable from the process_message loop - for handler in _PYRO_STACK[-pointer-1:]: + for handler in _PYRO_STACK[-pointer - 1:]: handler.postprocess_message(msg) return msg @@ -277,6 +276,7 @@ class plate(Messenger): is used as the plate dim. If `None` (default), the leftmost available dim is allocated. """ + def __init__(self, name, size, subsample_size=None, dim=None): self.name = name self.size = size @@ -304,10 +304,11 @@ def _subsample(name, size, subsample_size, dim): } apply_stack(msg) subsample = msg['value'] + subsample_size = msg['args'][1] if subsample_size is not None and subsample_size != subsample.shape[0]: warnings.warn("subsample_size does not match len(subsample), {} vs {}.".format( subsample_size, len(subsample)) + - " Did you accidentally use different subsample_size in the model and guide?") + " Did you accidentally use different subsample_size in the model and guide?") cond_indep_stack = msg['cond_indep_stack'] occupied_dims = {f.dim for f in cond_indep_stack} if dim is None: @@ -355,7 +356,7 @@ def process_message(self, msg): msg['fn'] = msg['fn'].expand(batch_shape) if self.size != self.subsample_size: scale = 1. if msg['scale'] is None else msg['scale'] - msg['scale'] = scale * self.size / self.subsample_size + msg['scale'] = scale * (self.size / self.subsample_size if self.subsample_size else 1) def postprocess_message(self, msg): if msg["type"] in ("subsample", "param") and self.dim is not None: diff --git a/setup.py b/setup.py index bd20fd1b0..dcad69e77 100644 --- a/setup.py +++ b/setup.py @@ -33,9 +33,9 @@ author='Uber AI Labs', install_requires=[ # TODO: pin to a specific version for the release (until JAX's API becomes stable) - 'jax==0.2.8', + 'jax>=0.2.8', # check min version here: https://github.com/google/jax/blob/master/jax/lib/__init__.py#L26 - 'jaxlib==0.1.59', + 'jaxlib>=0.1.59', 'tqdm', ], extras_require={ diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index 9b0737599..e15eb47e0 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -1,20 +1,20 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 - from functools import partial import numpy as np from numpy.testing import assert_allclose import pytest -from jax import random +from jax import hessian, jacrev, random, vmap import jax.numpy as jnp from jax.scipy.linalg import cho_factor, cho_solve, inv, solve_triangular import numpyro import numpyro.distributions as dist -from numpyro.handlers import plate from numpyro.infer import HMC, HMCECS, MCMC, NUTS, DiscreteHMCGibbs, HMCGibbs +from numpyro.infer.hmc_gibbs import taylor_proxy +from numpyro.infer.util import log_density def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): @@ -206,28 +206,25 @@ def model(probs, locs): assert_allclose(jnp.var(samples["c"]), 1.03, atol=0.1) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) @pytest.mark.parametrize('num_blocks', [1, 2, 50, 100]) -def test_subsample_gibbs_partitioning(kernel_cls, num_blocks): - def model(obs): - with plate('N', obs.shape[0], subsample_size=100) as idx: - numpyro.sample('x', dist.Normal(0, 1), obs=obs[idx]) - - obs = random.normal(random.PRNGKey(0), (10000,)) / 100 - kernel = HMCECS(kernel_cls(model), num_blocks=num_blocks) - state = kernel.init(random.PRNGKey(1), 10, None, model_args=(obs,), model_kwargs=None) - gibbs_sites = {'N': jnp.arange(100)} - - def potential_fn(z_gibbs, z_hmc): - return kernel.inner_kernel._potential_fn_gen(obs, _gibbs_sites=z_gibbs)(z_hmc) - - gibbs_fn = numpyro.infer.hmc_gibbs._subsample_gibbs_fn(potential_fn, kernel._plate_sizes, num_blocks) - new_gibbs_sites, _ = gibbs_fn(random.PRNGKey(2), gibbs_sites, state.hmc_state.z, - state.hmc_state.potential_energy) # accept_prob > .999 +def test_block_update_partitioning(num_blocks): + plate_size = 10000, 100 + + plate_sizes = {'N': plate_size} + gibbs_sites = {'N': jnp.arange(plate_size[1])} + gibbs_state = {} + + new_gibbs_sites, new_gibbs_state = numpyro.infer.hmc_gibbs._block_update(plate_sizes, + num_blocks, + random.PRNGKey(2), + gibbs_sites, + gibbs_state) block_size = 100 // num_blocks for name in gibbs_sites: assert block_size == jnp.not_equal(gibbs_sites[name], new_gibbs_sites[name]).sum() + assert gibbs_state == new_gibbs_state + def test_enum_subsample_smoke(): def model(data): @@ -240,3 +237,104 @@ def model(data): kernel = HMCECS(NUTS(model), num_blocks=10) mcmc = MCMC(kernel, 10, 10) mcmc.run(random.PRNGKey(0), data) + + +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +@pytest.mark.parametrize('num_block', [1, 2, 50]) +@pytest.mark.parametrize('subsample_size', [50, 150]) +def test_hmcecs_normal_normal(kernel_cls, num_block, subsample_size): + true_loc = jnp.array([0.3, 0.1, 0.9]) + num_warmup, num_samples = 200, 200 + data = true_loc + dist.Normal(jnp.zeros(3, ), jnp.ones(3, )).sample(random.PRNGKey(1), (10000,)) + + def model(data, subsample_size): + mean = numpyro.sample('mean', dist.Normal().expand((3,)).to_event(1)) + with numpyro.plate('batch', data.shape[0], dim=-2, subsample_size=subsample_size): + sub_data = numpyro.subsample(data, 0) + numpyro.sample("obs", dist.Normal(mean, 1), obs=sub_data) + + ref_params = {'mean': true_loc + dist.Normal(true_loc, 5e-2).sample(random.PRNGKey(0))} + proxy_fn = taylor_proxy(ref_params) + + kernel = HMCECS(kernel_cls(model), proxy=proxy_fn) + mcmc = MCMC(kernel, num_warmup, num_samples) + mcmc.run(random.PRNGKey(0), data, subsample_size) + + samples = mcmc.get_samples() + assert_allclose(np.mean(mcmc.get_samples()['mean'], axis=0), true_loc, atol=0.1) + assert len(samples['mean']) == num_samples + + +@pytest.mark.parametrize('subsample_size', [5, 10, 15]) +def test_taylor_proxy_norm(subsample_size): + data_key, tr_key, rng_key = random.split(random.PRNGKey(0), 3) + ref_params = jnp.array([0.1, 0.5, -0.2]) + sigma = .1 + + data = ref_params + dist.Normal(jnp.zeros(3), jnp.ones(3)).sample(data_key, (100,)) + n, _ = data.shape + + def model(data, subsample_size): + mean = numpyro.sample('mean', dist.Normal(ref_params, jnp.ones_like(ref_params))) + with numpyro.plate('data', data.shape[0], subsample_size=subsample_size, dim=-2) as idx: + numpyro.sample('obs', dist.Normal(mean, sigma), obs=data[idx]) + + def log_prob_fn(params): + return vmap(dist.Normal(params, sigma).log_prob)(data).sum(-1) + + log_prob = log_prob_fn(ref_params) + log_norm_jac = jacrev(log_prob_fn)(ref_params) + log_norm_hessian = hessian(log_prob_fn)(ref_params) + + tr = numpyro.handlers.trace(numpyro.handlers.seed(model, tr_key)).get_trace(data, subsample_size) + plate_sizes = {'data': (n, subsample_size)} + + proxy_constructor = taylor_proxy({'mean': ref_params}) + proxy_fn, gibbs_init, gibbs_update = proxy_constructor(tr, plate_sizes, model, (data, subsample_size), {}) + + def taylor_expand_2nd_order(idx, pos): + return log_prob[idx] + (log_norm_jac[idx] @ pos) + .5 * (pos @ log_norm_hessian[idx]) @ pos + + def taylor_expand_2nd_order_sum(pos): + return log_prob.sum() + log_norm_jac.sum(0) @ pos + .5 * pos @ log_norm_hessian.sum(0) @ pos + + for _ in range(5): + split_key, perturbe_key, rng_key = random.split(rng_key, 3) + perturbe_params = ref_params + dist.Normal(.1, 0.1).sample(perturbe_key, ref_params.shape) + subsample_idx = random.randint(rng_key, (subsample_size,), 0, n) + gibbs_site = {'data': subsample_idx} + proxy_state = gibbs_init(None, gibbs_site) + actual_proxy_sum, actual_proxy_sub = proxy_fn({'data': perturbe_params}, ['data'], proxy_state) + assert_allclose(actual_proxy_sub['data'], + taylor_expand_2nd_order(subsample_idx, perturbe_params - ref_params), rtol=1e-5) + assert_allclose(actual_proxy_sum['data'], taylor_expand_2nd_order_sum(perturbe_params - ref_params), rtol=1e-5) + + +@pytest.mark.filterwarnings('ignore::UserWarning') +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +def test_estimate_likelihood(kernel_cls): + data_key, tr_key, sub_key, rng_key = random.split(random.PRNGKey(0), 4) + ref_params = jnp.array([0.1, 0.5, -0.2]) + sigma = .1 + data = ref_params + dist.Normal(jnp.zeros(3), jnp.ones(3)).sample(data_key, (10_000,)) + n, _ = data.shape + num_warmup = 200 + num_samples = 200 + num_blocks = 20 + + def model(data): + mean = numpyro.sample('mean', dist.Normal(ref_params, jnp.ones_like(ref_params))) + with numpyro.plate('N', data.shape[0], subsample_size=100, dim=-2) as idx: + numpyro.sample('obs', dist.Normal(mean, sigma), obs=data[idx]) + + proxy_fn = taylor_proxy({'mean': ref_params}) + kernel = HMCECS(kernel_cls(model), proxy=proxy_fn, num_blocks=num_blocks) + mcmc = MCMC(kernel, num_warmup, num_samples) + + mcmc.run(random.PRNGKey(0), data, extra_fields=['hmc_state.potential_energy']) + + pes = mcmc.get_extra_fields()['hmc_state.potential_energy'] + samples = mcmc.get_samples() + pes_full = vmap(lambda sample: log_density(model, (data,), {}, {**sample, **{'N': jnp.arange(n)}})[0])(samples) + + assert jnp.var(jnp.exp(-pes - pes_full)) < 1. From 5da83d0c2a19d8d9da61f93edf688b1ee5bee7e2 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 11 Feb 2021 13:40:10 -0600 Subject: [PATCH 050/222] add positive ordered vector transform, deprecate InvCholeskyTransform (#913) --- docs/source/distributions.rst | 20 ++++++++++++ numpyro/distributions/constraints.py | 16 +++++++++ numpyro/distributions/continuous.py | 4 +-- numpyro/distributions/transforms.py | 49 ++++++++++++++++++++++++++-- test/test_distributions.py | 4 ++- 5 files changed, 88 insertions(+), 5 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 5ab0222ef..be9716599 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -526,6 +526,10 @@ positive_integer ----------------- .. autodata:: numpyro.distributions.constraints.positive_integer +positive_ordered_vector +----------------------- +.. autodata:: numpyro.distributions.constraints.positive_ordered_vector + real ---- .. autodata:: numpyro.distributions.constraints.real @@ -574,6 +578,14 @@ AffineTransform :show-inheritance: :member-order: bysource +CholeskyTransform +----------------- +.. autoclass:: numpyro.distributions.transforms.CholeskyTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + ComposeTransform ---------------- .. autoclass:: numpyro.distributions.transforms.ComposeTransform @@ -590,6 +602,14 @@ CorrCholeskyTransform :show-inheritance: :member-order: bysource +CorrMatrixCholeskyTransform +--------------------------- +.. autoclass:: numpyro.distributions.transforms.CorrMatrixCholeskyTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + ExpTransform ------------ .. autoclass:: numpyro.distributions.transforms.ExpTransform diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 5f9314a25..e96da6e8d 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -333,6 +333,21 @@ def feasible_like(self, prototype): return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) +class _PositiveOrderedVector(Constraint): + """ + Constrains to a positive real-valued tensor where the elements are monotonically + increasing along the `event_shape` dimension. + """ + event_dim = 1 + + def __call__(self, x): + return ordered_vector.check(x) & independent(positive, 1).check(x) + + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(jax.numpy.exp(jax.numpy.arange(float(prototype.shape[-1]))), + prototype.shape) + + class _Real(Constraint): def __call__(self, x): # XXX: consider to relax this condition to [-inf, inf] interval @@ -372,6 +387,7 @@ def feasible_like(self, prototype): positive = _GreaterThan(0.) positive_definite = _PositiveDefinite() positive_integer = _IntegerGreaterThan(1) +positive_ordered_vector = _PositiveOrderedVector() real = _Real() real_vector = independent(real, 1) simplex = _Simplex() diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 3f6dbc5dc..f4b87cef6 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -35,7 +35,7 @@ from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution, TransformedDistribution -from numpyro.distributions.transforms import AffineTransform, ExpTransform, InvCholeskyTransform, PowerTransform +from numpyro.distributions.transforms import AffineTransform, CorrMatrixCholeskyTransform, ExpTransform, PowerTransform from numpyro.distributions.util import ( cholesky_of_inverse, is_prng_key, @@ -446,7 +446,7 @@ def __init__(self, dimension, concentration=1., sample_method='onion', validate_ base_dist = LKJCholesky(dimension, concentration, sample_method) self.dimension, self.concentration = base_dist.dimension, base_dist.concentration self.sample_method = sample_method - super(LKJ, self).__init__(base_dist, InvCholeskyTransform(domain=constraints.corr_cholesky), + super(LKJ, self).__init__(base_dist, CorrMatrixCholeskyTransform().inv, validate_args=validate_args) @property diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index e6981f32c..c405124a6 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -29,8 +29,10 @@ 'biject_to', 'AbsTransform', 'AffineTransform', + 'CholeskyTransform', 'ComposeTransform', 'CorrCholeskyTransform', + 'CorrMatrixCholeskyTransform', 'ExpTransform', 'IdentityTransform', 'InvCholeskyTransform', @@ -315,6 +317,27 @@ def _matrix_inverse_shape(shape, offset=0): return shape[:-2] + (N,) +class CholeskyTransform(Transform): + r""" + Transform via the mapping :math:`y = cholesky(x)`, where `x` is a + positive definite matrix. + """ + domain = constraints.positive_definite + codomain = constraints.lower_cholesky + + def __call__(self, x): + return jnp.linalg.cholesky(x) + + def _inverse(self, y): + return jnp.matmul(y, jnp.swapaxes(y, -2, -1)) + + def log_abs_det_jacobian(self, x, y, intermediates=None): + # Ref: http://web.mit.edu/18.325/www/handouts/handout2.pdf page 13 + n = jnp.shape(x)[-1] + order = -jnp.arange(n, 0, -1) + return -n * jnp.log(2) + jnp.sum(order * jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1)), axis=-1) + + class CorrCholeskyTransform(Transform): r""" Transforms a uncontrained real vector :math:`x` with length :math:`D*(D-1)/2` into the @@ -384,6 +407,21 @@ def inverse_shape(self, shape): return _matrix_inverse_shape(shape, offset=-1) +class CorrMatrixCholeskyTransform(CholeskyTransform): + r""" + Transform via the mapping :math:`y = cholesky(x)`, where `x` is a + correlation matrix. + """ + domain = constraints.corr_matrix + codomain = constraints.corr_cholesky + + def log_abs_det_jacobian(self, x, y, intermediates=None): + # NB: see derivation in LKJCholesky implementation + n = jnp.shape(x)[-1] + order = -jnp.arange(n - 1, -1, -1) + return jnp.sum(order * jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1)), axis=-1) + + class ExpTransform(Transform): # TODO: refine domain/codomain logic through setters, especially when # transforms for inverses are supported @@ -477,6 +515,8 @@ class InvCholeskyTransform(Transform): """ def __init__(self, domain=constraints.lower_cholesky): + warnings.warn("InvCholeskyTransform is deprecated. Please use CholeskyTransform" + " or CorrMatrixCholeskyTransform instead.", FutureWarning) assert domain in [constraints.lower_cholesky, constraints.corr_cholesky] self.domain = domain @@ -779,7 +819,7 @@ def _transform_to_corr_cholesky(constraint): @biject_to.register(constraints.corr_matrix) def _transform_to_corr_matrix(constraint): return ComposeTransform([CorrCholeskyTransform(), - InvCholeskyTransform(domain=constraints.corr_cholesky)]) + CorrMatrixCholeskyTransform().inv]) @biject_to.register(constraints.greater_than) @@ -826,7 +866,12 @@ def _transform_to_ordered_vector(constraint): @biject_to.register(constraints.positive_definite) def _transform_to_positive_definite(constraint): - return ComposeTransform([LowerCholeskyTransform(), InvCholeskyTransform()]) + return ComposeTransform([LowerCholeskyTransform(), CholeskyTransform().inv]) + + +@biject_to.register(constraints.positive_ordered_vector) +def _transform_to_positive_ordered_vector(constraint): + return ComposeTransform([OrderedTransform(), ExpTransform()]) @biject_to.register(constraints.real) diff --git a/test/test_distributions.py b/test/test_distributions.py index d29a8a167..c601e6952 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -953,6 +953,7 @@ def test_constraints(constraint, x, expected): constraints.ordered_vector, constraints.positive, constraints.positive_definite, + constraints.positive_ordered_vector, constraints.real, constraints.real_vector, constraints.simplex, @@ -1001,7 +1002,8 @@ def test_biject_to(constraint, shape): if constraint is constraints.simplex: expected = np.linalg.slogdet(jax.jacobian(transform)(x)[:-1, :])[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y)[:, :-1])[1] - elif constraint in [constraints.real_vector, constraints.ordered_vector]: + elif constraint in [constraints.real_vector, constraints.ordered_vector, + constraints.positive_ordered_vector]: expected = np.linalg.slogdet(jax.jacobian(transform)(x))[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y))[1] elif constraint in [constraints.corr_cholesky, constraints.corr_matrix]: From 0b2002ba1ccd9073e9dcda569ca2cb63f974dd41 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 12 Feb 2021 11:24:54 -0600 Subject: [PATCH 051/222] mention that progress_bar=False can require more memory (#904) --- numpyro/infer/mcmc.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 836b1c6d4..f8ab76fb0 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -200,7 +200,8 @@ class MCMC(object): .. note:: `chain_method` is an experimental arg, which might be removed in a future version. - .. note:: Setting `progress_bar=False` will improve the speed for many cases. + .. note:: Setting `progress_bar=False` will improve the speed for many cases. But it might + require more memory than the other option. :param MCMCKernel sampler: an instance of :class:`~numpyro.infer.mcmc.MCMCKernel` that determines the sampler for running MCMC. Currently, only :class:`~numpyro.infer.hmc.HMC` From d37307b6555b50fb65df0417067625ba036c72c3 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 12 Feb 2021 11:26:01 -0600 Subject: [PATCH 052/222] add regression test (#912) --- numpyro/infer/svi.py | 4 ++-- test/test_svi.py | 12 ++++++++++++ 2 files changed, 14 insertions(+), 2 deletions(-) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index bf954b55b..2c4544a5f 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -176,15 +176,15 @@ def body_fn(svi_state, carry): if progress_bar: losses = [] with tqdm.trange(1, num_steps + 1) as t: - batch = num_steps // 20 + batch = max(num_steps // 20, 1) for i in t: svi_state, loss = jit(body_fn)(svi_state, None) + losses.append(loss) if i % batch == 0: avg_loss = sum(losses[i-batch:]) / batch t.set_postfix_str("init loss: {:.4f}, avg. loss [{}-{}]: {:.4f}" .format(losses[0], i - batch + 1, i, avg_loss), refresh=False) - losses.append(loss) losses = jnp.stack(losses) else: svi_state, losses = lax.scan(body_fn, svi_state, None, length=num_steps) diff --git a/test/test_svi.py b/test/test_svi.py index d265fd617..e8b0704c3 100644 --- a/test/test_svi.py +++ b/test/test_svi.py @@ -174,3 +174,15 @@ def guide(): assert jnp.isfinite(actual_loss) expected_loss = x_guide.log_prob(x) - x_prior.log_prob(x) assert_allclose(actual_loss, expected_loss) + + +@pytest.mark.parametrize("num_steps", [10, 30, 50]) +def test_run_with_small_num_steps(num_steps): + def model(): + pass + + def guide(): + pass + + svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) + svi.run(random.PRNGKey(0), num_steps) From 989f31760cfe41c53c00c0c3618eb248a1324b13 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Fri, 12 Feb 2021 21:53:14 -0500 Subject: [PATCH 053/222] Add goodness of fit helpers for testing distributions (#916) * Add numpyro.distributions.gof module and a test_gof * make license --- Makefile | 6 +- numpyro/distributions/gof.py | 367 +++++++++++++++++++++++++++++++++++ numpyro/handlers.py | 1 + scripts/update_headers.py | 29 ++- setup.cfg | 1 - setup.py | 3 +- test/test_distributions.py | 31 +++ test/test_hmc_gibbs.py | 1 + 8 files changed, 431 insertions(+), 8 deletions(-) create mode 100644 numpyro/distributions/gof.py diff --git a/Makefile b/Makefile index af7088bf5..b9a69c0f8 100644 --- a/Makefile +++ b/Makefile @@ -2,8 +2,12 @@ all: test lint: FORCE flake8 + python scripts/update_headers.py --check -format: FORCE +license: FORCE + python scripts/update_headers.py + +format: license FORCE isort -rc . install: FORCE diff --git a/numpyro/distributions/gof.py b/numpyro/distributions/gof.py new file mode 100644 index 000000000..0439e2482 --- /dev/null +++ b/numpyro/distributions/gof.py @@ -0,0 +1,367 @@ +# Copyright Contributors to the Pyro project. +# Copyright (c) 2015, Gamelan Labs, Inc. +# Copyright (c) 2016, Google, Inc. +# Copyright (c) 2019, Gamalon, Inc. +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# - Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# - Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# - Neither the name of Salesforce.com nor the names of its contributors +# may be used to endorse or promote products derived from this +# software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR +# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE +# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +""" +Goodness of Fit Testing +----------------------- + +This module implements goodness of fit tests for checking agreement between +distributions' ``.sample()`` and ``.log_prob()`` methods. The main functions +return a goodness of fit p-value ``gof`` which for good data should be +``Uniform(0,1)`` distributed and for bad data should be close to zero. To use +this returned number in tests, set a global variable ``TEST_FAILURE_RATE`` to +something smaller than 1 / number of tests in your suite, then in each test +assert ``gof > TEST_FAILURE_RATE``. For example:: + + TEST_FAILURE_RATE = 1 / 20 # For 1 in 20 chance of spurious failure. + + def test_my_distribution(): + d = MyDistribution() + samples = d.sample([10000]) + probs = d.log_prob(samples).exp() + gof = auto_goodness_of_fit(samples, probs) + assert gof > TEST_FAILURE_RATE + +This module is a port of the +`goftests `_ library. +""" + +import math +import sys +import warnings + +import numpy as np + +import jax + +HISTOGRAM_WIDTH = 60 + + +class InvalidTest(ValueError): + pass + + +def print_histogram(probs, counts): + max_count = max(counts) + print('{: >8} {: >8}'.format('Prob', 'Count')) + for prob, count in sorted(zip(probs, counts), reverse=True): + width = int(round(HISTOGRAM_WIDTH * count / max_count)) + print('{: >8.3f} {: >8d} {}'.format(prob, count, '-' * width)) + + +def multinomial_goodness_of_fit( + probs, + counts, + *, + total_count=None, + plot=False, +): + """ + Pearson's chi^2 test, on possibly truncated data. + https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test + + :param numpy.ndarray probs: Vector of probabilities. + :param numpy.ndarray counts: Vector of counts. + :param int total_count: Optional total count in case data is truncated, + otherwise None. + :param bool plot: Whether to print a histogram. Defaults to False. + :returns: p-value of truncated multinomial sample. + :rtype: float + """ + probs = jax.lax.stop_gradient(probs) + assert len(probs.shape) == 1 + assert probs.shape == counts.shape + if total_count is None: + truncated = False + total_count = int(counts.sum()) + else: + truncated = True + assert total_count >= counts.sum() + if plot: + print_histogram(probs, counts) + + chi_squared = 0 + dof = 0 + for p, c in zip(probs.tolist(), counts.tolist()): + if abs(p - 1) < 1e-8: + return 1 if c == total_count else 0 + assert p < 1, f'bad probability: {p:g}' + if p > 0: + mean = total_count * p + variance = total_count * p * (1 - p) + if not (variance > 1): + raise InvalidTest('Goodness of fit is inaccurate; use more samples') + chi_squared += (c - mean) ** 2 / variance + dof += 1 + else: + warnings.warn('Zero probability in goodness-of-fit test') + if c > 0: + return math.inf + + if not truncated: + dof -= 1 + + survival = _chi2sf(chi_squared, dof) + return survival + + +def unif01_goodness_of_fit(samples, *, plot=False): + """ + Bin uniformly distributed samples and apply Pearson's chi^2 test. + + :param numpy.ndarray samples: A vector of real-valued samples from a + candidate distribution that should be Uniform(0, 1)-distributed. + :param bool plot: Whether to print a histogram. Defaults to False. + :returns: Goodness of fit, as a p-value. + :rtype: float + """ + samples = jax.lax.stop_gradient(samples) + assert samples.min() >= 0 + assert samples.max() <= 1 + bin_count = int(round(len(samples) ** 0.333)) + if bin_count < 7: + raise InvalidTest('imprecise test, use more samples') + probs = np.ones(bin_count) / bin_count + binned = (samples * bin_count).astype(np.int) + binned = np.clip(binned, 0, bin_count - 1) + counts = np.bincount(binned, minlength=bin_count) + return multinomial_goodness_of_fit(probs, counts, plot=plot) + + +def exp_goodness_of_fit(samples, plot=False): + """ + Transform exponentially distribued samples to Uniform(0,1) distribution and + assess goodness of fit via binned Pearson's chi^2 test. + + :param numpy.ndarray samples: A vector of real-valued samples from a + candidate distribution that should be Exponential(1)-distributed. + :param bool plot: Whether to print a histogram. Defaults to False. + :returns: Goodness of fit, as a p-value. + :rtype: float + """ + samples = jax.lax.stop_gradient(samples) + unif01_samples = np.exp(-samples) + return unif01_goodness_of_fit(unif01_samples, plot=plot) + + +def density_goodness_of_fit(samples, probs, plot=False): + """ + Transform arbitrary continuous samples to Uniform(0,1) distribution and + assess goodness of fit via binned Pearson's chi^2 test. + + :param numpy.ndarray samples: A vector list of real-valued samples from a + distribution. + :param numpy.ndarray probs: A vector of probability densities evaluated at + those samples. + :param bool plot: Whether to print a histogram. Defaults to False. + :returns: Goodness of fit, as a p-value. + :rtype: float + """ + samples = jax.lax.stop_gradient(samples) + probs = jax.lax.stop_gradient(probs) + assert samples.shape == probs.shape + if len(samples) <= 100: + raise InvalidTest('imprecision; use more samples') + + index = np.argsort(samples, 0, kind='quicksort') + samples = samples[index] + probs = probs[index] + gaps = samples[1:] - samples[:-1] + + sparsity = 1 / probs + sparsity = 0.5 * (sparsity[1:] + sparsity[:-1]) + density = len(samples) / sparsity + + exp_samples = density * gaps + return exp_goodness_of_fit(exp_samples, plot=plot) + + +def volume_of_sphere(dim, radius): + return radius ** dim * math.pi ** (0.5 * dim) / math.gamma(0.5 * dim + 1) + + +def get_nearest_neighbor_distances(samples): + try: + # This version scales as O(N log(N)). + from scipy.spatial import cKDTree + distances, indices = cKDTree(samples).query(samples, k=2) + return distances[:, 1] + except ImportError: + # This version scales as O(N^2). + x = samples + x2 = (x * x).sum(-1) + d2 = x2[:, None] + x2 - 2 * x @ x.T + min_d2 = np.partition(d2, 1)[:, 1] + return np.sqrt(np.clip(min_d2, 0, None)) + + +def vector_density_goodness_of_fit(samples, probs, *, dim=None, plot=False): + """ + Transform arbitrary multivariate continuous samples to Univariate(0,1) + distribution via nearest neighbor distribution [1,2,3] and assess goodness + of fit via binned Pearson's chi^2 test. + + [1] Peter J. Bickel and Leo Breiman (1983) + "Sums of Functions of Nearest Neighbor Distances, Moment Bounds, Limit + Theorems and a Goodness of Fit Test" + https://projecteuclid.org/download/pdf_1/euclid.aop/1176993668 + [2] Mike Williams (2010) + "How good are your fits? Unbinned multivariate goodness-of-fit tests in + high energy physics." + https://arxiv.org/abs/1006.3019 + [3] Nearest Neighbour Distribution + https://en.wikipedia.org/wiki/Nearest_neighbour_distribution + + :param numpy.ndarray samples: A tensor of real-vector-valued samples from a + distribution. + :param numpy.ndarray probs: A vector of probability densities evaluated at + those samples. + :param int dim: Optional dimension of the submanifold on which data lie. + Defaults to ``samples.shape[-1]``. + :param bool plot: Whether to print a histogram. Defaults to False. + :returns: Goodness of fit, as a p-value. + :rtype: float + """ + samples = jax.lax.stop_gradient(samples) + probs = jax.lax.stop_gradient(probs) + assert samples.shape and len(samples) + assert probs.shape == samples.shape[:1] + if dim is None: + dim = samples.shape[-1] + assert dim + if len(samples) <= 1000 * dim: + raise InvalidTest('imprecision; use more samples') + radii = get_nearest_neighbor_distances(samples) + density = len(samples) * probs + volume = volume_of_sphere(dim, radii) + exp_samples = density * volume + return exp_goodness_of_fit(exp_samples, plot=plot) + + +def auto_goodness_of_fit(samples, probs, *, dim=None, plot=False): + """ + Dispatch on sample dimension and delegate to either + :func:`density_goodness_of_fit` or :func:`vector_density_goodness_of_fit`. + + :param numpy.ndarray samples: A tensor of samples stacked on their leftmost + dimension. + :param numpy.ndarray probs: A vector of probabilities evaluated at those + samples. + :param int dim: Optional manifold dimension, defaults to + ``samples[:1].size``. + :param bool plot: Whether to print a histogram. Defaults to False. + """ + samples = jax.lax.stop_gradient(samples) + probs = jax.lax.stop_gradient(probs) + assert samples.shape and samples.shape[0] + assert probs.shape == samples.shape[:1] + + samples = samples.reshape(samples.shape[0], -1) + ambient_dim = samples[:1].size + if dim is None: + dim = ambient_dim + + if ambient_dim == 0: + return 1.0 + if ambient_dim == 1: + samples = samples.reshape(-1) + return density_goodness_of_fit(samples, probs, plot=plot) + return vector_density_goodness_of_fit(samples, probs, dim=dim, plot=plot) + + +def _safe_log(x): + if x > sys.float_info.min: + value = math.log(x) + else: + value = -math.inf + return value + + +def _incomplete_gamma(x, s): + r""" + This function computes the incomplete lower gamma function + using the series expansion: + + .. math:: + + \gamma(x, s) = x^s \Gamma(s)e^{-x}\sum^\infty_{k=0} + \frac{x^k}{\Gamma(s + k + 1)} + + This series will converge strongly because the Gamma + function grows factorially. + + Because the Gamma function does grow so quickly, we can + run into numerical stability issues. To solve this we carry + out as much math as possible in the log domain to reduce + numerical error. This function matches the results from + scipy to numerical precision. + """ + if x < 0: + return 1 + if x > 1e3: + return math.gamma(s) + log_gamma_s = math.lgamma(s) + log_x = _safe_log(x) + value = 0 + for k in range(100): + log_num = (k + s) * log_x + (-x) + log_gamma_s + log_denom = math.lgamma(k + s + 1) + value += math.exp(log_num - log_denom) + return value + + +def _chi2sf(x, s): + r""" + This function returns the survival function of the chi^2 + distribution. The survival function is given as: + + .. math:: + 1 - CDF + + where rhe chi^2 CDF is given as + + .. math:: + F(x; s) = \frac{ \gamma( x/2, s/2 ) }{ \Gamma(s/2) }, + + with :math:`\gamma` is the incomplete gamma function defined above. + Therefore, the survival probability is givne by: + + .. math:: + 1 - \frac{ \gamma( x/2, s/2 ) }{ \Gamma(s/2) }. + + This function matches the results from + scipy to numerical precision. + """ + top = _incomplete_gamma(x / 2, s / 2) + bottom = math.gamma(s / 2) + value = top / bottom + return 1 - value diff --git a/numpyro/handlers.py b/numpyro/handlers.py index a40572504..bab065487 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -1,5 +1,6 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 + """ This provides a small set of effect handlers in NumPyro that are modeled after Pyro's `poutine `_ module. diff --git a/scripts/update_headers.py b/scripts/update_headers.py index 566c85324..284d2d219 100644 --- a/scripts/update_headers.py +++ b/scripts/update_headers.py @@ -1,8 +1,10 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +import argparse import glob import os +import sys root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) blacklist = ["/build/", "/dist/", "/pyro_api.egg"] @@ -11,6 +13,11 @@ ("*.cpp", "// {}"), ] +parser = argparse.ArgumentParser() +parser.add_argument("--check", action="store_true") +args = parser.parse_args() +dirty = [] + for basename, comment in file_types: copyright_line = comment.format("Copyright Contributors to the Pyro project.\n") # See https://spdx.org/ids-how @@ -32,11 +39,11 @@ continue # Ensure first few line are copyright notices. + changed = False lineno = 0 if not lines[lineno].startswith(comment.format("Copyright")): lines.insert(lineno, copyright_line) - else: - lines[lineno] = copyright_line + changed = True lineno += 1 while lines[lineno].startswith(comment.format("Copyright")): lineno += 1 @@ -44,15 +51,27 @@ # Ensure next line is an SPDX short identifier. if not lines[lineno].startswith(comment.format("SPDX-License-Identifier")): lines.insert(lineno, spdx_line) - else: - lines[lineno] = spdx_line + changed = True lineno += 1 # Ensure next line is blank. - if not lines[lineno].isspace(): + if lineno < len(lines) and not lines[lineno].isspace(): lines.insert(lineno, "\n") + changed = True + + if not changed: + continue + + if args.check: + dirty.append(filename) + continue with open(filename, "w") as f: f.write("".join(lines)) print("updated {}".format(filename[len(root) + 1:])) + +if dirty: + print("The following files need license headers:\n{}".format("\n".join(dirty))) + print("Please run 'make license'") + sys.exit(1) diff --git a/setup.cfg b/setup.cfg index 3759d08ef..93f080d30 100644 --- a/setup.cfg +++ b/setup.cfg @@ -4,7 +4,6 @@ exclude = docs/src, build, dist, .ipynb_checkpoints [isort] line_length = 120 -not_skip = __init__.py skip_glob = .ipynb_checkpoints known_first_party = funsor, numpyro, test known_third_party = opt_einsum diff --git a/setup.py b/setup.py index dcad69e77..4ad1c9adf 100644 --- a/setup.py +++ b/setup.py @@ -43,7 +43,8 @@ 'test': [ 'flake8', 'pytest>=4.1', - 'pyro-api>=0.1.1' + 'pyro-api>=0.1.1', + 'scipy>=1.1', ], 'dev': [ 'dm-haiku', diff --git a/test/test_distributions.py b/test/test_distributions.py index c601e6952..d8b746c38 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -21,6 +21,7 @@ from numpyro.distributions import constraints, kl_divergence, transforms from numpyro.distributions.discrete import _to_probs_bernoulli, _to_probs_multinom from numpyro.distributions.flows import InverseAutoregressiveTransform +from numpyro.distributions.gof import InvalidTest, auto_goodness_of_fit from numpyro.distributions.transforms import LowerCholeskyAffine, PermuteTransform, PowerTransform, biject_to from numpyro.distributions.util import ( matrix_to_tril_vec, @@ -31,6 +32,8 @@ ) from numpyro.nn import AutoregressiveNN +TEST_FAILURE_RATE = 2e-5 # For all goodness-of-fit tests. + def _identity(x): return x @@ -516,6 +519,34 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): assert_allclose(jit_fn(jax_dist.log_prob)(samples), expected, atol=1e-5) +@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) +def test_gof(jax_dist, sp_dist, params): + if "Improper" in jax_dist.__name__: + pytest.skip("distribution has improper .log_prob()") + if "LKJ" in jax_dist.__name__: + pytest.xfail("incorrect submanifold scaling") + + num_samples = 10000 + rng_key = random.PRNGKey(0) + d = jax_dist(*params) + samples = d.sample(key=rng_key, sample_shape=(num_samples,)) + probs = np.exp(d.log_prob(samples)) + + # Test each batch independently. + probs = probs.reshape(num_samples, -1) + samples = samples.reshape(probs.shape + d.event_shape) + if "Dirichlet" in jax_dist.__name__: + # The Dirichlet density is over all but one of the probs. + samples = samples[..., :-1] + for b in range(probs.shape[-1]): + try: + gof = auto_goodness_of_fit(samples[:, b], probs[:, b]) + except InvalidTest: + pytest.skip("expensive test") + else: + assert gof > TEST_FAILURE_RATE + + @pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE) def test_independent_shape(jax_dist, sp_dist, params): d = jax_dist(*params) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index e15eb47e0..c248f4a21 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -1,5 +1,6 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 + from functools import partial import numpy as np From 77a5711defbd87e44f226c3444025a31443521b8 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 13 Feb 2021 15:03:44 -0600 Subject: [PATCH 054/222] Fix DiscreteHMCGibbs to work with multiple chains (#908) * fix chain mcmc * assert when there is no gibbs sites * fix numerical tests * skip doctest for print_summary --- .github/workflows/ci.yml | 1 + numpyro/infer/hmc_gibbs.py | 14 ++++++++------ numpyro/infer/hmc_util.py | 10 +++++++++- test/test_hmc_gibbs.py | 8 +++++--- test/test_hmc_util.py | 2 +- 5 files changed, 24 insertions(+), 11 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 78a530886..7b74b9c92 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -78,6 +78,7 @@ jobs: run: | XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/test_mcmc.py -k "chain or pmap or vmap" XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/contrib/test_tfp.py -k "chain" + XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/test_hmc_gibbs.py -k "chain" examples: diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index ef6881123..970f33369 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -6,6 +6,8 @@ from functools import partial import warnings +import numpy as np + from jax import device_put, grad, hessian, jacfwd, jacobian, lax, ops, random, value_and_grad import jax.numpy as jnp from jax.scipy.special import expit @@ -294,13 +296,11 @@ class DiscreteHMCGibbs(HMCGibbs): corresponding :func:`~numpyro.primitives.sample` statement. :param inner_kernel: One of :class:`~numpyro.infer.hmc.HMC` or :class:`~numpyro.infer.hmc.NUTS`. - :param list discrete_sites: a list of site names for the discrete latent variables - that are covered by the Gibbs sampler. :param bool random_walk: If False, Gibbs sampling will be used to draw a sample from the conditional `p(gibbs_site | remaining sites)`. Otherwise, a sample will be drawn uniformly - from the domain of `gibbs_site`. + from the domain of `gibbs_site`. Defaults to False. :param bool modified: whether to use a modified proposal, as suggested in reference [1], which - always proposes a new state for the current Gibbs site. + always proposes a new state for the current Gibbs site. Defaults to False. The modified scheme appears in the literature under the name "modified Gibbs sampler" or "Metropolised Gibbs sampler". @@ -328,7 +328,7 @@ class DiscreteHMCGibbs(HMCGibbs): >>> kernel = DiscreteHMCGibbs(NUTS(model), modified=True) >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) >>> mcmc.run(random.PRNGKey(0), probs, locs) - >>> mcmc.print_summary() + >>> mcmc.print_summary() # doctest: +SKIP >>> samples = mcmc.get_samples()["x"] >>> assert abs(jnp.mean(samples) - 1.3) < 0.1 >>> assert abs(jnp.var(samples) - 4.36) < 0.5 @@ -356,7 +356,7 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) self._support_sizes = { - name: jnp.broadcast_to(site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"])) + name: np.broadcast_to(site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"])) for name, site in self._prototype_trace.items() if site["type"] == "sample" and site["fn"].has_enumerate_support and not site["is_observed"] } @@ -365,6 +365,7 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): and site["fn"].has_enumerate_support and not site["is_observed"] and site["infer"].get("enumerate", "") != "parallel"] + assert self._gibbs_sites, "Cannot detect any discrete latent variables in the model." return super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) def sample(self, state, model_args, model_kwargs): @@ -533,6 +534,7 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size } self._gibbs_sites = list(self._subsample_plate_sizes.keys()) + assert self._gibbs_sites, "Cannot detect any subsample statements in the model." if self._proxy is not None: proxy_fn, gibbs_init, self._gibbs_update = self._proxy(self._prototype_trace, self._subsample_plate_sizes, diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index a97b33fc6..eafc0a3b7 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -415,7 +415,9 @@ def _update_at_window_end(z_info, rng_key_ss, state): if adapt_step_size: step_size = find_reasonable_step_size(step_size, inverse_mass_matrix, z_info, rng_key_ss) - ss_state = ss_init(jnp.log(10 * step_size)) + # NB: when step_size is large, say 1e38, jnp.log(10 * step_size) will be inf + # and jnp.log(10) + jnp.log(step_size) will be finite + ss_state = ss_init(jnp.log(10) + jnp.log(step_size)) return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, ss_state, mm_state, window_idx, rng_key) @@ -475,6 +477,8 @@ def _is_turning(inverse_mass_matrix, r_left, r_right, r_sum): elif inverse_mass_matrix.ndim == 1: v_left = jnp.multiply(inverse_mass_matrix, r_left) v_right = jnp.multiply(inverse_mass_matrix, r_right) + else: + raise ValueError("inverse_mass_matrix should have 1 or 2 dimensions.") # This implements dynamic termination criterion (ref [2], section A.4.2). r_sum = r_sum - (r_left + r_right) / 2 @@ -737,6 +741,8 @@ def euclidean_kinetic_energy(inverse_mass_matrix, r): v = jnp.matmul(inverse_mass_matrix, r) elif inverse_mass_matrix.ndim == 1: v = jnp.multiply(inverse_mass_matrix, r) + else: + raise ValueError("inverse_mass_matrix should have 1 or 2 dimensions.") return 0.5 * jnp.dot(v, r) @@ -748,6 +754,8 @@ def _euclidean_kinetic_energy_grad(inverse_mass_matrix, r): v = jnp.matmul(inverse_mass_matrix, r) elif inverse_mass_matrix.ndim == 1: v = jnp.multiply(inverse_mass_matrix, r) + else: + raise ValueError("inverse_mass_matrix should have 1 or 2 dimensions.") return unravel_fn(v) diff --git a/test/test_hmc_gibbs.py b/test/test_hmc_gibbs.py index c248f4a21..4ddc5f3ac 100644 --- a/test/test_hmc_gibbs.py +++ b/test/test_hmc_gibbs.py @@ -150,13 +150,15 @@ def model(): assert_allclose(x1_std, np.sqrt(np.diagonal(cov11)), rtol=0.1) -def test_discrete_gibbs_multiple_sites(): +@pytest.mark.parametrize("num_chains", [1, 2]) +@pytest.mark.filterwarnings("ignore:There are not enough devices:UserWarning") +def test_discrete_gibbs_multiple_sites_chain(num_chains): def model(): numpyro.sample("x", dist.Bernoulli(0.7).expand([3])) numpyro.sample("y", dist.Binomial(10, 0.3)) kernel = DiscreteHMCGibbs(NUTS(model)) - mcmc = MCMC(kernel, 1000, 10000, progress_bar=False) + mcmc = MCMC(kernel, 1000, 10000, num_chains=num_chains, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["x"], 0), 0.7 * jnp.ones(3), atol=0.01) @@ -202,7 +204,7 @@ def model(probs, locs): mcmc.run(random.PRNGKey(0), probs, locs) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["x"]), 1.3, atol=0.1) - assert_allclose(jnp.var(samples["x"]), 4.36, atol=0.1) + assert_allclose(jnp.var(samples["x"]), 4.36, atol=0.2) assert_allclose(jnp.mean(samples["c"]), 1.65, atol=0.1) assert_allclose(jnp.var(samples["c"]), 1.03, atol=0.1) diff --git a/test/test_hmc_util.py b/test/test_hmc_util.py index c330db2c0..8f7be95db 100644 --- a/test/test_hmc_util.py +++ b/test/test_hmc_util.py @@ -322,7 +322,7 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): assert window_idx == 3 # during the last window, because target_accept_prob=0.8, # log_step_size will be equal to the constant prox_center=log(10*last_step_size) - assert_allclose(step_size, last_step_size * 10) + assert_allclose(step_size, last_step_size * 10, atol=1e-6) # Verifies that inverse_mass_matrix does not change during the last window # despite z_flat changes w.r.t time t, assert_allclose(final_inverse_mass_matrix, inverse_mass_matrix) From 402a1f965266a996920694107f360c6741e17be4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ra=C3=BAl=20Peralta=20Lozada?= Date: Sun, 14 Feb 2021 14:00:01 -0600 Subject: [PATCH 055/222] add an example of how to use mask (#917) --- numpyro/distributions/distribution.py | 36 +++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 599424af0..314b42fa8 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -348,6 +348,42 @@ def mask(self, mask): :type mask: bool or jnp.ndarray :return: A masked copy of this distribution. :rtype: :class:`MaskedDistribution` + + **Example:** + + .. doctest:: + + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.distributions import constraints + >>> from numpyro.infer import SVI, Trace_ELBO + + >>> def model(data, m): + ... f = numpyro.sample("latent_fairness", dist.Beta(1, 1)) + ... with numpyro.plate("N", data.shape[0]): + ... # only take into account the values selected by the mask + ... masked_dist = dist.Bernoulli(f).mask(m) + ... numpyro.sample("obs", masked_dist, obs=data) + + + >>> def guide(data, m): + ... alpha_q = numpyro.param("alpha_q", 5., constraint=constraints.positive) + ... beta_q = numpyro.param("beta_q", 5., constraint=constraints.positive) + ... numpyro.sample("latent_fairness", dist.Beta(alpha_q, beta_q)) + + + >>> data = jnp.concatenate([jnp.ones(5), jnp.zeros(5)]) + >>> # select values equal to one + >>> masked_array = jnp.where(data == 1, True, False) + >>> optimizer = numpyro.optim.Adam(step_size=0.05) + >>> svi = SVI(model, guide, optimizer, loss=Trace_ELBO()) + >>> svi_result = svi.run(random.PRNGKey(0), 300, data, masked_array) + >>> params = svi_result.params + >>> # inferred_mean is closer to 1 + >>> inferred_mean = params["alpha_q"] / (params["alpha_q"] + params["beta_q"]) + """ if mask is True: return self From 53e7555e0afc7932e83677bd0dbb4f2089b9abd4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ra=C3=BAl=20Peralta=20Lozada?= Date: Mon, 15 Feb 2021 23:35:40 -0600 Subject: [PATCH 056/222] fix typo (#918) --- numpyro/handlers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index bab065487..0be31343c 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -383,7 +383,7 @@ def process_message(self, msg): class infer_config(Messenger): """ - Given a callable `fn` that contains Pyro primitive calls + Given a callable `fn` that contains NumPyro primitive calls and a callable `config_fn` taking a trace site and returning a dictionary, updates the value of the infer kwarg at a sample site to config_fn(site). From ff691bee1c3ae1a75e01b76858ced98dece69809 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 17 Feb 2021 07:58:25 -0600 Subject: [PATCH 057/222] Add one-sided/two-sided truncated distribution and cdf/icdf method for univariate symmetric distributions (#915) --- docs/source/distributions.rst | 8 + numpyro/distributions/__init__.py | 2 + numpyro/distributions/continuous.py | 330 +++++++++++++++++++++++--- numpyro/distributions/distribution.py | 18 ++ test/test_distributions.py | 73 +++++- 5 files changed, 397 insertions(+), 34 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index be9716599..d48c29435 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -245,6 +245,14 @@ TruncatedCauchy :show-inheritance: :member-order: bysource +TruncatedDistribution +--------------------- +.. autoclass:: numpyro.distributions.continuous.TruncatedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + TruncatedNormal --------------- .. autoclass:: numpyro.distributions.continuous.TruncatedNormal diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index cc5fbec9a..9f2cb662c 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -26,6 +26,7 @@ Pareto, StudentT, TruncatedCauchy, + TruncatedDistribution, TruncatedNormal, TruncatedPolyaGamma, Uniform @@ -121,6 +122,7 @@ 'StudentT', 'TransformedDistribution', 'TruncatedCauchy', + 'TruncatedDistribution', 'TruncatedNormal', 'TruncatedPolyaGamma', 'Uniform', diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index f4b87cef6..acfd7112e 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -26,12 +26,12 @@ # POSSIBILITY OF SUCH DAMAGE. -from jax import lax, ops +from jax import lax, ops, tree_map import jax.nn as nn import jax.numpy as jnp import jax.random as random from jax.scipy.linalg import cho_solve, solve_triangular -from jax.scipy.special import gammaln, log_ndtr, logsumexp, multigammaln, ndtr, ndtri +from jax.scipy.special import betainc, expit, gammaln, logit, log_ndtr, logsumexp, multigammaln, ndtr, ndtri from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution, TransformedDistribution @@ -81,6 +81,9 @@ def variance(self): total = self.concentration1 + self.concentration0 return self.concentration1 * self.concentration0 / (total ** 2 * (total + 1)) + def cdf(self, value): + return betainc(self.concentration1, self.concentration0, value) + class Cauchy(Distribution): arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} @@ -109,6 +112,13 @@ def mean(self): def variance(self): return jnp.full(self.batch_shape, jnp.nan) + def cdf(self, value): + scaled = (value - self.loc) / self.scale + return jnp.arctan(scaled) / jnp.pi + 0.5 + + def icdf(self, q): + return self.loc + self.scale * jnp.tan(jnp.pi * (q - 0.5)) + class Dirichlet(Distribution): arg_constraints = {'concentration': constraints.independent(constraints.positive, 1)} @@ -412,6 +422,14 @@ def mean(self): def variance(self): return jnp.broadcast_to(2 * self.scale ** 2, self.batch_shape) + def cdf(self, value): + scaled = (value - self.loc) / self.scale + return 0.5 - 0.5 * jnp.sign(scaled) * jnp.expm1(-jnp.abs(scaled)) + + def icdf(self, q): + a = q - 0.5 + return self.loc - self.scale * jnp.sign(a) * jnp.log1p(-2 * jnp.abs(a)) + class LKJ(TransformedDistribution): r""" @@ -659,6 +677,44 @@ def tree_flatten(self): return super(TransformedDistribution, self).tree_flatten() +class Logistic(Distribution): + arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + support = constraints.real + reparametrized_params = ['loc', 'scale'] + + def __init__(self, loc=0., scale=1., validate_args=None): + self.loc, self.scale = promote_shapes(loc, scale) + batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) + super(Logistic, self).__init__(batch_shape, validate_args=validate_args) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + z = random.logistic(key, shape=sample_shape + self.batch_shape + self.event_shape) + return self.loc + z * self.scale + + @validate_sample + def log_prob(self, value): + log_exponent = (self.loc - value) / self.scale + log_denominator = jnp.log(self.scale) + 2 * nn.softplus(log_exponent) + return log_exponent - log_denominator + + @property + def mean(self): + return jnp.broadcast_to(self.loc, self.batch_shape) + + @property + def variance(self): + var = (self.scale ** 2) * (jnp.pi ** 2) / 3 + return jnp.broadcast_to(var, self.batch_shape) + + def cdf(self, value): + scaled = (value - self.loc) / self.scale + return expit(scaled) + + def icdf(self, q): + return self.loc + self.scale * logit(q) + + def _batch_mahalanobis(bL, bx): if bL.shape[:-1] == bx.shape: # no need to use the below optimization procedure @@ -966,6 +1022,10 @@ def log_prob(self, value): value_scaled = (value - self.loc) / self.scale return -0.5 * value_scaled ** 2 - normalize_term + def cdf(self, value): + scaled = (value - self.loc) / self.scale + return ndtr(scaled) + def icdf(self, q): return self.loc + self.scale * ndtri(q) @@ -1049,6 +1109,241 @@ def variance(self): var = jnp.where(self.df <= 1, jnp.nan, var) return jnp.broadcast_to(var, self.batch_shape) + def cdf(self, value): + # Ref: https://en.wikipedia.org/wiki/Student's_t-distribution#Related_distributions + # X^2 ~ F(1, df) -> df / (df + X^2) ~ Beta(df/2, 0.5) + scaled = (value - self.loc) / self.scale + scaled_squared = scaled * scaled + beta_value = self.df / (self.df + scaled_squared) + # when scaled < 0, returns 0.5 * Beta(df/2, 0.5).cdf(beta_value) + # when scaled > 0, returns 1 - 0.5 * Beta(df/2, 0.5).cdf(beta_value) + return 0.5 * (1 + jnp.sign(scaled) * (1 - betainc(0.5 * self.df, 0.5, beta_value))) + + def icdf(self, q): + # scipy.special.betaincinv is not avaiable yet in JAX + # upstream issue: https://github.com/google/jax/issues/2399 + raise NotImplementedError + + +class LeftTruncatedDistribution(Distribution): + arg_constraints = {"low": constraints.real} + reparametrized_params = ["low"] + supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) + + def __init__(self, base_dist, low=0., validate_args=None): + assert isinstance(base_dist, self.supported_types) + assert base_dist.support is constraints.real, \ + "The base distribution should be univariate and have real support." + batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(low)) + self.base_dist = tree_map(lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist) + self.low, = promote_shapes(low, shape=batch_shape) + self._support = constraints.greater_than(low) + super().__init__(batch_shape, validate_args=validate_args) + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return self._support + + @lazy_property + def _tail_prob_at_low(self): + # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1., -1.) + return self.base_dist.cdf(loc - sign * (loc - self.low)) + + @lazy_property + def _tail_prob_at_high(self): + # if low < loc, returns cdf(high) = 1; otherwise returns 1 - cdf(high) = 0 + return jnp.where(self.low < self.base_dist.loc, 1., 0.) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + u = random.uniform(key, sample_shape + self.batch_shape) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1., -1.) + return (1 - sign) * loc + sign * self.base_dist.icdf( + (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high) + + @validate_sample + def log_prob(self, value): + sign = jnp.where(self.base_dist.loc >= self.low, 1., -1.) + return self.base_dist.log_prob(value) - \ + jnp.log(sign * (self._tail_prob_at_high - self._tail_prob_at_low)) + + def tree_flatten(self): + base_flatten, base_aux = self.base_dist.tree_flatten() + if isinstance(self._support.lower_bound, (int, float)): + return base_flatten, (type(self.base_dist), base_aux, self._support.lower_bound) + else: + return (base_flatten, self.low), (type(self.base_dist), base_aux) + + @classmethod + def tree_unflatten(cls, aux_data, params): + if len(aux_data) == 2: + base_flatten, low = params + base_cls, base_aux = aux_data + else: + base_flatten = params + base_cls, base_aux, low = aux_data + base_dist = base_cls.tree_unflatten(base_aux, base_flatten) + return cls(base_dist, low=low) + + +class RightTruncatedDistribution(Distribution): + arg_constraints = {"high": constraints.real} + reparametrized_params = ["high"] + supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) + + def __init__(self, base_dist, high=0., validate_args=None): + assert isinstance(base_dist, self.supported_types) + assert base_dist.support is constraints.real, \ + "The base distribution should be univariate and have real support." + batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(high)) + self.base_dist = tree_map(lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist) + self.high, = promote_shapes(high, shape=batch_shape) + self._support = constraints.less_than(high) + super().__init__(batch_shape, validate_args=validate_args) + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return self._support + + @lazy_property + def _cdf_at_high(self): + return self.base_dist.cdf(self.high) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + u = random.uniform(key, sample_shape + self.batch_shape) + return self.base_dist.icdf(u * self._cdf_at_high) + + @validate_sample + def log_prob(self, value): + return self.base_dist.log_prob(value) - jnp.log(self._cdf_at_high) + + def tree_flatten(self): + base_flatten, base_aux = self.base_dist.tree_flatten() + if isinstance(self._support.upper_bound, (int, float)): + return base_flatten, (type(self.base_dist), base_aux, self._support.upper_bound) + else: + return (base_flatten, self.high), (type(self.base_dist), base_aux) + + @classmethod + def tree_unflatten(cls, aux_data, params): + if len(aux_data) == 2: + base_flatten, high = params + base_cls, base_aux = aux_data + else: + base_flatten = params + base_cls, base_aux, high = aux_data + base_dist = base_cls.tree_unflatten(base_aux, base_flatten) + return cls(base_dist, high=high) + + +class TwoSidedTruncatedDistribution(Distribution): + arg_constraints = {"low": constraints.dependent, "high": constraints.dependent} + reparametrized_params = ["low", "high"] + supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) + + def __init__(self, base_dist, low=0., high=1., validate_args=None): + assert isinstance(base_dist, self.supported_types) + assert base_dist.support is constraints.real, \ + "The base distribution should be univariate and have real support." + batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(low), jnp.shape(high)) + self.base_dist = tree_map(lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist) + self.low, = promote_shapes(low, shape=batch_shape) + self.high, = promote_shapes(high, shape=batch_shape) + self._support = constraints.interval(low, high) + super().__init__(batch_shape, validate_args=validate_args) + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return self._support + + @lazy_property + def _tail_prob_at_low(self): + # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1., -1.) + return self.base_dist.cdf(loc - sign * (loc - self.low)) + + @lazy_property + def _tail_prob_at_high(self): + # if low < loc, returns cdf(high); otherwise returns 1 - cdf(high) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1., -1.) + return self.base_dist.cdf(loc - sign * (loc - self.high)) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + u = random.uniform(key, sample_shape + self.batch_shape) + + # NB: we use a more numerically stable formula for a symmetric base distribution + # A = icdf(cdf(low) + (cdf(high) - cdf(low)) * u) = icdf[(1 - u) * cdf(low) + u * cdf(high)] + # will suffer by precision issues when low is large; + # If low < loc: + # A = icdf[(1 - u) * cdf(low) + u * cdf(high)] + # Else + # A = 2 * loc - icdf[(1 - u) * cdf(2*loc-low)) + u * cdf(2*loc - high)] + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1., -1.) + return (1 - sign) * loc + sign * self.base_dist.icdf( + (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high) + + @validate_sample + def log_prob(self, value): + # NB: we use a more numerically stable formula for a symmetric base distribution + # if low < loc + # cdf(high) - cdf(low) = as-is + # if low > loc + # cdf(high) - cdf(low) = cdf(2 * loc - low) - cdf(2 * loc - high) + sign = jnp.where(self.base_dist.loc >= self.low, 1., -1.) + return self.base_dist.log_prob(value) - \ + jnp.log(sign * (self._tail_prob_at_high - self._tail_prob_at_low)) + + def tree_flatten(self): + base_flatten, base_aux = self.base_dist.tree_flatten() + if isinstance(self._support.lower_bound, (int, float)) and \ + isinstance(self._support.upper_bound, (int, float)): + return base_flatten, (type(self.base_dist), base_aux, + self._support.lower_bound, self._support.upper_bound) + else: + return (base_flatten, self.low, self.high), (type(self.base_dist), base_aux) + + @classmethod + def tree_unflatten(cls, aux_data, params): + if len(aux_data) == 2: + base_flatten, low, high = params + base_cls, base_aux = aux_data + else: + base_flatten = params + base_cls, base_aux, low, high = aux_data + base_dist = base_cls.tree_unflatten(base_aux, base_flatten) + return cls(base_dist, low=low, high=high) + + +def TruncatedDistribution(base_dist, low=None, high=None, validate_args=None): + """ + A function to generate a truncated distribution. + + :param base_dist: The base distribution to be truncated. This should be a univariate + distribution. Currently, only the following distributions are supported: + Cauchy, Laplace, Logistic, Normal, and StudentT. + :param low: the value which is used to truncate the base distribution from below. + Setting this parameter to None to not truncate from below. + :param high: the value which is used to truncate the base distribution from above. + Setting this parameter to None to not truncate from above. + """ + if high is None: + if low is None: + return base_dist + else: + return LeftTruncatedDistribution(base_dist, low=low, validate_args=validate_args) + elif low is None: + return RightTruncatedDistribution(base_dist, high=high, validate_args=validate_args) + else: + return TwoSidedTruncatedDistribution(base_dist, low=low, high=high, validate_args=validate_args) + class _BaseTruncatedCauchy(Distribution): # NB: this is a truncated cauchy with low=0, scale=1 @@ -1252,37 +1547,6 @@ def infer_shapes(low=(), high=()): return batch_shape, event_shape -class Logistic(Distribution): - arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} - support = constraints.real - reparametrized_params = ['loc', 'scale'] - - def __init__(self, loc=0., scale=1., validate_args=None): - self.loc, self.scale = promote_shapes(loc, scale) - batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) - super(Logistic, self).__init__(batch_shape, validate_args=validate_args) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - z = random.logistic(key, shape=sample_shape + self.batch_shape + self.event_shape) - return self.loc + z * self.scale - - @validate_sample - def log_prob(self, value): - log_exponent = (self.loc - value) / self.scale - log_denominator = jnp.log(self.scale) + 2 * nn.softplus(log_exponent) - return log_exponent - log_denominator - - @property - def mean(self): - return jnp.broadcast_to(self.loc, self.batch_shape) - - @property - def variance(self): - var = (self.scale ** 2) * (jnp.pi ** 2) / 3 - return jnp.broadcast_to(var, self.batch_shape) - - class TruncatedPolyaGamma(Distribution): truncation_point = 2.5 num_log_prob_terms = 7 diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 314b42fa8..d9a95488a 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -427,6 +427,24 @@ def infer_shapes(cls, *args, **kwargs): event_shape = () return batch_shape, event_shape + def cdf(self, value): + """ + The cummulative distribution function of this distribution. + + :param value: samples from this distribution. + :return: output of the cummulative distribution function evaluated at `value`. + """ + raise NotImplementedError + + def icdf(self, q): + """ + The inverse cumulative distribution function of this distribution. + + :param q: quantile values, should belong to [0, 1]. + :return: the samples whose cdf values equals to `q`. + """ + raise NotImplementedError + class ExpandedDistribution(Distribution): arg_constraints = {} diff --git a/test/test_distributions.py b/test/test_distributions.py index d8b746c38..76602bd5f 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -60,6 +60,27 @@ def _lowrank_mvn_to_scipy(loc, cov_fac, cov_diag): return osp.multivariate_normal(mean=mean, cov=cov) +def _truncnorm_to_scipy(loc, scale, low, high): + if low is None: + a = -np.inf + else: + a = (low - loc) / scale + if high is None: + b = np.inf + else: + b = (high - loc) / scale + return osp.truncnorm(a, b, loc=loc, scale=scale) + + +def _TruncatedNormal(loc, scale, low, high): + return dist.TruncatedDistribution(dist.Normal(loc, scale), low, high) + + +_TruncatedNormal.arg_constraints = {} +_TruncatedNormal.reparametrized_params = [] +_TruncatedNormal.infer_shapes = lambda *args: (lax.broadcast_shapes(*args), ()) + + class _ImproperWrapper(dist.ImproperUniform): def sample(self, key, sample_shape=()): transform = biject_to(self.support) @@ -103,7 +124,8 @@ def sample(self, key, sample_shape=()): dist.Uniform: lambda a, b: osp.uniform(a, b - a), dist.Logistic: lambda loc, scale: osp.logistic(loc=loc, scale=scale), dist.VonMises: lambda loc, conc: osp.vonmises(loc=np.array(loc, dtype=np.float64), - kappa=np.array(conc, dtype=np.float64)) + kappa=np.array(conc, dtype=np.float64)), + _TruncatedNormal: _truncnorm_to_scipy, } CONTINUOUS = [ @@ -178,6 +200,12 @@ def sample(self, key, sample_shape=()): T(dist.TruncatedNormal, -1., 0., 1.), T(dist.TruncatedNormal, 1., -1., jnp.array([1., 2.])), T(dist.TruncatedNormal, jnp.array([-2., 2.]), jnp.array([0., 1.]), jnp.array([[1.], [2.]])), + T(_TruncatedNormal, -1., 2., 1., 5.), + T(_TruncatedNormal, jnp.array([-1., 4.]), 2., None, 5.), + T(_TruncatedNormal, -1., jnp.array([2., 3.]), 1., None), + T(_TruncatedNormal, -1., 2., jnp.array([-6., 4.]), jnp.array([-4., 6.])), + T(_TruncatedNormal, jnp.array([0., 1.]), jnp.array([[1.], [2.]]), None, jnp.array([-2., 2.])), + T(dist.continuous.TwoSidedTruncatedDistribution, dist.Laplace(0., 1.), -2., 3.), T(dist.Uniform, 0., 2.), T(dist.Uniform, 1., jnp.array([2., 3.])), T(dist.Uniform, jnp.array([0., 0.]), jnp.array([[2.], [3.]])), @@ -346,6 +374,7 @@ def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): @pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) def test_infer_shapes(jax_dist, sp_dist, params, prepend_shape): shapes = tuple(getattr(p, "shape", ()) for p in params) + shapes = tuple(x() if callable(x) else x for x in shapes) try: expected_batch_shape, expected_event_shape = jax_dist.infer_shapes(*shapes) except NotImplementedError: @@ -519,6 +548,40 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): assert_allclose(jit_fn(jax_dist.log_prob)(samples), expected, atol=1e-5) +@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) +def test_cdf_and_icdf(jax_dist, sp_dist, params): + d = jax_dist(*params) + if d.event_dim > 0: + pytest.skip('skip testing cdf/icdf methods of multivariate distributions') + samples = d.sample(key=random.PRNGKey(0), sample_shape=(100,)) + quantiles = random.uniform(random.PRNGKey(1), (100,) + d.shape()) + try: + if d.shape() == (): + rtol = 1e-3 if jax_dist is dist.StudentT else 1e-5 + assert_allclose(jax.vmap(jax.grad(d.cdf))(samples), + jnp.exp(d.log_prob(samples)), atol=1e-5, rtol=rtol) + assert_allclose(jax.vmap(jax.grad(d.icdf))(quantiles), + jnp.exp(-d.log_prob(d.icdf(quantiles))), atol=1e-5, rtol=rtol) + assert_allclose(d.cdf(d.icdf(quantiles)), quantiles, atol=1e-5, rtol=1e-5) + assert_allclose(d.icdf(d.cdf(samples)), samples, atol=1e-5, rtol=1e-5) + except NotImplementedError: + pass + + # test against scipy + if not sp_dist: + pytest.skip('no corresponding scipy distn.') + sp_dist = sp_dist(*params) + try: + actual_cdf = d.cdf(samples) + expected_cdf = sp_dist.cdf(samples) + assert_allclose(actual_cdf, expected_cdf, atol=1e-5, rtol=1e-5) + actual_icdf = d.icdf(quantiles) + expected_icdf = sp_dist.ppf(quantiles) + assert_allclose(actual_icdf, expected_icdf, atol=1e-5, rtol=1e-4) + except NotImplementedError: + pass + + @pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) def test_gof(jax_dist, sp_dist, params): if "Improper" in jax_dist.__name__: @@ -713,6 +776,8 @@ def fn(*args): eps = 1e-3 for i in range(len(params)): + if isinstance(params[i], dist.Distribution): # skip taking grad w.r.t. base_dist + continue if params[i] is None or jnp.result_type(params[i]) in (jnp.int32, jnp.int64): continue actual_grad = jax.grad(fn, i)(*params) @@ -734,6 +799,8 @@ def fn(*args): def test_mean_var(jax_dist, sp_dist, params): if jax_dist is _ImproperWrapper: pytest.skip("Improper distribution does not has mean/var implemented") + if jax_dist in (_TruncatedNormal, dist.continuous.TwoSidedTruncatedDistribution): + pytest.skip("Truncated distributions do not has mean/var implemented") n = 20000 if jax_dist in [dist.LKJ, dist.LKJCholesky] else 200000 d_jax = jax_dist(*params) @@ -808,6 +875,8 @@ def test_mean_var(jax_dist, sp_dist, params): (2, 3), ]) def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): + if jax_dist is _TruncatedNormal: + pytest.skip("_TruncatedNormal is a function, not a class") dist_args = [p for p in inspect.getfullargspec(jax_dist.__init__)[0][1:]] valid_params, oob_params = list(params), list(params) @@ -816,6 +885,8 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): for i in range(len(params)): if jax_dist in (_ImproperWrapper, dist.LKJ, dist.LKJCholesky) and dist_args[i] != "concentration": continue + if jax_dist is dist.continuous.TwoSidedTruncatedDistribution and dist_args[i] == "base_dist": + continue if jax_dist is dist.GaussianRandomWalk and dist_args[i] == "num_steps": continue if params[i] is None: From 0c6b17eee603dbed4523af752ba7e96462e5d5a6 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Wed, 17 Feb 2021 10:15:05 -0500 Subject: [PATCH 058/222] Add constraints.sphere, dist.ProjectedNormal, ProjectedNormalReparam (#910) * Add constraints.sphere * WIP start to add ProjectedNormal distribution * Move ProjectedNormal to directional.py * Add some tests * Add tests * Add ProjectedNormalReparam and tests * Address review comments --- docs/source/distributions.rst | 12 +++ docs/source/reparam.rst | 9 ++ numpyro/distributions/__init__.py | 3 +- numpyro/distributions/constraints.py | 21 +++++ numpyro/distributions/directional.py | 124 ++++++++++++++++++++++++++- numpyro/distributions/util.py | 21 +++++ numpyro/infer/reparam.py | 26 +++++- test/test_distributions.py | 23 ++++- test/test_distributions_util.py | 13 +++ test/test_reparam.py | 35 +++++++- 10 files changed, 280 insertions(+), 7 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index d48c29435..05c6f56d5 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -441,6 +441,14 @@ ZeroInflatedPoisson Directional Distributions ========================= +ProjectedNormal +--------------- +.. autoclass:: numpyro.distributions.directional.ProjectedNormal + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + VonMises -------- .. autoclass:: numpyro.distributions.directional.VonMises @@ -550,6 +558,10 @@ simplex ------- .. autodata:: numpyro.distributions.constraints.simplex +sphere +------ +.. autodata:: numpyro.distributions.constraints.sphere + unit_interval ------------- .. autodata:: numpyro.distributions.constraints.unit_interval diff --git a/docs/source/reparam.rst b/docs/source/reparam.rst index a01be75ca..b809f9e56 100644 --- a/docs/source/reparam.rst +++ b/docs/source/reparam.rst @@ -42,3 +42,12 @@ Transformed Distributions :show-inheritance: :member-order: bysource :special-members: __call__ + +Projected Normal Distributions +------------------------------ +.. autoclass:: numpyro.infer.reparam.ProjectedNormalReparam + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + :special-members: __call__ diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 9f2cb662c..b7f46167e 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -31,7 +31,7 @@ TruncatedPolyaGamma, Uniform ) -from numpyro.distributions.directional import VonMises +from numpyro.distributions.directional import ProjectedNormal, VonMises from numpyro.distributions.discrete import ( Bernoulli, BernoulliLogits, @@ -118,6 +118,7 @@ 'OrderedLogistic', 'Pareto', 'Poisson', + 'ProjectedNormal', 'PRNGIdentity', 'StudentT', 'TransformedDistribution', diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index e96da6e8d..331a8f102 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -46,6 +46,7 @@ 'real', 'real_vector', 'simplex', + 'sphere', 'unit_interval', 'Constraint', ] @@ -368,7 +369,26 @@ def feasible_like(self, prototype): return jax.numpy.full_like(prototype, 1 / prototype.shape[-1]) +class _Sphere(Constraint): + """ + Constrain to the Euclidean sphere of any dimension. + """ + event_dim = 1 + reltol = 10. # Relative to finfo.eps. + + def __call__(self, x): + jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy + eps = jnp.finfo(x.dtype).eps + norm = jnp.linalg.norm(x, axis=-1) + error = jnp.abs(norm - 1) + return error < self.reltol * eps * x.shape[-1] ** 0.5 + + def feasible_like(self, prototype): + return jax.numpy.full_like(prototype, prototype.shape[-1] ** (-0.5)) + + # TODO: Make types consistent +# See https://github.com/pytorch/pytorch/issues/50616 boolean = _Boolean() corr_cholesky = _CorrCholesky() @@ -391,4 +411,5 @@ def feasible_like(self, prototype): real = _Real() real_vector = independent(real, 1) simplex = _Simplex() +sphere = _Sphere() unit_interval = _Interval(0., 1.) diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index de7eb95ce..aeccc9c95 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -5,11 +5,12 @@ from jax import lax import jax.numpy as jnp -from jax.scipy.special import i0e, i1e +import jax.random as random +from jax.scipy.special import erf, i0e, i1e from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution -from numpyro.distributions.util import is_prng_key, promote_shapes, validate_sample, von_mises_centered +from numpyro.distributions.util import is_prng_key, promote_shapes, safe_normalize, validate_sample, von_mises_centered class VonMises(Distribution): @@ -59,3 +60,122 @@ def variance(self): """ Computes circular variance of distribution """ return jnp.broadcast_to(1. - i1e(self.concentration) / i0e(self.concentration), self.batch_shape) + + +class ProjectedNormal(Distribution): + """ + Projected isotropic normal distribution of arbitrary dimension. + + This distribution over directional data is qualitatively similar to the von + Mises and von Mises-Fisher distributions, but permits tractable variational + inference via reparametrized gradients. + + To use this distribution with autoguides and HMC, use ``handlers.reparam`` + with a :class:`~numpyro.infer.reparam.ProjectedNormalReparam` + reparametrizer in the model, e.g.:: + + @handlers.reparam(config={"direction": ProjectedNormalReparam()}) + def model(): + direction = numpyro.sample("direction", + ProjectedNormal(zeros(3))) + ... + + .. note:: This implements :meth:`log_prob` only for dimensions {2,3}. + + [1] D. Hernandez-Stumpfhauser, F.J. Breidt, M.J. van der Woerd (2017) + "The General Projected Normal Distribution of Arbitrary Dimension: + Modeling and Bayesian Inference" + https://projecteuclid.org/euclid.ba/1453211962 + """ + arg_constraints = {"concentration": constraints.real_vector} + reparametrized_params = ["concentration"] + support = constraints.sphere + + def __init__(self, concentration, *, validate_args=None): + assert jnp.ndim(concentration) >= 1 + self.concentration = concentration + batch_shape = concentration.shape[:-1] + event_shape = concentration.shape[-1:] + super().__init__(batch_shape, event_shape, validate_args=validate_args) + + @property + def mean(self): + """ + Note this is the mean in the sense of a centroid in the submanifold + that minimizes expected squared geodesic distance. + """ + return safe_normalize(self.concentration) + + @property + def mode(self): + return safe_normalize(self.concentration) + + def sample(self, key, sample_shape=()): + shape = sample_shape + self.batch_shape + self.event_shape + eps = random.normal(key, shape=shape) + return safe_normalize(self.concentration + eps) + + def log_prob(self, value): + if self._validate_args: + event_shape = value.shape[-1:] + if event_shape != self.event_shape: + raise ValueError(f"Expected event shape {self.event_shape}, " + f"but got {event_shape}") + self._validate_sample(value) + dim = int(self.concentration.shape[-1]) + if dim == 2: + return _projected_normal_log_prob_2(self.concentration, value) + if dim == 3: + return _projected_normal_log_prob_3(self.concentration, value) + raise NotImplementedError( + f"ProjectedNormal.log_prob() is not implemented for dim = {dim}. " + "Consider using handlers.reparam with ProjectedNormalReparam." + ) + + @staticmethod + def infer_shapes(concentration): + batch_shape = concentration[:-1] + event_shape = concentration[-1:] + return batch_shape, event_shape + + +def _projected_normal_log_prob_2(concentration, value): + def _dot(x, y): + return (x[..., None, :] @ y[..., None])[..., 0, 0] + + # We integrate along a ray, factorizing the integrand as a product of: + # a truncated normal distribution over coordinate t parallel to the ray, and + # a univariate normal distribution over coordinate r perpendicular to the ray. + t = _dot(concentration, value) + t2 = t * t + r2 = _dot(concentration, concentration) - t2 + perp_part = (-0.5) * r2 - 0.5 * math.log(2 * math.pi) + + # This is the log of a definite integral, computed by mathematica: + # Integrate[x/(E^((x-t)^2/2) Sqrt[2 Pi]), {x, 0, Infinity}] + # = (t + Sqrt[2/Pi]/E^(t^2/2) + t Erf[t/Sqrt[2]])/2 + para_part = jnp.log((jnp.exp((-0.5) * t2) * ((2 / math.pi) ** 0.5) + + t * (1 + erf(t * 0.5 ** 0.5))) / 2) + + return para_part + perp_part + + +def _projected_normal_log_prob_3(concentration, value): + def _dot(x, y): + return (x[..., None, :] @ y[..., None])[..., 0, 0] + + # We integrate along a ray, factorizing the integrand as a product of: + # a truncated normal distribution over coordinate t parallel to the ray, and + # a bivariate normal distribution over coordinate r perpendicular to the ray. + t = _dot(concentration, value) + t2 = t * t + r2 = _dot(concentration, concentration) - t2 + perp_part = (-0.5) * r2 - math.log(2 * math.pi) + + # This is the log of a definite integral, computed by mathematica: + # Integrate[x^2/(E^((x-t)^2/2) Sqrt[2 Pi]), {x, 0, Infinity}] + # = t/(E^(t^2/2) Sqrt[2 Pi]) + ((1 + t^2) (1 + Erf[t/Sqrt[2]]))/2 + para_part = jnp.log(t * jnp.exp((-0.5) * t2) / (2 * math.pi) ** 0.5 + + (1 + t2) * (1 + erf(t * 0.5 ** 0.5)) / 2) + + return para_part + perp_part diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index 07329e631..9601a77bb 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -479,6 +479,27 @@ def periodic_repeat(x, size, dim): return result +def safe_normalize(x, *, p=2): + """ + Safely project a vector onto the sphere wrt the ``p``-norm. This avoids the + singularity at zero by mapping zero to the uniform unit vector proportional + to ``[1, 1, ..., 1]``. + + :param numpy.ndarray x: A vector + :param float p: The norm exponent, defaults to 2 i.e. the Euclidean norm. + :returns: A normalized version ``x / ||x||_p``. + :rtype: numpy.ndarray + """ + assert isinstance(p, (float, int)) + assert p >= 0 + norm = jnp.linalg.norm(x, p, axis=-1, keepdims=True) + x = x / jnp.clip(norm, a_min=jnp.finfo(x).tiny) + # Avoid the singularity. + mask = jnp.all(x == 0, axis=-1, keepdims=True) + x = jnp.where(mask, x.shape[-1] ** (-1/p), x) + return x + + # src: https://github.com/google/jax/blob/5a41779fbe12ba7213cd3aa1169d3b0ffb02a094/jax/_src/random.py#L95 def is_prng_key(key): try: diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index 05c5573d8..2165fa9ef 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -9,7 +9,7 @@ import numpyro import numpyro.distributions as dist from numpyro.distributions import biject_to, constraints -from numpyro.distributions.util import is_identically_one, sum_rightmost +from numpyro.distributions.util import is_identically_one, safe_normalize, sum_rightmost from numpyro.infer.autoguide import AutoContinuous @@ -145,6 +145,30 @@ def __call__(self, name, fn, obs): return None, x +class ProjectedNormalReparam(Reparam): + """ + Reparametrizer for :class:`~numpyro.distributions.ProjectedNormal` latent + variables. + + This reparameterization works only for latent variables, not likelihoods. + """ + def __call__(self, name, fn, obs): + assert obs is None, "ProjectedNormalReparam does not support observe statements" + fn, batch_shape, event_dim = self._unwrap(fn) + assert isinstance(fn, dist.ProjectedNormal) + + # Draw parameter-free noise. + new_fn = dist.Normal(jnp.zeros(fn.concentration.shape), 1) + x = numpyro.sample("{}_normal".format(name), + self._wrap(new_fn, batch_shape, event_dim)) + + # Differentiably transform. + value = safe_normalize(x + fn.concentration) + + # Simulate a pyro.deterministic() site. + return None, value + + class NeuTraReparam(Reparam): """ Neural Transport reparameterizer [1] of multiple latent variables. diff --git a/test/test_distributions.py b/test/test_distributions.py index 76602bd5f..257c48b4a 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -215,6 +215,10 @@ def sample(self, key, sample_shape=()): T(dist.VonMises, 2., 10.), T(dist.VonMises, 2., jnp.array([150., 10.])), T(dist.VonMises, jnp.array([1 / 3 * jnp.pi, -1.]), jnp.array([20., 30.])), + T(dist.ProjectedNormal, jnp.array([0., 0.])), + T(dist.ProjectedNormal, jnp.array([[2., 3.]])), + T(dist.ProjectedNormal, jnp.array([0., 0., 0.])), + T(dist.ProjectedNormal, jnp.array([[-1., 2., 3.]])), ] DISCRETE = [ @@ -299,6 +303,9 @@ def gen_values_within_bounds(constraint, size, key=random.PRNGKey(11)): return x - random.normal(key, size[:-1]) elif isinstance(constraint, constraints.independent): return gen_values_within_bounds(constraint.base_constraint, size, key) + elif constraint is constraints.sphere: + x = random.normal(key, size) + return x / jnp.linalg.norm(x, axis=-1) else: raise NotImplementedError('{} not implemented.'.format(constraint)) @@ -340,6 +347,10 @@ def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)): return x[..., ::-1] elif isinstance(constraint, constraints.independent): return gen_values_outside_bounds(constraint.base_constraint, size, key) + elif constraint is constraints.sphere: + x = random.normal(key, size) + x = x / jnp.linalg.norm(x, axis=-1, keepdims=True) + return 2 * x else: raise NotImplementedError('{} not implemented.'.format(constraint)) @@ -582,7 +593,7 @@ def test_cdf_and_icdf(jax_dist, sp_dist, params): pass -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) +@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DIRECTIONAL) def test_gof(jax_dist, sp_dist, params): if "Improper" in jax_dist.__name__: pytest.skip("distribution has improper .log_prob()") @@ -595,6 +606,10 @@ def test_gof(jax_dist, sp_dist, params): samples = d.sample(key=rng_key, sample_shape=(num_samples,)) probs = np.exp(d.log_prob(samples)) + dim = None + if jax_dist is dist.ProjectedNormal: + dim = samples.shape[-1] - 1 + # Test each batch independently. probs = probs.reshape(num_samples, -1) samples = samples.reshape(probs.shape + d.event_shape) @@ -603,7 +618,7 @@ def test_gof(jax_dist, sp_dist, params): samples = samples[..., :-1] for b in range(probs.shape[-1]): try: - gof = auto_goodness_of_fit(samples[:, b], probs[:, b]) + gof = auto_goodness_of_fit(samples[:, b], probs[:, b], dim=dim) except InvalidTest: pytest.skip("expensive test") else: @@ -801,6 +816,8 @@ def test_mean_var(jax_dist, sp_dist, params): pytest.skip("Improper distribution does not has mean/var implemented") if jax_dist in (_TruncatedNormal, dist.continuous.TwoSidedTruncatedDistribution): pytest.skip("Truncated distributions do not has mean/var implemented") + if jax_dist is dist.ProjectedNormal: + pytest.skip("Mean is defined in submanifold") n = 20000 if jax_dist in [dist.LKJ, dist.LKJCholesky] else 200000 d_jax = jax_dist(*params) @@ -1029,6 +1046,8 @@ def g(x): (constraints.unit_interval, 0.1, True), (constraints.unit_interval, jnp.array([-5, 0, 0.5, 1, 7]), jnp.array([False, True, True, True, False])), + (constraints.sphere, jnp.array([[1, 0, 0], [0.5, 0.5, 0]]), + jnp.array([True, False])), ]) def test_constraints(constraint, x, expected): assert_array_equal(constraint(x), expected) diff --git a/test/test_distributions_util.py b/test/test_distributions_util.py index 11b5698de..b11e01612 100644 --- a/test/test_distributions_util.py +++ b/test/test_distributions_util.py @@ -18,6 +18,7 @@ categorical, cholesky_update, multinomial, + safe_normalize, vec_to_tril_matrix, von_mises_centered ) @@ -156,3 +157,15 @@ def test_von_mises_centered(concentration): samples = von_mises_centered(random.PRNGKey(0), concentration, shape=(10000,)) cdf = scipy.stats.vonmises(kappa=concentration).cdf assert scipy.stats.kstest(samples, cdf).pvalue > 0.01 + + +@pytest.mark.parametrize("dim", [2, 3, 4, 5]) +def test_safe_normalize(dim): + data = random.normal(random.PRNGKey(0), (100, dim)) + x = safe_normalize(data) + assert_allclose((x * x).sum(-1), jnp.ones(x.shape[:-1]), rtol=1e-6) + assert_allclose((x * data).sum(-1) ** 2, (data * data).sum(-1), rtol=1e-6) + + data = jnp.zeros((10, dim)) + x = safe_normalize(data) + assert_allclose((x * x).sum(-1), jnp.ones(x.shape[:-1]), rtol=1e-6) diff --git a/test/test_reparam.py b/test/test_reparam.py index 5aaae6bb9..274d9f1a5 100644 --- a/test/test_reparam.py +++ b/test/test_reparam.py @@ -14,7 +14,7 @@ import numpyro.handlers as handlers from numpyro.infer import MCMC, NUTS, SVI, Trace_ELBO from numpyro.infer.autoguide import AutoIAFNormal -from numpyro.infer.reparam import LocScaleReparam, NeuTraReparam, TransformReparam +from numpyro.infer.reparam import LocScaleReparam, NeuTraReparam, ProjectedNormalReparam, TransformReparam from numpyro.infer.util import initialize_model from numpyro.optim import Adam @@ -164,3 +164,36 @@ def get_actual_probe(loc, scale): actual_grad = jacobian(get_actual_probe, argnums=(0, 1))(loc, scale) assert_allclose(actual_grad[0], expected_grad[0], atol=0.05) # loc grad assert_allclose(actual_grad[1], expected_grad[1], atol=0.05) # scale grad + + +@pytest.mark.parametrize("shape", [(), (4,), (3, 2)], ids=str) +@pytest.mark.parametrize("dim", [2, 3, 4]) +def test_projected_normal(shape, dim): + + def model(concentration): + with numpyro.plate_stack("plates", shape): + with numpyro.plate("particles", 10000): + numpyro.sample("x", dist.ProjectedNormal(concentration)) + + def get_expected_probe(concentration): + with numpyro.handlers.trace() as trace: + with numpyro.handlers.seed(rng_seed=0): + model(concentration) + return get_moments(trace["x"]["value"]) + + def get_actual_probe(concentration): + with numpyro.handlers.trace() as trace: + with numpyro.handlers.seed(rng_seed=0): + reparam = ProjectedNormalReparam() + with numpyro.handlers.reparam(config={"x": reparam}): + model(concentration) + return get_moments(trace["x"]["value"]) + + concentration = np.random.normal(shape + (dim,)) + expected_probe = get_expected_probe(concentration) + actual_probe = get_actual_probe(concentration) + assert_allclose(actual_probe, expected_probe, atol=0.1) + + expected_grad = jacobian(get_expected_probe)(concentration) + actual_grad = jacobian(get_actual_probe)(concentration) + assert_allclose(actual_grad, expected_grad, atol=0.05) From c19e7bf3bcc73f2795c736ef5b4a5ad848dce9d4 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 18 Feb 2021 07:57:31 -0600 Subject: [PATCH 059/222] Reduce memory requirement for AutoLowRankMultivariateNormal.quantiles (#921) --- numpyro/infer/autoguide.py | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index bd4966bdd..16efa1932 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -691,9 +691,12 @@ def median(self, params): return self._unpack_and_constrain(loc, params) def quantiles(self, params, quantiles): - transform = self.get_transform(params) + loc = params[f'{self.prefix}_loc'] + cov_factor = params[f'{self.prefix}_cov_factor'] + scale = params[f'{self.prefix}_scale'] + scale = scale * jnp.sqrt(jnp.square(cov_factor).sum(-1) + 1) quantiles = jnp.array(quantiles)[..., None] - latent = dist.Normal(transform.loc, jnp.diagonal(transform.scale_tril)).icdf(quantiles) + latent = dist.Normal(loc, scale).icdf(quantiles) return self._unpack_and_constrain(latent, params) From 68253f61adbb2d4aed60d05eec1549a3d9eb916a Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Sat, 20 Feb 2021 11:43:53 -0800 Subject: [PATCH 060/222] add BarkerMH kernel (#922) * add adaptation scheme * support model * add barker file * docstring * fl8 * tests * docs * license * doctest * typo * more docstring * assert chain_method!=vectorized * split modelling and inference * tweak test * fix all logistic regression tests * probably a typo * address comments * fl8 Co-authored-by: Du Phan --- .github/workflows/ci.yml | 39 ++++- docs/source/mcmc.rst | 8 ++ numpyro/infer/__init__.py | 2 + numpyro/infer/barker.py | 211 ++++++++++++++++++++++++++++ numpyro/infer/hmc_util.py | 6 +- test/contrib/test_tfp.py | 3 +- test/{ => infer}/test_autoguide.py | 3 +- test/{ => infer}/test_hmc_gibbs.py | 0 test/{ => infer}/test_hmc_util.py | 0 test/{ => infer}/test_infer_util.py | 0 test/{ => infer}/test_mcmc.py | 37 +++-- test/{ => infer}/test_reparam.py | 0 test/{ => infer}/test_svi.py | 0 13 files changed, 292 insertions(+), 17 deletions(-) create mode 100644 numpyro/infer/barker.py rename test/{ => infer}/test_autoguide.py (99%) rename test/{ => infer}/test_hmc_gibbs.py (100%) rename test/{ => infer}/test_hmc_util.py (100%) rename test/{ => infer}/test_infer_util.py (100%) rename test/{ => infer}/test_mcmc.py (95%) rename test/{ => infer}/test_reparam.py (100%) rename test/{ => infer}/test_svi.py (100%) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 7b74b9c92..3091d6ed9 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -44,7 +44,7 @@ jobs: python -m doctest -v README.md - test: + test-modeling: runs-on: ubuntu-latest needs: lint @@ -70,15 +70,44 @@ jobs: pip freeze - name: Test with pytest run: | - pytest -vs -k "not test_example" --durations=100 + pytest -vs -k "not test_example" --durations=100 --ignore=test/infer/ + + + test-inference: + + runs-on: ubuntu-latest + needs: lint + strategy: + matrix: + python-version: [3.6] + + steps: + - uses: actions/checkout@v2 + - name: Set up Python ${{ matrix.python-version }} + uses: actions/setup-python@v2 + with: + python-version: ${{ matrix.python-version }} + - name: Install dependencies + run: | + python -m pip install --upgrade pip + # Keep track of pyro-api master branch + pip install https://github.com/pyro-ppl/pyro-api/archive/master.zip + pip install https://github.com/pyro-ppl/funsor/archive/master.zip + pip install jaxlib + pip install jax + pip install .[dev,test] + pip freeze + - name: Test with pytest + run: | + pytest -vs --durations=100 test/infer - name: Test x64 run: | - JAX_ENABLE_X64=1 pytest -vs test/test_mcmc.py -k x64 + JAX_ENABLE_X64=1 pytest -vs test/infer/test_mcmc.py -k x64 - name: Test chains run: | - XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/test_mcmc.py -k "chain or pmap or vmap" + XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/infer/test_mcmc.py -k "chain or pmap or vmap" XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/contrib/test_tfp.py -k "chain" - XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/test_hmc_gibbs.py -k "chain" + XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs test/infer/test_hmc_gibbs.py -k "chain" examples: diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index 16734f154..09ed21e02 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -16,6 +16,12 @@ MCMC Kernels :show-inheritance: :member-order: bysource + .. autoclass:: numpyro.infer.barker.BarkerMH + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + .. autoclass:: numpyro.infer.hmc.HMC :members: :undoc-members: @@ -58,6 +64,8 @@ MCMC Kernels .. autofunction:: numpyro.infer.hmc.hmc.sample_kernel +.. autodata:: numpyro.infer.barker.BarkerMHState + .. autodata:: numpyro.infer.hmc.HMCState .. autodata:: numpyro.infer.hmc_gibbs.HMCGibbsState diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 789a250bd..3d277c1eb 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -11,6 +11,7 @@ init_to_uniform, init_to_value ) +from numpyro.infer.barker import BarkerMH from numpyro.infer.mcmc import MCMC from numpyro.infer.sa import SA from numpyro.infer.svi import SVI @@ -23,6 +24,7 @@ 'init_to_uniform', 'init_to_value', 'log_likelihood', + 'BarkerMH', 'DiscreteHMCGibbs', 'ELBO', 'HMC', diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py new file mode 100644 index 000000000..dd89f6e9c --- /dev/null +++ b/numpyro/infer/barker.py @@ -0,0 +1,211 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from collections import namedtuple + +import jax +from jax import random +from jax.flatten_util import ravel_pytree +import jax.numpy as jnp +from jax.scipy.special import expit +from jax.nn import softplus + +from numpyro.infer.hmc_util import warmup_adapter +from numpyro.infer.util import initialize_model +from numpyro.util import identity +from numpyro.infer import init_to_uniform +from numpyro.infer.mcmc import MCMCKernel + + +BarkerMHState = namedtuple("BarkerMHState", [ + "i", "z", "potential_energy", "z_grad", "accept_prob", "mean_accept_prob", "adapt_state", "rng_key"]) +""" +A :func:`~collections.namedtuple` consisting of the following fields: + + - **i** - iteration. This is reset to 0 after warmup. + - **z** - Python collection representing values (unconstrained samples from + the posterior) at latent sites. + - **potential_energy** - Potential energy computed at the given value of ``z``. + - **z_grad** - Gradient of potential energy w.r.t. latent sample sites. + - **accept_prob** - Acceptance probability of the proposal. Note that ``z`` + does not correspond to the proposal if it is rejected. + - **mean_accept_prob** - Mean acceptance probability until current iteration + during warmup adaptation or sampling (for diagnostics). + - **adapt_state** - A ``HMCAdaptState`` namedtuple which contains adaptation information + during warmup: + + + **step_size** - Step size to be used by the integrator in the next iteration. + + **inverse_mass_matrix** - The inverse mass matrix to be used for the next + iteration. + + **mass_matrix_sqrt** - The square root of mass matrix to be used for the next + iteration. In case of dense mass, this is the Cholesky factorization of the + mass matrix. + + - **rng_key** - random number generator seed used for generating proposals, etc. +""" + + +class BarkerMH(MCMCKernel): + """ + This is a gradient-based MCMC algorithm of Metropolis-Hastings type that uses + a skew-symmetric proposal distribution that depends on the gradient of the + potential (the Barker proposal; see reference [1]). In particular the proposal + distribution is skewed in the direction of the gradient at the current sample. + + We expect this algorithm to be particularly effective for low to moderate dimensional + models, where it may be competitive with HMC and NUTS. + + .. note:: We recommend to use this kernel with `progress_bar=False` in :class:`MCMC` + to reduce JAX's dispatch overhead. + + **References:** + + 1. The Barker proposal: combining robustness and efficiency in gradient-based MCMC. + Samuel Livingstone, Giacomo Zanella. + + :param model: Python callable containing Pyro :mod:`~numpyro.primitives`. + If model is provided, `potential_fn` will be inferred using the model. + :param potential_fn: Python callable that computes the potential energy + given input parameters. The input parameters to `potential_fn` can be + any python collection type, provided that `init_params` argument to + :meth:`init` has the same type. + :param float step_size: (Initial) step size to use in the Barker proposal. + :param bool adapt_step_size: Whether to adapt the step size during warm-up. + Defaults to ``adapt_step_size==True``. + :param bool adapt_mass_matrix: Whether to adapt the mass matrix during warm-up. + Defaults to ``adapt_mass_matrix==True``. + :param bool dense_mass: Whether to use a dense (i.e. full-rank) or diagonal mass matrix. + (defaults to ``dense_mass=False``). Currently only ``dense_mass=False`` is supported. + :param float target_accept_prob: The target acceptance probability that is used to guide + step size adapation. Defaults to ``target_accept_prob=0.4``. + :param callable init_strategy: a per-site initialization function. + See :ref:`init_strategy` section for available functions. + + **Example** + + .. doctest:: + + >>> import jax + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.infer import MCMC, BarkerMH + + >>> def model(): + ... numpyro.sample("x", dist.Normal().expand([10])) + ... numpyro.sample("obs", dist.Normal(x, 1.0), obs=jnp.ones(10)) + >>> + >>> kernel = Barker(model) + >>> mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000, progress_bar=True) + >>> mcmc.run(jax.random.PRNGKey(0)) + >>> mcmc.print_summary() # doctest: +SKIP + """ + def __init__(self, model=None, potential_fn=None, step_size=1.0, + adapt_step_size=True, adapt_mass_matrix=True, dense_mass=False, + target_accept_prob=0.4, init_strategy=init_to_uniform): + if not (model is None) ^ (potential_fn is None): + raise ValueError('Only one of `model` or `potential_fn` must be specified.') + if dense_mass: + raise ValueError('Only dense_mass=False is currently supported') + self._model = model + self._potential_fn = potential_fn + self._step_size = step_size + self._adapt_step_size = adapt_step_size + self._adapt_mass_matrix = adapt_mass_matrix + self._dense_mass = dense_mass + self._target_accept_prob = target_accept_prob + self._init_strategy = init_strategy + + @property + def model(self): + return self._model + + @property + def sample_field(self): + return 'z' + + def get_diagnostics_str(self, state): + return 'step size {:.2e}. acc. prob={:.2f}'.format(state.adapt_state.step_size, + state.mean_accept_prob) + + def _init_state(self, rng_key, model_args, model_kwargs, init_params): + if self._model is not None: + params_info, potential_fn_gen, self._postprocess_fn, model_trace = initialize_model( + rng_key, + self._model, + dynamic_args=True, + init_strategy=self._init_strategy, + model_args=model_args, + model_kwargs=model_kwargs) + init_params = params_info[0] + model_kwargs = {} if model_kwargs is None else model_kwargs + self._potential_fn = potential_fn_gen(*model_args, **model_kwargs) + return init_params + + def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): + self._num_warmup = num_warmup + # TODO (low-priority): support chain_method="vectorized", i.e. rng_key is a batch of keys + assert rng_key.shape == (2,), ("BarkerMH only supports chain_method='parallel' or chain_method='sequential'." + " Please put in a feature request if you think it would be useful to be able " + "to use BarkerMH in vectorized mode.") + rng_key, rng_key_init_model, rng_key_wa = random.split(rng_key, 3) + init_params = self._init_state(rng_key_init_model, model_args, model_kwargs, init_params) + if self._potential_fn and init_params is None: + raise ValueError('Valid value of `init_params` must be provided with' + ' `potential_fn`.') + + pe, grad = jax.value_and_grad(self._potential_fn)(init_params) + + wa_init, self._wa_update = warmup_adapter( + num_warmup, + adapt_step_size=self._adapt_step_size, + adapt_mass_matrix=self._adapt_mass_matrix, + dense_mass=self._dense_mass, + target_accept_prob=self._target_accept_prob) + size = len(ravel_pytree(init_params)[0]) + wa_state = wa_init(None, rng_key_wa, self._step_size, mass_matrix_size=size) + wa_state = wa_state._replace(rng_key=None) + return jax.device_put(BarkerMHState(0, init_params, pe, grad, 0., 0., wa_state, rng_key)) + + def postprocess_fn(self, args, kwargs): + if self._postprocess_fn is None: + return identity + return self._postprocess_fn(*args, **kwargs) + + def sample(self, state, model_args, model_kwargs): + i, x, x_pe, x_grad, _, mean_accept_prob, adapt_state, rng_key = state + x_flat, unravel_fn = ravel_pytree(x) + x_grad_flat, _ = ravel_pytree(x_grad) + shape = jnp.shape(x_flat) + rng_key, key_normal, key_bernoulli, key_accept = random.split(rng_key, 4) + + # Generate proposal y. + # TODO: Support dense_mass=True + z_proposal = adapt_state.step_size * random.normal(key_normal, shape) * adapt_state.mass_matrix_sqrt + p = expit(-z_proposal * x_grad_flat) + b = jnp.where(random.uniform(key_bernoulli, shape) < p, 1., -1.) + bz = b * z_proposal + y_flat = x_flat + bz + + y = unravel_fn(y_flat) + y_pe, y_grad = jax.value_and_grad(self._potential_fn)(y) + y_grad_flat, _ = ravel_pytree(y_grad) + log_accept_ratio = x_pe - y_pe + jnp.sum(softplus(bz * x_grad_flat) - softplus(-bz * y_grad_flat)) + accept_prob = jnp.clip(jnp.exp(log_accept_ratio), a_max=1.) + + x, x_flat, pe, x_grad = jax.lax.cond(random.bernoulli(key_accept, accept_prob), + (y, y_flat, y_pe, y_grad), identity, + (x, x_flat, x_pe, x_grad), identity) + + # do not update adapt_state after warmup phase + adapt_state = jax.lax.cond(i < self._num_warmup, + (i, accept_prob, (x,), adapt_state), + lambda args: self._wa_update(*args), + adapt_state, + identity) + + itr = i + 1 + n = jnp.where(i < self._num_warmup, itr, itr - self._num_warmup) + mean_accept_prob = mean_accept_prob + (accept_prob - mean_accept_prob) / n + + return BarkerMHState(itr, x, pe, x_grad, accept_prob, mean_accept_prob, adapt_state, rng_key) diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index eafc0a3b7..009f321f3 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -15,6 +15,7 @@ from numpyro.util import cond, identity, while_loop AdaptWindow = namedtuple('AdaptWindow', ['start', 'end']) +# XXX: we need to store rng_key here in case we use find_reasonable_step_size functionality HMCAdaptState = namedtuple('HMCAdaptState', ['step_size', 'inverse_mass_matrix', 'mass_matrix_sqrt', 'ss_state', 'mm_state', 'window_idx', 'rng_key']) IntegratorState = namedtuple('IntegratorState', ['z', 'r', 'potential_energy', 'z_grad']) @@ -431,7 +432,10 @@ def update_fn(t, accept_prob, z_info, state): :return: new state of the adapt scheme. """ step_size, inverse_mass_matrix, mass_matrix_sqrt, ss_state, mm_state, window_idx, rng_key = state - rng_key, rng_key_ss = random.split(rng_key) + if rng_key is not None: + rng_key, rng_key_ss = random.split(rng_key) + else: + rng_key_ss = None # update step size state if adapt_step_size: diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index 4d664134f..04dfd9e74 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -88,7 +88,8 @@ def model(labels): mcmc.print_summary() samples = mcmc.get_samples() assert samples['logits'].shape == (num_samples, N) - assert_allclose(jnp.mean(samples['coefs'], 0), true_coefs, atol=0.22) + expected_coefs = jnp.array([0.97, 2.05, 3.18]) + assert_allclose(jnp.mean(samples['coefs'], 0), expected_coefs, atol=0.22) @pytest.mark.filterwarnings("ignore:can't resolve package") diff --git a/test/test_autoguide.py b/test/infer/test_autoguide.py similarity index 99% rename from test/test_autoguide.py rename to test/infer/test_autoguide.py index 8f3612dd2..0a560d201 100644 --- a/test/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -124,7 +124,8 @@ def body_fn(i, val): assert_allclose(median['coefs'][1], true_coefs, rtol=0.1) # test .sample_posterior method posterior_samples = guide.sample_posterior(random.PRNGKey(1), params, sample_shape=(1000,)) - assert_allclose(jnp.mean(posterior_samples['coefs'], 0), true_coefs, rtol=0.1) + expected_coefs = jnp.array([0.97, 2.05, 3.18]) + assert_allclose(jnp.mean(posterior_samples['coefs'], 0), expected_coefs, rtol=0.1) def test_iaf(): diff --git a/test/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py similarity index 100% rename from test/test_hmc_gibbs.py rename to test/infer/test_hmc_gibbs.py diff --git a/test/test_hmc_util.py b/test/infer/test_hmc_util.py similarity index 100% rename from test/test_hmc_util.py rename to test/infer/test_hmc_util.py diff --git a/test/test_infer_util.py b/test/infer/test_infer_util.py similarity index 100% rename from test/test_infer_util.py rename to test/infer/test_infer_util.py diff --git a/test/test_mcmc.py b/test/infer/test_mcmc.py similarity index 95% rename from test/test_mcmc.py rename to test/infer/test_mcmc.py index ea955b705..9c5ea85ff 100644 --- a/test/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -16,7 +16,7 @@ import numpyro import numpyro.distributions as dist from numpyro.distributions.transforms import AffineTransform -from numpyro.infer import HMC, MCMC, NUTS, SA +from numpyro.infer import HMC, MCMC, NUTS, SA, BarkerMH from numpyro.infer.hmc import hmc from numpyro.infer.reparam import TransformReparam from numpyro.infer.sa import _get_proposal_loc_and_scale, _numpy_delete @@ -24,7 +24,7 @@ from numpyro.util import fori_collect -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA]) +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA, BarkerMH]) @pytest.mark.parametrize('dense_mass', [False, True]) def test_unnormalized_normal_x64(kernel_cls, dense_mass): true_mean, true_std = 1., 0.5 @@ -36,6 +36,9 @@ def potential_fn(z): init_params = jnp.array(0.) if kernel_cls is SA: kernel = SA(potential_fn=potential_fn, dense_mass=dense_mass) + elif kernel_cls is BarkerMH: + # TODO: fix dense_mass once BarkerMH supports it + kernel = SA(potential_fn=potential_fn, dense_mass=False) else: kernel = kernel_cls(potential_fn=potential_fn, trajectory_length=8, dense_mass=dense_mass) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) @@ -72,10 +75,15 @@ def potential_fn(z): assert np.sum(np.abs(np.cov(samples.T) - true_cov)) / D**2 < 0.02 -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA]) +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA, BarkerMH]) def test_logistic_regression_x64(kernel_cls): N, dim = 3000, 3 - warmup_steps, num_samples = (100000, 100000) if kernel_cls is SA else (1000, 8000) + if kernel_cls is SA: + warmup_steps, num_samples = (100000, 100000) + elif kernel_cls is BarkerMH: + warmup_steps, num_samples = (2000, 12000) + else: + warmup_steps, num_samples = (1000, 8000) data = random.normal(random.PRNGKey(0), (N, dim)) true_coefs = jnp.arange(1., dim + 1.) logits = jnp.sum(true_coefs * data, axis=-1) @@ -88,6 +96,9 @@ def model(labels): if kernel_cls is SA: kernel = SA(model=model, adapt_state_size=9) + elif kernel_cls is BarkerMH: + # TODO: fix dense_mass once BarkerMH supports it + kernel = BarkerMH(model=model, dense_mass=False) else: kernel = kernel_cls(model=model, trajectory_length=8, find_heuristic_step_size=True) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) @@ -95,7 +106,9 @@ def model(labels): mcmc.print_summary() samples = mcmc.get_samples() assert samples['logits'].shape == (num_samples, N) - assert_allclose(jnp.mean(samples['coefs'], 0), true_coefs, atol=0.22) + # those coefficients are found by doing MAP inference using AutoDelta + expected_coefs = jnp.array([0.97, 2.05, 3.18]) + assert_allclose(jnp.mean(samples['coefs'], 0), expected_coefs, atol=0.1) if 'JAX_ENABLE_X64' in os.environ: assert samples['coefs'].dtype == jnp.float64 @@ -150,7 +163,7 @@ def model(data): assert_allclose(jnp.mean(samples['loc'], 0), true_coef, atol=0.05) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA]) +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA, BarkerMH]) def test_beta_bernoulli_x64(kernel_cls): warmup_steps, num_samples = (100000, 100000) if kernel_cls is SA else (500, 20000) @@ -162,9 +175,11 @@ def model(data): return p_latent true_probs = jnp.array([0.9, 0.1]) - data = dist.Bernoulli(true_probs).sample(random.PRNGKey(1), (1000, 2)) + data = dist.Bernoulli(true_probs).sample(random.PRNGKey(1), (1000,)) if kernel_cls is SA: kernel = SA(model=model) + elif kernel_cls is BarkerMH: + kernel = BarkerMH(model=model) else: kernel = kernel_cls(model=model, trajectory_length=0.1) mcmc = MCMC(kernel, num_warmup=warmup_steps, num_samples=num_samples, progress_bar=False) @@ -177,7 +192,7 @@ def model(data): assert samples['p_latent'].dtype == jnp.float64 -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, BarkerMH]) @pytest.mark.parametrize('dense_mass', [False, True]) def test_dirichlet_categorical_x64(kernel_cls, dense_mass): warmup_steps, num_samples = 100, 20000 @@ -190,7 +205,11 @@ def model(data): true_probs = jnp.array([0.1, 0.6, 0.3]) data = dist.Categorical(true_probs).sample(random.PRNGKey(1), (2000,)) - kernel = kernel_cls(model, trajectory_length=1., dense_mass=dense_mass) + if kernel_cls is BarkerMH: + # TODO: fix dense_mass once BarkerMH supports it + kernel = BarkerMH(model=model, dense_mass=False) + else: + kernel = kernel_cls(model, trajectory_length=1., dense_mass=dense_mass) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() diff --git a/test/test_reparam.py b/test/infer/test_reparam.py similarity index 100% rename from test/test_reparam.py rename to test/infer/test_reparam.py diff --git a/test/test_svi.py b/test/infer/test_svi.py similarity index 100% rename from test/test_svi.py rename to test/infer/test_svi.py From 3fac7b145305a2354683c5908926264e133615b3 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 20 Feb 2021 15:03:20 -0600 Subject: [PATCH 061/222] Improving compiling time in MCMC samplers (#924) * fix compile time * also address compiling time for barker * fix init state of sa --- numpyro/infer/barker.py | 4 +++- numpyro/infer/hmc.py | 4 ++-- numpyro/infer/sa.py | 3 ++- 3 files changed, 7 insertions(+), 4 deletions(-) diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py index dd89f6e9c..15994e774 100644 --- a/numpyro/infer/barker.py +++ b/numpyro/infer/barker.py @@ -165,7 +165,9 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): size = len(ravel_pytree(init_params)[0]) wa_state = wa_init(None, rng_key_wa, self._step_size, mass_matrix_size=size) wa_state = wa_state._replace(rng_key=None) - return jax.device_put(BarkerMHState(0, init_params, pe, grad, 0., 0., wa_state, rng_key)) + init_state = BarkerMHState(jnp.array(0), init_params, pe, grad, jnp.array(0.), + jnp.array(0.), wa_state, rng_key) + return jax.device_put(init_state) def postprocess_fn(self, args, kwargs): if self._postprocess_fn is None: diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 8e9d9302b..c245995bf 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -245,8 +245,8 @@ def init_kernel(init_params, vv_init, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) vv_state = vv_init(z, r, potential_energy=pe, z_grad=z_grad) energy = kinetic_fn(wa_state.inverse_mass_matrix, vv_state.r) - hmc_state = HMCState(0, vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, - 0, 0., 0., False, wa_state, rng_key_hmc) + hmc_state = HMCState(jnp.array(0), vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, + jnp.array(0), jnp.array(0.), jnp.array(0.), jnp.array(False), wa_state, rng_key_hmc) return device_put(hmc_state) def _hmc_next(step_size, inverse_mass_matrix, vv_state, diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index aadb0e2df..1bb6eb389 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -135,7 +135,8 @@ def init_kernel(init_params, k = random.categorical(rng_key_z, jnp.zeros(zs.shape[0])) z = unravel_fn(zs[k]) pe = pes[k] - sa_state = SAState(0, z, pe, 0., 0., False, adapt_state, rng_key_sa) + sa_state = SAState(jnp.array(0), z, pe, jnp.array(0.), jnp.array(0.), jnp.array(False), + adapt_state, rng_key_sa) return device_put(sa_state) def sample_kernel(sa_state, model_args=(), model_kwargs=None): From 6a193f08542191e5afd1e141b304e8cf642aab02 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Sun, 21 Feb 2021 12:02:26 -0800 Subject: [PATCH 062/222] add dense_mass=True support to BarkerMH (#925) * wip * wip2 * add numpyro/infer/test.py * fix * fix test * fl8 * fix * fix? * moreassert * add test * tweaktest * tweak tolerance * dense mass in barker tests * change step size * tweaktest * tweak test * fix dense mass * update docstring --- numpyro/infer/barker.py | 32 +++++++++++++++++++++----------- test/infer/test_mcmc.py | 39 +++++++++++++++++++++++++++++++++------ 2 files changed, 54 insertions(+), 17 deletions(-) diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py index 15994e774..afbffa520 100644 --- a/numpyro/infer/barker.py +++ b/numpyro/infer/barker.py @@ -75,7 +75,7 @@ class BarkerMH(MCMCKernel): :param bool adapt_mass_matrix: Whether to adapt the mass matrix during warm-up. Defaults to ``adapt_mass_matrix==True``. :param bool dense_mass: Whether to use a dense (i.e. full-rank) or diagonal mass matrix. - (defaults to ``dense_mass=False``). Currently only ``dense_mass=False`` is supported. + (defaults to ``dense_mass=False``). :param float target_accept_prob: The target acceptance probability that is used to guide step size adapation. Defaults to ``target_accept_prob=0.4``. :param callable init_strategy: a per-site initialization function. @@ -92,10 +92,10 @@ class BarkerMH(MCMCKernel): >>> from numpyro.infer import MCMC, BarkerMH >>> def model(): - ... numpyro.sample("x", dist.Normal().expand([10])) + ... x = numpyro.sample("x", dist.Normal().expand([10])) ... numpyro.sample("obs", dist.Normal(x, 1.0), obs=jnp.ones(10)) >>> - >>> kernel = Barker(model) + >>> kernel = BarkerMH(model) >>> mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000, progress_bar=True) >>> mcmc.run(jax.random.PRNGKey(0)) >>> mcmc.print_summary() # doctest: +SKIP @@ -105,8 +105,6 @@ def __init__(self, model=None, potential_fn=None, step_size=1.0, target_accept_prob=0.4, init_strategy=init_to_uniform): if not (model is None) ^ (potential_fn is None): raise ValueError('Only one of `model` or `potential_fn` must be specified.') - if dense_mass: - raise ValueError('Only dense_mass=False is currently supported') self._model = model self._potential_fn = potential_fn self._step_size = step_size @@ -181,18 +179,30 @@ def sample(self, state, model_args, model_kwargs): shape = jnp.shape(x_flat) rng_key, key_normal, key_bernoulli, key_accept = random.split(rng_key, 4) + mass_sqrt = adapt_state.mass_matrix_sqrt + inverse_mass = adapt_state.inverse_mass_matrix + mass_sqrt_inv = mass_sqrt.T @ inverse_mass if self._dense_mass else 1.0 / mass_sqrt + + x_grad_flat_scaled = mass_sqrt_inv @ x_grad_flat if self._dense_mass else mass_sqrt_inv * x_grad_flat + # Generate proposal y. - # TODO: Support dense_mass=True - z_proposal = adapt_state.step_size * random.normal(key_normal, shape) * adapt_state.mass_matrix_sqrt - p = expit(-z_proposal * x_grad_flat) + z = adapt_state.step_size * random.normal(key_normal, shape) + + p = expit(-z * x_grad_flat_scaled) b = jnp.where(random.uniform(key_bernoulli, shape) < p, 1., -1.) - bz = b * z_proposal - y_flat = x_flat + bz + + dx_flat = b * z + dx_flat_scaled = mass_sqrt_inv.T @ dx_flat if self._dense_mass else mass_sqrt_inv * dx_flat + + y_flat = x_flat + dx_flat_scaled y = unravel_fn(y_flat) y_pe, y_grad = jax.value_and_grad(self._potential_fn)(y) y_grad_flat, _ = ravel_pytree(y_grad) - log_accept_ratio = x_pe - y_pe + jnp.sum(softplus(bz * x_grad_flat) - softplus(-bz * y_grad_flat)) + y_grad_flat_scaled = mass_sqrt_inv @ y_grad_flat if self._dense_mass else mass_sqrt_inv * y_grad_flat + + log_accept_ratio = x_pe - y_pe + jnp.sum(softplus(dx_flat * x_grad_flat_scaled) - + softplus(-dx_flat * y_grad_flat_scaled)) accept_prob = jnp.clip(jnp.exp(log_accept_ratio), a_max=1.) x, x_flat, pe, x_grad = jax.lax.cond(random.bernoulli(key_accept, accept_prob), diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index 9c5ea85ff..6c6ad7842 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -37,8 +37,7 @@ def potential_fn(z): if kernel_cls is SA: kernel = SA(potential_fn=potential_fn, dense_mass=dense_mass) elif kernel_cls is BarkerMH: - # TODO: fix dense_mass once BarkerMH supports it - kernel = SA(potential_fn=potential_fn, dense_mass=False) + kernel = SA(potential_fn=potential_fn, dense_mass=dense_mass) else: kernel = kernel_cls(potential_fn=potential_fn, trajectory_length=8, dense_mass=dense_mass) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) @@ -97,8 +96,7 @@ def model(labels): if kernel_cls is SA: kernel = SA(model=model, adapt_state_size=9) elif kernel_cls is BarkerMH: - # TODO: fix dense_mass once BarkerMH supports it - kernel = BarkerMH(model=model, dense_mass=False) + kernel = BarkerMH(model=model) else: kernel = kernel_cls(model=model, trajectory_length=8, find_heuristic_step_size=True) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) @@ -206,8 +204,7 @@ def model(data): true_probs = jnp.array([0.1, 0.6, 0.3]) data = dist.Categorical(true_probs).sample(random.PRNGKey(1), (2000,)) if kernel_cls is BarkerMH: - # TODO: fix dense_mass once BarkerMH supports it - kernel = BarkerMH(model=model, dense_mass=False) + kernel = BarkerMH(model=model, dense_mass=dense_mass) else: kernel = kernel_cls(model, trajectory_length=1., dense_mass=dense_mass) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) @@ -219,6 +216,36 @@ def model(data): assert samples['p_latent'].dtype == jnp.float64 +@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, BarkerMH]) +@pytest.mark.parametrize('rho', [-0.7, 0.8]) +def test_dense_mass(kernel_cls, rho): + warmup_steps, num_samples = 20000, 10000 + + true_cov = jnp.array([[10.0, rho], [rho, 0.1]]) + + def model(): + numpyro.sample("x", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=true_cov)) + + if kernel_cls is HMC or kernel_cls is NUTS: + kernel = kernel_cls(model, trajectory_length=1., dense_mass=True) + elif kernel_cls is BarkerMH: + kernel = BarkerMH(model, dense_mass=True) + + mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc.run(random.PRNGKey(0)) + + mass_matrix_sqrt = mcmc.last_state.adapt_state.mass_matrix_sqrt + mass_matrix = jnp.matmul(mass_matrix_sqrt, jnp.transpose(mass_matrix_sqrt)) + estimated_cov = jnp.linalg.inv(mass_matrix) + assert_allclose(estimated_cov, true_cov, rtol=0.10) + + samples = mcmc.get_samples()['x'] + assert_allclose(jnp.mean(samples[:, 0]), jnp.array(0.0), atol=0.50) + assert_allclose(jnp.mean(samples[:, 1]), jnp.array(0.0), atol=0.05) + assert_allclose(jnp.mean(samples[:, 0] * samples[:, 1]), jnp.array(rho), atol=0.20) + assert_allclose(jnp.var(samples, axis=0), jnp.array([10.0, 0.1]), rtol=0.20) + + def test_change_point_x64(): # Ref: https://forum.pyro.ai/t/i-dont-understand-why-nuts-code-is-not-working-bayesian-hackers-mail/696 warmup_steps, num_samples = 500, 3000 From 131835172e51644c66caf26052f5467e41204a9b Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 21 Feb 2021 15:00:15 -0600 Subject: [PATCH 063/222] Store mass_sqrt_inv in adapt state (#926) * wip * wip2 * add numpyro/infer/test.py * fix * fix test * fl8 * fix * fix? * moreassert * add test * tweaktest * tweak tolerance * dense mass in barker tests * change step size * tweaktest * tweak test * fix dense mass * update docstring * store mass_matrix_sqrt_inv to adapt state to save computation for barker Co-authored-by: Martin Jankowiak --- .github/workflows/ci.yml | 3 --- numpyro/infer/barker.py | 4 +--- numpyro/infer/hmc_util.py | 41 ++++++++++++++++++++++++------------- test/infer/test_hmc_util.py | 10 ++++----- test/test_examples.py | 2 +- 5 files changed, 34 insertions(+), 26 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 3091d6ed9..9ef398107 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -133,8 +133,5 @@ jobs: pip install .[dev,examples,test] pip freeze - name: Test with pytest - run: | - pytest -vs -k test_example - - name: Test chains run: | XLA_FLAGS="--xla_force_host_platform_device_count=2" pytest -vs -k test_example diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py index afbffa520..6e910971d 100644 --- a/numpyro/infer/barker.py +++ b/numpyro/infer/barker.py @@ -179,9 +179,7 @@ def sample(self, state, model_args, model_kwargs): shape = jnp.shape(x_flat) rng_key, key_normal, key_bernoulli, key_accept = random.split(rng_key, 4) - mass_sqrt = adapt_state.mass_matrix_sqrt - inverse_mass = adapt_state.inverse_mass_matrix - mass_sqrt_inv = mass_sqrt.T @ inverse_mass if self._dense_mass else 1.0 / mass_sqrt + mass_sqrt_inv = adapt_state.mass_matrix_sqrt_inv x_grad_flat_scaled = mass_sqrt_inv @ x_grad_flat if self._dense_mass else mass_sqrt_inv * x_grad_flat diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 009f321f3..bed612478 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -7,16 +7,18 @@ from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.ops import index_update +from jax.scipy.linalg import solve_triangular from jax.scipy.special import expit from jax.tree_util import tree_flatten, tree_map, tree_multimap import numpyro.distributions as dist -from numpyro.distributions.util import cholesky_of_inverse, get_dtype +from numpyro.distributions.util import get_dtype from numpyro.util import cond, identity, while_loop AdaptWindow = namedtuple('AdaptWindow', ['start', 'end']) # XXX: we need to store rng_key here in case we use find_reasonable_step_size functionality HMCAdaptState = namedtuple('HMCAdaptState', ['step_size', 'inverse_mass_matrix', 'mass_matrix_sqrt', + 'mass_matrix_sqrt_inv', 'ss_state', 'mm_state', 'window_idx', 'rng_key']) IntegratorState = namedtuple('IntegratorState', ['z', 'r', 'potential_energy', 'z_grad']) IntegratorState.__new__.__defaults__ = (None,) * len(IntegratorState._fields) @@ -149,7 +151,8 @@ def final_fn(state, regularize=False): """ :param state: Current state of the scheme. :param bool regularize: Whether to adjust diagonal for numerical stability. - :return: a pair of estimated covariance and the square root of precision. + :return: a triple of estimated covariance, the square root of precision, and + the inverse of that square root. """ mean, m2, n = state # XXX it is not necessary to check for the case n=1 @@ -163,10 +166,14 @@ def final_fn(state, regularize=False): else: cov = scaled_cov + shrinkage * jnp.identity(mean.shape[0]) if jnp.ndim(cov) == 2: - cov_inv_sqrt = cholesky_of_inverse(cov) + # copy the implementation of distributions.util.cholesky_of_inverse here + tril_inv = jnp.swapaxes(jnp.linalg.cholesky(cov[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1) + identity = jnp.identity(cov.shape[-1]) + cov_inv_sqrt = solve_triangular(tril_inv, identity, lower=True) else: - cov_inv_sqrt = jnp.sqrt(jnp.reciprocal(cov)) - return cov, cov_inv_sqrt + tril_inv = jnp.sqrt(cov) + cov_inv_sqrt = jnp.reciprocal(tril_inv) + return cov, cov_inv_sqrt, tril_inv return init_fn, update_fn, final_fn @@ -390,12 +397,16 @@ def init_fn(z_info, rng_key, step_size=1.0, inverse_mass_matrix=None, mass_matri inverse_mass_matrix = jnp.identity(mass_matrix_size) else: inverse_mass_matrix = jnp.ones(mass_matrix_size) - mass_matrix_sqrt = inverse_mass_matrix + mass_matrix_sqrt = mass_matrix_sqrt_inv = inverse_mass_matrix else: if dense_mass: - mass_matrix_sqrt = cholesky_of_inverse(inverse_mass_matrix) + mass_matrix_sqrt_inv = jnp.swapaxes(jnp.linalg.cholesky( + inverse_mass_matrix[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1) + identity = jnp.identity(inverse_mass_matrix.shape[-1]) + mass_matrix_sqrt = solve_triangular(mass_matrix_sqrt_inv, identity, lower=True) else: - mass_matrix_sqrt = jnp.sqrt(jnp.reciprocal(inverse_mass_matrix)) + mass_matrix_sqrt_inv = jnp.sqrt(inverse_mass_matrix) + mass_matrix_sqrt = jnp.reciprocal(mass_matrix_sqrt_inv) if adapt_step_size: step_size = find_reasonable_step_size(step_size, inverse_mass_matrix, z_info, rng_key_ss) @@ -404,14 +415,15 @@ def init_fn(z_info, rng_key, step_size=1.0, inverse_mass_matrix=None, mass_matri mm_state = mm_init(inverse_mass_matrix.shape[-1]) window_idx = 0 - return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, + return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, ss_state, mm_state, window_idx, rng_key) def _update_at_window_end(z_info, rng_key_ss, state): - step_size, inverse_mass_matrix, mass_matrix_sqrt, ss_state, mm_state, window_idx, rng_key = state + step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, \ + ss_state, mm_state, window_idx, rng_key = state if adapt_mass_matrix: - inverse_mass_matrix, mass_matrix_sqrt = mm_final(mm_state, regularize=True) + inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv = mm_final(mm_state, regularize=True) mm_state = mm_init(inverse_mass_matrix.shape[-1]) if adapt_step_size: @@ -420,7 +432,7 @@ def _update_at_window_end(z_info, rng_key_ss, state): # and jnp.log(10) + jnp.log(step_size) will be finite ss_state = ss_init(jnp.log(10) + jnp.log(step_size)) - return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, + return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, ss_state, mm_state, window_idx, rng_key) def update_fn(t, accept_prob, z_info, state): @@ -431,7 +443,8 @@ def update_fn(t, accept_prob, z_info, state): :param state: Current state of the adapt scheme. :return: new state of the adapt scheme. """ - step_size, inverse_mass_matrix, mass_matrix_sqrt, ss_state, mm_state, window_idx, rng_key = state + step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, \ + ss_state, mm_state, window_idx, rng_key = state if rng_key is not None: rng_key, rng_key_ss = random.split(rng_key) else: @@ -460,7 +473,7 @@ def update_fn(t, accept_prob, z_info, state): t_at_window_end = t == adaptation_schedule[window_idx, 1] window_idx = jnp.where(t_at_window_end, window_idx + 1, window_idx) - state = HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, + state = HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, ss_state, mm_state, window_idx, rng_key) state = cond(t_at_window_end & is_middle_window, (z_info, rng_key_ss, state), lambda args: _update_at_window_end(*args), diff --git a/test/infer/test_hmc_util.py b/test/infer/test_hmc_util.py index 8f7be95db..ee8c5474b 100644 --- a/test/infer/test_hmc_util.py +++ b/test/infer/test_hmc_util.py @@ -69,7 +69,7 @@ def get_cov(x): wc_init, wc_update, wc_final = welford_covariance(diagonal=diagonal) wc_state = wc_init(3) wc_state = fori_loop(0, 2000, lambda i, val: wc_update(x[i], val), wc_state) - cov, cov_inv_sqrt = wc_final(wc_state, regularize=regularize) + cov, cov_inv_sqrt, _ = wc_final(wc_state, regularize=regularize) return cov, cov_inv_sqrt cov, cov_inv_sqrt = get_cov(x) @@ -279,7 +279,7 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): rng_key = random.PRNGKey(0) z = jnp.ones(3) wa_state = wa_init((z, None, None, None), rng_key, init_step_size, mass_matrix_size=mass_matrix_size) - step_size, inverse_mass_matrix, _, _, _, window_idx, _ = wa_state + step_size, inverse_mass_matrix, _, _, _, _, window_idx, _ = wa_state assert step_size == find_reasonable_step_size(init_step_size, inverse_mass_matrix, z, rng_key) assert_allclose(inverse_mass_matrix, jnp.ones(mass_matrix_size)) assert window_idx == 0 @@ -288,7 +288,7 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): for t in range(window.start, window.end + 1): wa_state = wa_update(t, 0.7 + 0.1 * t / (window.end - window.start), z, wa_state) last_step_size = step_size - step_size, inverse_mass_matrix, _, _, _, window_idx, _ = wa_state + step_size, inverse_mass_matrix, _, _, _, _, window_idx, _ = wa_state assert window_idx == 1 # step_size is decreased because accept_prob < target_accept_prob assert step_size < last_step_size @@ -300,7 +300,7 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): for t in range(window.start, window.end + 1): wa_state = wa_update(t, 0.8 + 0.1 * (t - window.start) / window_len, 2 * z, wa_state) last_step_size = step_size - step_size, inverse_mass_matrix, _, _, _, window_idx, _ = wa_state + step_size, inverse_mass_matrix, _, _, _, _, window_idx, _ = wa_state assert window_idx == 2 # step_size is increased because accept_prob > target_accept_prob assert step_size > last_step_size @@ -318,7 +318,7 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): for t in range(window.start, window.end + 1): wa_state = wa_update(t, 0.8, t * z, wa_state) last_step_size = step_size - step_size, final_inverse_mass_matrix, _, _, _, window_idx, _ = wa_state + step_size, final_inverse_mass_matrix, _, _, _, _, window_idx, _ = wa_state assert window_idx == 3 # during the last window, because target_accept_prob=0.8, # log_step_size will be equal to the constant prox_center=log(10*last_step_size) diff --git a/test/test_examples.py b/test/test_examples.py index 3d0029df5..a7829f3d1 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -22,7 +22,7 @@ 'bnn.py --num-samples 10 --num-warmup 10 --num-data 7 --num-chains 2', 'capture_recapture.py --num-samples 4 --num-warmup 1 -m 3', 'capture_recapture.py --num-samples 4 --num-warmup 1 -m 5', - 'covtype.py --algo HMC --num-samples 10', + 'covtype.py --algo HMC --num-samples 10 --num-warmup 10', 'gp.py --num-samples 10 --num-warmup 10 --num-chains 2', 'hmm.py --num-samples 100 --num-warmup 100 --num-chains 2', 'hmm_enum.py -m 1 -t 3 -d 4 --num-warmup 1 -n 4', From 5004691a4e4d5b3f10b0f4114096d5dfc5f8599c Mon Sep 17 00:00:00 2001 From: Vitalii Kleshchevnikov Date: Mon, 22 Feb 2021 16:50:32 +0000 Subject: [PATCH 064/222] adding Softplus transform (#919) * added SoftPlus class * added SoftplusTransform as default way to enforce positive constraint * Revert "added SoftplusTransform as default way to enforce positive constraint" This reverts commit 2369cae8c1b4ffb05f7473f4c24eadc13bf86ecd. * numerically stable inverse * added softplus transform to docs * added test for softplus transform * flake8 and bug fix in SoftplusTransform _inverse * more flake8 changes * changed softplus transform init to take no input * changed softplus transform test * flake8 * changed softplus transform test * simiplified codomain in softplus transform * minor change to docs * changed softplus transform test --- docs/source/distributions.rst | 8 ++++++++ numpyro/distributions/transforms.py | 19 +++++++++++++++++++ test/test_distributions.py | 9 ++++++++- 3 files changed, 35 insertions(+), 1 deletion(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 05c6f56d5..9de94be6f 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -637,6 +637,14 @@ ExpTransform :undoc-members: :show-inheritance: :member-order: bysource + +SoftplusTransform +----------------- +.. autoclass:: numpyro.distributions.transforms.SoftplusTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource IdentityTransform ----------------- diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index c405124a6..932cbca83 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -34,6 +34,7 @@ 'CorrCholeskyTransform', 'CorrMatrixCholeskyTransform', 'ExpTransform', + 'SoftplusTransform', 'IdentityTransform', 'InvCholeskyTransform', 'LowerCholeskyTransform', @@ -451,6 +452,24 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): return x +class SoftplusTransform(Transform): + r""" + Transform from unconstrained space to positive domain via softplus :math:`y = \log(1 + \exp(x))`. + The inverse is computed as :math:`y = \log(\exp(x) - 1)`. + """ + domain = constraints.real + codomain = constraints.positive + + def __call__(self, x): + return softplus(x) + + def _inverse(self, x): + return jnp.log(-jnp.expm1(-x)) + x + + def log_abs_det_jacobian(self, x, y, intermediates=None): + return -softplus(-x) + + class IdentityTransform(Transform): def __call__(self, x): diff --git a/test/test_distributions.py b/test/test_distributions.py index 257c48b4a..bb51a9bd0 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -22,7 +22,13 @@ from numpyro.distributions.discrete import _to_probs_bernoulli, _to_probs_multinom from numpyro.distributions.flows import InverseAutoregressiveTransform from numpyro.distributions.gof import InvalidTest, auto_goodness_of_fit -from numpyro.distributions.transforms import LowerCholeskyAffine, PermuteTransform, PowerTransform, biject_to +from numpyro.distributions.transforms import ( + LowerCholeskyAffine, + PermuteTransform, + SoftplusTransform, + PowerTransform, + biject_to +) from numpyro.distributions.util import ( matrix_to_tril_vec, multinomial, @@ -1165,6 +1171,7 @@ def inv_vec_transform(y): @pytest.mark.parametrize('transform, event_shape', [ (PermuteTransform(jnp.array([3, 0, 4, 1, 2])), (5,)), (PowerTransform(2.), ()), + (SoftplusTransform(), ()), (LowerCholeskyAffine(jnp.array([1., 2.]), jnp.array([[0.6, 0.], [1.5, 0.4]])), (2,)) ]) @pytest.mark.parametrize('batch_shape', [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) From 62f4556750f026fceca0ba88577c1105400ff88f Mon Sep 17 00:00:00 2001 From: Matt Ludkin Date: Thu, 25 Feb 2021 00:14:57 +0000 Subject: [PATCH 065/222] Update README.md (#929) * Update README.md added space so the docs on page http://num.pyro.ai/en/stable/getting_started.html have proper code formatting Updated comments on the seed handler example to show the actual behaviour re splitting of keys * README Citation title --- README.md | 42 ++++++++++++++++++++++-------------------- 1 file changed, 22 insertions(+), 20 deletions(-) diff --git a/README.md b/README.md index 5bdd712c8..16606aa19 100644 --- a/README.md +++ b/README.md @@ -19,7 +19,7 @@ NumPyro is designed to be *lightweight* and focuses on providing a flexible subs - **Inference algorithms:** NumPyro currently supports Hamiltonian Monte Carlo, including an implementation of the No U-Turn Sampler. One of the motivations for NumPyro was to speed up Hamiltonian Monte Carlo by JIT compiling the verlet integrator that includes multiple gradient computations. With JAX, we can compose `jit` and `grad` to compile the entire integration step into an XLA optimized kernel. We also eliminate Python overhead by JIT compiling the entire tree building stage in NUTS (this is possible using [Iterative NUTS](https://github.com/pyro-ppl/numpyro/wiki/Iterative-NUTS)). There is also a basic Variational Inference implementation for reparameterized distributions together with many flexible (auto)guides for Automatic Differentiation Variational Inference (ADVI). - **Distributions:** The [numpyro.distributions](https://numpyro.readthedocs.io/en/latest/distributions.html) module provides distribution classes, constraints and bijective transforms. The distribution classes wrap over samplers implemented to work with JAX's [functional pseudo-random number generator](https://github.com/google/jax#random-numbers-are-different). The design of the distributions module largely follows from [PyTorch](https://pytorch.org/docs/stable/distributions.html). A major subset of the API is implemented, and it contains most of the common distributions that exist in PyTorch. As a result, Pyro and PyTorch users can rely on the same API and batching semantics as in `torch.distributions`. In addition to distributions, `constraints` and `transforms` are very useful when operating on distribution classes with bounded support. - **Effect handlers:** Like Pyro, primitives like `sample` and `param` can be provided nonstandard interpretations using effect-handlers from the [numpyro.handlers](https://numpyro.readthedocs.io/en/latest/handlers.html) module, and these can be easily extended to implement custom inference algorithms and inference utilities. - + ## A Simple Example - 8 Schools Let us explore NumPyro using a simple example. We will use the eight schools example from Gelman et al., Bayesian Data Analysis: Sec. 5.5, 2003, which studies the effect of coaching on SAT performance in eight schools. @@ -145,7 +145,7 @@ Note that for the class of distributions with `loc,scale` paramaters such as `No with numpyro.handlers.reparam(config={'theta': LocScaleReparam(centered=0)}): theta = numpyro.sample('theta', dist.Normal(mu, tau)) -Now, let us assume that we have a new school for which we have not observed any test scores, but we would like to generate predictions. NumPyro provides a [Predictive](http://num.pyro.ai/en/latest/utilities.html#numpyro.infer.util.Predictive) class for such a purpose. Note that in the absence of any observed data, we simply use the population-level parameters to generate predictions. The `Predictive` utility conditions the unobserved `mu` and `tau` sites to values drawn from the posterior distribution from our last MCMC run, and runs the model forward to generate predictions. +Now, let us assume that we have a new school for which we have not observed any test scores, but we would like to generate predictions. NumPyro provides a [Predictive](http://num.pyro.ai/en/latest/utilities.html#numpyro.infer.util.Predictive) class for such a purpose. Note that in the absence of any observed data, we simply use the population-level parameters to generate predictions. The `Predictive` utility conditions the unobserved `mu` and `tau` sites to values drawn from the posterior distribution from our last MCMC run, and runs the model forward to generate predictions. ```python >>> from numpyro.infer import Predictive @@ -177,7 +177,7 @@ For some more examples on specifying models and doing inference in NumPyro: - [Statistical Rethinking with NumPyro](https://github.com/fehiepsi/rethinking-numpyro) - [Notebooks](https://nbviewer.jupyter.org/github/fehiepsi/rethinking-numpyro/tree/master/notebooks/) containing translation of the code in Richard McElreath's [Statistical Rethinking](https://xcelab.net/rm/statistical-rethinking/) book second version, to NumPyro. - Other model examples can be found in the [examples](https://github.com/pyro-ppl/numpyro/tree/master/examples) folder. -Pyro users will note that the API for model specification and inference is largely the same as Pyro, including the distributions API, by design. However, there are some important core differences (reflected in the internals) that users should be aware of. e.g. in NumPyro, there is no global parameter store or random state, to make it possible for us to leverage JAX's JIT compilation. Also, users may need to write their models in a more *functional* style that works better with JAX. Refer to [FAQs](#frequently-asked-questions) for a list of differences. +Pyro users will note that the API for model specification and inference is largely the same as Pyro, including the distributions API, by design. However, there are some important core differences (reflected in the internals) that users should be aware of. e.g. in NumPyro, there is no global parameter store or random state, to make it possible for us to leverage JAX's JIT compilation. Also, users may need to write their models in a more *functional* style that works better with JAX. Refer to [FAQs](#frequently-asked-questions) for a list of differences. ## Installation @@ -211,42 +211,44 @@ pip install -e .[dev] # contains additional dependencies for NumPyro developmen You are most likely using a `numpyro.sample` statement outside an inference context. JAX does not have a global random state, and as such, distribution samplers need an explicit random number generator key ([PRNGKey](https://jax.readthedocs.io/en/latest/jax.random.html#jax.random.PRNGKey)) to generate samples from. NumPyro's inference algorithms use the [seed](http://num.pyro.ai/en/latest/handlers.html#seed) handler to thread in a random number generator key, behind the scenes. Your options are: - + - Call the distribution directly and provide a `PRNGKey`, e.g. `dist.Normal(0, 1).sample(PRNGKey(0))` - - Provide the `rng_key` argument to `numpyro.sample`. e.g. `numpyro.sample('x', dist.Normal(0, 1), rng_key=PRNGKey(0))`. - - Wrap the code in a `seed` handler, used either as a context manager or as a function that wraps over the original callable. e.g. + - Provide the `rng_key` argument to `numpyro.sample`. e.g. `numpyro.sample('x', dist.Normal(0, 1), rng_key=PRNGKey(0))`. + - Wrap the code in a `seed` handler, used either as a context manager or as a function that wraps over the original callable. e.g. + ```python - with handlers.seed(rng_seed=0): - x = numpyro.sample('x', dist.Beta(1, 1)) # random.PRNGKey(0) is used + with handlers.seed(rng_seed=0): # random.PRNGKey(0) is used + x = numpyro.sample('x', dist.Beta(1, 1)) # uses a PRNGKey split from random.PRNGKey(0) y = numpyro.sample('y', dist.Bernoulli(x)) # uses different PRNGKey split from the last one ``` + , or as a higher order function: - + ```python def fn(): x = numpyro.sample('x', dist.Beta(1, 1)) y = numpyro.sample('y', dist.Bernoulli(x)) return y - + print(handlers.seed(fn, rng_seed=0)()) ``` 2. Can I use the same Pyro model for doing inference in NumPyro? - + As you may have noticed from the examples, NumPyro supports all Pyro primitives like `sample`, `param`, `plate` and `module`, and effect handlers. Additionally, we have ensured that the [distributions](https://numpyro.readthedocs.io/en/latest/distributions.html) API is based on `torch.distributions`, and the inference classes like `SVI` and `MCMC` have the same interface. This along with the similarity in the API for NumPy and PyTorch operations ensures that models containing Pyro primitive statements can be used with either backend with some minor changes. Example of some differences along with the changes needed, are noted below: - + - Any `torch` operation in your model will need to be written in terms of the corresponding `jax.numpy` operation. Additionally, not all `torch` operations have a `numpy` counterpart (and vice-versa), and sometimes there are minor differences in the API. - `pyro.sample` statements outside an inference context will need to be wrapped in a `seed` handler, as mentioned above. - - There is no global parameter store, and as such using `numpyro.param` outside an inference context will have no effect. To retrieve the optimized parameter values from SVI, use the [SVI.get_params](http://num.pyro.ai/en/latest/svi.html#numpyro.infer.svi.SVI.get_params) method. Note that you can still use `param` statements inside a model and NumPyro will use the [substitute](http://num.pyro.ai/en/latest/handlers.html#substitute) effect handler internally to substitute values from the optimizer when running the model in SVI. + - There is no global parameter store, and as such using `numpyro.param` outside an inference context will have no effect. To retrieve the optimized parameter values from SVI, use the [SVI.get_params](http://num.pyro.ai/en/latest/svi.html#numpyro.infer.svi.SVI.get_params) method. Note that you can still use `param` statements inside a model and NumPyro will use the [substitute](http://num.pyro.ai/en/latest/handlers.html#substitute) effect handler internally to substitute values from the optimizer when running the model in SVI. - PyTorch neural network modules will need to rewritten as [stax](https://github.com/google/jax#neural-net-building-with-stax) neural networks. See the [VAE](#examples) example for differences in syntax between the two backends. - JAX works best with functional code, particularly if we would like to leverage JIT compilation, which NumPyro does internally for many inference subroutines. As such, if your model has side-effects that are not visible to the JAX tracer, it may need to rewritten in a more functional style. - + For most small models, changes required to run inference in NumPyro should be minor. Additionally, we are working on [pyro-api](https://github.com/pyro-ppl/pyro-api) which allows you to write the same code and dispatch it to multiple backends, including NumPyro. This will necessarily be more restrictive, but has the advantage of being backend agnostic. See the [documentation](https://pyro-api.readthedocs.io/en/latest/dispatch.html#module-pyroapi.dispatch) for an example, and let us know your feedback. 3. How can I contribute to the project? - - Thanks for your interest in the project! You can take a look at beginner friendly issues that are marked with the [good first issue](https://github.com/pyro-ppl/numpyro/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) tag on Github. Also, please feel to reach out to us on the [forum](https://forum.pyro.ai/). + + Thanks for your interest in the project! You can take a look at beginner friendly issues that are marked with the [good first issue](https://github.com/pyro-ppl/numpyro/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22) tag on Github. Also, please feel to reach out to us on the [forum](https://forum.pyro.ai/). ## Future / Ongoing Work @@ -258,10 +260,10 @@ In the near term, we plan to work on the following. Please open new issues for f - More inference algorithms, particularly those that require second order derivaties or use HMC. - Integration with [Funsor](https://github.com/pyro-ppl/funsor) to support inference algorithms with delayed sampling. - Other areas motivated by Pyro's research goals and application focus, and interest from the community. - - ## Citing NumPyro - -The motivating ideas behind NumPyro and a description of Iterative NUTS can be found in this [paper](https://arxiv.org/abs/1912.11554) that appeared in NeurIPS 2019 Program Transformations for Machine Learning Workshop. + +## Citing NumPyro + +The motivating ideas behind NumPyro and a description of Iterative NUTS can be found in this [paper](https://arxiv.org/abs/1912.11554) that appeared in NeurIPS 2019 Program Transformations for Machine Learning Workshop. If you use NumPyro, please consider citing: From ce6cac87ec715ea467a353160dcb56a1827b28a9 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 28 Feb 2021 17:32:13 -0600 Subject: [PATCH 066/222] fix student-t.cdf numerical issue (#934) --- numpyro/distributions/continuous.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index acfd7112e..1ba58fb9e 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -1117,7 +1117,8 @@ def cdf(self, value): beta_value = self.df / (self.df + scaled_squared) # when scaled < 0, returns 0.5 * Beta(df/2, 0.5).cdf(beta_value) # when scaled > 0, returns 1 - 0.5 * Beta(df/2, 0.5).cdf(beta_value) - return 0.5 * (1 + jnp.sign(scaled) * (1 - betainc(0.5 * self.df, 0.5, beta_value))) + scaled_sign_half = 0.5 * jnp.sign(scaled) + return 0.5 + scaled_sign_half - 0.5 * jnp.sign(scaled) * betainc(0.5 * self.df, 0.5, beta_value) def icdf(self, q): # scipy.special.betaincinv is not avaiable yet in JAX @@ -1154,7 +1155,7 @@ def _tail_prob_at_low(self): @lazy_property def _tail_prob_at_high(self): # if low < loc, returns cdf(high) = 1; otherwise returns 1 - cdf(high) = 0 - return jnp.where(self.low < self.base_dist.loc, 1., 0.) + return jnp.where(self.low <= self.base_dist.loc, 1., 0.) def sample(self, key, sample_shape=()): assert is_prng_key(key) From 216bcd12d7ff856f12803505b4b3470bb7af70e1 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 4 Mar 2021 11:17:36 -0600 Subject: [PATCH 067/222] Expose covtype example to docs (#939) * fix docs of potential energy * fix some imports --- docs/source/conf.py | 2 +- docs/source/index.rst | 1 + examples/covtype.py | 25 ++++++++++++++++++++++++- numpyro/distributions/__init__.py | 4 ++-- numpyro/infer/__init__.py | 4 ++++ numpyro/infer/hmc.py | 5 +++-- numpyro/infer/util.py | 6 ++---- 7 files changed, 37 insertions(+), 10 deletions(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index adf47cdd4..ad61d11d7 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -188,7 +188,7 @@ 'gallery_dirs': ['examples'], # only execute files beginning with plot_ 'filename_pattern': '/plot_', - 'ignore_pattern': '(minipyro|covtype|__init__)', + 'ignore_pattern': '(minipyro|__init__)', # not display Total running time of the script because we do not execute it 'min_reported_time': 1 } diff --git a/docs/source/index.rst b/docs/source/index.rst index 60a4ec378..424d194dd 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -54,6 +54,7 @@ NumPyro documentation examples/hmm examples/ode examples/neutra + examples/covtype Indices and tables diff --git a/examples/covtype.py b/examples/covtype.py index 702b0d151..836c099e1 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -1,6 +1,29 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +""" +Example: MCMC Methods for Tall Data +=================================== + +This example illustrates the usages of various MCMC methods which are suitable for tall data: + + - `algo="SA"` uses the sample adaptive MCMC method in [1] + - `algo="HMCECS"` uses the energy conserving subsampling method in [2] + - `algo="FlowHMCECS"` utilizes a normalizing flow to neutralize the posterior + geometry into a Gaussian-like one. Then HMCECS is used to draw the posterior + samples. Currently, this method gives the best mixing rate among those methods. + +**References:** + + 1. *Sample Adaptive MCMC*, + Michael Zhu (2019) + 2. *Hamiltonian Monte Carlo with energy conserving subsampling*, + Dang, K. D., Quiroz, M., Kohn, R., Minh-Ngoc, T., & Villani, M. (2019) + 3. *NeuTra-lizing Bad Geometry in Hamiltonian Monte Carlo Using Neural Transport*, + Hoffman, M. et al. (2019) + +""" + import argparse import time @@ -124,7 +147,7 @@ def main(args): parser.add_argument('--num-steps', default=10, type=int, help='number of steps (for "HMC")') parser.add_argument('--num-chains', nargs='?', default=1, type=int) parser.add_argument('--algo', default='HMCECS', type=str, - help='whether to run "HMCECS", "NUTS", "HMCECS", "SA" or "FlowHMCECS"') + help='whether to run "HMC", "NUTS", "HMCECS", "SA" or "FlowHMCECS"') parser.add_argument('--dense-mass', action="store_true") parser.add_argument('--x64', action="store_true") parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index b7f46167e..fad05d574 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -2,7 +2,6 @@ # SPDX-License-Identifier: Apache-2.0 from numpyro.distributions.conjugate import BetaBinomial, DirichletMultinomial, GammaPoisson -import numpyro.distributions.constraints # noqa: F401 from numpyro.distributions.continuous import ( LKJ, Beta, @@ -64,9 +63,10 @@ Unit ) from numpyro.distributions.kl import kl_divergence -import numpyro.distributions.transforms # noqa: F401 from numpyro.distributions.transforms import biject_to +from . import constraints, transforms + __all__ = [ 'biject_to', 'constraints', diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 3d277c1eb..6a978d739 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -17,13 +17,17 @@ from numpyro.infer.svi import SVI from numpyro.infer.util import Predictive, log_likelihood +from . import autoguide, reparam + __all__ = [ + 'autoguide', 'init_to_feasible', 'init_to_median', 'init_to_sample', 'init_to_uniform', 'init_to_value', 'log_likelihood', + 'reparam', 'BarkerMH', 'DiscreteHMCGibbs', 'ELBO', diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index c245995bf..42ff09135 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -401,12 +401,13 @@ def __init__(self, self._model = model self._potential_fn = potential_fn self._kinetic_fn = kinetic_fn if kinetic_fn is not None else euclidean_kinetic_energy - self._step_size = step_size + self._step_size = float(step_size) if isinstance(step_size, int) else step_size self._adapt_step_size = adapt_step_size self._adapt_mass_matrix = adapt_mass_matrix self._dense_mass = dense_mass self._target_accept_prob = target_accept_prob - self._trajectory_length = trajectory_length + self._trajectory_length = float(trajectory_length) \ + if isinstance(trajectory_length, int) else trajectory_length self._algo = 'HMC' self._max_tree_depth = 10 self._init_strategy = init_strategy diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 8b4227819..b5a9e8060 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -143,10 +143,8 @@ def _unconstrain_reparam(params, site): def potential_energy(model, model_args, model_kwargs, params, enum=False): """ (EXPERIMENTAL INTERFACE) Computes potential energy of a model given unconstrained params. - The `inv_transforms` is used to transform these unconstrained parameters to base values - of the corresponding priors in `model`. If a prior is a transformed distribution, - the corresponding base value lies in the support of base distribution. Otherwise, - the base value lies in the support of the distribution. + Under the hood, we will transform these unconstrained parameters to the values + belong to the supports of the corresponding priors in `model`. :param model: a callable containing NumPyro primitives. :param tuple model_args: args provided to the model. From 90a407ff48fc93cd81918c53a2eb1976dfe3d194 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 4 Mar 2021 13:59:44 -0600 Subject: [PATCH 068/222] Use softplus transform in autoguide (#941) * use softplus transform in autoguide * fix some mistakes in the implementation * switch back to the old implementation --- docs/source/distributions.rst | 16 ++++++ numpyro/distributions/constraints.py | 17 ++++++ numpyro/distributions/transforms.py | 84 ++++++++++++++++++++++------ numpyro/infer/autoguide.py | 24 ++++++-- test/infer/test_autoguide.py | 8 +-- test/test_distributions.py | 12 +++- 6 files changed, 133 insertions(+), 28 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 9de94be6f..2c21bf311 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -710,6 +710,22 @@ SigmoidTransform :show-inheritance: :member-order: bysource +SoftplusLowerCholeskyTransform +------------------------------ +.. autoclass:: numpyro.distributions.transforms.SoftplusLowerCholeskyTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +SoftplusTransform +----------------- +.. autoclass:: numpyro.distributions.transforms.SoftplusTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + StickBreakingTransform ---------------------- .. autoclass:: numpyro.distributions.transforms.StickBreakingTransform diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 331a8f102..b2ccf3f4f 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -47,6 +47,8 @@ 'real_vector', 'simplex', 'sphere', + 'softplus_lower_cholesky', + 'softplus_positive', 'unit_interval', 'Constraint', ] @@ -369,6 +371,19 @@ def feasible_like(self, prototype): return jax.numpy.full_like(prototype, 1 / prototype.shape[-1]) +class _SoftplusPositive(_GreaterThan): + def __init__(self): + super().__init__(lower_bound=0.0) + + def feasible_like(self, prototype): + return jax.numpy.full(jax.numpy.shape(prototype), np.log(2)) + + +class _SoftplusLowerCholesky(_LowerCholesky): + def feasible_like(self, prototype): + return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]) * np.log(2), prototype.shape) + + class _Sphere(Constraint): """ Constrain to the Euclidean sphere of any dimension. @@ -411,5 +426,7 @@ def feasible_like(self, prototype): real = _Real() real_vector = independent(real, 1) simplex = _Simplex() +softplus_lower_cholesky = _SoftplusLowerCholesky() +softplus_positive = _SoftplusPositive() sphere = _Sphere() unit_interval = _Interval(0., 1.) diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 932cbca83..0f769b547 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -42,6 +42,8 @@ 'PermuteTransform', 'PowerTransform', 'SigmoidTransform', + 'SoftplusTransform', + 'SoftplusLowerCholeskyTransform', 'StickBreakingTransform', 'Transform', 'UnpackTransform', @@ -452,24 +454,6 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): return x -class SoftplusTransform(Transform): - r""" - Transform from unconstrained space to positive domain via softplus :math:`y = \log(1 + \exp(x))`. - The inverse is computed as :math:`y = \log(\exp(x) - 1)`. - """ - domain = constraints.real - codomain = constraints.positive - - def __call__(self, x): - return softplus(x) - - def _inverse(self, x): - return jnp.log(-jnp.expm1(-x)) + x - - def log_abs_det_jacobian(self, x, y, intermediates=None): - return -softplus(-x) - - class IdentityTransform(Transform): def __call__(self, x): @@ -716,6 +700,60 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): return -x_abs - 2 * jnp.log1p(jnp.exp(-x_abs)) +def _softplus_inv(y): + return jnp.log(-jnp.expm1(-y)) + y + + +class SoftplusTransform(Transform): + r""" + Transform from unconstrained space to positive domain via softplus :math:`y = \log(1 + \exp(x))`. + The inverse is computed as :math:`x = \log(\exp(y) - 1)`. + """ + domain = constraints.real + codomain = constraints.softplus_positive + + def __call__(self, x): + return softplus(x) + + def _inverse(self, y): + return _softplus_inv(y) + + def log_abs_det_jacobian(self, x, y, intermediates=None): + return -softplus(-x) + + +class SoftplusLowerCholeskyTransform(Transform): + """ + Transform from unconstrained vector to lower-triangular matrices with + nonnegative diagonal entries. This is useful for parameterizing positive + definite matrices in terms of their Cholesky factorization. + """ + domain = constraints.real_vector + codomain = constraints.softplus_lower_cholesky + + def __call__(self, x): + n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) + z = vec_to_tril_matrix(x[..., :-n], diagonal=-1) + diag = softplus(x[..., -n:]) + return z + jnp.expand_dims(diag, axis=-1) * jnp.identity(n) + + def _inverse(self, y): + z = matrix_to_tril_vec(y, diagonal=-1) + diag = _softplus_inv(jnp.diagonal(y, axis1=-2, axis2=-1)) + return jnp.concatenate([z, diag], axis=-1) + + def log_abs_det_jacobian(self, x, y, intermediates=None): + # the jacobian is diagonal, so logdet is the sum of diagonal `exp` transform + n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) + return -softplus(-x[..., -n:]).sum(-1) + + def forward_shape(self, shape): + return _matrix_forward_shape(shape) + + def inverse_shape(self, shape): + return _matrix_inverse_shape(shape) + + class StickBreakingTransform(Transform): domain = constraints.real_vector codomain = constraints.simplex @@ -898,6 +936,16 @@ def _transform_to_real(constraint): return IdentityTransform() +@biject_to.register(constraints.softplus_positive) +def _transform_to_softplus_positive(constraint): + return SoftplusTransform() + + +@biject_to.register(constraints.softplus_lower_cholesky) +def _transform_to_softplus_lower_cholesky(constraint): + return SoftplusLowerCholeskyTransform() + + @biject_to.register(constraints.simplex) def _transform_to_simplex(constraint): return StickBreakingTransform() diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 16efa1932..405ff1f4d 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -160,6 +160,10 @@ class AutoNormal(AutoGuide): or iterable of plates. Plates not returned will be created automatically as usual. This is useful for data subsampling. """ + # TODO consider switching to constraints.softplus_positive + # See https://github.com/pyro-ppl/numpyro/issues/855 + scale_constraint = constraints.positive + def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, create_plates=None): self._init_scale = init_scale @@ -210,7 +214,7 @@ def __call__(self, *args, **kwargs): event_dim=event_dim) site_scale = numpyro.param("{}_{}_scale".format(name, self.prefix), jnp.full(jnp.shape(init_loc), self._init_scale), - constraint=constraints.positive, + constraint=self.scale_constraint, event_dim=event_dim) site_fn = dist.Normal(site_loc, site_scale).to_event(event_dim) @@ -535,6 +539,10 @@ class AutoDiagonalNormal(AutoContinuous): guide = AutoDiagonalNormal(model, ...) svi = SVI(model, guide, ...) """ + # TODO consider switching to constraints.softplus_positive + # See https://github.com/pyro-ppl/numpyro/issues/855 + scale_constraint = constraints.positive + def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, init_strategy=None): if init_strategy is not None: @@ -550,7 +558,7 @@ def _get_posterior(self): loc = numpyro.param('{}_loc'.format(self.prefix), self._init_latent) scale = numpyro.param('{}_scale'.format(self.prefix), jnp.full(self.latent_dim, self._init_scale), - constraint=constraints.positive) + constraint=self.scale_constraint) return dist.Normal(loc, scale) def get_base_dist(self): @@ -589,6 +597,10 @@ class AutoMultivariateNormal(AutoContinuous): guide = AutoMultivariateNormal(model, ...) svi = SVI(model, guide, ...) """ + # TODO consider switching to constraints.softplus_lower_cholesky + # See https://github.com/pyro-ppl/numpyro/issues/855 + scale_tril_constraint = constraints.lower_cholesky + def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, init_strategy=None): if init_strategy is not None: @@ -604,7 +616,7 @@ def _get_posterior(self): loc = numpyro.param('{}_loc'.format(self.prefix), self._init_latent) scale_tril = numpyro.param('{}_scale_tril'.format(self.prefix), jnp.identity(self.latent_dim) * self._init_scale, - constraint=constraints.lower_cholesky) + constraint=self.scale_tril_constraint) return dist.MultivariateNormal(loc, scale_tril=scale_tril) def get_base_dist(self): @@ -644,6 +656,10 @@ class AutoLowRankMultivariateNormal(AutoContinuous): guide = AutoLowRankMultivariateNormal(model, rank=2, ...) svi = SVI(model, guide, ...) """ + # TODO consider switching to constraints.softplus_positive + # See https://github.com/pyro-ppl/numpyro/issues/855 + scale_constraint = constraints.positive + def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, rank=None, init_strategy=None): if init_strategy is not None: @@ -663,7 +679,7 @@ def _get_posterior(self, *args, **kwargs): cov_factor = numpyro.param('{}_cov_factor'.format(self.prefix), jnp.zeros((self.latent_dim, rank))) scale = numpyro.param('{}_scale'.format(self.prefix), jnp.full(self.latent_dim, self._init_scale), - constraint=constraints.positive) + constraint=self.scale_constraint) cov_diag = scale * scale cov_factor = cov_factor * scale[..., None] return dist.LowRankMultivariateNormal(loc, cov_factor, cov_diag) diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 0a560d201..ad3405289 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -232,10 +232,10 @@ def __call__(self, *args, **kwargs): svi_state = svi.init(rng_key_init) params = svi.get_params(svi_state) - assert_allclose(params['a'], a_init) - assert_allclose(params['b'], b_init) - assert_allclose(params['auto_loc'], guide._init_latent) - assert_allclose(params['auto_scale'], jnp.ones(1) * guide._init_scale) + assert_allclose(params['a'], a_init, rtol=1e-6) + assert_allclose(params['b'], b_init, rtol=1e-6) + assert_allclose(params['auto_loc'], guide._init_latent, rtol=1e-6) + assert_allclose(params['auto_scale'], jnp.ones(1) * guide._init_scale, rtol=1e-6) actual_loss = svi.evaluate(svi_state) assert jnp.isfinite(actual_loss) diff --git a/test/test_distributions.py b/test/test_distributions.py index bb51a9bd0..c603386c0 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -25,8 +25,8 @@ from numpyro.distributions.transforms import ( LowerCholeskyAffine, PermuteTransform, - SoftplusTransform, PowerTransform, + SoftplusTransform, biject_to ) from numpyro.distributions.util import ( @@ -1049,6 +1049,11 @@ def g(x): (constraints.simplex, jnp.array([0.1, 0.3, 0.6]), True), (constraints.simplex, jnp.array([[0.1, 0.3, 0.6], [-0.1, 0.6, 0.5], [0.1, 0.6, 0.5]]), jnp.array([True, False, False])), + (constraints.softplus_positive, 3, True), + (constraints.softplus_positive, jnp.array([-1, 0, 5]), jnp.array([False, False, True])), + (constraints.softplus_lower_cholesky, jnp.array([[1., 0.], [-2., 0.1]]), True), + (constraints.softplus_lower_cholesky, jnp.array([[[1., 0.], [-2., -0.1]], [[1., 0.1], [2., 0.2]]]), + jnp.array([False, False])), (constraints.unit_interval, 0.1, True), (constraints.unit_interval, jnp.array([-5, 0, 0.5, 1, 7]), jnp.array([False, True, True, True, False])), @@ -1084,6 +1089,8 @@ def test_constraints(constraint, x, expected): constraints.real, constraints.real_vector, constraints.simplex, + constraints.softplus_positive, + constraints.softplus_lower_cholesky, constraints.unit_interval, ], ids=lambda x: x.__class__) @pytest.mark.parametrize('shape', [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) @@ -1146,7 +1153,8 @@ def inv_vec_transform(y): expected = np.linalg.slogdet(jax.jacobian(vec_transform)(x))[1] inv_expected = np.linalg.slogdet(jax.jacobian(inv_vec_transform)(y_tril))[1] - elif constraint in [constraints.lower_cholesky, constraints.positive_definite]: + elif constraint in [constraints.lower_cholesky, constraints.positive_definite, + constraints.softplus_lower_cholesky]: vec_transform = lambda x: matrix_to_tril_vec(transform(x)) # noqa: E731 y_tril = matrix_to_tril_vec(y) From 5dc20692fcf132b36dae4305f194627672fc58c0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Fri, 5 Mar 2021 21:55:33 +0100 Subject: [PATCH 069/222] Higgs example for HMCECS (#937) * Added higgs example. * Added visualization. * Fixed visualization and fetch time for dataset * Fixed isort * Fixed set_plateform to use input argument in example/hmcecs * Fixed lint * Fixed license header. * Added ignore for userwarning. * Fixed problem hmcecs call configuration in test/test_examples.py * Added hmcecs.png to _static/image/examples. Fixed test to use mock data. Updated parser arguments to use choice. * Fixed istort * Removed naive case from HMCECS example. * Added taylor_proxy as a staticmethod in HMCECS. Co-authored-by: Ola --- docs/source/_static/img/examples/hmcecs.png | Bin 0 -> 37164 bytes docs/source/index.rst | 1 + examples/covtype.py | 5 +- examples/hmcecs.py | 151 ++++++++++++++++++++ numpyro/examples/datasets.py | 25 ++-- numpyro/infer/hmc_gibbs.py | 4 + test/infer/test_hmc_gibbs.py | 7 +- test/test_examples.py | 4 +- 8 files changed, 180 insertions(+), 17 deletions(-) create mode 100644 docs/source/_static/img/examples/hmcecs.png create mode 100644 examples/hmcecs.py diff --git a/docs/source/_static/img/examples/hmcecs.png b/docs/source/_static/img/examples/hmcecs.png new file mode 100644 index 0000000000000000000000000000000000000000..bd20c921f38efc67beea88e65b75db8a1262845e GIT binary patch literal 37164 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 args.num_datapoints, "11,000,000 data points in the Higgs dataset" + # full dataset takes hours for plain hmc! + if args.dataset == 'higgs': + _, fetch = load_dataset(HIGGS, shuffle=False, num_datapoints=args.num_datapoints) + data, obs = fetch() + else: + data, obs = (np.random.normal(size=(10, 28)), np.ones(10)) + + hmcecs_key, hmc_key = random.split(random.PRNGKey(args.rng_seed)) + + # choose inner_kernel + if args.inner_kernel == 'hmc': + inner_kernel = HMC(model) + else: + inner_kernel = NUTS(model) + + start = time.time() + losses, hmcecs_samples = run_hmcecs(hmcecs_key, args, data, obs, inner_kernel) + hmcecs_runtime = time.time() - start + + start = time.time() + hmc_samples = run_hmc(hmc_key, args, data, obs, inner_kernel) + hmc_runtime = time.time() - start + + summary_plot(losses, hmc_samples, hmcecs_samples, hmc_runtime, hmcecs_runtime) + + +def summary_plot(losses, hmc_samples, hmcecs_samples, hmc_runtime, hmcecs_runtime): + fig, ax = plt.subplots(2, 2) + ax[0, 0].plot(losses, 'r') + ax[0, 0].set_title('SVI losses') + ax[0, 0].set_ylabel('ELBO') + + if hmc_runtime > hmcecs_runtime: + ax[0, 1].bar([0], hmc_runtime, label='hmc', color='b') + ax[0, 1].bar([0], hmcecs_runtime, label='hmcecs', color='r') + else: + ax[0, 1].bar([0], hmcecs_runtime, label='hmcecs', color='r') + ax[0, 1].bar([0], hmc_runtime, label='hmc', color='b') + ax[0, 1].set_title('Runtime') + ax[0, 1].set_ylabel('Seconds') + ax[0, 1].legend() + ax[0, 1].set_xticks([]) + + ax[1, 0].plot(jnp.sort(hmc_samples['theta'].mean(0)), 'or') + ax[1, 0].plot(jnp.sort(hmcecs_samples['theta'].mean(0)), 'b') + ax[1, 0].set_title(r'$\mathrm{\mathbb{E}}[\theta]$') + + ax[1, 1].plot(jnp.sort(hmc_samples['theta'].var(0)), 'or') + ax[1, 1].plot(jnp.sort(hmcecs_samples['theta'].var(0)), 'b') + ax[1, 1].set_title(r'Var$[\theta]$') + + for a in ax[1, :]: + a.set_xticks([]) + + fig.tight_layout() + fig.savefig('hmcecs_plot.pdf', bbox_inches='tight') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser("Hamiltonian Monte Carlo with Energy Conserving Subsampling") + parser.add_argument('--subsample_size', type=int, default=1300) + parser.add_argument('--num_svi_steps', type=int, default=5000) + parser.add_argument('--num_blocks', type=int, default=100) + parser.add_argument('--num_warmup', type=int, default=500) + parser.add_argument('--num_samples', type=int, default=500) + parser.add_argument('--num_datapoints', type=int, default=1_500_000) + parser.add_argument('--dataset', type=str, choices=['higgs', 'mock'], default='higgs') + parser.add_argument('--inner_kernel', type=str, choices=['nuts', 'hmc'], default='nuts') + parser.add_argument('--device', default='cpu', type=str, choices=['cpu', 'gpu']) + parser.add_argument('--rng_seed', default=37, type=int, help='random number generator seed') + + args = parser.parse_args() + + numpyro.set_platform(args.device) + + main(args) diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index 18ace29e3..b008f4ba4 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -237,7 +237,7 @@ def _load_jsb_chorales(): return processed_dataset -def _load_higgs(): +def _load_higgs(num_datapoints): warnings.warn("Higgs is a 2.6 GB dataset") _download(HIGGS) @@ -246,13 +246,20 @@ def _load_higgs(): csv_reader = csv.reader(f, delimiter=',', quoting=csv.QUOTE_NONE) obs = [] data = [] - for row in csv_reader: - obs.append(row[0]) - data.append(row[1:]) - return np.stack(obs), np.stack(data) + for i, row in enumerate(csv_reader): + obs.append(int(float(row[0]))) + data.append([float(v) for v in row[1:]]) + if num_datapoints and i > num_datapoints: + break + obs = np.stack(obs) + data = np.stack(data) + n, = obs.shape + + return {'train': (data[:-(n//20)], obs[:-(n//20)]), + 'test': (data[-(n//20):], obs[-(n//20):])} # standard split -500_000: as test -def _load(dset): +def _load(dset, num_datapoints=-1): if dset == BASEBALL: return _load_baseball() elif dset == COVTYPE: @@ -270,7 +277,7 @@ def _load(dset): elif dset == JSB_CHORALES: return _load_jsb_chorales() elif dset == HIGGS: - return _load_higgs() + return _load_higgs(num_datapoints) raise ValueError('Dataset - {} not found.'.format(dset.name)) @@ -288,8 +295,8 @@ def iter_dataset(dset, batch_size=None, split='train', shuffle=True): yield tuple(a[idxs[start_idx:end_idx]] for a in arrays) -def load_dataset(dset, batch_size=None, split='train', shuffle=True): - arrays = _load(dset)[split] +def load_dataset(dset, batch_size=None, split='train', shuffle=True, num_datapoints=None): + arrays = _load(dset, num_datapoints)[split] num_records = len(arrays[0]) idxs = np.arange(num_records) if not batch_size: diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 970f33369..416fe09ec 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -589,6 +589,10 @@ def potential_fn(z_gibbs, gibbs_state, z_hmc): z = {**z_gibbs, **hmc_state.z} return HMCECSState(z, hmc_state, rng_key, gibbs_state, accept_prob) + @staticmethod + def taylor_proxy(reference_params): + return taylor_proxy(reference_params) + def perturbed_method(subsample_plate_sizes, proxy_fn): def estimator(likelihoods, params, gibbs_state): diff --git a/test/infer/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py index 4ddc5f3ac..b73bb5940 100644 --- a/test/infer/test_hmc_gibbs.py +++ b/test/infer/test_hmc_gibbs.py @@ -14,7 +14,6 @@ import numpyro import numpyro.distributions as dist from numpyro.infer import HMC, HMCECS, MCMC, NUTS, DiscreteHMCGibbs, HMCGibbs -from numpyro.infer.hmc_gibbs import taylor_proxy from numpyro.infer.util import log_density @@ -257,7 +256,7 @@ def model(data, subsample_size): numpyro.sample("obs", dist.Normal(mean, 1), obs=sub_data) ref_params = {'mean': true_loc + dist.Normal(true_loc, 5e-2).sample(random.PRNGKey(0))} - proxy_fn = taylor_proxy(ref_params) + proxy_fn = HMCECS.taylor_proxy(ref_params) kernel = HMCECS(kernel_cls(model), proxy=proxy_fn) mcmc = MCMC(kernel, num_warmup, num_samples) @@ -292,7 +291,7 @@ def log_prob_fn(params): tr = numpyro.handlers.trace(numpyro.handlers.seed(model, tr_key)).get_trace(data, subsample_size) plate_sizes = {'data': (n, subsample_size)} - proxy_constructor = taylor_proxy({'mean': ref_params}) + proxy_constructor = HMCECS.taylor_proxy({'mean': ref_params}) proxy_fn, gibbs_init, gibbs_update = proxy_constructor(tr, plate_sizes, model, (data, subsample_size), {}) def taylor_expand_2nd_order(idx, pos): @@ -330,7 +329,7 @@ def model(data): with numpyro.plate('N', data.shape[0], subsample_size=100, dim=-2) as idx: numpyro.sample('obs', dist.Normal(mean, sigma), obs=data[idx]) - proxy_fn = taylor_proxy({'mean': ref_params}) + proxy_fn = HMCECS.taylor_proxy({'mean': ref_params}) kernel = HMCECS(kernel_cls(model), proxy=proxy_fn, num_blocks=num_blocks) mcmc = MCMC(kernel, num_warmup, num_samples) diff --git a/test/test_examples.py b/test/test_examples.py index a7829f3d1..771c7b660 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -10,7 +10,6 @@ TESTS_DIR = os.path.dirname(os.path.abspath(__file__)) EXAMPLES_DIR = os.path.join(os.path.dirname(TESTS_DIR), 'examples') - EXAMPLES = [ 'annotation.py --model mn', 'annotation.py --model ds', @@ -24,6 +23,8 @@ 'capture_recapture.py --num-samples 4 --num-warmup 1 -m 5', 'covtype.py --algo HMC --num-samples 10 --num-warmup 10', 'gp.py --num-samples 10 --num-warmup 10 --num-chains 2', + 'hmcecs.py --subsample_size 5 --num_svi_steps 1 --num_blocks 1 ' + '--dataset mock --num_warmup 1 --num_samples 5 --num_datapoints 100', 'hmm.py --num-samples 100 --num-warmup 100 --num-chains 2', 'hmm_enum.py -m 1 -t 3 -d 4 --num-warmup 1 -n 4', 'hmm_enum.py -m 2 -t 3 -d 4 --num-warmup 1 -n 4', @@ -43,6 +44,7 @@ @pytest.mark.parametrize('example', EXAMPLES) @pytest.mark.filterwarnings("ignore:There are not enough devices:UserWarning") +@pytest.mark.filterwarnings("ignore:Higgs is a 2.6 GB dataset:UserWarning") def test_cpu(example): print('Running:\npython examples/{}'.format(example)) example = example.split() From 13237fe8794d7f52e61995f10ed24c3492de1f8a Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 8 Mar 2021 09:52:01 -0600 Subject: [PATCH 070/222] fix autodelta with deterministic sites (#946) --- docs/source/distributions.rst | 8 -------- examples/neutra.py | 10 +++++----- numpyro/infer/autoguide.py | 8 ++++---- test/infer/test_autoguide.py | 2 +- test/pyroapi/test_pyroapi.py | 2 +- 5 files changed, 11 insertions(+), 19 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 2c21bf311..6150b6124 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -638,14 +638,6 @@ ExpTransform :show-inheritance: :member-order: bysource -SoftplusTransform ------------------ -.. autoclass:: numpyro.distributions.transforms.SoftplusTransform - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - IdentityTransform ----------------- .. autoclass:: numpyro.distributions.transforms.IdentityTransform diff --git a/examples/neutra.py b/examples/neutra.py index 54d76d644..bee94edb0 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -116,28 +116,28 @@ def main(args): ax1.set_title('Autoguide training loss\n(after 1000 steps)') ax2.contourf(X1, X2, P, cmap='OrRd') - sns.kdeplot(guide_samples[:, 0], guide_samples[:, 1], n_levels=30, ax=ax2) + sns.kdeplot(x=guide_samples[:, 0], y=guide_samples[:, 1], n_levels=30, ax=ax2) ax2.set(xlim=[-3, 3], ylim=[-3, 3], xlabel='x0', ylabel='x1', title='Posterior using\nAutoBNAFNormal guide') - sns.scatterplot(guide_base_samples[:, 0], guide_base_samples[:, 1], ax=ax3, + sns.scatterplot(x=guide_base_samples[:, 0], y=guide_base_samples[:, 1], ax=ax3, hue=guide_trans_samples[:, 0] < 0.) ax3.set(xlim=[-3, 3], ylim=[-3, 3], xlabel='x0', ylabel='x1', title='AutoBNAFNormal base samples\n(True=left moon; False=right moon)') ax4.contourf(X1, X2, P, cmap='OrRd') - sns.kdeplot(vanilla_samples[:, 0], vanilla_samples[:, 1], n_levels=30, ax=ax4) + sns.kdeplot(x=vanilla_samples[:, 0], y=vanilla_samples[:, 1], n_levels=30, ax=ax4) ax4.plot(vanilla_samples[-50:, 0], vanilla_samples[-50:, 1], 'bo-', alpha=0.5) ax4.set(xlim=[-3, 3], ylim=[-3, 3], xlabel='x0', ylabel='x1', title='Posterior using\nvanilla HMC sampler') - sns.scatterplot(zs[:, 0], zs[:, 1], ax=ax5, hue=samples[:, 0] < 0., + sns.scatterplot(x=zs[:, 0], y=zs[:, 1], ax=ax5, hue=samples[:, 0] < 0., s=30, alpha=0.5, edgecolor="none") ax5.set(xlim=[-5, 5], ylim=[-5, 5], xlabel='x0', ylabel='x1', title='Samples from the\nwarped posterior - p(z)') ax6.contourf(X1, X2, P, cmap='OrRd') - sns.kdeplot(samples[:, 0], samples[:, 1], n_levels=30, ax=ax6) + sns.kdeplot(x=samples[:, 0], y=samples[:, 1], n_levels=30, ax=ax6) ax6.plot(samples[-50:, 0], samples[-50:, 1], 'bo-', alpha=0.2) ax6.set(xlim=[-3, 3], ylim=[-3, 3], xlabel='x0', ylabel='x1', title='Posterior using\nNeuTra HMC sampler') diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 405ff1f4d..46ae895e7 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -287,15 +287,15 @@ class AutoDelta(AutoGuide): """ def __init__(self, model, *, prefix='auto', init_loc_fn=init_to_median, create_plates=None): - self.init_loc_fn = init_loc_fn self._event_dims = {} super().__init__(model, prefix=prefix, init_loc_fn=init_loc_fn, create_plates=create_plates) def _setup_prototype(self, *args, **kwargs): super()._setup_prototype(*args, **kwargs) - self._init_locs = { - k: v for k, v in self._postprocess_fn(self._init_locs).items() if k in self._init_locs - } + with numpyro.handlers.block(): + self._init_locs = { + k: v for k, v in self._postprocess_fn(self._init_locs).items() if k in self._init_locs + } for name, site in self.prototype_trace.items(): if site["type"] != "sample" or site["is_observed"]: continue diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index ad3405289..e8756d22a 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -92,7 +92,7 @@ def test_logistic_regression(auto_class, Elbo): def model(data, labels): coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) - logits = jnp.sum(coefs * data, axis=-1) + logits = numpyro.deterministic("logits", jnp.sum(coefs * data, axis=-1)) return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) adam = optim.Adam(0.01) diff --git a/test/pyroapi/test_pyroapi.py b/test/pyroapi/test_pyroapi.py index f61fca833..d76c9d737 100644 --- a/test/pyroapi/test_pyroapi.py +++ b/test/pyroapi/test_pyroapi.py @@ -8,7 +8,7 @@ pytestmark = pytest.mark.filterwarnings("ignore::numpyro.compat.util.UnsupportedAPIWarning") -@pytest.yield_fixture +@pytest.fixture def backend(): with pyro_backend('numpy'): yield From 9b1693403b27b901f02777e43d560d2871f636da Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 9 Mar 2021 07:37:54 -0600 Subject: [PATCH 071/222] Clean TruncatedNormal/Cauchy and Uniform (#940) --- docs/source/distributions.rst | 30 +++++-- docs/source/mcmc.rst | 2 +- numpyro/distributions/__init__.py | 8 +- numpyro/distributions/continuous.py | 123 +++++----------------------- numpyro/infer/reparam.py | 34 ++++---- test/contrib/test_tfp.py | 4 +- test/infer/test_autoguide.py | 6 +- test/infer/test_mcmc.py | 3 +- test/infer/test_reparam.py | 16 ++-- test/test_distributions.py | 44 ++++++---- 10 files changed, 122 insertions(+), 148 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 6150b6124..b3c1ff69c 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -205,6 +205,14 @@ MultivariateNormal :show-inheritance: :member-order: bysource +LeftTruncatedDistribution +------------------------- +.. autoclass:: numpyro.distributions.continuous.LeftTruncatedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + LowRankMultivariateNormal ------------------------- .. autoclass:: numpyro.distributions.continuous.LowRankMultivariateNormal @@ -229,6 +237,14 @@ Pareto :show-inheritance: :member-order: bysource +RightTruncatedDistribution +-------------------------- +.. autoclass:: numpyro.distributions.continuous.RightTruncatedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + StudentT -------- .. autoclass:: numpyro.distributions.continuous.StudentT @@ -247,11 +263,7 @@ TruncatedCauchy TruncatedDistribution --------------------- -.. autoclass:: numpyro.distributions.continuous.TruncatedDistribution - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource +.. autofunction:: numpyro.distributions.continuous.TruncatedDistribution TruncatedNormal --------------- @@ -269,6 +281,14 @@ TruncatedPolyaGamma :show-inheritance: :member-order: bysource +TwoSidedTruncatedDistribution +----------------------------- +.. autoclass:: numpyro.distributions.continuous.TwoSidedTruncatedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + Uniform ------- .. autoclass:: numpyro.distributions.continuous.Uniform diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index 09ed21e02..a20e51280 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -16,7 +16,7 @@ MCMC Kernels :show-inheritance: :member-order: bysource - .. autoclass:: numpyro.infer.barker.BarkerMH +.. autoclass:: numpyro.infer.barker.BarkerMH :members: :undoc-members: :show-inheritance: diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index fad05d574..fc436894d 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -16,6 +16,7 @@ HalfNormal, InverseGamma, Laplace, + LeftTruncatedDistribution, LKJCholesky, Logistic, LogNormal, @@ -23,11 +24,13 @@ MultivariateNormal, Normal, Pareto, + RightTruncatedDistribution, StudentT, TruncatedCauchy, TruncatedDistribution, TruncatedNormal, TruncatedPolyaGamma, + TwoSidedTruncatedDistribution, Uniform ) from numpyro.distributions.directional import ProjectedNormal, VonMises @@ -103,9 +106,10 @@ 'ImproperUniform', 'Independent', 'InverseGamma', - 'Laplace', 'LKJ', 'LKJCholesky', + 'Laplace', + 'LeftTruncatedDistribution', 'Logistic', 'LogNormal', 'MaskedDistribution', @@ -120,12 +124,14 @@ 'Poisson', 'ProjectedNormal', 'PRNGIdentity', + 'RightTruncatedDistribution', 'StudentT', 'TransformedDistribution', 'TruncatedCauchy', 'TruncatedDistribution', 'TruncatedNormal', 'TruncatedPolyaGamma', + 'TwoSidedTruncatedDistribution', 'Uniform', 'Unit', 'VonMises', diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 1ba58fb9e..8fdc12cbc 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -31,7 +31,7 @@ import jax.numpy as jnp import jax.random as random from jax.scipy.linalg import cho_solve, solve_triangular -from jax.scipy.special import betainc, expit, gammaln, logit, log_ndtr, logsumexp, multigammaln, ndtr, ndtri +from jax.scipy.special import betainc, expit, gammaln, logit, logsumexp, multigammaln, ndtr, ndtri from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution, TransformedDistribution @@ -1346,52 +1346,15 @@ def TruncatedDistribution(base_dist, low=None, high=None, validate_args=None): return TwoSidedTruncatedDistribution(base_dist, low=low, high=high, validate_args=validate_args) -class _BaseTruncatedCauchy(Distribution): - # NB: this is a truncated cauchy with low=0, scale=1 - arg_constraints = {"base_loc": constraints.real} - reparametrized_params = ["base_loc"] - support = constraints.positive - - def __init__(self, base_loc): - self.base_loc = base_loc - super(_BaseTruncatedCauchy, self).__init__(batch_shape=jnp.shape(base_loc)) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - # We use inverse transform method: - # z ~ inv_cdf(U), where U ~ Uniform(cdf(low), cdf(high)). - # ~ Uniform(arctan(low), arctan(high)) / pi + 1/2 - size = sample_shape + self.batch_shape - minval = -jnp.arctan(self.base_loc) - maxval = jnp.pi / 2 - u = minval + random.uniform(key, shape=size) * (maxval - minval) - return self.base_loc + jnp.tan(u) - - @validate_sample - def log_prob(self, value): - # pi / 2 is arctan of self.high when that arg is supported - normalize_term = jnp.log(jnp.pi / 2 + jnp.arctan(self.base_loc)) - return - jnp.log1p((value - self.base_loc) ** 2) - normalize_term - - -class TruncatedCauchy(TransformedDistribution): +class TruncatedCauchy(LeftTruncatedDistribution): arg_constraints = {'low': constraints.real, 'loc': constraints.real, 'scale': constraints.positive} reparametrized_params = ["low", "loc", "scale"] def __init__(self, low=0., loc=0., scale=1., validate_args=None): self.low, self.loc, self.scale = promote_shapes(low, loc, scale) - base_loc = (loc - low) / scale - base_dist = _BaseTruncatedCauchy(base_loc) - self._support = constraints.greater_than(low) - super(TruncatedCauchy, self).__init__(base_dist, AffineTransform(low, scale), - validate_args=validate_args) + super().__init__(Cauchy(self.loc, self.scale), low=self.low, validate_args=validate_args) - @constraints.dependent_property(is_discrete=False, event_dim=0) - def support(self): - return self._support - - # NB: these stats do not apply when arg `high` is supported @property def mean(self): return jnp.full(self.batch_shape, jnp.nan) @@ -1415,61 +1378,24 @@ def tree_unflatten(cls, aux_data, params): return d -class _BaseTruncatedNormal(Distribution): - # NB: this is a truncated normal with low=0, scale=1 - arg_constraints = {"base_loc": constraints.real} - reparametrized_params = ["base_loc"] - support = constraints.positive - - def __init__(self, base_loc): - self.base_loc = base_loc - self._normal = Normal(base_loc, 1.) - super(_BaseTruncatedNormal, self).__init__(batch_shape=jnp.shape(base_loc)) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - size = sample_shape + self.batch_shape - # We use inverse transform method: - # z ~ icdf(U), where U ~ Uniform(0, 1). - u = random.uniform(key, shape=size) - # Ref: https://en.wikipedia.org/wiki/Truncated_normal_distribution#Simulating - # icdf[cdf_a + u * (1 - cdf_a)] = icdf[1 - (1 - cdf_a)(1 - u)] - # = - icdf[(1 - cdf_a)(1 - u)] - return self.base_loc - ndtri(ndtr(self.base_loc) * (1 - u)) - - @validate_sample - def log_prob(self, value): - # log(cdf(high) - cdf(low)) = log(1 - cdf(low)) = log(cdf(-low)) - return self._normal.log_prob(value) - log_ndtr(self.base_loc) - - -class TruncatedNormal(TransformedDistribution): +class TruncatedNormal(LeftTruncatedDistribution): arg_constraints = {'low': constraints.real, 'loc': constraints.real, 'scale': constraints.positive} reparametrized_params = ["low", "loc", "scale"] - # TODO: support `high` arg def __init__(self, low=0., loc=0., scale=1., validate_args=None): self.low, self.loc, self.scale = promote_shapes(low, loc, scale) - base_loc = (loc - low) / scale - base_dist = _BaseTruncatedNormal(base_loc) - self._support = constraints.greater_than(low) - super(TruncatedNormal, self).__init__(base_dist, AffineTransform(low, scale), - validate_args=validate_args) - - @constraints.dependent_property(is_discrete=False, event_dim=0) - def support(self): - return self._support + super().__init__(Normal(self.loc, self.scale), low=self.low, validate_args=validate_args) @property def mean(self): - low_prob_scaled = jnp.exp(self.base_dist.log_prob(0.)) - return self.loc + low_prob_scaled * self.scale + low_prob = jnp.exp(self.log_prob(self.low)) + return self.loc + low_prob * self.scale ** 2 @property def variance(self): - low_prob_scaled = jnp.exp(self.base_dist.log_prob(0.)) - return (self.scale ** 2) * (1 - self.base_dist.base_loc * low_prob_scaled - low_prob_scaled ** 2) + low_prob = jnp.exp(self.log_prob(self.low)) + return (self.scale ** 2) * (1 + (self.low - self.loc) * low_prob - (low_prob * self.scale) ** 2) def tree_flatten(self): if isinstance(self._support.lower_bound, (int, float)): @@ -1486,38 +1412,29 @@ def tree_unflatten(cls, aux_data, params): return d -class _BaseUniform(Distribution): - support = constraints.unit_interval - - def __init__(self, batch_shape=()): - super(_BaseUniform, self).__init__(batch_shape=batch_shape) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - size = sample_shape + self.batch_shape - return random.uniform(key, shape=size) - - @validate_sample - def log_prob(self, value): - batch_shape = lax.broadcast_shapes(self.batch_shape, jnp.shape(value)) - return - jnp.zeros(batch_shape) - - -class Uniform(TransformedDistribution): +class Uniform(Distribution): arg_constraints = {'low': constraints.dependent, 'high': constraints.dependent} reparametrized_params = ['low', 'high'] def __init__(self, low=0., high=1., validate_args=None): self.low, self.high = promote_shapes(low, high) batch_shape = lax.broadcast_shapes(jnp.shape(low), jnp.shape(high)) - base_dist = _BaseUniform(batch_shape) self._support = constraints.interval(low, high) - super(Uniform, self).__init__(base_dist, AffineTransform(low, high - low), validate_args=validate_args) + super().__init__(batch_shape, validate_args=validate_args) @constraints.dependent_property(is_discrete=False, event_dim=0) def support(self): return self._support + def sample(self, key, sample_shape=()): + shape = sample_shape + self.batch_shape + return random.uniform(key, shape=shape, minval=self.low, maxval=self.high) + + @validate_sample + def log_prob(self, value): + shape = lax.broadcast_shapes(jnp.shape(value), self.batch_shape) + return - jnp.broadcast_to(jnp.log(self.high - self.low), shape) + @property def mean(self): return self.low + (self.high - self.low) / 2. diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index 2165fa9ef..4870cd22f 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -3,7 +3,6 @@ from abc import ABC, abstractmethod -from jax import lax import jax.numpy as jnp import numpyro @@ -30,23 +29,23 @@ def __call__(self, name, fn, obs): def _unwrap(self, fn): """ Unwrap Independent(...) and ExpandedDistribution(...) distributions. + We can recover the input `fn` from the result triple `(fn, expand_shape, event_dim)` + with `fn.expand(expand_shape).to_event(event_dim - fn.event_dim)`. """ - batch_shape = fn.batch_shape + shape = fn.shape() event_dim = fn.event_dim while isinstance(fn, (dist.Independent, dist.ExpandedDistribution)): fn = fn.base_dist - return fn, batch_shape, event_dim + expand_shape = shape[:len(shape) - fn.event_dim] + return fn, expand_shape, event_dim - def _wrap(self, fn, batch_shape, event_dim): + def _wrap(self, fn, expand_shape, event_dim): """ Wrap in Independent and ExpandedDistribution distributions. """ # Match batch_shape. assert fn.event_dim <= event_dim - fn_batch_shape = batch_shape + (1,) * (event_dim - fn.event_dim) - fn_batch_shape = lax.broadcast_shapes(fn_batch_shape, fn.batch_shape) - if fn.batch_shape != fn_batch_shape: - fn = fn.expand(fn_batch_shape) + fn = fn.expand(expand_shape) # no-op if expand_shape == fn.batch_shape # Match event_dim. if fn.event_dim < event_dim: @@ -90,7 +89,7 @@ def __call__(self, name, fn, obs): if is_identically_one(centered): return name, fn, obs event_shape = fn.event_shape - fn, batch_shape, event_dim = self._unwrap(fn) + fn, expand_shape, event_dim = self._unwrap(fn) # Apply a partial decentering transform. params = {key: getattr(fn, key) for key in self.shape_params} @@ -100,7 +99,7 @@ def __call__(self, name, fn, obs): constraint=constraints.unit_interval) params["loc"] = fn.loc * centered params["scale"] = fn.scale ** centered - decentered_fn = self._wrap(type(fn)(**params), batch_shape, event_dim) + decentered_fn = self._wrap(type(fn)(**params), expand_shape, event_dim) # Draw decentered noise. decentered_value = numpyro.sample("{}_decentered".format(name), @@ -127,7 +126,12 @@ class TransformReparam(Reparam): """ def __call__(self, name, fn, obs): assert obs is None, "TransformReparam does not support observe statements" - fn, batch_shape, event_dim = self._unwrap(fn) + fn, expand_shape, event_dim = self._unwrap(fn) + if isinstance(fn, (dist.Uniform, dist.TruncatedCauchy, dist.TruncatedNormal)): + raise ValueError("TransformReparam does not automatically work with {}" + " distribution anymore. Please explicitly using" + " TransformedDistribution(base_dist, AffineTransform(...)) pattern" + " with TransformReparam.".format(type(fn).__name__)) assert isinstance(fn, dist.TransformedDistribution) # Draw noise from the base distribution. @@ -135,7 +139,7 @@ def __call__(self, name, fn, obs): for t in reversed(fn.transforms): base_event_dim += t.domain.event_dim - t.codomain.event_dim x = numpyro.sample("{}_base".format(name), - self._wrap(fn.base_dist, batch_shape, base_event_dim)) + self._wrap(fn.base_dist, expand_shape, base_event_dim)) # Differentiably transform. for t in fn.transforms: @@ -154,13 +158,13 @@ class ProjectedNormalReparam(Reparam): """ def __call__(self, name, fn, obs): assert obs is None, "ProjectedNormalReparam does not support observe statements" - fn, batch_shape, event_dim = self._unwrap(fn) + fn, expand_shape, event_dim = self._unwrap(fn) assert isinstance(fn, dist.ProjectedNormal) # Draw parameter-free noise. - new_fn = dist.Normal(jnp.zeros(fn.concentration.shape), 1) + new_fn = dist.Normal(jnp.zeros(fn.concentration.shape), 1).to_event(1) x = numpyro.sample("{}_normal".format(name), - self._wrap(new_fn, batch_shape, event_dim)) + self._wrap(new_fn, expand_shape, event_dim)) # Differentiably transform. value = safe_normalize(x + fn.concentration) diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index 04dfd9e74..545068cd7 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 import inspect +from numpyro.distributions.transforms import AffineTransform import os from numpy.testing import assert_allclose @@ -146,7 +147,8 @@ def test_mcmc_kernels(kernel, kwargs): def model(data): alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.Uniform(0, alpha)) + loc = numpyro.sample( + 'loc', dist.TransformedDistribution(dist.Uniform(0, 1), AffineTransform(0, alpha))) numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index e8756d22a..8c7bd372e 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -183,7 +183,8 @@ def test_uniform_normal(): def model(data): alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.Uniform(0, alpha)) + loc = numpyro.sample('loc', dist.TransformedDistribution( + dist.Uniform(0, 1), transforms.AffineTransform(0, alpha))) numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) adam = optim.Adam(0.01) @@ -251,7 +252,8 @@ def test_dynamic_supports(): def actual_model(data): alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.Uniform(0, alpha)) + loc = numpyro.sample('loc', dist.TransformedDistribution( + dist.Uniform(0, 1), transforms.AffineTransform(0, alpha))) numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) def expected_model(data): diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index 6c6ad7842..6d6d4c885 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -120,7 +120,8 @@ def test_uniform_normal(forward_mode_differentiation): def model(data): alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.Uniform(0, alpha)) + loc = numpyro.sample('loc', dist.TransformedDistribution( + dist.Uniform(0, 1), AffineTransform(0, alpha))) numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index 274d9f1a5..135fd12d1 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -32,17 +32,23 @@ def get_moments(x): return jnp.stack([m1, m2, m3, m4]) -@pytest.mark.parametrize("batch_shape", [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("batch_shape,base_batch_shape", [ + ((), ()), + ((4,), (4,)), + ((2, 3), (2, 3)), + ((2, 3), ()), +], ids=str) @pytest.mark.parametrize("event_shape", [(), (5,)], ids=str) -def test_log_normal(batch_shape, event_shape): +def test_log_normal(batch_shape, base_batch_shape, event_shape): shape = batch_shape + event_shape - loc = np.random.rand(*shape) * 2 - 1 - scale = np.random.rand(*shape) + 0.5 + base_shape = base_batch_shape + event_shape + loc = np.random.rand(*base_shape) * 2 - 1 + scale = np.random.rand(*base_shape) + 0.5 def model(): fn = dist.TransformedDistribution( dist.Normal(jnp.zeros_like(loc), jnp.ones_like(scale)), - [AffineTransform(loc, scale), ExpTransform()]) + [AffineTransform(loc, scale), ExpTransform()]).expand(shape) if event_shape: fn = fn.to_event(len(event_shape)).expand_by([100000]) with numpyro.plate_stack("plates", batch_shape): diff --git a/test/test_distributions.py b/test/test_distributions.py index c603386c0..b304e8099 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -392,11 +392,11 @@ def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): def test_infer_shapes(jax_dist, sp_dist, params, prepend_shape): shapes = tuple(getattr(p, "shape", ()) for p in params) shapes = tuple(x() if callable(x) else x for x in shapes) + jax_dist = jax_dist(*params) try: - expected_batch_shape, expected_event_shape = jax_dist.infer_shapes(*shapes) + expected_batch_shape, expected_event_shape = type(jax_dist).infer_shapes(*shapes) except NotImplementedError: - pytest.skip(f'{jax_dist.__name__}.infer_shapes() is not implemented') - jax_dist = jax_dist(*params) + pytest.skip(f'{type(jax_dist).__name__}.infer_shapes() is not implemented') assert jax_dist.batch_shape == expected_batch_shape assert jax_dist.event_shape == expected_event_shape @@ -455,13 +455,19 @@ def test_sample_gradient(jax_dist, sp_dist, params): "LKJCholesky": ["concentration"], "StudentT": ["df"] }.get(jax_dist.__name__, []) - reparameterized_params = [p for p in jax_dist.reparametrized_params + + dist_args = [p for p in ( + inspect.getfullargspec(jax_dist.__init__)[0][1:] if inspect.isclass(jax_dist) + # account the the case jax_dist is a function + else inspect.getfullargspec(jax_dist)[0])] + params_dict = dict(zip(dist_args[:len(params)], params)) + + jax_class = type(jax_dist(**params_dict)) + reparameterized_params = [p for p in jax_class.reparametrized_params if p not in gamma_derived_params] if not reparameterized_params: - pytest.skip('{} not reparametrized.'.format(jax_dist.__name__)) + pytest.skip('{} not reparametrized.'.format(jax_class.__name__)) - dist_args = [p for p in inspect.getfullargspec(jax_dist.__init__)[0][1:]] - params_dict = dict(zip(dist_args[:len(params)], params)) nonrepara_params_dict = {k: v for k, v in params_dict.items() if k not in reparameterized_params} repara_params = tuple(v for k, v in params_dict.items() @@ -531,12 +537,21 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): rng_key = random.PRNGKey(0) samples = jax_dist.sample(key=rng_key, sample_shape=prepend_shape) assert jax_dist.log_prob(samples).shape == prepend_shape + jax_dist.batch_shape - if not sp_dist: - if isinstance(jax_dist, dist.TruncatedCauchy) or isinstance(jax_dist, dist.TruncatedNormal): - low, loc, scale = params - high = jnp.inf - sp_dist = osp.cauchy if isinstance(jax_dist, dist.TruncatedCauchy) else osp.norm - sp_dist = sp_dist(loc, scale) + if sp_dist is None: + if isinstance(jax_dist, (dist.LeftTruncatedDistribution, dist.RightTruncatedDistribution, + dist.TwoSidedTruncatedDistribution)): + if isinstance(params[0], dist.Distribution): + # new api + loc, scale, low, high = params[0].loc, params[0].scale, params[1], params[2] + if low is None: + low = -np.inf + if high is None: + high = np.inf + else: + # old api + low, loc, scale = params + high = jnp.inf + sp_dist = _DIST_MAP[type(jax_dist.base_dist)](loc, scale) expected = sp_dist.logpdf(samples) - jnp.log(sp_dist.cdf(high) - sp_dist.cdf(low)) assert_allclose(jit_fn(jax_dist.log_prob)(samples), expected, atol=1e-5) return @@ -820,7 +835,8 @@ def fn(*args): def test_mean_var(jax_dist, sp_dist, params): if jax_dist is _ImproperWrapper: pytest.skip("Improper distribution does not has mean/var implemented") - if jax_dist in (_TruncatedNormal, dist.continuous.TwoSidedTruncatedDistribution): + if jax_dist in (_TruncatedNormal, dist.LeftTruncatedDistribution, dist.RightTruncatedDistribution, + dist.TwoSidedTruncatedDistribution): pytest.skip("Truncated distributions do not has mean/var implemented") if jax_dist is dist.ProjectedNormal: pytest.skip("Mean is defined in submanifold") From 944b9372c65207904bec839b5f27acaae3d25a9e Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 9 Mar 2021 14:40:23 -0600 Subject: [PATCH 072/222] Improve precision for dirchlet sampler (#943) --- numpyro/distributions/continuous.py | 13 +++++++++++-- test/infer/test_infer_util.py | 12 +++--------- test/infer/test_svi.py | 2 +- test/test_distributions.py | 1 + 4 files changed, 16 insertions(+), 12 deletions(-) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 8fdc12cbc..4d6977ba1 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -137,8 +137,17 @@ def __init__(self, concentration, validate_args=None): def sample(self, key, sample_shape=()): assert is_prng_key(key) shape = sample_shape + self.batch_shape + self.event_shape - gamma_samples = random.gamma(key, self.concentration, shape=shape) - samples = gamma_samples / jnp.sum(gamma_samples, axis=-1, keepdims=True) + key_gamma, key_expon = random.split(key) + # To improve precision for the cases concentration << 1, + # we boost concentration to concentration + 1 and get gamma samples according to + # Gamma(concentration) ~ Gamma(concentration+1) * Uniform()^(1 / concentration) + # When concentration << 1, u^(1 / concentration) is very near 0 and lost precision, so + # we will convert the samples to log space + # log(Gamma(concentration)) ~ log(Gamma(concentration + 1)) - Expon() / concentration + # and apply softmax to get a dirichlet sample + gamma_samples = random.gamma(key_gamma, self.concentration + 1, shape=shape) + expon_samples = random.exponential(key_expon, shape=shape) + samples = nn.softmax(jnp.log(gamma_samples) - expon_samples / self.concentration, -1) return jnp.clip(samples, a_min=jnp.finfo(samples).tiny, a_max=1 - jnp.finfo(samples).eps) @validate_sample diff --git a/test/infer/test_infer_util.py b/test/infer/test_infer_util.py index 8a16a0989..046128bb5 100644 --- a/test/infer/test_infer_util.py +++ b/test/infer/test_infer_util.py @@ -7,7 +7,7 @@ from numpy.testing import assert_allclose import pytest -from jax import lax, random +from jax import random import jax.numpy as jnp import numpyro @@ -88,14 +88,8 @@ def guide(data): numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) svi = SVI(model, guide, optim.Adam(0.1), Trace_ELBO()) - svi_state = svi.init(random.PRNGKey(1), data) - - def body_fn(i, val): - svi_state, _ = svi.update(val, data) - return svi_state - - svi_state = lax.fori_loop(0, 1000, body_fn, svi_state) - params = svi.get_params(svi_state) + svi_result = svi.run(random.PRNGKey(1), 3000, data) + params = svi_result.params predictive = Predictive(model, guide=guide, params=params, num_samples=1000)(random.PRNGKey(2), data=None) assert predictive["beta_sq"].shape == (1000,) obs_pred = predictive["obs"].astype(np.float32) diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index e8b0704c3..ed145f137 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -65,7 +65,7 @@ def body_fn(i, val): svi_state, _ = svi.update(val, data) return svi_state - svi_state = fori_loop(0, 1000, body_fn, svi_state) + svi_state = fori_loop(0, 2000, body_fn, svi_state) params = svi.get_params(svi_state) assert_allclose(params['alpha_q'] / (params['alpha_q'] + params['beta_q']), 0.8, atol=0.05, rtol=0.05) diff --git a/test/test_distributions.py b/test/test_distributions.py index b304e8099..5b832b01e 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -450,6 +450,7 @@ def test_sample_gradient(jax_dist, sp_dist, params): "Gamma": ["concentration"], "Beta": ["concentration1", "concentration0"], "Chi2": ["df"], + "Dirichlet": ["concentration"], "InverseGamma": ["concentration"], "LKJ": ["concentration"], "LKJCholesky": ["concentration"], From eb03c3db993cff8a1ab7613ea334d80a26de42ff Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 9 Mar 2021 15:06:20 -0600 Subject: [PATCH 073/222] Support obs_mask in sample statement. (#938) * add obs_mask and test * address comment * address comments --- numpyro/primitives.py | 24 +++++++++++++- test/test_handlers.py | 76 ++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 98 insertions(+), 2 deletions(-) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 3353f4966..89dc02474 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -80,7 +80,21 @@ def __call__(self, *args, **kwargs): return self.fn(*args, **kwargs) -def sample(name, fn, obs=None, rng_key=None, sample_shape=(), infer=None): +def _masked_observe(name, fn, obs, obs_mask, **kwargs): + # Split into two auxiliary sample sites. + with numpyro.handlers.mask(mask=obs_mask): + observed = sample(f"{name}_observed", fn, **kwargs, obs=obs) + with numpyro.handlers.mask(mask=(obs_mask ^ True)): + unobserved = sample(f"{name}_unobserved", fn, **kwargs) + + # Interleave observed and unobserved events. + shape = jnp.shape(obs_mask) + (1,) * fn.event_dim + batch_mask = jnp.reshape(obs_mask, shape) + value = jnp.where(batch_mask, observed, unobserved) + return deterministic(name, value) + + +def sample(name, fn, obs=None, rng_key=None, sample_shape=(), infer=None, obs_mask=None): """ Returns a random sample from the stochastic function `fn`. This can have additional side effects when wrapped inside effect handlers like @@ -101,12 +115,20 @@ def sample(name, fn, obs=None, rng_key=None, sample_shape=(), infer=None): for inference algorithms. For example, if `fn` is a discrete distribution, setting `infer={'enumerate': 'parallel'}` to tell MCMC marginalize this discrete latent site. + :param numpy.ndarray obs_mask: Optional boolean array mask of shape + broadcastable with ``fn.batch_shape``. If provided, events with + mask=True will be conditioned on ``obs`` and remaining events will be + imputed by sampling. This introduces a latent sample site named ``name + + "_unobserved"`` which should be used by guides. :return: sample from the stochastic `fn`. """ # if there are no active Messengers, we just draw a sample and return it as expected: if not _PYRO_STACK: return fn(rng_key=rng_key, sample_shape=sample_shape) + if obs_mask is not None: + return _masked_observe(name, fn, obs, obs_mask, rng_key=rng_key, sample_shape=(), infer=infer) + # Otherwise, we initialize a message... initial_msg = { 'type': 'sample', diff --git a/test/test_handlers.py b/test/test_handlers.py index 0423b8bd8..d868792c0 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -15,7 +15,7 @@ from numpyro.infer import SVI, Trace_ELBO from numpyro.infer.util import log_density import numpyro.optim as optim -from numpyro.util import optional +from numpyro.util import not_jax_tracer, optional @pytest.mark.parametrize('mask_last', [1, 5, 10]) @@ -47,6 +47,80 @@ def model(data, mask): assert_allclose(log_joint, expected, atol=1e-4) +@pytest.mark.parametrize("num_particles", [1, 2]) +@pytest.mark.parametrize("mask", [ + True, + False, + np.array([True]), + np.array([False]), + np.array([False, True, False]), +]) +@pytest.mark.parametrize("Elbo", [ + Trace_ELBO, +]) +def test_obs_mask_ok(Elbo, mask, num_particles): + data = np.array([7., 7., 7.]) + + def model(): + x = numpyro.sample("x", dist.Normal(0., 1.)) + with numpyro.plate("plate", len(data)): + y = numpyro.sample("y", dist.Normal(x, 1.), + obs=data, obs_mask=mask) + if not_jax_tracer(y): + assert ((y == data) == mask).all() + + def guide(): + loc = numpyro.param("loc", np.zeros(())) + scale = numpyro.param("scale", np.ones(()), + constraint=constraints.positive) + x = numpyro.sample("x", dist.Normal(loc, scale)) + with numpyro.plate("plate", len(data)): + with handlers.mask(mask=np.invert(mask)): + numpyro.sample("y_unobserved", dist.Normal(x, 1.)) + + elbo = Elbo(num_particles=num_particles) + svi = SVI(model, guide, numpyro.optim.Adam(1), elbo) + svi_state = svi.init(random.PRNGKey(0)) + svi.update(svi_state) + + +@pytest.mark.parametrize("num_particles", [1, 2]) +@pytest.mark.parametrize("mask", [ + True, + False, + np.array([True]), + np.array([False]), + np.array([False, True, True, False]), +]) +@pytest.mark.parametrize("Elbo", [ + Trace_ELBO, +]) +def test_obs_mask_multivariate_ok(Elbo, mask, num_particles): + data = np.full((4, 3), 7.0) + + def model(): + x = numpyro.sample("x", dist.MultivariateNormal(np.zeros(3), np.eye(3))) + with numpyro.plate("plate", len(data)): + y = numpyro.sample("y", dist.MultivariateNormal(x, np.eye(3)), + obs=data, obs_mask=mask) + if not_jax_tracer(y): + assert ((y == data).all(-1) == mask).all() + + def guide(): + loc = numpyro.param("loc", np.zeros(3)) + cov = numpyro.param("cov", np.eye(3), + constraint=constraints.positive_definite) + x = numpyro.sample("x", dist.MultivariateNormal(loc, cov)) + with numpyro.plate("plate", len(data)): + with handlers.mask(mask=np.invert(mask)): + numpyro.sample("y_unobserved", dist.MultivariateNormal(x, np.eye(3))) + + elbo = Elbo(num_particles=num_particles) + svi = SVI(model, guide, numpyro.optim.Adam(1), elbo) + svi_state = svi.init(random.PRNGKey(0)) + svi.update(svi_state) + + def test_mask_inf(): def model(): with handlers.mask(mask=jnp.zeros(10, dtype=bool)): From e2e82189e96f45a1d2715c15217b85ed55e9f16e Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 11 Mar 2021 10:08:11 -0600 Subject: [PATCH 074/222] Port get_mask to NumPyro (#947) --- docs/source/primitives.rst | 4 +++ numpyro/__init__.py | 58 +++++++++++++++++++++-------------- numpyro/handlers.py | 2 ++ numpyro/infer/autoguide.py | 11 ++++--- numpyro/infer/hmc_gibbs.py | 7 ++--- numpyro/infer/reparam.py | 12 +++++--- numpyro/infer/util.py | 2 ++ numpyro/primitives.py | 43 ++++++++++++++++++++++++++ test/infer/test_infer_util.py | 44 ++++++++++++++++++++++++++ 9 files changed, 147 insertions(+), 36 deletions(-) diff --git a/docs/source/primitives.rst b/docs/source/primitives.rst index 1669a5127..1505d2e66 100644 --- a/docs/source/primitives.rst +++ b/docs/source/primitives.rst @@ -35,6 +35,10 @@ factor ------ .. autofunction:: numpyro.primitives.factor +get_mask +-------- +.. autofunction:: numpyro.primitives.get_mask + module ------ .. autofunction:: numpyro.primitives.module diff --git a/numpyro/__init__.py b/numpyro/__init__.py index afe7b8070..018b34cb5 100644 --- a/numpyro/__init__.py +++ b/numpyro/__init__.py @@ -4,33 +4,45 @@ from numpyro import compat, diagnostics, distributions, handlers, infer, optim from numpyro.distributions.distribution import enable_validation, validation_enabled import numpyro.patch # noqa: F401 -from numpyro.primitives import deterministic, factor, module, param, plate, plate_stack, prng_key, sample, subsample +from numpyro.primitives import ( + deterministic, + factor, + get_mask, + module, + param, + plate, + plate_stack, + prng_key, + sample, + subsample, +) from numpyro.util import enable_x64, set_host_device_count, set_platform from numpyro.version import __version__ -set_platform('cpu') +set_platform("cpu") __all__ = [ - '__version__', - 'compat', - 'deterministic', - 'diagnostics', - 'distributions', - 'enable_x64', - 'enable_validation', - 'factor', - 'handlers', - 'infer', - 'module', - 'optim', - 'param', - 'plate', - 'plate_stack', - 'prng_key', - 'sample', - 'subsample', - 'set_host_device_count', - 'set_platform', - 'validation_enabled', + "__version__", + "compat", + "deterministic", + "diagnostics", + "distributions", + "enable_x64", + "enable_validation", + "factor", + "get_mask", + "handlers", + "infer", + "module", + "optim", + "param", + "plate", + "plate_stack", + "prng_key", + "sample", + "subsample", + "set_host_device_count", + "set_platform", + "validation_enabled", ] diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 0be31343c..a041f3c5b 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -484,6 +484,8 @@ def __init__(self, fn=None, mask=True): def process_message(self, msg): if msg['type'] != 'sample': + if msg["type"] == "inspect": + msg["mask"] = self.mask if msg["mask"] is None else (self.mask & msg["mask"]) return msg['fn'] = msg['fn'].mask(self.mask) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 46ae895e7..4ff2885a6 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -416,10 +416,13 @@ def __call__(self, *args, **kwargs): site = self.prototype_trace[name] transform = biject_to(site['fn'].support) value = transform(unconstrained_value) - log_density = - transform.log_abs_det_jacobian(unconstrained_value, value) - event_ndim = site['fn'].event_dim - log_density = sum_rightmost(log_density, - jnp.ndim(log_density) - jnp.ndim(value) + event_ndim) + if numpyro.get_mask() is False: + log_density = 0. + else: + log_density = - transform.log_abs_det_jacobian(unconstrained_value, value) + event_ndim = site['fn'].event_dim + log_density = sum_rightmost(log_density, + jnp.ndim(log_density) - jnp.ndim(value) + event_ndim) delta_dist = dist.Delta(value, log_density=log_density, event_dim=event_ndim) result[name] = numpyro.sample(name, delta_dist) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 416fe09ec..e5bc9e05a 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -760,10 +760,9 @@ def __exit__(self, exc_type, exc_value, traceback): if self.params is None: return - # add numpyro.factor; ideally, we will want to skip this computation when making prediction - # see: https://github.com/pyro-ppl/pyro/issues/2744 - numpyro.factor("_biased_corrected_log_likelihood", - self.method(self.likelihoods, self.params, self.gibbs_state)) + if numpyro.get_mask() is not False: + numpyro.factor("_biased_corrected_log_likelihood", + self.method(self.likelihoods, self.params, self.gibbs_state)) # clean up self.params = None diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index 4870cd22f..46dff3e9e 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -230,6 +230,7 @@ def __call__(self, name, fn, obs): assert obs is None, "NeuTraReparam does not support observe statements" log_density = 0. + compute_density = (numpyro.get_mask() is not False) if not self._x_unconstrained: # On first sample site. # Sample a shared latent. z_unconstrained = numpyro.sample("{}_shared_latent".format(self.guide.prefix), @@ -237,17 +238,18 @@ def __call__(self, name, fn, obs): # Differentiably transform. x_unconstrained = self.transform(z_unconstrained) - # TODO: find a way to only compute those log_prob terms when needed - log_density = self.transform.log_abs_det_jacobian(z_unconstrained, x_unconstrained) + if compute_density: + log_density = self.transform.log_abs_det_jacobian(z_unconstrained, x_unconstrained) self._x_unconstrained = self.guide._unpack_latent(x_unconstrained) # Extract a single site's value from the shared latent. unconstrained_value = self._x_unconstrained.pop(name) transform = biject_to(fn.support) value = transform(unconstrained_value) - logdet = transform.log_abs_det_jacobian(unconstrained_value, value) - logdet = sum_rightmost(logdet, jnp.ndim(logdet) - jnp.ndim(value) + len(fn.event_shape)) - log_density = log_density + fn.log_prob(value) + logdet + if compute_density: + logdet = transform.log_abs_det_jacobian(unconstrained_value, value) + logdet = sum_rightmost(logdet, jnp.ndim(logdet) - jnp.ndim(value) + len(fn.event_shape)) + log_density = log_density + fn.log_prob(value) + logdet numpyro.factor("_{}_log_prob".format(name), log_density) return None, value diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index b5a9e8060..e48017ff5 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -490,6 +490,8 @@ def initialize_model(rng_key, model, def _predictive(rng_key, model, posterior_samples, batch_shape, return_sites=None, parallel=True, model_args=(), model_kwargs={}): + model = numpyro.handlers.mask(model, mask=False) + def single_prediction(val): rng_key, samples = val model_trace = trace(seed(substitute(model, samples), rng_key)).get_trace( diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 89dc02474..4ff6b3563 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -228,6 +228,49 @@ def deterministic(name, value): return msg['value'] +def _inspect(): + """ + EXPERIMENTAL Inspect the Pyro stack. + + .. warning:: The format of the returned message may change at any time and + does not guarantee backwards compatibility. + + :returns: A message with mask effects applied. + :rtype: dict + """ + # NB: this is different from Pyro that in Pyro, all effects applied. + # Here, we only apply mask effect handler. + msg = { + "type": "inspect", + "fn": lambda: True, + "args": (), + "kwargs": {}, + "value": None, + "mask": None, + } + apply_stack(msg) + return msg + + +def get_mask(): + """ + Records the effects of enclosing ``handlers.mask`` handlers. + This is useful for avoiding expensive ``numpyro.factor()`` computations during + prediction, when the log density need not be computed, e.g.:: + + def model(): + # ... + if numpyro.get_mask() is not False: + log_density = my_expensive_computation() + numpyro.factor("foo", log_density) + # ... + + :returns: The mask. + :rtype: None, bool, or numpy.ndarray + """ + return _inspect()["mask"] + + def module(name, nn, input_shape=None): """ Declare a :mod:`~jax.experimental.stax` style neural network inside a diff --git a/test/infer/test_infer_util.py b/test/infer/test_infer_util.py index 046128bb5..2024b58e2 100644 --- a/test/infer/test_infer_util.py +++ b/test/infer/test_infer_util.py @@ -278,3 +278,47 @@ def model(): model_info = initialize_model(random.PRNGKey(0), model) assert model_info.param_info.z['incidence'].shape == (3,) + event_shape + + +def test_get_mask_optimization(): + + def model(): + with numpyro.handlers.seed(rng_seed=0): + x = numpyro.sample("x", dist.Normal(0, 1)) + numpyro.sample("y", dist.Normal(x, 1), obs=0.) + called.add("model-always") + if numpyro.get_mask() is not False: + called.add("model-sometimes") + numpyro.factor("f", x + 1) + + def guide(): + with numpyro.handlers.seed(rng_seed=1): + x = numpyro.sample("x", dist.Normal(0, 1)) + called.add("guide-always") + if numpyro.get_mask() is not False: + called.add("guide-sometimes") + numpyro.factor("g", 2 - x) + + called = set() + trace = handlers.trace(guide).get_trace() + handlers.replay(model, trace)() + assert "model-always" in called + assert "guide-always" in called + assert "model-sometimes" in called + assert "guide-sometimes" in called + + called = set() + with handlers.mask(mask=False): + trace = handlers.trace(guide).get_trace() + handlers.replay(model, trace)() + assert "model-always" in called + assert "guide-always" in called + assert "model-sometimes" not in called + assert "guide-sometimes" not in called + + called = set() + Predictive(model, guide=guide, num_samples=2, parallel=True)(random.PRNGKey(2)) + assert "model-always" in called + assert "guide-always" in called + assert "model-sometimes" not in called + assert "guide-sometimes" not in called From 5112fa72f7d3f8c0e95ecd20fa6d43ea9ddbdac7 Mon Sep 17 00:00:00 2001 From: Jeremie Coullon Date: Mon, 15 Mar 2021 14:15:40 +0000 Subject: [PATCH 075/222] Pbar jitted mcmc (#900) * added basic progress bar to _body_fn. This works even when the entire MCMC chain is run with fori_loop * previous progress_bar interacted with tqdm. Now only add progress_bar to _body_fun when its called in fori_loop * fixed flake8 issues * compiled sampler pbar: added tqdm; only works for 1 chain though * tqdm works for several chains. Some UI glitches remain though * compiled pbar: added tqdm.auto, and bug fixes * progress_bar=True/False now maps exactly to whether there's a progress bar * tqdm.auto is now only used when running multiple chains * parallel pbar: chains appear in order * progress bar: added compiling message. fixed rtol in reparam_log_joint test * progress bar: message appears at the start of the sampling rather than at 5% Co-authored-by: Jeremie Coullon --- numpyro/infer/mcmc.py | 7 ++-- numpyro/util.py | 76 ++++++++++++++++++++++++++++++++++++++ test/infer/test_reparam.py | 2 +- 3 files changed, 80 insertions(+), 5 deletions(-) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index f8ab76fb0..8535551ac 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -262,9 +262,7 @@ def __init__(self, .format(self.num_chains, local_device_count(), self.num_chains)) self.chain_method = chain_method self.progress_bar = progress_bar - # TODO: We should have progress bars (maybe without diagnostics) for num_chains > 1 - if (chain_method == 'parallel' and num_chains > 1) or ( - "CI" in os.environ or "PYTEST_XDIST_WORKER" in os.environ): + if "CI" in os.environ or "PYTEST_XDIST_WORKER" in os.environ: self.progress_bar = False self._jit_model_args = jit_model_args self._states = None @@ -352,7 +350,8 @@ def _single_chain_mcmc(self, init, args, kwargs, collect_fields): thinning=self.thinning, collection_size=collection_size, progbar_desc=partial(_get_progbar_desc_str, lower_idx, phase), - diagnostics_fn=diagnostics) + diagnostics_fn=diagnostics, + num_chains=self.num_chains if self.chain_method == 'parallel' else 1) states, last_val = collect_vals # Get first argument of type `HMCState` last_state = last_val[0] diff --git a/numpyro/util.py b/numpyro/util.py index d8d6a6d54..150000054 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -9,6 +9,7 @@ import numpy as np import tqdm +from tqdm.auto import tqdm as tqdm_auto import jax from jax import device_put, jit, lax, ops, vmap @@ -16,6 +17,7 @@ from jax.dtypes import canonicalize_dtype import jax.numpy as jnp from jax.tree_util import tree_flatten, tree_map, tree_unflatten +from jax.experimental import host_callback _DISABLE_CONTROL_FLOW_PRIM = False @@ -164,6 +166,75 @@ def _wrapped(fn): return _wrapped +def progress_bar_factory(num_samples, num_chains): + """Factory that builds a progress bar decorator along + with the `set_tqdm_description` and `close_tqdm` functions + """ + + if num_samples > 20: + print_rate = int(num_samples / 20) + else: + print_rate = 1 + + remainder = num_samples % print_rate + + tqdm_bars = {} + finished_chains = [] + for chain in range(num_chains): + tqdm_bars[chain] = tqdm_auto(range(num_samples), position=chain) + tqdm_bars[chain].set_description("Compiling.. ", refresh=True,) + + def _update_tqdm(arg, transform, device): + chain = int(str(device)[4:]) + tqdm_bars[chain].set_description(f"Running chain {chain}", refresh=False,) + tqdm_bars[chain].update(arg) + + def _close_tqdm(arg, transform, device): + chain = int(str(device)[4:]) + tqdm_bars[chain].update(arg) + finished_chains.append(chain) + if len(finished_chains) == num_chains: + for chain in range(num_chains): + tqdm_bars[chain].close() + + def _update_progress_bar(iter_num): + """Updates tqdm progress bar of a JAX loop only if the iteration number is a multiple of the print_rate + Usage: carry = progress_bar((iter_num, print_rate), carry) + """ + + _ = lax.cond( + iter_num == 1, + lambda _: host_callback.id_tap(_update_tqdm, 0, result=iter_num, tap_with_device=True), + lambda _: iter_num, + operand=None, + ) + _ = lax.cond( + iter_num % print_rate == 0, + lambda _: host_callback.id_tap(_update_tqdm, print_rate, result=iter_num, tap_with_device=True), + lambda _: iter_num, + operand=None, + ) + _ = lax.cond( + iter_num == num_samples, + lambda _: host_callback.id_tap(_close_tqdm, remainder, result=iter_num, tap_with_device=True), + lambda _: iter_num, + operand=None, + ) + + def progress_bar_fori_loop(func): + """Decorator that adds a progress bar to `body_fun` used in `lax.fori_loop`. + Note that `body_fun` must be looping over a tuple who's first element is `np.arange(num_samples)`. + This means that `iter_num` is the current iteration number + """ + def wrapper_progress_bar(i, vals): + result = func(i, vals) + _update_progress_bar(i + 1) + return result + return wrapper_progress_bar + + return progress_bar_fori_loop + + def fori_collect(lower, upper, body_fun, init_val, transform=identity, progbar=True, return_last_val=False, collection_size=None, thinning=1, **progbar_opts): @@ -206,6 +277,7 @@ def fori_collect(lower, upper, body_fun, init_val, transform=identity, assert collection_size >= (upper - lower) // thinning init_val_flat, unravel_fn = ravel_pytree(transform(init_val)) start_idx = lower + (upper - lower) % thinning + num_chains = progbar_opts.pop('num_chains', 1) @cached_by(fori_collect, body_fun, transform) def _body_fn(i, vals): @@ -222,6 +294,10 @@ def _body_fn(i, vals): collection = jnp.zeros((collection_size,) + init_val_flat.shape) if not progbar: last_val, collection, _, _ = fori_loop(0, upper, _body_fn, (init_val, collection, start_idx, thinning)) + elif num_chains > 1: + progress_bar_fori_loop = progress_bar_factory(upper, num_chains) + _body_fn_pbar = progress_bar_fori_loop(_body_fn) + last_val, collection, _, _ = fori_loop(0, upper, _body_fn_pbar, (init_val, collection, start_idx, thinning)) else: diagnostics_fn = progbar_opts.pop('diagnostics_fn', None) progbar_desc = progbar_opts.pop('progbar_desc', lambda x: '') diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index 135fd12d1..928d221fa 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -124,7 +124,7 @@ def test_reparam_log_joint(model, kwargs): latent_y = neutra.transform(latent_x) log_det_jacobian = neutra.transform.log_abs_det_jacobian(latent_x, latent_y) pe = pe_fn(guide._unpack_latent(latent_y)) - assert_allclose(pe_transformed, pe - log_det_jacobian) + assert_allclose(pe_transformed, pe - log_det_jacobian, rtol=2e-7) @pytest.mark.parametrize("shape", [(), (4,), (3, 2)], ids=str) From ebad0518389cefcc39358369993c1d08d073d29a Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 15 Mar 2021 17:06:36 -0500 Subject: [PATCH 076/222] Allow SVI to skip invalid updates (#958) * temp save * add stable run * fix precision issue * fix lint * also assert size of plate positive * address comments --- numpyro/infer/svi.py | 37 ++++++++++++++++++++++++++++++++++--- numpyro/optim.py | 20 +++++++++++++++++++- numpyro/primitives.py | 1 + test/infer/test_svi.py | 16 ++++++++++++++++ 4 files changed, 70 insertions(+), 4 deletions(-) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 2c4544a5f..c8f1972b3 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -146,7 +146,25 @@ def update(self, svi_state, *args, **kwargs): loss_val, optim_state = self.optim.eval_and_update(loss_fn, svi_state.optim_state) return SVIState(optim_state, rng_key), loss_val - def run(self, rng_key, num_steps, *args, progress_bar=True, **kwargs): + def stable_update(self, svi_state, *args, **kwargs): + """ + Similar to :meth:`update` but returns the current state if the + the loss or the new state contains invalid values. + + :param svi_state: current state of SVI. + :param args: arguments to the model / guide (these can possibly vary during + the course of fitting). + :param kwargs: keyword arguments to the model / guide (these can possibly vary + during the course of fitting). + :return: tuple of `(svi_state, loss)`. + """ + rng_key, rng_key_step = random.split(svi_state.rng_key) + loss_fn = partial(_apply_loss_fn, self.loss.loss, rng_key_step, self.constrain_fn, self.model, + self.guide, args, kwargs, self.static_kwargs) + loss_val, optim_state = self.optim.eval_and_stable_update(loss_fn, svi_state.optim_state) + return SVIState(optim_state, rng_key), loss_val + + def run(self, rng_key, num_steps, *args, progress_bar=True, stable_update=False, **kwargs): """ (EXPERIMENTAL INTERFACE) Run SVI with `num_steps` iterations, then return the optimized parameters and the stacked losses at every step. If `num_steps` @@ -162,6 +180,8 @@ def run(self, rng_key, num_steps, *args, progress_bar=True, **kwargs): :param args: arguments to the model / guide :param bool progress_bar: Whether to enable progress bar updates. Defaults to ``True``. + :param bool stable_update: whether to use :meth:`stable_update` to update + the state. Defaults to False. :param kwargs: keyword arguments to the model / guide :return: a namedtuple with fields `params` and `losses` where `params` holds the optimized values at :class:`numpyro.param` sites, @@ -169,7 +189,10 @@ def run(self, rng_key, num_steps, *args, progress_bar=True, **kwargs): :rtype: SVIRunResult """ def body_fn(svi_state, carry): - svi_state, loss = self.update(svi_state, *args, **kwargs) + if stable_update: + svi_state, loss = self.stable_update(svi_state, *args, **kwargs) + else: + svi_state, loss = self.update(svi_state, *args, **kwargs) return svi_state, loss svi_state = self.init(rng_key, *args, **kwargs) @@ -181,7 +204,15 @@ def body_fn(svi_state, carry): svi_state, loss = jit(body_fn)(svi_state, None) losses.append(loss) if i % batch == 0: - avg_loss = sum(losses[i-batch:]) / batch + if stable_update: + valid_losses = [x for x in losses[i - batch:] if x == x] + num_valid = len(valid_losses) + if num_valid == 0: + avg_loss = float('nan') + else: + avg_loss = sum(valid_losses) / num_valid + else: + avg_loss = sum(losses[i-batch:]) / batch t.set_postfix_str("init loss: {:.4f}, avg. loss [{}-{}]: {:.4f}" .format(losses[0], i - batch + 1, i, avg_loss), refresh=False) diff --git a/numpyro/optim.py b/numpyro/optim.py index 53745be3a..abba1d83a 100644 --- a/numpyro/optim.py +++ b/numpyro/optim.py @@ -10,7 +10,7 @@ from collections import namedtuple from typing import Callable, Tuple, TypeVar -from jax import value_and_grad +from jax import lax, value_and_grad from jax.experimental import optimizers from jax.flatten_util import ravel_pytree import jax.numpy as jnp @@ -77,6 +77,24 @@ def eval_and_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: out, grads = value_and_grad(fn)(params) return out, self.update(grads, state) + def eval_and_stable_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: + """ + Like :meth:`eval_and_update` but when the value of the objective function + or the gradients are not finite, we will not update the input `state` + and will set the objective output to `nan`. + + :param fn: objective function. + :param state: current optimizer state. + :return: a pair of the output of objective function and the new optimizer state. + """ + params = self.get_params(state) + out, grads = value_and_grad(fn)(params) + out, state = lax.cond(jnp.isfinite(out) & jnp.isfinite(ravel_pytree(grads)[0]).all(), + lambda _: (out, self.update(grads, state)), + lambda _: (jnp.nan, state), + None) + return out, state + def get_params(self, state: _IterOptState) -> _Params: """ Get current parameter values. diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 4ff6b3563..60d23dfd9 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -344,6 +344,7 @@ class plate(Messenger): def __init__(self, name, size, subsample_size=None, dim=None): self.name = name + assert size > 0, "size of plate should be positive" self.size = size if dim is not None and dim >= 0: raise ValueError('dim arg must be negative.') diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index ed145f137..2989e7a9f 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -186,3 +186,19 @@ def guide(): svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) svi.run(random.PRNGKey(0), num_steps) + + +@pytest.mark.parametrize("stable_run", [True, False]) +def test_stable_run(stable_run): + + def model(): + var = numpyro.sample("var", dist.Exponential(1)) + numpyro.sample("obs", dist.Normal(0, jnp.sqrt(var)), obs=0.) + + def guide(): + loc = numpyro.param("loc", 0.) + numpyro.sample("var", dist.Normal(loc, 10)) + + svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) + svi_result = svi.run(random.PRNGKey(0), 1000, stable_update=stable_run) + assert jnp.isfinite(svi_result.params["loc"]) == stable_run From af06eda3d931f9d3b9d8be6ed7e1400a47fae9b8 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 16 Mar 2021 12:14:17 -0500 Subject: [PATCH 077/222] Implement mixed hmc (#826) * sketch the plan * add a running implementation (not working yet * remove unnecessary changes * sequential update * temp save * add a working implementation * add 24d example * fix lint * test for the order * merge master * fix bug at reset momentum * add various mh functions * add various discrete gibbs function method * change stay_prob to modified to avoid confusing users * expose more information for mixed hmc * sketch an implementation * temp save * temp save * finish the implementation * keep kinetic energy * add temperature experiment * add dual averaging * add various debug statements * fix bugs * clean up and separating out clock adapter; but target distribution is wrong due to a bug somewhere * clean up * add comments and an example * make sure forward mode work * add docs for new HMC fields * add tests for mixedhmc * fix step_size bug * use modified=False * tests pass with the fix * skip print summary * adjust trajectory length * add print summary * address comments * fix wrong docs --- docs/source/mcmc.rst | 6 + numpyro/infer/__init__.py | 2 + numpyro/infer/hmc.py | 36 ++++-- numpyro/infer/mixed_hmc.py | 222 +++++++++++++++++++++++++++++++++++ test/infer/test_hmc_gibbs.py | 47 +++++--- test/infer/test_mcmc.py | 2 +- 6 files changed, 288 insertions(+), 27 deletions(-) create mode 100644 numpyro/infer/mixed_hmc.py diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index a20e51280..337b5b792 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -46,6 +46,12 @@ MCMC Kernels :show-inheritance: :member-order: bysource +.. autoclass:: numpyro.infer.mixed_hmc.MixedHMC + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + .. autoclass:: numpyro.infer.hmc_gibbs.HMCECS :members: :undoc-members: diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 6a978d739..665c43e87 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -13,6 +13,7 @@ ) from numpyro.infer.barker import BarkerMH from numpyro.infer.mcmc import MCMC +from numpyro.infer.mixed_hmc import MixedHMC from numpyro.infer.sa import SA from numpyro.infer.svi import SVI from numpyro.infer.util import Predictive, log_likelihood @@ -35,6 +36,7 @@ 'HMCECS', 'HMCGibbs', 'MCMC', + 'MixedHMC', 'NUTS', 'Predictive', 'RenyiELBO', diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 42ff09135..e81923768 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -22,7 +22,8 @@ from numpyro.infer.util import ParamInfo, init_to_uniform, initialize_model from numpyro.util import cond, fori_loop, identity -HMCState = namedtuple('HMCState', ['i', 'z', 'z_grad', 'potential_energy', 'energy', 'num_steps', 'accept_prob', +HMCState = namedtuple('HMCState', ['i', 'z', 'z_grad', 'potential_energy', 'energy', + 'r', 'trajectory_length', 'num_steps', 'accept_prob', 'mean_accept_prob', 'diverging', 'adapt_state', 'rng_key']) """ A :func:`~collections.namedtuple` consisting of the following fields: @@ -33,6 +34,10 @@ - **z_grad** - Gradient of potential energy w.r.t. latent sample sites. - **potential_energy** - Potential energy computed at the given value of ``z``. - **energy** - Sum of potential energy and kinetic energy of the current state. + - **r** - The current momentum variable. If this is None, a new momentum variable + will be drawn at the beginning of each sampling step. + - **trajectory_length** - The amount of time to run HMC dynamics in each sampling step. + This field is not used in NUTS. - **num_steps** - Number of steps in the Hamiltonian trajectory (for diagnostics). In NUTS sampler, the tree depth of a trajectory can be computed from this field with `tree_depth = np.log2(num_steps).astype(int) + 1`. @@ -56,7 +61,7 @@ def _get_num_steps(step_size, trajectory_length): - num_steps = jnp.clip(trajectory_length / step_size, a_min=1) + num_steps = jnp.ceil(trajectory_length / step_size) # NB: casting to jnp.int64 does not take effect (returns jnp.int32 instead) # if jax_enable_x64 is False return num_steps.astype(canonicalize_dtype(jnp.int64)) @@ -146,7 +151,6 @@ def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo='NUTS'): if kinetic_fn is None: kinetic_fn = euclidean_kinetic_energy vv_update = None - trajectory_len = None max_treedepth = None wa_update = None wa_steps = None @@ -205,10 +209,9 @@ def init_kernel(init_params, """ step_size = lax.convert_element_type(step_size, canonicalize_dtype(jnp.float64)) - nonlocal wa_update, trajectory_len, max_treedepth, vv_update, wa_steps, forward_mode_ad + nonlocal wa_update, max_treedepth, vv_update, wa_steps, forward_mode_ad forward_mode_ad = forward_mode_differentiation wa_steps = num_warmup - trajectory_len = trajectory_length max_treedepth = max_tree_depth if isinstance(init_params, ParamInfo): z, pe, z_grad = init_params @@ -246,17 +249,24 @@ def init_kernel(init_params, vv_state = vv_init(z, r, potential_energy=pe, z_grad=z_grad) energy = kinetic_fn(wa_state.inverse_mass_matrix, vv_state.r) hmc_state = HMCState(jnp.array(0), vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, + None, trajectory_length, jnp.array(0), jnp.array(0.), jnp.array(0.), jnp.array(False), wa_state, rng_key_hmc) return device_put(hmc_state) def _hmc_next(step_size, inverse_mass_matrix, vv_state, - model_args, model_kwargs, rng_key): + model_args, model_kwargs, rng_key, trajectory_length): if potential_fn_gen: nonlocal vv_update, forward_mode_ad pe_fn = potential_fn_gen(*model_args, **model_kwargs) _, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) - num_steps = _get_num_steps(step_size, trajectory_len) + # no need to spend too many steps if the state z has 0 size (i.e. z is empty) + if inverse_mass_matrix.shape[0] == 0: + num_steps = 1 + else: + num_steps = _get_num_steps(step_size, trajectory_length) + # makes sure trajectory length is constant, rather than step_size * num_steps + step_size = trajectory_length / num_steps vv_state_new = fori_loop(0, num_steps, lambda i, val: vv_update(step_size, inverse_mass_matrix, val), vv_state) @@ -273,7 +283,7 @@ def _hmc_next(step_size, inverse_mass_matrix, vv_state, return vv_state, energy, num_steps, accept_prob, diverging def _nuts_next(step_size, inverse_mass_matrix, vv_state, - model_args, model_kwargs, rng_key): + model_args, model_kwargs, rng_key, trajectory_length): if potential_fn_gen: nonlocal vv_update, forward_mode_ad pe_fn = potential_fn_gen(*model_args, **model_kwargs) @@ -307,14 +317,16 @@ def sample_kernel(hmc_state, model_args=(), model_kwargs=None): """ model_kwargs = {} if model_kwargs is None else model_kwargs rng_key, rng_key_momentum, rng_key_transition = random.split(hmc_state.rng_key, 3) - r = momentum_generator(hmc_state.z, hmc_state.adapt_state.mass_matrix_sqrt, rng_key_momentum) + r = momentum_generator(hmc_state.z, hmc_state.adapt_state.mass_matrix_sqrt, rng_key_momentum) \ + if hmc_state.r is None else hmc_state.r vv_state = IntegratorState(hmc_state.z, r, hmc_state.potential_energy, hmc_state.z_grad) vv_state, energy, num_steps, accept_prob, diverging = _next(hmc_state.adapt_state.step_size, hmc_state.adapt_state.inverse_mass_matrix, vv_state, model_args, model_kwargs, - rng_key_transition) + rng_key_transition, + hmc_state.trajectory_length) # not update adapt_state after warmup phase adapt_state = cond(hmc_state.i < wa_steps, (hmc_state.i, accept_prob, vv_state, hmc_state.adapt_state), @@ -326,7 +338,9 @@ def sample_kernel(hmc_state, model_args=(), model_kwargs=None): n = jnp.where(hmc_state.i < wa_steps, itr, itr - wa_steps) mean_accept_prob = hmc_state.mean_accept_prob + (accept_prob - hmc_state.mean_accept_prob) / n - return HMCState(itr, vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, num_steps, + r = vv_state.r if hmc_state.r is not None else None + return HMCState(itr, vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, + r, hmc_state.trajectory_length, num_steps, accept_prob, mean_accept_prob, diverging, adapt_state, rng_key) # Make `init_kernel` and `sample_kernel` visible from the global scope once diff --git a/numpyro/infer/mixed_hmc.py b/numpyro/infer/mixed_hmc.py new file mode 100644 index 000000000..282372f28 --- /dev/null +++ b/numpyro/infer/mixed_hmc.py @@ -0,0 +1,222 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from collections import namedtuple +from functools import partial + +from jax import jacfwd, grad, lax, ops, random +import jax.numpy as jnp + +from numpyro.infer.hmc import momentum_generator +from numpyro.infer.hmc_gibbs import DiscreteHMCGibbs +from numpyro.infer.hmc_util import euclidean_kinetic_energy, warmup_adapter +from numpyro.util import cond, fori_loop, identity, ravel_pytree + + +MixedHMCState = namedtuple("MixedHMCState", "z, hmc_state, rng_key, accept_prob") + + +class MixedHMC(DiscreteHMCGibbs): + """ + Implementation of Mixed Hamiltonian Monte Carlo (reference [1]). + + .. note:: The number of discrete sites to update at each MCMC iteration + (`n_D` in reference [1]) is fixed at value 1. + + **References** + + 1. *Mixed Hamiltonian Monte Carlo for Mixed Discrete and Continuous Variables*, + Guangyao Zhou (2020) + 2. *Peskun's theorem and a modified discrete-state Gibbs sampler*, + Liu, J. S. (1996) + + :param inner_kernel: A :class:`~numpyro.infer.hmc.HMC` kernel. + :param int num_discrete_updates: Number of times to update discrete variables. + Defaults to the number of discrete latent variables. + :param bool random_walk: If False, Gibbs sampling will be used to draw a sample from the + conditional `p(gibbs_site | remaining sites)`, where `gibbs_site` is one of the + discrete sample sites in the model. Otherwise, a sample will be drawn uniformly + from the domain of `gibbs_site`. Defaults to False. + :param bool modified: whether to use a modified proposal, as suggested in reference [2], which + always proposes a new state for the current Gibbs site (i.e. discrete site). Defaults to False. + The modified scheme appears in the literature under the name "modified Gibbs sampler" or + "Metropolised Gibbs sampler". + + **Example** + + .. doctest:: + + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.infer import HMC, MCMC, MixedHMC + ... + >>> def model(probs, locs): + ... c = numpyro.sample("c", dist.Categorical(probs)) + ... numpyro.sample("x", dist.Normal(locs[c], 0.5)) + ... + >>> probs = jnp.array([0.15, 0.3, 0.3, 0.25]) + >>> locs = jnp.array([-2, 0, 2, 4]) + >>> kernel = MixedHMC(HMC(model, trajectory_length=1.2), num_discrete_updates=20) + >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) + >>> mcmc.run(random.PRNGKey(0), probs, locs) + >>> mcmc.print_summary() # doctest: +SKIP + >>> samples = mcmc.get_samples() + >>> assert "x" in samples and "c" in samples + >>> assert abs(jnp.mean(samples["x"]) - 1.3) < 0.1 + >>> assert abs(jnp.var(samples["x"]) - 4.36) < 0.5 + """ + + def __init__(self, inner_kernel, *, num_discrete_updates=None, random_walk=False, modified=False): + super().__init__(inner_kernel, random_walk=random_walk, modified=modified) + if inner_kernel._algo == "NUTS": + raise ValueError("The algorithm only works with HMC and and does not support NUTS.") + self._num_discrete_updates = num_discrete_updates + + def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): + rng_key, rng_r = random.split(rng_key) + state = super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) + self._support_sizes_flat, _ = ravel_pytree({k: self._support_sizes[k] for k in self._gibbs_sites}) + if self._num_discrete_updates is None: + self._num_discrete_updates = self._support_sizes_flat.shape[0] + self._num_warmup = num_warmup + + # NB: the warmup adaptation can not be performed in sub-trajectories (i.e. the hmc trajectory + # between two discrete updates), so we will do it here, at the end of each MixedHMC step. + _, self._wa_update = warmup_adapter(num_warmup, + adapt_step_size=self.inner_kernel._adapt_step_size, + adapt_mass_matrix=self.inner_kernel._adapt_mass_matrix, + dense_mass=self.inner_kernel._dense_mass, + target_accept_prob=self.inner_kernel._target_accept_prob, + find_reasonable_step_size=None) + + # In HMC, when `hmc_state.r` is not None, we will skip drawing a random momemtum at the + # beginning of an HMC step. The reason is we need to maintain `r` between each sub-trajectories. + r = momentum_generator(state.hmc_state.z, state.hmc_state.adapt_state.mass_matrix_sqrt, rng_r) + return MixedHMCState(state.z, state.hmc_state._replace(r=r), state.rng_key, jnp.array(0.)) + + def sample(self, state, model_args, model_kwargs): + model_kwargs = {} if model_kwargs is None else model_kwargs + num_discretes = self._support_sizes_flat.shape[0] + + def potential_fn(z_gibbs, z_hmc): + return self.inner_kernel._potential_fn_gen( + *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + + def update_discrete(idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum): + # Algo 1, line 19: get a new discrete proposal + rng_key, z_discrete_new, pe_new, log_accept_ratio = self._discrete_proposal_fn( + rng_key, z_discrete, hmc_state.potential_energy, + partial(potential_fn, z_hmc=hmc_state.z), idx, self._support_sizes_flat[idx]) + # Algo 1, line 20: depending on reject or refract, we will update + # the discrete variable and its corresponding kinetic energy. In case of + # refract, we will need to update the potential energy and its grad w.r.t. hmc_state.z + ke_discrete_i_new = ke_discrete[idx] + log_accept_ratio + grad_ = jacfwd if self.inner_kernel._forward_mode_differentiation else grad + z_discrete, pe, ke_discrete_i, z_grad = lax.cond( + ke_discrete_i_new > 0, + (z_discrete_new, pe_new, ke_discrete_i_new), + lambda vals: vals + (grad_(partial(potential_fn, vals[0]))(hmc_state.z),), + (z_discrete, hmc_state.potential_energy, ke_discrete[idx], hmc_state.z_grad), + identity) + + delta_pe_sum = delta_pe_sum + pe - hmc_state.potential_energy + ke_discrete = ops.index_update(ke_discrete, idx, ke_discrete_i) + hmc_state = hmc_state._replace(potential_energy=pe, z_grad=z_grad) + return rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum + + def update_continuous(hmc_state, z_discrete): + model_kwargs_ = model_kwargs.copy() + model_kwargs_["_gibbs_sites"] = z_discrete + hmc_state_new = self.inner_kernel.sample(hmc_state, model_args, model_kwargs_) + + # each time a sub-trajectory is performed, we need to reset i and adapt_state + # (we will only update them at the end of HMCGibbs step) + # For `num_steps`, we will record its cumulative sum for diagnostics + hmc_state = hmc_state_new._replace(i=hmc_state.i, + adapt_state=hmc_state.adapt_state, + num_steps=hmc_state.num_steps + hmc_state_new.num_steps) + return hmc_state + + def body_fn(i, vals): + rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum, arrival_times = vals + idx = jnp.argmin(arrival_times) + # NB: length of each sub-trajectory is scaled from the current min(arrival_times) + # (see the note at total_time below) + trajectory_length = arrival_times[idx] * time_unit + arrival_times = arrival_times - arrival_times[idx] + arrival_times = ops.index_update(arrival_times, idx, 1.) + + # this is a trick, so that in a sub-trajectory of HMC, we always accept the new proposal + pe = jnp.inf + hmc_state = hmc_state._replace(trajectory_length=trajectory_length, potential_energy=pe) + # Algo 1, line 7: perform a sub-trajectory + hmc_state = update_continuous(hmc_state, z_discrete) + # Algo 1, line 8: perform a discrete update + rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum = update_discrete( + idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum) + return rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum, arrival_times + + z_discrete = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} + rng_key, rng_ke, rng_time, rng_r, rng_accept = random.split(state.rng_key, 5) + # Algo 1, line 2: sample discrete kinetic energy + ke_discrete = random.exponential(rng_ke, (num_discretes,)) + # Algo 1, line 4 and 5: sample the initial amount of time that each discrete site visits + # the point 0/1. The logic in GetStepSizesNSteps(...) is more complicated but does + # the same job: the sub-trajectory length eta_t * M_t is the lag between two arrival time. + arrival_times = random.uniform(rng_time, (num_discretes,)) + # compute the amount of time to make `num_discrete_updates` discrete updates + total_time = (self._num_discrete_updates - 1) // num_discretes \ + + jnp.sort(arrival_times)[(self._num_discrete_updates - 1) % num_discretes] + # NB: total_time can be different from the HMC trajectory length, so we need to scale + # the time unit so that total_time * time_unit = hmc_trajectory_length + time_unit = state.hmc_state.trajectory_length / total_time + + # Algo 1, line 2: sample hmc momentum + r = momentum_generator(state.hmc_state.r, state.hmc_state.adapt_state.mass_matrix_sqrt, rng_r) + hmc_state = state.hmc_state._replace(r=r, num_steps=0) + hmc_ke = euclidean_kinetic_energy(hmc_state.adapt_state.inverse_mass_matrix, r) + # Algo 1, line 10: compute the initial energy + energy_old = hmc_ke + hmc_state.potential_energy + + # Algo 1, line 3: set initial values + delta_pe_sum = 0. + init_val = (rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum, arrival_times) + # Algo 1, line 6-9: perform the update loop + rng_key, hmc_state_new, z_discrete_new, _, delta_pe_sum, _ = fori_loop( + 0, self._num_discrete_updates, body_fn, init_val) + # Algo 1, line 10: compute the proposal energy + hmc_ke = euclidean_kinetic_energy(hmc_state.adapt_state.inverse_mass_matrix, hmc_state_new.r) + energy_new = hmc_ke + hmc_state_new.potential_energy + # Algo 1, line 11: perform MH correction + delta_energy = energy_new - energy_old - delta_pe_sum + delta_energy = jnp.where(jnp.isnan(delta_energy), jnp.inf, delta_energy) + accept_prob = jnp.clip(jnp.exp(-delta_energy), a_max=1.0) + + # record the correct new num_steps + hmc_state = hmc_state._replace(num_steps=hmc_state_new.num_steps) + # reset the trajectory length + hmc_state_new = hmc_state_new._replace(trajectory_length=hmc_state.trajectory_length) + hmc_state, z_discrete = cond(random.bernoulli(rng_key, accept_prob), + (hmc_state_new, z_discrete_new), identity, + (hmc_state, z_discrete), identity) + + # perform hmc adapting (similar to the implementation in hmc) + adapt_state = cond(hmc_state.i < self._num_warmup, + (hmc_state.i, accept_prob, (hmc_state.z,), hmc_state.adapt_state), + lambda args: self._wa_update(*args), + hmc_state.adapt_state, + identity) + + itr = hmc_state.i + 1 + n = jnp.where(hmc_state.i < self._num_warmup, itr, itr - self._num_warmup) + mean_accept_prob_prev = state.hmc_state.mean_accept_prob + mean_accept_prob = mean_accept_prob_prev + (accept_prob - mean_accept_prob_prev) / n + hmc_state = hmc_state._replace(i=itr, + accept_prob=accept_prob, + mean_accept_prob=mean_accept_prob, + adapt_state=adapt_state) + + z = {**z_discrete, **hmc_state.z} + return MixedHMCState(z, hmc_state, rng_key, accept_prob) diff --git a/test/infer/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py index b73bb5940..73a096cb1 100644 --- a/test/infer/test_hmc_gibbs.py +++ b/test/infer/test_hmc_gibbs.py @@ -13,7 +13,7 @@ import numpyro import numpyro.distributions as dist -from numpyro.infer import HMC, HMCECS, MCMC, NUTS, DiscreteHMCGibbs, HMCGibbs +from numpyro.infer import HMC, HMCECS, MCMC, NUTS, DiscreteHMCGibbs, HMCGibbs, MixedHMC from numpyro.infer.util import log_density @@ -149,61 +149,78 @@ def model(): assert_allclose(x1_std, np.sqrt(np.diagonal(cov11)), rtol=0.1) +@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ + (MixedHMC, HMC, {"num_discrete_updates": 5}), + (DiscreteHMCGibbs, NUTS, {}) +]) @pytest.mark.parametrize("num_chains", [1, 2]) @pytest.mark.filterwarnings("ignore:There are not enough devices:UserWarning") -def test_discrete_gibbs_multiple_sites_chain(num_chains): +def test_discrete_gibbs_multiple_sites_chain(kernel, inner_kernel, kwargs, num_chains): def model(): numpyro.sample("x", dist.Bernoulli(0.7).expand([3])) numpyro.sample("y", dist.Binomial(10, 0.3)) - kernel = DiscreteHMCGibbs(NUTS(model)) - mcmc = MCMC(kernel, 1000, 10000, num_chains=num_chains, progress_bar=False) + sampler = kernel(inner_kernel(model), **kwargs) + mcmc = MCMC(sampler, 1000, 10000, num_chains=num_chains, progress_bar=False) mcmc.run(random.PRNGKey(0)) + mcmc.print_summary() samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["x"], 0), 0.7 * jnp.ones(3), atol=0.01) assert_allclose(jnp.mean(samples["y"], 0), 0.3 * 10, atol=0.1) -def test_discrete_gibbs_enum(): +@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ + (MixedHMC, HMC, {"num_discrete_updates": 6}), + (DiscreteHMCGibbs, NUTS, {}) +]) +def test_discrete_gibbs_enum(kernel, inner_kernel, kwargs): def model(): numpyro.sample("x", dist.Bernoulli(0.7), infer={"enumerate": "parallel"}) y = numpyro.sample("y", dist.Binomial(10, 0.3)) numpyro.deterministic("y2", y ** 2) - kernel = DiscreteHMCGibbs(NUTS(model)) - mcmc = MCMC(kernel, 1000, 10000, progress_bar=False) + sampler = kernel(inner_kernel(model), **kwargs) + mcmc = MCMC(sampler, 1000, 10000, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["y"], 0), 0.3 * 10, atol=0.1) @pytest.mark.parametrize("random_walk", [False, True]) -@pytest.mark.parametrize("modified", [False, True]) -def test_discrete_gibbs_bernoulli(random_walk, modified): +@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ + (MixedHMC, HMC, {"num_discrete_updates": 6}), + (DiscreteHMCGibbs, NUTS, {"modified": True}), + (DiscreteHMCGibbs, NUTS, {"modified": False}), +]) +def test_discrete_gibbs_bernoulli(random_walk, kernel, inner_kernel, kwargs): def model(): numpyro.sample("c", dist.Bernoulli(0.8)) - kernel = DiscreteHMCGibbs(NUTS(model), random_walk=random_walk, modified=modified) - mcmc = MCMC(kernel, 1000, 200000, progress_bar=False) + sampler = kernel(inner_kernel(model), random_walk=random_walk, **kwargs) + mcmc = MCMC(sampler, 1000, 10000, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples()["c"] assert_allclose(jnp.mean(samples), 0.8, atol=0.05) @pytest.mark.parametrize("modified", [False, True]) -def test_discrete_gibbs_gmm_1d(modified): +@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ + (MixedHMC, HMC, {"num_discrete_updates": 20}), + (DiscreteHMCGibbs, NUTS, {}) +]) +def test_discrete_gibbs_gmm_1d(modified, kernel, inner_kernel, kwargs): def model(probs, locs): c = numpyro.sample("c", dist.Categorical(probs)) numpyro.sample("x", dist.Normal(locs[c], 0.5)) probs = jnp.array([0.15, 0.3, 0.3, 0.25]) locs = jnp.array([-2, 0, 2, 4]) - kernel = DiscreteHMCGibbs(NUTS(model), modified=modified) - mcmc = MCMC(kernel, 1000, 200000, progress_bar=False) + sampler = kernel(inner_kernel(model, trajectory_length=1.2), modified=modified, **kwargs) + mcmc = MCMC(sampler, 1000, 200000, progress_bar=False) mcmc.run(random.PRNGKey(0), probs, locs) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["x"]), 1.3, atol=0.1) - assert_allclose(jnp.var(samples["x"]), 4.36, atol=0.2) + assert_allclose(jnp.var(samples["x"]), 4.36, atol=0.4) assert_allclose(jnp.mean(samples["c"]), 1.65, atol=0.1) assert_allclose(jnp.var(samples["c"]), 1.03, atol=0.1) diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index 6d6d4c885..aeaaadb23 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -228,7 +228,7 @@ def model(): numpyro.sample("x", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=true_cov)) if kernel_cls is HMC or kernel_cls is NUTS: - kernel = kernel_cls(model, trajectory_length=1., dense_mass=True) + kernel = kernel_cls(model, trajectory_length=2., dense_mass=True) elif kernel_cls is BarkerMH: kernel = BarkerMH(model, dense_mass=True) From ecd6255a3804a697f2a0c0b6aca734ef4c7784cf Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 16 Mar 2021 12:47:32 -0500 Subject: [PATCH 078/222] Bump to 0.6.0 (#959) * sketch the plan * add a running implementation (not working yet * remove unnecessary changes * sequential update * temp save * add a working implementation * add 24d example * fix lint * test for the order * merge master * fix bug at reset momentum * add various mh functions * add various discrete gibbs function method * change stay_prob to modified to avoid confusing users * expose more information for mixed hmc * sketch an implementation * temp save * temp save * finish the implementation * keep kinetic energy * add temperature experiment * add dual averaging * add various debug statements * fix bugs * clean up and separating out clock adapter; but target distribution is wrong due to a bug somewhere * clean up * add comments and an example * make sure forward mode work * add docs for new HMC fields * add tests for mixedhmc * fix step_size bug * use modified=False * tests pass with the fix * skip print summary * adjust trajectory length * port update_version script from Pyro * pin jax/jaxlib versions * run isort * fix some issues during collection notes * use result_type instead of canonicalize_dtype * fix lint * change get_dtype to jnp.result_type * add print summary * fix compiling issue for mcmc * also try to avoid compiling issue in other samplers * also fix compiling issue in barkermh * convert init params types to strong types * address comments * fix wrong docs * run isort --- README.md | 2 +- docs/source/distributions.rst | 8 +++++ docs/source/mcmc.rst | 2 ++ examples/annotation.py | 2 +- examples/baseball.py | 2 +- examples/bnn.py | 2 +- examples/covtype.py | 2 +- examples/funnel.py | 2 +- examples/gp.py | 2 +- examples/hmm.py | 2 +- examples/minipyro.py | 2 +- examples/neutra.py | 2 +- examples/ode.py | 2 +- examples/proportion_test.py | 2 +- examples/sparse_regression.py | 2 +- examples/stochastic_volatility.py | 2 +- examples/ucbadmit.py | 2 +- examples/vae.py | 2 +- notebooks/source/bayesian_regression.ipynb | 2 +- notebooks/source/logistic_regression.ipynb | 2 +- notebooks/source/ordinal_regression.ipynb | 2 +- numpyro/__init__.py | 2 +- numpyro/contrib/tfp/distributions.py | 3 +- numpyro/distributions/discrete.py | 15 +++++---- numpyro/distributions/transforms.py | 13 ++------ numpyro/distributions/util.py | 9 ++---- numpyro/infer/__init__.py | 2 +- numpyro/infer/barker.py | 11 +++---- numpyro/infer/hmc.py | 8 ++--- numpyro/infer/hmc_gibbs.py | 4 +-- numpyro/infer/hmc_util.py | 5 ++- numpyro/infer/mcmc.py | 1 + numpyro/infer/mixed_hmc.py | 5 ++- numpyro/infer/sa.py | 2 +- numpyro/infer/svi.py | 7 +++-- numpyro/util.py | 5 ++- numpyro/version.py | 2 +- scripts/update_version.py | 36 ++++++++++++++++++++++ setup.py | 4 +-- test/contrib/test_tfp.py | 2 +- test/test_util.py | 4 +-- 41 files changed, 109 insertions(+), 79 deletions(-) create mode 100644 scripts/update_version.py diff --git a/README.md b/README.md index 16606aa19..c62cb0b61 100644 --- a/README.md +++ b/README.md @@ -182,7 +182,7 @@ Pyro users will note that the API for model specification and inference is large ## Installation -> **Limited Windows Support:** Note that NumPyro is untested on Windows, and might require building jaxlib from source. See this [JAX issue](https://github.com/google/jax/issues/438) for more details. Alternatively, you can install [Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/) and use NumPyro on it as on a Linux system. See also [CUDA on Windows Subsystem for Linux](https://developer.nvidia.com/cuda/wsl) if you want to use GPUs on Windows. +> **Limited Windows Support:** Note that NumPyro is untested on Windows, and might require building jaxlib from source. See this [JAX issue](https://github.com/google/jax/issues/438) for more details. Alternatively, you can install [Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/) and use NumPyro on it as on a Linux system. See also [CUDA on Windows Subsystem for Linux](https://developer.nvidia.com/cuda/wsl) and [this forum post](https://forum.pyro.ai/t/numpyro-with-gpu-works-on-windows/2690) if you want to use GPUs on Windows. To install NumPyro with a CPU version of JAX, you can use pip: diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index b3c1ff69c..83bf83e63 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -574,6 +574,14 @@ real_vector ----------- .. autodata:: numpyro.distributions.constraints.real_vector +softplus_positive +----------------- +.. autodata:: numpyro.distributions.constraints.softplus_positive + +softplus_lower_cholesky +----------------------- +.. autodata:: numpyro.distributions.constraints.softplus_lower_cholesky + simplex ------- .. autodata:: numpyro.distributions.constraints.simplex diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index 337b5b792..416e0a3a6 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -70,6 +70,8 @@ MCMC Kernels .. autofunction:: numpyro.infer.hmc.hmc.sample_kernel +.. autofunction:: numpyro.infer.hmc_gibbs.taylor_proxy + .. autodata:: numpyro.infer.barker.BarkerMHState .. autodata:: numpyro.infer.hmc.HMCState diff --git a/examples/annotation.py b/examples/annotation.py index 7c9cd6ef4..e14e30eae 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -266,7 +266,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.5.0") + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Bayesian Models of Annotation") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/baseball.py b/examples/baseball.py index 9be4206c6..45c5c47f0 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -196,7 +196,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Baseball batting average using MCMC") parser.add_argument("-n", "--num-samples", nargs="?", default=3000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1500, type=int) diff --git a/examples/bnn.py b/examples/bnn.py index 08b68407c..b72c75cfe 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -138,7 +138,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Bayesian neural network example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) diff --git a/examples/covtype.py b/examples/covtype.py index 1ebe4220d..e81a62b70 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -139,7 +139,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="parse args") parser.add_argument('-n', '--num-samples', default=1000, type=int, help='number of samples') parser.add_argument('--num-warmup', default=1000, type=int, help='number of warmup steps') diff --git a/examples/funnel.py b/examples/funnel.py index 16305aa7c..add3288f4 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -87,7 +87,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Non-centered reparameterization example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) diff --git a/examples/gp.py b/examples/gp.py index bccf22a3d..a64405d83 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -142,7 +142,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) diff --git a/examples/hmm.py b/examples/hmm.py index c07e15fcf..7be0f19b5 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -191,7 +191,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description='Semi-supervised Hidden Markov Model') parser.add_argument('--num-categories', default=3, type=int) parser.add_argument('--num-words', default=10, type=int) diff --git a/examples/minipyro.py b/examples/minipyro.py index f59abd2c8..db5ca14e5 100644 --- a/examples/minipyro.py +++ b/examples/minipyro.py @@ -58,7 +58,7 @@ def body_fn(i, val): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Mini Pyro demo") parser.add_argument("-f", "--full-pyro", action="store_true", default=False) parser.add_argument("-n", "--num-steps", default=1001, type=int) diff --git a/examples/neutra.py b/examples/neutra.py index bee94edb0..848179aa2 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -146,7 +146,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="NeuTra HMC") parser.add_argument('-n', '--num-samples', nargs='?', default=4000, type=int) parser.add_argument('--num-warmup', nargs='?', default=1000, type=int) diff --git a/examples/ode.py b/examples/ode.py index df06a84a7..a4c167a58 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -103,7 +103,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description='Predator-Prey Model') parser.add_argument('-n', '--num-samples', nargs='?', default=1000, type=int) parser.add_argument('--num-warmup', nargs='?', default=1000, type=int) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index 3e6e0f5a7..359f9c17d 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -128,7 +128,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description='Testing whether ') parser.add_argument('-n', '--num-samples', nargs='?', default=500, type=int) parser.add_argument('--num-warmup', nargs='?', default=1500, type=int) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index a91c27297..f95135feb 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -320,7 +320,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs='?', default=500, type=int) diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index fb480c325..3ce8bbe68 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -112,7 +112,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="Stochastic Volatility Model") parser.add_argument('-n', '--num-samples', nargs='?', default=600, type=int) parser.add_argument('--num-warmup', nargs='?', default=600, type=int) diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index a7fdff6ec..eef87f06d 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -131,7 +131,7 @@ def main(args): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description='UCBadmit gender discrimination using HMC') parser.add_argument('-n', '--num-samples', nargs='?', default=2000, type=int) parser.add_argument('--num-warmup', nargs='?', default=500, type=int) diff --git a/examples/vae.py b/examples/vae.py index 3935fbf3e..4d8ec0b2f 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -131,7 +131,7 @@ def reconstruct_img(epoch, rng_key): if __name__ == '__main__': - assert numpyro.__version__.startswith('0.5.0') + assert numpyro.__version__.startswith('0.6.0') parser = argparse.ArgumentParser(description="parse args") parser.add_argument('-n', '--num-epochs', default=15, type=int, help='number of training epochs') parser.add_argument('-lr', '--learning-rate', default=1.0e-3, type=float, help='learning rate') diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 329fa6801..d73afefec 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -66,7 +66,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats('svg')\n", "\n", - "assert numpyro.__version__.startswith('0.5.0')" + "assert numpyro.__version__.startswith('0.6.0')" ] }, { diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index 901a0da06..a3902514c 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -31,7 +31,7 @@ "import numpyro.distributions as dist\n", "from numpyro.examples.datasets import COVTYPE, load_dataset\n", "from numpyro.infer import HMC, MCMC, NUTS\n", - "assert numpyro.__version__.startswith('0.5.0')\n", + "assert numpyro.__version__.startswith('0.6.0')\n", "\n", "# NB: replace gpu by cpu to run this notebook in cpu\n", "numpyro.set_platform(\"gpu\")" diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 8b1ac5b74..14ff1a699 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -30,7 +30,7 @@ "from numpyro.infer import MCMC, NUTS\n", "import pandas as pd\n", "import seaborn as sns\n", - "assert numpyro.__version__.startswith('0.5.0')" + "assert numpyro.__version__.startswith('0.6.0')" ] }, { diff --git a/numpyro/__init__.py b/numpyro/__init__.py index 018b34cb5..91970b71b 100644 --- a/numpyro/__init__.py +++ b/numpyro/__init__.py @@ -14,7 +14,7 @@ plate_stack, prng_key, sample, - subsample, + subsample ) from numpyro.util import enable_x64, set_host_device_count, set_platform from numpyro.version import __version__ diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index 5714099a3..cb5ce0a0d 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -3,7 +3,6 @@ import numpy as np -from jax.dtypes import canonicalize_dtype import jax.numpy as jnp from tensorflow_probability.substrates.jax import bijectors as tfb from tensorflow_probability.substrates.jax import distributions as tfd @@ -162,7 +161,7 @@ class OneHotCategorical(tfd.OneHotCategorical, TFPDistributionMixin): def enumerate_support(self, expand=True): n = self.event_shape[-1] - values = jnp.identity(n, dtype=canonicalize_dtype(self.dtype)) + values = jnp.identity(n, dtype=jnp.result_type(self.dtype)) values = values.reshape((n,) + (1,) * len(self.batch_shape) + (n,)) if expand: values = jnp.broadcast_to(values, (n,) + self.batch_shape + (n,)) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 50790c14f..76bf5ad82 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -42,7 +42,6 @@ binomial, categorical, clamp_probs, - get_dtype, is_prng_key, lazy_property, multinomial, @@ -66,7 +65,7 @@ def _to_probs_multinom(logits): def _to_logits_multinom(probs): - minval = jnp.finfo(get_dtype(probs)).min + minval = jnp.finfo(jnp.result_type(probs)).min return jnp.clip(jnp.log(probs), a_min=minval) @@ -292,11 +291,11 @@ def logits(self): @property def mean(self): - return jnp.full(self.batch_shape, jnp.nan, dtype=get_dtype(self.probs)) + return jnp.full(self.batch_shape, jnp.nan, dtype=jnp.result_type(self.probs)) @property def variance(self): - return jnp.full(self.batch_shape, jnp.nan, dtype=get_dtype(self.probs)) + return jnp.full(self.batch_shape, jnp.nan, dtype=jnp.result_type(self.probs)) @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): @@ -340,11 +339,11 @@ def probs(self): @property def mean(self): - return jnp.full(self.batch_shape, jnp.nan, dtype=get_dtype(self.logits)) + return jnp.full(self.batch_shape, jnp.nan, dtype=jnp.result_type(self.logits)) @property def variance(self): - return jnp.full(self.batch_shape, jnp.nan, dtype=get_dtype(self.logits)) + return jnp.full(self.batch_shape, jnp.nan, dtype=jnp.result_type(self.logits)) @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): @@ -609,7 +608,7 @@ def __init__(self, probs, validate_args=None): def sample(self, key, sample_shape=()): assert is_prng_key(key) probs = self.probs - dtype = get_dtype(probs) + dtype = jnp.result_type(probs) shape = sample_shape + self.batch_shape u = random.uniform(key, shape, dtype) return jnp.floor(jnp.log1p(-u) / jnp.log1p(-probs)) @@ -649,7 +648,7 @@ def probs(self): def sample(self, key, sample_shape=()): assert is_prng_key(key) logits = self.logits - dtype = get_dtype(logits) + dtype = jnp.result_type(logits) shape = sample_shape + self.batch_shape u = random.uniform(key, shape, dtype) return jnp.floor(jnp.log1p(-u) / -softplus(logits)) diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 0f769b547..f71af1f58 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -8,7 +8,6 @@ import numpy as np from jax import lax, ops, tree_flatten, tree_map, vmap -from jax.dtypes import canonicalize_dtype from jax.flatten_util import ravel_pytree from jax.nn import softplus import jax.numpy as jnp @@ -16,13 +15,7 @@ from jax.scipy.special import expit, logit from numpyro.distributions import constraints -from numpyro.distributions.util import ( - get_dtype, - matrix_to_tril_vec, - signed_stick_breaking_tril, - sum_rightmost, - vec_to_tril_matrix -) +from numpyro.distributions.util import matrix_to_tril_vec, signed_stick_breaking_tril, sum_rightmost, vec_to_tril_matrix from numpyro.util import not_jax_tracer __all__ = [ @@ -51,7 +44,7 @@ def _clipped_expit(x): - finfo = jnp.finfo(get_dtype(x)) + finfo = jnp.finfo(jnp.result_type(x)) return jnp.clip(expit(x), a_min=finfo.tiny, a_max=1. - finfo.eps) @@ -654,7 +647,7 @@ def __call__(self, x): def _inverse(self, y): size = self.permutation.size - permutation_inv = ops.index_update(jnp.zeros(size, dtype=canonicalize_dtype(jnp.int64)), + permutation_inv = ops.index_update(jnp.zeros(size, dtype=jnp.result_type(int)), self.permutation, jnp.arange(size)) return y[..., permutation_inv] diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index 9601a77bb..79aaeab06 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -8,7 +8,6 @@ import numpy as np from jax import jit, lax, random, vmap -from jax.dtypes import canonicalize_dtype from jax.lib import xla_bridge import jax.numpy as jnp from jax.scipy.linalg import solve_triangular @@ -253,10 +252,6 @@ def promote_shapes(*args, shape=()): if len(s) < num_dims else arg for arg, s in zip(args, shapes)] -def get_dtype(x): - return canonicalize_dtype(lax.dtype(x)) - - def sum_rightmost(x, dim): """ Sum out ``dim`` many rightmost dimensions of a given tensor. @@ -351,7 +346,7 @@ def logmatmulexp(x, y): def clamp_probs(probs): - finfo = jnp.finfo(get_dtype(probs)) + finfo = jnp.finfo(jnp.result_type(probs)) return jnp.clip(probs, a_min=finfo.tiny, a_max=1. - finfo.eps) @@ -392,7 +387,7 @@ def von_mises_centered(key, concentration, shape=(), dtype=jnp.float64): :return: centered samples from von Mises """ shape = shape or jnp.shape(concentration) - dtype = canonicalize_dtype(dtype) + dtype = jnp.result_type(dtype) concentration = lax.convert_element_type(concentration, dtype) concentration = jnp.broadcast_to(concentration, shape) return _von_mises_centered(key, concentration, shape, dtype) diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 665c43e87..66857a33a 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -1,6 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +from numpyro.infer.barker import BarkerMH from numpyro.infer.elbo import ELBO, RenyiELBO, Trace_ELBO, TraceMeanField_ELBO from numpyro.infer.hmc import HMC, NUTS from numpyro.infer.hmc_gibbs import HMCECS, DiscreteHMCGibbs, HMCGibbs @@ -11,7 +12,6 @@ init_to_uniform, init_to_value ) -from numpyro.infer.barker import BarkerMH from numpyro.infer.mcmc import MCMC from numpyro.infer.mixed_hmc import MixedHMC from numpyro.infer.sa import SA diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py index 6e910971d..e4f79f91f 100644 --- a/numpyro/infer/barker.py +++ b/numpyro/infer/barker.py @@ -6,16 +6,15 @@ import jax from jax import random from jax.flatten_util import ravel_pytree +from jax.nn import softplus import jax.numpy as jnp from jax.scipy.special import expit -from jax.nn import softplus from numpyro.infer.hmc_util import warmup_adapter +from numpyro.infer.initialization import init_to_uniform +from numpyro.infer.mcmc import MCMCKernel from numpyro.infer.util import initialize_model from numpyro.util import identity -from numpyro.infer import init_to_uniform -from numpyro.infer.mcmc import MCMCKernel - BarkerMHState = namedtuple("BarkerMHState", [ "i", "z", "potential_energy", "z_grad", "accept_prob", "mean_accept_prob", "adapt_state", "rng_key"]) @@ -163,8 +162,8 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): size = len(ravel_pytree(init_params)[0]) wa_state = wa_init(None, rng_key_wa, self._step_size, mass_matrix_size=size) wa_state = wa_state._replace(rng_key=None) - init_state = BarkerMHState(jnp.array(0), init_params, pe, grad, jnp.array(0.), - jnp.array(0.), wa_state, rng_key) + init_state = BarkerMHState(jnp.array(0), init_params, pe, grad, jnp.zeros(()), + jnp.zeros(()), wa_state, rng_key) return jax.device_put(init_state) def postprocess_fn(self, args, kwargs): diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index e81923768..985ed3720 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -6,7 +6,6 @@ import os from jax import device_put, lax, partial, random, vmap -from jax.dtypes import canonicalize_dtype from jax.flatten_util import ravel_pytree import jax.numpy as jnp @@ -64,7 +63,7 @@ def _get_num_steps(step_size, trajectory_length): num_steps = jnp.ceil(trajectory_length / step_size) # NB: casting to jnp.int64 does not take effect (returns jnp.int32 instead) # if jax_enable_x64 is False - return num_steps.astype(canonicalize_dtype(jnp.int64)) + return num_steps.astype(jnp.result_type(int)) def momentum_generator(prototype_r, mass_matrix_sqrt, rng_key): @@ -208,7 +207,8 @@ def init_kernel(init_params, randomness. """ - step_size = lax.convert_element_type(step_size, canonicalize_dtype(jnp.float64)) + step_size = lax.convert_element_type(step_size, jnp.result_type(float)) + trajectory_length = lax.convert_element_type(trajectory_length, jnp.result_type(float)) nonlocal wa_update, max_treedepth, vv_update, wa_steps, forward_mode_ad forward_mode_ad = forward_mode_differentiation wa_steps = num_warmup @@ -250,7 +250,7 @@ def init_kernel(init_params, energy = kinetic_fn(wa_state.inverse_mass_matrix, vv_state.r) hmc_state = HMCState(jnp.array(0), vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, None, trajectory_length, - jnp.array(0), jnp.array(0.), jnp.array(0.), jnp.array(False), wa_state, rng_key_hmc) + jnp.array(0), jnp.zeros(()), jnp.zeros(()), jnp.array(False), wa_state, rng_key_hmc) return device_put(hmc_state) def _hmc_next(step_size, inverse_mass_matrix, vv_state, diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index e5bc9e05a..7e92fd7ab 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -478,7 +478,7 @@ class HMCECS(HMCGibbs): :param inner_kernel: One of :class:`~numpyro.infer.hmc.HMC` or :class:`~numpyro.infer.hmc.NUTS`. :param int num_blocks: Number of blocks to partition subsample into. - :param proxy: Either :function `~numpyro.infer.hmc_gibbs.taylor_proxy` for likelihood estimation, + :param proxy: Either :func:`~numpyro.infer.hmc_gibbs.taylor_proxy` for likelihood estimation, or, None for naive (in-between trajectory) subsampling as outlined in [4]. **Example** @@ -554,7 +554,7 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs["_gibbs_state"] = gibbs_state state = super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) - return HMCECSState(state.z, state.hmc_state, state.rng_key, gibbs_state, jnp.array(0.)) + return HMCECSState(state.z, state.hmc_state, state.rng_key, gibbs_state, jnp.zeros(())) def sample(self, state, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index bed612478..09370f7a2 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -12,7 +12,6 @@ from jax.tree_util import tree_flatten, tree_map, tree_multimap import numpyro.distributions as dist -from numpyro.distributions.util import get_dtype from numpyro.util import cond, identity, while_loop AdaptWindow = namedtuple('AdaptWindow', ['start', 'end']) @@ -265,7 +264,7 @@ def find_reasonable_step_size(potential_fn, kinetic_fn, momentum_generator, z, _, potential_energy, z_grad = z_info if potential_energy is None or z_grad is None: potential_energy, z_grad = value_and_grad(potential_fn)(z) - finfo = jnp.finfo(get_dtype(init_step_size)) + finfo = jnp.finfo(jnp.result_type(init_step_size)) def _body_fn(state): step_size, _, direction, rng_key = state @@ -459,7 +458,7 @@ def update_fn(t, accept_prob, z_info, state): jnp.exp(log_step_size_avg), jnp.exp(log_step_size)) # account the the case log_step_size is an extreme number - finfo = jnp.finfo(get_dtype(step_size)) + finfo = jnp.finfo(jnp.result_type(step_size)) step_size = jnp.clip(step_size, a_min=finfo.tiny, a_max=finfo.max) # update mass matrix state diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 8535551ac..a992ee0ba 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -470,6 +470,7 @@ def run(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): See https://jax.readthedocs.io/en/latest/async_dispatch.html and https://jax.readthedocs.io/en/latest/profiling.html for pointers on profiling jax programs. """ + init_params = tree_map(lambda x: lax.convert_element_type(x, jnp.result_type(x)), init_params) self._args = args self._kwargs = kwargs init_state = self._get_cached_init_state(rng_key, args, kwargs) diff --git a/numpyro/infer/mixed_hmc.py b/numpyro/infer/mixed_hmc.py index 282372f28..57a173a89 100644 --- a/numpyro/infer/mixed_hmc.py +++ b/numpyro/infer/mixed_hmc.py @@ -4,7 +4,7 @@ from collections import namedtuple from functools import partial -from jax import jacfwd, grad, lax, ops, random +from jax import grad, jacfwd, lax, ops, random import jax.numpy as jnp from numpyro.infer.hmc import momentum_generator @@ -12,7 +12,6 @@ from numpyro.infer.hmc_util import euclidean_kinetic_energy, warmup_adapter from numpyro.util import cond, fori_loop, identity, ravel_pytree - MixedHMCState = namedtuple("MixedHMCState", "z, hmc_state, rng_key, accept_prob") @@ -94,7 +93,7 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): # In HMC, when `hmc_state.r` is not None, we will skip drawing a random momemtum at the # beginning of an HMC step. The reason is we need to maintain `r` between each sub-trajectories. r = momentum_generator(state.hmc_state.z, state.hmc_state.adapt_state.mass_matrix_sqrt, rng_r) - return MixedHMCState(state.z, state.hmc_state._replace(r=r), state.rng_key, jnp.array(0.)) + return MixedHMCState(state.z, state.hmc_state._replace(r=r), state.rng_key, jnp.zeros(())) def sample(self, state, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index 1bb6eb389..4b8525289 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -135,7 +135,7 @@ def init_kernel(init_params, k = random.categorical(rng_key_z, jnp.zeros(zs.shape[0])) z = unravel_fn(zs[k]) pe = pes[k] - sa_state = SAState(jnp.array(0), z, pe, jnp.array(0.), jnp.array(0.), jnp.array(False), + sa_state = SAState(jnp.array(0), z, pe, jnp.zeros(()), jnp.zeros(()), jnp.array(False), adapt_state, rng_key_sa) return device_put(sa_state) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index c8f1972b3..fbfe80cbd 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -5,7 +5,7 @@ import tqdm -from jax import jit, lax, random +from jax import jit, lax, random, tree_map import jax.numpy as jnp from numpyro.distributions import constraints @@ -116,6 +116,9 @@ def init(self, rng_key, *args, **kwargs): params[site['name']] = transform.inv(site['value']) self.constrain_fn = partial(transform_fn, inv_transforms) + # we convert weak types like float to float32/float64 + # to avoid recompiling body_fn in svi.run + params = tree_map(lambda x: lax.convert_element_type(x, jnp.result_type(x)), params) return SVIState(self.optim.init(params), rng_key) def get_params(self, svi_state): @@ -188,7 +191,7 @@ def run(self, rng_key, num_steps, *args, progress_bar=True, stable_update=False, and `losses` is the collected loss during the process. :rtype: SVIRunResult """ - def body_fn(svi_state, carry): + def body_fn(svi_state, _): if stable_update: svi_state, loss = self.stable_update(svi_state, *args, **kwargs) else: diff --git a/numpyro/util.py b/numpyro/util.py index 150000054..8b247e0b6 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -14,10 +14,9 @@ import jax from jax import device_put, jit, lax, ops, vmap from jax.core import Tracer -from jax.dtypes import canonicalize_dtype +from jax.experimental import host_callback import jax.numpy as jnp from jax.tree_util import tree_flatten, tree_map, tree_unflatten -from jax.experimental import host_callback _DISABLE_CONTROL_FLOW_PRIM = False @@ -325,7 +324,7 @@ def _body_fn(i, vals): def _ravel_list(*leaves): leaves_metadata = tree_map(lambda l: pytree_metadata( - jnp.ravel(l), jnp.shape(l), jnp.size(l), canonicalize_dtype(lax.dtype(l))), leaves) + jnp.ravel(l), jnp.shape(l), jnp.size(l), jnp.result_type(l)), leaves) leaves_idx = jnp.cumsum(jnp.array((0,) + tuple(d.size for d in leaves_metadata))) def unravel_list(arr): diff --git a/numpyro/version.py b/numpyro/version.py index f86a79a48..48baadee9 100644 --- a/numpyro/version.py +++ b/numpyro/version.py @@ -1,4 +1,4 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -__version__ = '0.5.0' +__version__ = '0.6.0' diff --git a/scripts/update_version.py b/scripts/update_version.py new file mode 100644 index 000000000..5cb590545 --- /dev/null +++ b/scripts/update_version.py @@ -0,0 +1,36 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import glob +import os +import re + +root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + +# Get new version. +with open(os.path.join(root, "numpyro", "version.py")) as f: + for line in f: + if line.startswith("__version__ ="): + new_version = line.strip().split()[-1] + +# Collect potential files. +filenames = [] +for path in ["examples", "notebooks/source"]: + for ext in ["*.py", "*.ipynb"]: + filenames.extend(glob.glob(os.path.join(root, path, "**", ext), + recursive=True)) +filenames.sort() + +# Update version string. +pattern1 = re.compile("assert numpyro.__version__.startswith\\(\"[^\"]*\"\\)") +pattern2 = re.compile("assert numpyro.__version__.startswith\\('[^']*'\\)") +text = f"assert numpyro.__version__.startswith({new_version})" +for filename in filenames: + with open(filename) as f: + old_text = f.read() + new_text = pattern1.sub(text, old_text) + new_text = pattern2.sub(text, new_text) + if new_text != old_text: + print("updating {}".format(filename)) + with open(filename, "w") as f: + f.write(new_text) diff --git a/setup.py b/setup.py index 4ad1c9adf..452d2eee6 100644 --- a/setup.py +++ b/setup.py @@ -33,9 +33,9 @@ author='Uber AI Labs', install_requires=[ # TODO: pin to a specific version for the release (until JAX's API becomes stable) - 'jax>=0.2.8', + 'jax==0.2.10', # check min version here: https://github.com/google/jax/blob/master/jax/lib/__init__.py#L26 - 'jaxlib>=0.1.59', + 'jaxlib==0.1.62', 'tqdm', ], extras_require={ diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index 545068cd7..09677d25d 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -2,7 +2,6 @@ # SPDX-License-Identifier: Apache-2.0 import inspect -from numpyro.distributions.transforms import AffineTransform import os from numpy.testing import assert_allclose @@ -13,6 +12,7 @@ import numpyro import numpyro.distributions as dist +from numpyro.distributions.transforms import AffineTransform from numpyro.infer import MCMC, NUTS from numpyro.infer.reparam import TransformReparam diff --git a/test/test_util.py b/test/test_util.py index 3bf38a832..2d2bf75d2 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -4,8 +4,6 @@ from numpy.testing import assert_allclose import pytest -from jax import lax -from jax.dtypes import canonicalize_dtype import jax.numpy as jnp from jax.test_util import check_eq from jax.tree_util import tree_flatten, tree_multimap @@ -73,7 +71,7 @@ def test_ravel_pytree(pytree): unravel = unravel_fn(flat) tree_flatten(tree_multimap(lambda x, y: assert_allclose(x, y), unravel, pytree)) assert all(tree_flatten(tree_multimap(lambda x, y: - canonicalize_dtype(lax.dtype(x)) == canonicalize_dtype(lax.dtype(y)), + jnp.result_type(x) == jnp.result_type(y), unravel, pytree))[0]) From 20e0f2fa03aaf9595520f87dd913b1b3406506de Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 19 Mar 2021 10:02:44 -0500 Subject: [PATCH 079/222] Support structural mass matrix in HMC (#963) * implement the core math for structure mass matrix * add the remaining math * update adapter for structured mass * update welford covariance * fix lint * remove all potential weak type * mark xfail for failing collapse test * add tests * mark xfail wrong place * add a clearer error message * address comments for structured mass matrix * add more smoking tests for structured mass * fix lint * make a better senmatic for initial mass ndarray * fix typo * change precision due to jaxlib 0.1.64 precision change --- numpyro/infer/barker.py | 2 +- numpyro/infer/hmc.py | 105 ++++++++++++++--- numpyro/infer/hmc_util.py | 213 +++++++++++++++++++++++++++------- numpyro/infer/util.py | 2 +- test/infer/test_hmc_gibbs.py | 2 +- test/infer/test_infer_util.py | 2 +- test/infer/test_mcmc.py | 94 +++++++++++++++ test/test_handlers.py | 1 + 8 files changed, 359 insertions(+), 62 deletions(-) diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py index e4f79f91f..4e4691fd4 100644 --- a/numpyro/infer/barker.py +++ b/numpyro/infer/barker.py @@ -160,7 +160,7 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): dense_mass=self._dense_mass, target_accept_prob=self._target_accept_prob) size = len(ravel_pytree(init_params)[0]) - wa_state = wa_init(None, rng_key_wa, self._step_size, mass_matrix_size=size) + wa_state = wa_init((init_params,), rng_key_wa, self._step_size, mass_matrix_size=size) wa_state = wa_state._replace(rng_key=None) init_state = BarkerMHState(jnp.array(0), init_params, pe, grad, jnp.zeros(()), jnp.zeros(()), wa_state, rng_key) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 985ed3720..64b28d52b 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -1,7 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -from collections import namedtuple +from collections import OrderedDict, namedtuple import math import os @@ -67,6 +67,14 @@ def _get_num_steps(step_size, trajectory_length): def momentum_generator(prototype_r, mass_matrix_sqrt, rng_key): + if isinstance(mass_matrix_sqrt, dict): + rng_keys = random.split(rng_key, len(mass_matrix_sqrt)) + r = {} + for (site_names, mm_sqrt), rng_key in zip(mass_matrix_sqrt.items(), rng_keys): + r_block = OrderedDict([(k, prototype_r[k]) for k in site_names]) + r.update(momentum_generator(r_block, mm_sqrt, rng_key)) + return r + _, unpack_fn = ravel_pytree(prototype_r) eps = random.normal(rng_key, jnp.shape(mass_matrix_sqrt)[:1]) if mass_matrix_sqrt.ndim == 1: @@ -242,15 +250,15 @@ def init_kernel(init_params, rng_key_hmc, rng_key_wa, rng_key_momentum = random.split(rng_key, 3) z_info = IntegratorState(z=z, potential_energy=pe, z_grad=z_grad) wa_state = wa_init(z_info, rng_key_wa, step_size, - inverse_mass_matrix=inverse_mass_matrix, - mass_matrix_size=jnp.size(ravel_pytree(z)[0])) + inverse_mass_matrix=inverse_mass_matrix) r = momentum_generator(z, wa_state.mass_matrix_sqrt, rng_key_momentum) vv_init, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) vv_state = vv_init(z, r, potential_energy=pe, z_grad=z_grad) - energy = kinetic_fn(wa_state.inverse_mass_matrix, vv_state.r) - hmc_state = HMCState(jnp.array(0), vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, + energy = vv_state.potential_energy + kinetic_fn(wa_state.inverse_mass_matrix, vv_state.r) + zero_int = jnp.array(0, dtype=jnp.result_type(int)) + hmc_state = HMCState(zero_int, vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, None, trajectory_length, - jnp.array(0), jnp.zeros(()), jnp.zeros(()), jnp.array(False), wa_state, rng_key_hmc) + zero_int, jnp.zeros(()), jnp.zeros(()), jnp.array(False), wa_state, rng_key_hmc) return device_put(hmc_state) def _hmc_next(step_size, inverse_mass_matrix, vv_state, @@ -261,7 +269,7 @@ def _hmc_next(step_size, inverse_mass_matrix, vv_state, _, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) # no need to spend too many steps if the state z has 0 size (i.e. z is empty) - if inverse_mass_matrix.shape[0] == 0: + if len(inverse_mass_matrix) == 0: num_steps = 1 else: num_steps = _get_num_steps(step_size, trajectory_length) @@ -374,12 +382,39 @@ class HMC(MCMCKernel): :param float step_size: Determines the size of a single step taken by the verlet integrator while computing the trajectory using Hamiltonian dynamics. If not specified, it will be set to 1. + :param inverse_mass_matrix: Initial value for inverse mass matrix. + This may be adapted during warmup if adapt_mass_matrix = True. + If no value is specified, then it is initialized to the identity matrix. + For a potential_fn with general JAX pytree parameters, the order of entries + of the mass matrix is the order of the flattened version of pytree parameters + obtained with `jax.tree_flatten`, which is a bit ambiguous (see more at + https://jax.readthedocs.io/en/latest/pytrees.html). If `model` is not None, + here we can specify a structured block mass matrix as a dictionary, where + keys are tuple of site names and values are the corresponding block of the + mass matrix. + For more information about structured mass matrix, see `dense_mass` argument. + :type inverse_mass_matrix: numpy.ndarray or dict :param bool adapt_step_size: A flag to decide if we want to adapt step_size during warm-up phase using Dual Averaging scheme. :param bool adapt_mass_matrix: A flag to decide if we want to adapt mass matrix during warm-up phase using Welford scheme. - :param bool dense_mass: A flag to decide if mass matrix is dense or - diagonal (default when ``dense_mass=False``) + :param dense_mass: This flag controls whether mass matrix is dense (i.e. full-rank) or + diagonal (defaults to ``dense_mass=False``). To specify a structured mass matrix, + users can provide a list of tuples of site names. Each tuple represents + a block in the joint mass matrix. For example, assuming that the model + has latent variables "x", "y", "z" (where each variable can be multi-dimensional), + possible specifications and corresponding mass matrix structures are as follows: + + + dense_mass=[("x", "y")]: use a dense mass matrix for the joint + (x, y) and a diagonal mass matrix for z + + dense_mass=[] (equivalent to dense_mass=False): use a diagonal mass + matrix for the joint (x, y, z) + + dense_mass=[("x", "y", "z")] (equivalent to full_mass=True): + use a dense mass matrix for the joint (x, y, z) + + dense_mass=[("x",), ("y",), ("z")]: use dense mass matrices for + each of x, y, and z (i.e. block-diagonal with 3 blocks) + + :type dense_mass: bool or list :param float target_accept_prob: Target acceptance probability for step size adaptation using Dual Averaging. Increasing this value will lead to a smaller step size, hence the sampling will be slower but more robust. Default to 0.8. @@ -402,6 +437,7 @@ def __init__(self, potential_fn=None, kinetic_fn=None, step_size=1.0, + inverse_mass_matrix=None, adapt_step_size=True, adapt_mass_matrix=True, dense_mass=False, @@ -416,6 +452,7 @@ def __init__(self, self._potential_fn = potential_fn self._kinetic_fn = kinetic_fn if kinetic_fn is not None else euclidean_kinetic_energy self._step_size = float(step_size) if isinstance(step_size, int) else step_size + self._inverse_mass_matrix = inverse_mass_matrix self._adapt_step_size = adapt_step_size self._adapt_mass_matrix = adapt_mass_matrix self._dense_mass = dense_mass @@ -485,13 +522,26 @@ def init(self, rng_key, num_warmup, init_params=None, model_args=(), model_kwarg raise ValueError('Valid value of `init_params` must be provided with' ' `potential_fn`.') + # change dense_mass to a structural form + dense_mass = self._dense_mass + inverse_mass_matrix = self._inverse_mass_matrix + if self._model is not None: + z = init_params[0] if isinstance(init_params, ParamInfo) else init_params + if isinstance(dense_mass, bool): + # XXX: by default, the order variables are sorted by their names, + # this is to be compatible with older numpyro versions + # and to match autoguide scale parameter and jax flatten utils + dense_mass = [tuple(sorted(z))] if dense_mass else [] + assert isinstance(dense_mass, list) + hmc_init_fn = lambda init_params, rng_key: self._init_fn( # noqa: E731 init_params, num_warmup=num_warmup, step_size=self._step_size, + inverse_mass_matrix=inverse_mass_matrix, adapt_step_size=self._adapt_step_size, adapt_mass_matrix=self._adapt_mass_matrix, - dense_mass=self._dense_mass, + dense_mass=dense_mass, target_accept_prob=self._target_accept_prob, trajectory_length=self._trajectory_length, max_tree_depth=self._max_tree_depth, @@ -556,12 +606,39 @@ class NUTS(HMC): :param float step_size: Determines the size of a single step taken by the verlet integrator while computing the trajectory using Hamiltonian dynamics. If not specified, it will be set to 1. + :param inverse_mass_matrix: Initial value for inverse mass matrix. + This may be adapted during warmup if adapt_mass_matrix = True. + If no value is specified, then it is initialized to the identity matrix. + For a potential_fn with general JAX pytree parameters, the order of entries + of the mass matrix is the order of the flattened version of pytree parameters + obtained with `jax.tree_flatten`, which is a bit ambiguous (see more at + https://jax.readthedocs.io/en/latest/pytrees.html). If `model` is not None, + here we can specify a structured block mass matrix as a dictionary, where + keys are tuple of site names and values are the corresponding block of the + mass matrix. + For more information about structured mass matrix, see `dense_mass` argument. + :type inverse_mass_matrix: numpy.ndarray or dict :param bool adapt_step_size: A flag to decide if we want to adapt step_size during warm-up phase using Dual Averaging scheme. :param bool adapt_mass_matrix: A flag to decide if we want to adapt mass matrix during warm-up phase using Welford scheme. - :param bool dense_mass: A flag to decide if mass matrix is dense or - diagonal (default when ``dense_mass=False``) + :param dense_mass: This flag controls whether mass matrix is dense (i.e. full-rank) or + diagonal (defaults to ``dense_mass=False``). To specify a structured mass matrix, + users can provide a list of tuples of site names. Each tuple represents + a block in the joint mass matrix. For example, assuming that the model + has latent variables "x", "y", "z" (where each variable can be multi-dimensional), + possible specifications and corresponding mass matrix structures are as follows: + + + dense_mass=[("x", "y")]: use a dense mass matrix for the joint + (x, y) and a diagonal mass matrix for z + + dense_mass=[] (equivalent to dense_mass=False): use a diagonal mass + matrix for the joint (x, y, z) + + dense_mass=[("x", "y", "z")] (equivalent to full_mass=True): + use a dense mass matrix for the joint (x, y, z) + + dense_mass=[("x",), ("y",), ("z")]: use dense mass matrices for + each of x, y, and z (i.e. block-diagonal with 3 blocks) + + :type dense_mass: bool or list :param float target_accept_prob: Target acceptance probability for step size adaptation using Dual Averaging. Increasing this value will lead to a smaller step size, hence the sampling will be slower but more robust. Default to 0.8. @@ -586,6 +663,7 @@ def __init__(self, potential_fn=None, kinetic_fn=None, step_size=1.0, + inverse_mass_matrix=None, adapt_step_size=True, adapt_mass_matrix=True, dense_mass=False, @@ -596,7 +674,8 @@ def __init__(self, find_heuristic_step_size=False, forward_mode_differentiation=False): super(NUTS, self).__init__(potential_fn=potential_fn, model=model, kinetic_fn=kinetic_fn, - step_size=step_size, adapt_step_size=adapt_step_size, + step_size=step_size, inverse_mass_matrix=inverse_mass_matrix, + adapt_step_size=adapt_step_size, adapt_mass_matrix=adapt_mass_matrix, dense_mass=dense_mass, target_accept_prob=target_accept_prob, trajectory_length=trajectory_length, diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 09370f7a2..765423cdd 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -1,7 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -from collections import namedtuple +from collections import OrderedDict, namedtuple from jax import grad, jacfwd, random, value_and_grad, vmap from jax.flatten_util import ravel_pytree @@ -71,10 +71,10 @@ def init_fn(prox_center=0.): pulls the primal sequence towards it. Defaults to 0. :return: initial state for the scheme. """ - x_t = 0. - x_avg = 0. # average of primal sequence - g_avg = 0. # average of dual sequence - t = 0 + x_t = jnp.zeros(()) + x_avg = jnp.zeros(()) # average of primal sequence + g_avg = jnp.zeros(()) # average of dual sequence + t = jnp.array(0, dtype=jnp.result_type(int)) return x_t, x_avg, g_avg, t, prox_center def update_fn(g, state): @@ -118,14 +118,24 @@ def welford_covariance(diagonal=True): """ def init_fn(size): """ - :param int size: size of each sample. + :param int size: size of each sample. For a structured mass matrix, + this is a dict mapping from tuples of site names to the shape + of the mass matrix. :return: initial state for the scheme. """ - mean = jnp.zeros(size) - if diagonal: - m2 = jnp.zeros(size) + if isinstance(size, dict): + state = {} + for site_names, size_block in size.items(): + state[site_names] = init_fn(size_block) + return state + + if isinstance(size, int): + shape = (size,) if diagonal else (size, size) else: - m2 = jnp.zeros((size, size)) + shape = size + + mean = jnp.zeros(shape[-1]) + m2 = jnp.zeros(shape) n = 0 return mean, m2, n @@ -135,12 +145,21 @@ def update_fn(sample, state): :param state: Current state of the scheme. :return: new state for the scheme. """ + if isinstance(state, dict): + assert isinstance(sample, dict) + new_state = {} + for site_names, state_block in state.items(): + sample_block = tuple(sample[k] for k in site_names) + new_state[site_names] = update_fn(sample_block, state_block) + return new_state + + sample, _ = ravel_pytree(sample) mean, m2, n = state n = n + 1 delta_pre = sample - mean mean = mean + delta_pre / n delta_post = sample - mean - if diagonal: + if jnp.ndim(m2) == 1: m2 = m2 + delta_pre * delta_post else: m2 = m2 + jnp.outer(delta_post, delta_pre) @@ -153,6 +172,16 @@ def final_fn(state, regularize=False): :return: a triple of estimated covariance, the square root of precision, and the inverse of that square root. """ + if isinstance(state, dict): + cov, cov_inv_sqrt, tril_inv = {}, {}, {} + for site_names, state_block in state.items(): + cov_block, cov_inv_sqrt_block, tril_inv_block = final_fn( + state_block, regularize=regularize) + cov[site_names] = cov_block + cov_inv_sqrt[site_names] = cov_inv_sqrt_block + tril_inv[site_names] = tril_inv_block + return cov, cov_inv_sqrt, tril_inv + mean, m2, n = state # XXX it is not necessary to check for the case n=1 cov = m2 / (n - 1) @@ -160,7 +189,7 @@ def final_fn(state, regularize=False): # Regularization from Stan scaled_cov = (n / (n + 5)) * cov shrinkage = 1e-3 * (5 / (n + 5)) - if diagonal: + if jnp.ndim(scaled_cov) == 1: cov = scaled_cov + shrinkage else: cov = scaled_cov + shrinkage * jnp.identity(mean.shape[0]) @@ -350,6 +379,69 @@ def build_adaptation_schedule(num_steps): return adaptation_schedule +def _initialize_mass_matrix(z, inverse_mass_matrix, dense_mass): + if isinstance(dense_mass, list): + if inverse_mass_matrix is None: + inverse_mass_matrix = {} + # if user specifies an ndarray mass matrix, then we convert it to a dict + elif not isinstance(inverse_mass_matrix, dict): + inverse_mass_matrix = {tuple(sorted(z)): inverse_mass_matrix} + mass_matrix_sqrt = {} + mass_matrix_sqrt_inv = {} + for site_names in dense_mass: + inverse_mm = inverse_mass_matrix.get(site_names) + z_block = tuple(z[k] for k in site_names) + inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix(z_block, inverse_mm, True) + inverse_mass_matrix[site_names] = inverse_mm + mass_matrix_sqrt[site_names] = mm_sqrt + mass_matrix_sqrt_inv[site_names] = mm_sqrt_inv + # NB: this branch only happens when users want to use block diagonal + # inverse_mass_matrix, for example, {("a",): jnp.ones(3), ("b",): jnp.ones(3)}. + for site_names, inverse_mm in inverse_mass_matrix.items(): + if site_names in dense_mass: + continue + z_block = tuple(z[k] for k in site_names) + inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix(z_block, inverse_mm, False) + inverse_mass_matrix[site_names] = inverse_mm + mass_matrix_sqrt[site_names] = mm_sqrt + mass_matrix_sqrt_inv[site_names] = mm_sqrt_inv + remaining_sites = tuple(sorted(set(z) - set().union(*inverse_mass_matrix))) + if len(remaining_sites) > 0: + z_block = tuple(z[k] for k in remaining_sites) + inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix(z_block, None, False) + inverse_mass_matrix[remaining_sites] = inverse_mm + mass_matrix_sqrt[remaining_sites] = mm_sqrt + mass_matrix_sqrt_inv[remaining_sites] = mm_sqrt_inv + expected_site_names = sorted(z) + actual_site_names = sorted([k for site_names in inverse_mass_matrix for k in site_names]) + assert actual_site_names == expected_site_names, \ + ("There seems to be a conflict of sites names specified in the initial" + " `inverse_mass_matrix` and in `dense_mass` argument.") + return inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv + + mass_matrix_size = jnp.size(ravel_pytree(z)[0]) + if inverse_mass_matrix is None: + if dense_mass: + inverse_mass_matrix = jnp.identity(mass_matrix_size) + else: + inverse_mass_matrix = jnp.ones(mass_matrix_size) + mass_matrix_sqrt = mass_matrix_sqrt_inv = inverse_mass_matrix + else: + if dense_mass: + if jnp.ndim(inverse_mass_matrix) == 1: + inverse_mass_matrix = jnp.diag(inverse_mass_matrix) + mass_matrix_sqrt_inv = jnp.swapaxes(jnp.linalg.cholesky( + inverse_mass_matrix[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1) + identity = jnp.identity(inverse_mass_matrix.shape[-1]) + mass_matrix_sqrt = solve_triangular(mass_matrix_sqrt_inv, identity, lower=True) + else: + if jnp.ndim(inverse_mass_matrix) == 2: + inverse_mass_matrix = jnp.diag(inverse_mass_matrix) + mass_matrix_sqrt_inv = jnp.sqrt(inverse_mass_matrix) + mass_matrix_sqrt = jnp.reciprocal(mass_matrix_sqrt_inv) + return inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv + + def warmup_adapter(num_adapt_steps, find_reasonable_step_size=None, adapt_step_size=True, adapt_mass_matrix=True, dense_mass=False, target_accept_prob=0.8): @@ -390,30 +482,21 @@ def init_fn(z_info, rng_key, step_size=1.0, inverse_mass_matrix=None, mass_matri :return: initial state of the adapt scheme. """ rng_key, rng_key_ss = random.split(rng_key) - if inverse_mass_matrix is None: - assert mass_matrix_size is not None - if dense_mass: - inverse_mass_matrix = jnp.identity(mass_matrix_size) - else: - inverse_mass_matrix = jnp.ones(mass_matrix_size) - mass_matrix_sqrt = mass_matrix_sqrt_inv = inverse_mass_matrix - else: - if dense_mass: - mass_matrix_sqrt_inv = jnp.swapaxes(jnp.linalg.cholesky( - inverse_mass_matrix[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1) - identity = jnp.identity(inverse_mass_matrix.shape[-1]) - mass_matrix_sqrt = solve_triangular(mass_matrix_sqrt_inv, identity, lower=True) - else: - mass_matrix_sqrt_inv = jnp.sqrt(inverse_mass_matrix) - mass_matrix_sqrt = jnp.reciprocal(mass_matrix_sqrt_inv) + inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv = _initialize_mass_matrix( + z_info[0], inverse_mass_matrix, dense_mass + ) if adapt_step_size: step_size = find_reasonable_step_size(step_size, inverse_mass_matrix, z_info, rng_key_ss) ss_state = ss_init(jnp.log(10 * step_size)) - mm_state = mm_init(inverse_mass_matrix.shape[-1]) + if isinstance(inverse_mass_matrix, dict): + size = {k: v.shape for k, v in inverse_mass_matrix.items()} + else: + size = inverse_mass_matrix.shape[-1] + mm_state = mm_init(size) - window_idx = 0 + window_idx = jnp.array(0, dtype=jnp.result_type(int)) return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, ss_state, mm_state, window_idx, rng_key) @@ -423,7 +506,11 @@ def _update_at_window_end(z_info, rng_key_ss, state): if adapt_mass_matrix: inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv = mm_final(mm_state, regularize=True) - mm_state = mm_init(inverse_mass_matrix.shape[-1]) + if isinstance(inverse_mass_matrix, dict): + size = {k: v.shape for k, v in inverse_mass_matrix.items()} + else: + size = inverse_mass_matrix.shape[-1] + mm_state = mm_init(size) if adapt_step_size: step_size = find_reasonable_step_size(step_size, inverse_mass_matrix, z_info, rng_key_ss) @@ -465,9 +552,8 @@ def update_fn(t, accept_prob, z_info, state): is_middle_window = (0 < window_idx) & (window_idx < (num_windows - 1)) if adapt_mass_matrix: z = z_info[0] - z_flat, _ = ravel_pytree(z) mm_state = cond(is_middle_window, - (z_flat, mm_state), lambda args: mm_update(*args), + (z, mm_state), lambda args: mm_update(*args), mm_state, identity) t_at_window_end = t == adaptation_schedule[window_idx, 1] @@ -482,7 +568,18 @@ def update_fn(t, accept_prob, z_info, state): return init_fn, update_fn -def _is_turning(inverse_mass_matrix, r_left, r_right, r_sum): +def _momentum_angle(inverse_mass_matrix, r_left, r_right, r_sum): + if isinstance(inverse_mass_matrix, dict): + left_angle, right_angle = jnp.zeros(()), jnp.zeros(()) + for site_names, inverse_mm in inverse_mass_matrix.items(): + r_left_b = tuple(r_left[k] for k in site_names) + r_right_b = tuple(r_right[k] for k in site_names) + r_sum_b = tuple(r_sum[k] for k in site_names) + left_a, right_a = _momentum_angle(inverse_mm, r_left_b, r_right_b, r_sum_b) + left_angle = left_angle + left_a + right_angle = right_angle + right_a + return left_angle, right_angle + r_left, _ = ravel_pytree(r_left) r_right, _ = ravel_pytree(r_right) r_sum, _ = ravel_pytree(r_sum) @@ -498,8 +595,13 @@ def _is_turning(inverse_mass_matrix, r_left, r_right, r_sum): # This implements dynamic termination criterion (ref [2], section A.4.2). r_sum = r_sum - (r_left + r_right) / 2 - turning_at_left = jnp.dot(v_left, r_sum) <= 0 - turning_at_right = jnp.dot(v_right, r_sum) <= 0 + return jnp.dot(v_left, r_sum), jnp.dot(v_right, r_sum) + + +def _is_turning(inverse_mass_matrix, r_left, r_right, r_sum): + left_angle, right_angle = _momentum_angle(inverse_mass_matrix, r_left, r_right, r_sum) + turning_at_left = left_angle <= 0 + turning_at_right = right_angle <= 0 return turning_at_left | turning_at_right @@ -631,11 +733,14 @@ def _leaf_idx_to_ckpt_idxs(n): return idx_min, idx_max -def _is_iterative_turning(inverse_mass_matrix, r, r_sum, r_ckpts, r_sum_ckpts, idx_min, idx_max): +def _is_iterative_turning(inverse_mass_matrix, r, r_sum, r_ckpts, r_sum_ckpts, idx_min, idx_max, + unravel_fn=identity): def _body_fn(state): i, _ = state subtree_r_sum = r_sum - r_sum_ckpts[i] + r_ckpts[i] - return i - 1, _is_turning(inverse_mass_matrix, r_ckpts[i], r, subtree_r_sum) + subtree_r_sum = unravel_fn(subtree_r_sum) + r_left = unravel_fn(r_ckpts[i]) + return i - 1, _is_turning(inverse_mass_matrix, r_left, r, subtree_r_sum) _, turning = while_loop(lambda it: (it[0] >= idx_min) & ~it[1], _body_fn, @@ -669,7 +774,7 @@ def _body_fn(state): # NB: in the special case leaf_idx=0, ckpt_idx_min=1 and ckpt_idx_max=0, # the following logic is still valid for that case ckpt_idx_min, ckpt_idx_max = _leaf_idx_to_ckpt_idxs(leaf_idx) - r, _ = ravel_pytree(new_leaf.r_right) + r, unravel_fn = ravel_pytree(new_leaf.r_right) r_sum, _ = ravel_pytree(new_tree.r_sum) # we update checkpoints when leaf_idx is even r_ckpts, r_sum_ckpts = cond(leaf_idx % 2 == 0, @@ -679,8 +784,9 @@ def _body_fn(state): (r_ckpts, r_sum_ckpts), identity) - turning = _is_iterative_turning(inverse_mass_matrix, r, r_sum, r_ckpts, r_sum_ckpts, - ckpt_idx_min, ckpt_idx_max) + turning = _is_iterative_turning(inverse_mass_matrix, new_leaf.r_right, r_sum, + r_ckpts, r_sum_ckpts, + ckpt_idx_min, ckpt_idx_max, unravel_fn) return new_tree, turning, r_ckpts, r_sum_ckpts, rng_key basetree = prototype_tree._replace(num_proposals=0) @@ -725,12 +831,15 @@ def build_tree(verlet_update, kinetic_fn, verlet_state, inverse_mass_matrix, ste """ z, r, potential_energy, z_grad = verlet_state energy_current = potential_energy + kinetic_fn(inverse_mass_matrix, r) - r_ckpts = jnp.zeros((max_tree_depth, inverse_mass_matrix.shape[-1])) - r_sum_ckpts = jnp.zeros((max_tree_depth, inverse_mass_matrix.shape[-1])) + latent_size = jnp.size(ravel_pytree(r)[0]) + r_ckpts = jnp.zeros((max_tree_depth, latent_size)) + r_sum_ckpts = jnp.zeros((max_tree_depth, latent_size)) tree = TreeInfo(z, r, z_grad, z, r, z_grad, z, potential_energy, z_grad, energy_current, - depth=0, weight=0., r_sum=r, turning=False, diverging=False, - sum_accept_probs=0., num_proposals=0) + depth=0, weight=jnp.zeros(()), r_sum=r, turning=jnp.array(False), + diverging=jnp.array(False), + sum_accept_probs=jnp.zeros(()), + num_proposals=jnp.array(0, dtype=jnp.result_type(int))) def _cond_fn(state): tree, _ = state @@ -751,6 +860,13 @@ def _body_fn(state): def euclidean_kinetic_energy(inverse_mass_matrix, r): + if isinstance(inverse_mass_matrix, dict): + ke = jnp.zeros(()) + for site_names, inverse_mm in inverse_mass_matrix.items(): + r_block = tuple(r[k] for k in site_names) + ke = ke + euclidean_kinetic_energy(inverse_mm, r_block) + return ke + r, _ = ravel_pytree(r) if inverse_mass_matrix.ndim == 2: @@ -764,6 +880,13 @@ def euclidean_kinetic_energy(inverse_mass_matrix, r): def _euclidean_kinetic_energy_grad(inverse_mass_matrix, r): + if isinstance(inverse_mass_matrix, dict): + r_grad = {} + for site_names, inverse_mm in inverse_mass_matrix.items(): + r_block = OrderedDict([(k, r[k]) for k in site_names]) + r_grad.update(_euclidean_kinetic_energy_grad(inverse_mm, r_block)) + return r_grad + r, unravel_fn = ravel_pytree(r) if inverse_mass_matrix.ndim == 2: diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index e48017ff5..73e657f65 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -47,7 +47,7 @@ def log_density(model, model_args, model_kwargs, params): """ model = substitute(model, data=params) model_trace = trace(model).get_trace(*model_args, **model_kwargs) - log_joint = jnp.array(0.) + log_joint = jnp.zeros(()) for site in model_trace.values(): if site['type'] == 'sample': value = site['value'] diff --git a/test/infer/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py index 73a096cb1..ea3ab0332 100644 --- a/test/infer/test_hmc_gibbs.py +++ b/test/infer/test_hmc_gibbs.py @@ -101,7 +101,7 @@ def model(X, Y): @pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) -def test_gaussian_model(kernel_cls, D=2, warmup_steps=3000, num_samples=5000): +def test_gaussian_model(kernel_cls, D=2, warmup_steps=5000, num_samples=5000): np.random.seed(0) cov = np.random.randn(4 * D * D).reshape((2 * D, 2 * D)) cov = jnp.matmul(jnp.transpose(cov), cov) + 0.25 * jnp.eye(2 * D) diff --git a/test/infer/test_infer_util.py b/test/infer/test_infer_util.py index 2024b58e2..c0900390a 100644 --- a/test/infer/test_infer_util.py +++ b/test/infer/test_infer_util.py @@ -186,7 +186,7 @@ def model(): kernel = NUTS(model) mcmc = MCMC(kernel, num_warmup=500, num_samples=500, num_chains=1) mcmc.run(random.PRNGKey(1)) - assert_allclose(mcmc.get_samples()['x'].mean(), 0., atol=0.1) + assert_allclose(mcmc.get_samples()['x'].mean(), 0., atol=0.15) @pytest.mark.parametrize('init_strategy', [ diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index aeaaadb23..da53dcee2 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -236,6 +236,8 @@ def model(): mcmc.run(random.PRNGKey(0)) mass_matrix_sqrt = mcmc.last_state.adapt_state.mass_matrix_sqrt + if kernel_cls is HMC or kernel_cls is NUTS: + mass_matrix_sqrt = mass_matrix_sqrt[("x",)] mass_matrix = jnp.matmul(mass_matrix_sqrt, jnp.transpose(mass_matrix_sqrt)) estimated_cov = jnp.linalg.inv(mass_matrix) assert_allclose(estimated_cov, true_cov, rtol=0.10) @@ -739,3 +741,95 @@ def model(data): nuts_kernel = NUTS(numpyro.handlers.lift(model, prior={"c": dist.Gamma(0.01, 0.01)})) mcmc = MCMC(nuts_kernel, num_warmup=10, num_samples=10) mcmc.run(random.PRNGKey(1), jnp.exp(random.normal(random.PRNGKey(0), (1000,)))) + + +def test_structured_mass(): + def model(cov): + w = numpyro.sample("w", dist.Normal(0, 1000).expand([2]).to_event(1)) + x = numpyro.sample("x", dist.Normal(0, 1000).expand([1]).to_event(1)) + y = numpyro.sample("y", dist.Normal(0, 1000).expand([1]).to_event(1)) + z = numpyro.sample("z", dist.Normal(0, 1000).expand([1]).to_event(1)) + wxyz = jnp.concatenate([w, x, y, z]) + numpyro.sample("obs", dist.MultivariateNormal(jnp.zeros(5), cov), obs=wxyz) + + w_cov = np.array([[1.5, 0.5], [0.5, 1.5]]) + xy_cov = np.array([[2., 1.], [1., 3.]]) + z_var = np.array([2.5]) + cov = np.zeros((5, 5)) + cov[:2, :2] = w_cov + cov[2:4, 2:4] = xy_cov + cov[4, 4] = z_var + + kernel = NUTS(model, dense_mass=[("w",), ("x", "y")]) + mcmc = MCMC(kernel, num_warmup=1000, num_samples=1) + mcmc.run(random.PRNGKey(1), cov) + inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix + assert_allclose(inverse_mass_matrix[("w",)], w_cov, atol=0.5, rtol=0.5) + assert_allclose(inverse_mass_matrix[("x", "y")], xy_cov, atol=0.5, rtol=0.5) + assert_allclose(inverse_mass_matrix[("z",)], z_var, atol=0.5, rtol=0.5) + + kernel = NUTS(model, dense_mass=[("w",), ("y", "x")]) + mcmc = MCMC(kernel, num_warmup=1000, num_samples=1) + mcmc.run(random.PRNGKey(1), cov) + inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix + assert_allclose(inverse_mass_matrix[("w",)], w_cov, atol=0.5, rtol=0.5) + assert_allclose(inverse_mass_matrix[("y", "x")], xy_cov[::-1, ::-1], atol=0.5, rtol=0.5) + assert_allclose(inverse_mass_matrix[("z",)], z_var, atol=0.5, rtol=0.5) + + +@pytest.mark.parametrize("dense_mass, expected_shapes", [ + (False, {("w", "x", "y", "z"): (16,)}), + (True, {("w", "x", "y", "z"): (16, 16)}), + ([("y", "w", "z", "x")], {("y", "w", "z", "x"): (16, 16)}), + ([("x", "w"), ("y",)], {("x", "w"): (11, 11), ("y",): (4, 4), ("z",): (1,)}), + ([("y",)], {("w", "x", "z"): (12,), ("y",): (4, 4)}), + ([("z",), ("w",), ("y",)], {("w",): (10, 10), ("x",): (1,), ("y",): (4, 4), ("z",): (1, 1)}), +]) +def test_structured_mass_smoke(dense_mass, expected_shapes): + def model(): + numpyro.sample("x", dist.Normal(0, 1)) + numpyro.sample("y", dist.Normal(0, 1).expand([4])) + numpyro.sample("w", dist.Normal(0, 1).expand([2, 5])) + numpyro.sample("z", dist.Normal(0, 1).expand([1])) + + kernel = NUTS(model, dense_mass=dense_mass) + mcmc = MCMC(kernel, num_warmup=0, num_samples=1) + mcmc.run(random.PRNGKey(0)) + inverse_mm = mcmc.last_state.adapt_state.inverse_mass_matrix + actual_shapes = {k: v.shape for k, v in inverse_mm.items()} + assert expected_shapes == actual_shapes + + +@pytest.mark.parametrize("dense_mass", [[("x",)], False]) +def test_initial_inverse_mass_matrix(dense_mass): + def model(): + numpyro.sample("x", dist.Normal(0, 1).expand([3])) + numpyro.sample("z", dist.Normal(0, 1).expand([2])) + + expected_mm = jnp.arange(1, 4.) + kernel = NUTS(model, dense_mass=dense_mass, + inverse_mass_matrix={("x",): expected_mm}, adapt_mass_matrix=False) + mcmc = MCMC(kernel, 1, 1) + mcmc.run(random.PRNGKey(0)) + inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix + assert set(inverse_mass_matrix.keys()) == {("x",), ("z",)} + expected_mm = jnp.diag(expected_mm) if dense_mass else expected_mm + assert_allclose(inverse_mass_matrix[("x",)], expected_mm) + assert_allclose(inverse_mass_matrix[("z",)], jnp.ones(2)) + + +@pytest.mark.parametrize("dense_mass", [True, False]) +def test_initial_inverse_mass_matrix_ndarray(dense_mass): + def model(): + numpyro.sample("z", dist.Normal(0, 1).expand([2])) + numpyro.sample("x", dist.Normal(0, 1).expand([3])) + + expected_mm = jnp.arange(1, 6.) + kernel = NUTS(model, dense_mass=dense_mass, + inverse_mass_matrix=expected_mm, adapt_mass_matrix=False) + mcmc = MCMC(kernel, 1, 1) + mcmc.run(random.PRNGKey(0)) + inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix + assert set(inverse_mass_matrix.keys()) == {("x", "z")} + expected_mm = jnp.diag(expected_mm) if dense_mass else expected_mm + assert_allclose(inverse_mass_matrix[("x", "z")], expected_mm) diff --git a/test/test_handlers.py b/test/test_handlers.py index d868792c0..fea7fe00b 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -585,6 +585,7 @@ def model(): model() +@pytest.mark.xfail(reason="Issue: https://github.com/pyro-ppl/numpyro/issues/964") def test_collapse_beta_binomial(): total_count = 10 data = 3. From ed7cbf1835c1c26021a4476f4643e14a01534cd0 Mon Sep 17 00:00:00 2001 From: Alexander Hoyle Date: Fri, 19 Mar 2021 11:04:58 -0400 Subject: [PATCH 080/222] Clarify `epoch_train` and `eval_test` in VAE example (#965) * changed reliance on global scope * mark test per 965#issuecomment-802516024 * add missing blank line for pep8 --- examples/vae.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/examples/vae.py b/examples/vae.py index 4d8ec0b2f..247f8a6e8 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -82,7 +82,7 @@ def main(args): svi_state = svi.init(rng_key_init, sample_batch) @jit - def epoch_train(svi_state, rng_key): + def epoch_train(svi_state, rng_key, train_idx): def body_fn(i, val): loss_sum, svi_state = val rng_key_binarize = random.fold_in(rng_key, i) @@ -94,7 +94,7 @@ def body_fn(i, val): return lax.fori_loop(0, num_train, body_fn, (0., svi_state)) @jit - def eval_test(svi_state, rng_key): + def eval_test(svi_state, rng_key, test_idx): def body_fun(i, loss_sum): rng_key_binarize = random.fold_in(rng_key, i) batch = binarize(rng_key_binarize, test_fetch(i, test_idx)[0]) @@ -122,10 +122,10 @@ def reconstruct_img(epoch, rng_key): rng_key, rng_key_train, rng_key_test, rng_key_reconstruct = random.split(rng_key, 4) t_start = time.time() num_train, train_idx = train_init() - _, svi_state = epoch_train(svi_state, rng_key_train) + _, svi_state = epoch_train(svi_state, rng_key_train, train_idx) rng_key, rng_key_test, rng_key_reconstruct = random.split(rng_key, 3) num_test, test_idx = test_init() - test_loss = eval_test(svi_state, rng_key_test) + test_loss = eval_test(svi_state, rng_key_test, test_idx) reconstruct_img(i, rng_key_reconstruct) print("Epoch {}: loss = {} ({:.2f} s.)".format(i, test_loss, time.time() - t_start)) From 2136d1e72d15d40b46fc9a0a09c4dbd38e8f9f00 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 20 Mar 2021 19:45:12 -0500 Subject: [PATCH 081/222] update hmc docs (#966) --- numpyro/infer/hmc.py | 30 +++++++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 64b28d52b..5de5d9357 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -191,15 +191,39 @@ def init_kernel(init_params, :param float step_size: Determines the size of a single step taken by the verlet integrator while computing the trajectory using Hamiltonian dynamics. If not specified, it will be set to 1. - :param numpy.ndarray inverse_mass_matrix: Initial value for inverse mass matrix. + :param inverse_mass_matrix: Initial value for inverse mass matrix. This may be adapted during warmup if adapt_mass_matrix = True. If no value is specified, then it is initialized to the identity matrix. + For a potential_fn with general JAX pytree parameters, the order of entries + of the mass matrix is the order of the flattened version of pytree parameters + obtained with `jax.tree_flatten`, which is a bit ambiguous (see more at + https://jax.readthedocs.io/en/latest/pytrees.html). If `model` is not None, + here we can specify a structured block mass matrix as a dictionary, where + keys are tuple of site names and values are the corresponding block of the + mass matrix. + For more information about structured mass matrix, see `dense_mass` argument. + :type inverse_mass_matrix: numpy.ndarray or dict :param bool adapt_step_size: A flag to decide if we want to adapt step_size during warm-up phase using Dual Averaging scheme. :param bool adapt_mass_matrix: A flag to decide if we want to adapt mass matrix during warm-up phase using Welford scheme. - :param bool dense_mass: A flag to decide if mass matrix is dense or - diagonal (default when ``dense_mass=False``) + :param dense_mass: This flag controls whether mass matrix is dense (i.e. full-rank) or + diagonal (defaults to ``dense_mass=False``). To specify a structured mass matrix, + users can provide a list of tuples of site names. Each tuple represents + a block in the joint mass matrix. For example, assuming that the model + has latent variables "x", "y", "z" (where each variable can be multi-dimensional), + possible specifications and corresponding mass matrix structures are as follows: + + + dense_mass=[("x", "y")]: use a dense mass matrix for the joint + (x, y) and a diagonal mass matrix for z + + dense_mass=[] (equivalent to dense_mass=False): use a diagonal mass + matrix for the joint (x, y, z) + + dense_mass=[("x", "y", "z")] (equivalent to full_mass=True): + use a dense mass matrix for the joint (x, y, z) + + dense_mass=[("x",), ("y",), ("z")]: use dense mass matrices for + each of x, y, and z (i.e. block-diagonal with 3 blocks) + + :type dense_mass: bool or list :param float target_accept_prob: Target acceptance probability for step size adaptation using Dual Averaging. Increasing this value will lead to a smaller step size, hence the sampling will be slower but more robust. Default to 0.8. From 065c76d02a08cfa3e0579c2a2401221ec1e810a7 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 22 Mar 2021 07:58:03 -0500 Subject: [PATCH 082/222] Support pickling MCMC objects (#968) --- numpyro/infer/hmc.py | 8 ++++++ numpyro/infer/hmc_gibbs.py | 32 ++++++++++------------- numpyro/infer/mcmc.py | 5 ++++ numpyro/infer/mixed_hmc.py | 5 ++++ numpyro/infer/sa.py | 8 ++++++ test/test_handlers.py | 1 - test/test_pickle.py | 52 ++++++++++++++++++++++++++++++++++++++ 7 files changed, 91 insertions(+), 20 deletions(-) create mode 100644 test/test_pickle.py diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 5de5d9357..325579781 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -603,6 +603,14 @@ def sample(self, state, model_args, model_kwargs): """ return self._sample_fn(state, model_args, model_kwargs) + def __getstate__(self): + state = self.__dict__.copy() + state["_sample_fn"] = None + state["_init_fn"] = None + state["_postprocess_fn"] = None + state["_potential_fn_gen"] = None + return state + class NUTS(HMC): """ diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 7e92fd7ab..587ba1c46 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -28,13 +28,10 @@ """ -def _wrap_model(model): - def fn(*args, **kwargs): - gibbs_values = kwargs.pop("_gibbs_sites", {}) - with condition(data=gibbs_values), substitute(data=gibbs_values): - model(*args, **kwargs) - - return fn +def _wrap_model(model, *args, **kwargs): + gibbs_values = kwargs.pop("_gibbs_sites", {}) + with condition(data=gibbs_values), substitute(data=gibbs_values): + return model(*args, **kwargs) class HMCGibbs(MCMCKernel): @@ -94,7 +91,7 @@ def __init__(self, inner_kernel, gibbs_fn, gibbs_sites): assert inner_kernel.model is not None, "HMCGibbs does not support models specified via a potential function." self.inner_kernel = copy.copy(inner_kernel) - self.inner_kernel._model = _wrap_model(inner_kernel.model) + self.inner_kernel._model = partial(_wrap_model, inner_kernel.model) self._gibbs_sites = gibbs_sites self._gibbs_fn = gibbs_fn self._prototype_trace = None @@ -336,7 +333,7 @@ class DiscreteHMCGibbs(HMCGibbs): """ def __init__(self, inner_kernel, *, random_walk=False, modified=False): - super().__init__(inner_kernel, lambda *args: None, None) + super().__init__(inner_kernel, identity, None) self._random_walk = random_walk self._modified = modified if random_walk: @@ -439,14 +436,11 @@ def _block_update_proxy(num_blocks, rng_key, gibbs_sites, plate_sizes): "ref_subsample_log_lik_grads, ref_subsample_log_lik_hessians") -def _wrap_gibbs_state(model): - def wrapped_fn(*args, **kwargs): - # this is to let estimate_likelihood handler knows what is the current gibbs_state - msg = {"type": "_gibbs_state", "value": kwargs.pop("_gibbs_state", ())} - numpyro.primitives.apply_stack(msg) - return model(*args, **kwargs) - - return wrapped_fn +def _wrap_gibbs_state(model, *args, **kwargs): + # this is to let estimate_likelihood handler knows what is the current gibbs_state + msg = {"type": "_gibbs_state", "value": kwargs.pop("_gibbs_state", ())} + numpyro.primitives.apply_stack(msg) + return model(*args, **kwargs) class HMCECS(HMCGibbs): @@ -507,9 +501,9 @@ class HMCECS(HMCGibbs): """ def __init__(self, inner_kernel, *, num_blocks=1, proxy=None): - super().__init__(inner_kernel, lambda *args: None, None) + super().__init__(inner_kernel, identity, None) - self.inner_kernel._model = _wrap_gibbs_state(self.inner_kernel._model) + self.inner_kernel._model = partial(_wrap_gibbs_state, self.inner_kernel._model) self._num_blocks = num_blocks self._proxy = proxy diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index a992ee0ba..fe0f9c347 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -563,3 +563,8 @@ def print_summary(self, prob=0.9, exclude_deterministic=True): extra_fields = self.get_extra_fields() if 'diverging' in extra_fields: print("Number of divergences: {}".format(jnp.sum(extra_fields['diverging']))) + + def __getstate__(self): + state = self.__dict__.copy() + state["_cache"] = {} + return state diff --git a/numpyro/infer/mixed_hmc.py b/numpyro/infer/mixed_hmc.py index 57a173a89..73a285e6b 100644 --- a/numpyro/infer/mixed_hmc.py +++ b/numpyro/infer/mixed_hmc.py @@ -219,3 +219,8 @@ def body_fn(i, vals): z = {**z_discrete, **hmc_state.z} return MixedHMCState(z, hmc_state, rng_key, accept_prob) + + def __getstate__(self): + state = self.__dict__.copy() + state["_wa_update"] = None + return state diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index 4b8525289..5959423ee 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -332,3 +332,11 @@ def sample(self, state, model_args, model_kwargs): :return: Next `state` after running SA. """ return self._sample_fn(state, model_args, model_kwargs) + + def __getstate__(self): + state = self.__dict__.copy() + state["_sample_fn"] = None + state["_init_fn"] = None + state["_postprocess_fn"] = None + state["_potential_fn_gen"] = None + return state diff --git a/test/test_handlers.py b/test/test_handlers.py index fea7fe00b..d868792c0 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -585,7 +585,6 @@ def model(): model() -@pytest.mark.xfail(reason="Issue: https://github.com/pyro-ppl/numpyro/issues/964") def test_collapse_beta_binomial(): total_count = 10 data = 3. diff --git a/test/test_pickle.py b/test/test_pickle.py new file mode 100644 index 000000000..fbfcdd3c7 --- /dev/null +++ b/test/test_pickle.py @@ -0,0 +1,52 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import pickle + +import pytest + +from jax import random, test_util +import jax.numpy as jnp + +import numpyro +import numpyro.distributions as dist +from numpyro.infer import HMC, HMCECS, MCMC, NUTS, SA, DiscreteHMCGibbs, MixedHMC + + +def normal_model(): + numpyro.sample("x", dist.Normal(0, 1)) + + +def bernoulli_model(): + numpyro.sample("x", dist.Bernoulli(0.5)) + + +def logistic_regression(): + data = jnp.arange(10) + x = numpyro.sample("x", dist.Normal(0, 1)) + with numpyro.plate("N", 10, subsample_size=2): + batch = numpyro.subsample(data, 0) + numpyro.sample("obs", dist.Bernoulli(logits=x), obs=batch) + + +@pytest.mark.parametrize("kernel", [HMC, NUTS, SA]) +def test_pickle_hmc(kernel): + mcmc = MCMC(kernel(normal_model), 10, 10) + mcmc.run(random.PRNGKey(0)) + pickled_mcmc = pickle.loads(pickle.dumps(mcmc)) + test_util.check_close(mcmc.get_samples(), pickled_mcmc.get_samples()) + + +@pytest.mark.parametrize("kernel", [DiscreteHMCGibbs, MixedHMC]) +def test_pickle_discrete_hmc(kernel): + mcmc = MCMC(kernel(HMC(bernoulli_model)), 10, 10) + mcmc.run(random.PRNGKey(0)) + pickled_mcmc = pickle.loads(pickle.dumps(mcmc)) + test_util.check_close(mcmc.get_samples(), pickled_mcmc.get_samples()) + + +def test_pickle_hmcecs(): + mcmc = MCMC(HMCECS(NUTS(logistic_regression)), 10, 10) + mcmc.run(random.PRNGKey(0)) + pickled_mcmc = pickle.loads(pickle.dumps(mcmc)) + test_util.check_close(mcmc.get_samples(), pickled_mcmc.get_samples()) From 32fad82846a753e5a9e4b8b09910e6de4d8af91c Mon Sep 17 00:00:00 2001 From: Kim Date: Tue, 23 Mar 2021 00:57:54 +0100 Subject: [PATCH 083/222] Automatic rendering of probabilistic graphical models (#952) * Implement automatic visualization of model definitions * Comment model rendering functions * Add Jupyter notebook showcasing model rendering capabilities * Add ability to save rendered model to file * Update model tracing code * Make graphviz import safer * Add simple test for model rendering * Add dummy test for rendering of nested plates * Add test for link between discrete and continuous distributions * Add graphviz dependency * Improve plate detection to properly handle reused plates * Improve passing of model arguments * Simplify plate-graph access * Ensure that deeper plates are added to their parents first * Improve handling of plate order for improper RV subset relations * Use ellipse instead of circle shape for rendering RVs * Make graphviz a dev dependency * Add ability to show distribution of each RV in model rendering * Make TODO comment a NOTE * Document all arguments of 'render_model' function * Include 'render_model' in documentation * Include link to graphviz website in ImportError * Add two warnings to 'render_model' * Add more examples to model rendering notebook * Move model rendering code to numpyro.contrib.render * Fix imports in rendering tests * Format model rendering code * Add model rendering notebook to 'Introductory Tutorials' section * Improve formatting of warnings in 'render_model' docstring * Mention 'graph.format' in model rendering tutorial * Fix flake8 complaints * Add license headers --- .github/workflows/ci.yml | 1 + docs/source/index.rst | 1 + docs/source/utilities.rst | 7 + notebooks/source/index.rst | 1 + notebooks/source/model_rendering.ipynb | 559 +++++++++++++++++++++++++ numpyro/__init__.py | 2 + numpyro/contrib/render.py | 300 +++++++++++++ setup.py | 3 +- test/test_model_rendering.py | 91 ++++ 9 files changed, 964 insertions(+), 1 deletion(-) create mode 100644 notebooks/source/model_rendering.ipynb create mode 100644 numpyro/contrib/render.py create mode 100644 test/test_model_rendering.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 9ef398107..0ab485249 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -60,6 +60,7 @@ jobs: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | + sudo apt install -y graphviz python -m pip install --upgrade pip # Keep track of pyro-api master branch pip install https://github.com/pyro-ppl/pyro-api/archive/master.zip diff --git a/docs/source/index.rst b/docs/source/index.rst index 9ec8caf48..9ed708736 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -27,6 +27,7 @@ NumPyro documentation examples/vae examples/funnel examples/stochastic_volatility + tutorials/model_rendering .. nbgallery:: :maxdepth: 1 diff --git a/docs/source/utilities.rst b/docs/source/utilities.rst index cffd071b0..e16d53c1e 100644 --- a/docs/source/utilities.rst +++ b/docs/source/utilities.rst @@ -93,3 +93,10 @@ Tensor Indexing :undoc-members: :show-inheritance: :member-order: bysource + +Visualization Utilities +======================= + +render_model +------------ +.. autofunction:: numpyro.util.render_model diff --git a/notebooks/source/index.rst b/notebooks/source/index.rst index d499fae3f..879a2896a 100644 --- a/notebooks/source/index.rst +++ b/notebooks/source/index.rst @@ -16,6 +16,7 @@ Welcome to NumPyro Tutorials! ordinal_regression bayesian_hierarchical_linear_regression discrete_imputation + model_rendering Indices diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb new file mode 100644 index 000000000..bc99ca2c3 --- /dev/null +++ b/notebooks/source/model_rendering.ipynb @@ -0,0 +1,559 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "induced-highlight", + "metadata": {}, + "source": [ + "# Automatic rendering of NumPyro models\n", + "\n", + "In this tutorial we will demonstrate how to create beautiful visualizations of your probabilistic graphical models." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "recreational-forestry", + "metadata": {}, + "outputs": [], + "source": [ + "from jax import nn\n", + "import jax.numpy as jnp\n", + "\n", + "import numpyro\n", + "import numpyro.distributions as dist" + ] + }, + { + "cell_type": "markdown", + "id": "after-origin", + "metadata": {}, + "source": [ + "## A Simple Example\n", + "\n", + "The visualization interface can be readily used with your models:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "continued-rebate", + "metadata": {}, + "outputs": [], + "source": [ + "def model(data):\n", + " m = numpyro.sample('m', dist.Normal(0, 1))\n", + " sd = numpyro.sample('sd', dist.LogNormal(m, 1))\n", + " with numpyro.plate('N', len(data)):\n", + " numpyro.sample('obs', dist.Normal(m, sd), obs=data)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "impaired-solid", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_N\n", + "\n", + "N\n", + "\n", + "\n", + "\n", + "m\n", + "\n", + "m\n", + "\n", + "\n", + "\n", + "sd\n", + "\n", + "sd\n", + "\n", + "\n", + "\n", + "m->sd\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "obs\n", + "\n", + "obs\n", + "\n", + "\n", + "\n", + "m->obs\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "sd->obs\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = jnp.ones(10)\n", + "numpyro.render_model(model, model_args=(data,))" + ] + }, + { + "cell_type": "markdown", + "id": "false-qualification", + "metadata": {}, + "source": [ + "The visualization can be saved to a file by providing `filename='path'` to `numpyro.render_model`. You can use different formats such as PDF or PNG by changing the filename's suffix.\n", + "When not saving to a file (`filename=None`), you can also change the format with `graph.format = 'pdf'` where `graph` is the object returned by `numpyro.render_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "favorite-animal", + "metadata": {}, + "outputs": [], + "source": [ + "graph = numpyro.render_model(model, model_args=(data,), filename='model.pdf')" + ] + }, + { + "cell_type": "markdown", + "id": "hungarian-indianapolis", + "metadata": {}, + "source": [ + "# Tweaking the visualization\n", + "\n", + "As `numpyro.render_model` returns an object of type `graphviz.dot.Digraph`, you can further improve the visualization of this graph.\n", + "For example, you could use the [unflatten preprocessor](https://graphviz.readthedocs.io/en/stable/api.html#graphviz.unflatten) to improve the layout aspect ratio for more complex models." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "curious-commission", + "metadata": {}, + "outputs": [], + "source": [ + "def mace(positions, annotations):\n", + " \"\"\"\n", + " This model corresponds to the plate diagram in Figure 3 of https://www.aclweb.org/anthology/Q18-1040.pdf.\n", + " \"\"\"\n", + " num_annotators = int(jnp.max(positions)) + 1\n", + " num_classes = int(jnp.max(annotations)) + 1\n", + " num_items, num_positions = annotations.shape\n", + "\n", + " with numpyro.plate('annotator', num_annotators):\n", + " epsilon = numpyro.sample('epsilon', dist.Dirichlet(jnp.full(num_classes, 10)))\n", + " theta = numpyro.sample('theta', dist.Beta(0.5, 0.5))\n", + "\n", + " with numpyro.plate('item', num_items, dim=-2):\n", + " # NB: using constant logits for discrete uniform prior\n", + " # (NumPyro does not have DiscreteUniform distribution yet)\n", + " c = numpyro.sample('c', dist.Categorical(logits=jnp.zeros(num_classes)))\n", + "\n", + " with numpyro.plate('position', num_positions):\n", + " s = numpyro.sample('s', dist.Bernoulli(1 - theta[positions]))\n", + " probs = jnp.where(s[..., None] == 0, nn.one_hot(c, num_classes), epsilon[positions])\n", + " numpyro.sample('y', dist.Categorical(probs), obs=annotations)\n", + " \n", + "positions = jnp.array([1, 1, 1, 2, 3, 4, 5])\n", + "annotations = jnp.array([\n", + " [1, 3, 1, 2, 2, 2, 1, 3, 2, 2, 4, 2, 1, 2, 1,\n", + " 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 1, 1,\n", + " 1, 3, 1, 2, 2, 4, 2, 2, 3, 1, 1, 1, 2, 1, 2],\n", + " [1, 3, 1, 2, 2, 2, 2, 3, 2, 3, 4, 2, 1, 2, 2,\n", + " 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 1, 1,\n", + " 1, 3, 1, 2, 2, 3, 2, 3, 3, 1, 1, 2, 3, 2, 2],\n", + " [1, 3, 2, 2, 2, 2, 2, 3, 2, 2, 4, 2, 1, 2, 1,\n", + " 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 2, 1, 1, 2,\n", + " 1, 3, 1, 2, 2, 3, 1, 2, 3, 1, 1, 1, 2, 1, 2],\n", + " [1, 4, 2, 3, 3, 3, 2, 3, 2, 2, 4, 3, 1, 3, 1,\n", + " 2, 1, 1, 2, 1, 2, 2, 3, 2, 1, 1, 2, 1, 1, 1,\n", + " 1, 3, 1, 2, 3, 4, 2, 3, 3, 1, 1, 2, 2, 1, 2],\n", + " [1, 3, 1, 1, 2, 3, 1, 4, 2, 2, 4, 3, 1, 2, 1,\n", + " 1, 1, 1, 2, 3, 2, 2, 2, 2, 1, 1, 2, 1, 1, 1,\n", + " 1, 2, 1, 2, 2, 3, 2, 2, 4, 1, 1, 1, 2, 1, 2],\n", + " [1, 3, 2, 2, 2, 2, 1, 3, 2, 2, 4, 4, 1, 1, 1,\n", + " 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 1, 2,\n", + " 1, 3, 1, 2, 3, 4, 3, 3, 3, 1, 1, 1, 2, 1, 2],\n", + " [1, 4, 2, 1, 2, 2, 1, 3, 3, 3, 4, 3, 1, 2, 1,\n", + " 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1,\n", + " 1, 3, 1, 2, 2, 3, 2, 3, 2, 1, 1, 1, 2, 1, 2],\n", + "]).T\n", + "\n", + "# we subtract 1 because the first index starts with 0 in Python\n", + "positions -= 1\n", + "annotations -= 1\n", + "\n", + "mace_graph = numpyro.render_model(mace, model_args=(positions, annotations))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "champion-consultation", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_annotator\n", + "\n", + "annotator\n", + "\n", + "\n", + "cluster_item\n", + "\n", + "item\n", + "\n", + "\n", + "cluster_position\n", + "\n", + "position\n", + "\n", + "\n", + "\n", + "epsilon\n", + "\n", + "epsilon\n", + "\n", + "\n", + "\n", + "y\n", + "\n", + "y\n", + "\n", + "\n", + "\n", + "epsilon->y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "theta\n", + "\n", + "theta\n", + "\n", + "\n", + "\n", + "s\n", + "\n", + "s\n", + "\n", + "\n", + "\n", + "theta->s\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "c\n", + "\n", + "c\n", + "\n", + "\n", + "\n", + "c->y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s->y\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# default layout\n", + "mace_graph" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "portable-looking", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_annotator\n", + "\n", + "annotator\n", + "\n", + "\n", + "cluster_item\n", + "\n", + "item\n", + "\n", + "\n", + "cluster_position\n", + "\n", + "position\n", + "\n", + "\n", + "\n", + "epsilon\n", + "\n", + "epsilon\n", + "\n", + "\n", + "\n", + "y\n", + "\n", + "y\n", + "\n", + "\n", + "\n", + "epsilon->y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "theta\n", + "\n", + "theta\n", + "\n", + "\n", + "\n", + "s\n", + "\n", + "s\n", + "\n", + "\n", + "\n", + "theta->s\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "s->y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "c\n", + "\n", + "c\n", + "\n", + "\n", + "\n", + "c->y\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# layout after processing the layout with unflatten\n", + "mace_graph.unflatten(stagger=2)" + ] + }, + { + "cell_type": "markdown", + "id": "industrial-customs", + "metadata": {}, + "source": [ + "# Distribution annotations\n", + "\n", + "It is possible to display the distribution of each RV in the generated plot by providing `render_distributions=True` when calling `numpyro.render_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "inclusive-clear", + "metadata": {}, + "outputs": [], + "source": [ + "def model(data):\n", + " x = numpyro.sample('x', dist.Normal(0, 1))\n", + " y = numpyro.sample('y', dist.LogNormal(x, 1))\n", + " with numpyro.plate('N', len(data)):\n", + " numpyro.sample('z', dist.Normal(x, y), obs=data)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "derived-degree", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "cluster_N\n", + "\n", + "N\n", + "\n", + "\n", + "\n", + "x\n", + "\n", + "x\n", + "\n", + "\n", + "\n", + "y\n", + "\n", + "y\n", + "\n", + "\n", + "\n", + "x->y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "z\n", + "\n", + "z\n", + "\n", + "\n", + "\n", + "x->z\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "y->z\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "distribution_description_node\n", + "x ~ Normal\n", + "y ~ LogNormal\n", + "z ~ Normal\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = jnp.ones(10)\n", + "numpyro.render_model(model, model_args=(data,), render_distributions=True)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/numpyro/__init__.py b/numpyro/__init__.py index 91970b71b..d93db7c9b 100644 --- a/numpyro/__init__.py +++ b/numpyro/__init__.py @@ -17,6 +17,7 @@ subsample ) from numpyro.util import enable_x64, set_host_device_count, set_platform +from numpyro.contrib.render import render_model from numpyro.version import __version__ set_platform("cpu") @@ -40,6 +41,7 @@ "plate", "plate_stack", "prng_key", + "render_model", "sample", "subsample", "set_host_device_count", diff --git a/numpyro/contrib/render.py b/numpyro/contrib/render.py new file mode 100644 index 000000000..98c4fcb3e --- /dev/null +++ b/numpyro/contrib/render.py @@ -0,0 +1,300 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import itertools +from pathlib import Path + +import jax + +from numpyro import handlers +import numpyro.distributions as dist + + +def get_model_relations(model, model_args=None, model_kwargs=None, num_tries=10): + """ + Infer relations of RVs and plates from given model and optionally data. + See issue #949 on pyro-ppl/numpyro for more details. + + :param int num_tries: times to trace model to detect discrete -> continuous dependency. + """ + model_args = model_args or () + model_kwargs = model_kwargs or {} + + trace = handlers.trace(handlers.seed(model, 0)).get_trace( + *model_args, **model_kwargs + ) + obs_sites = [ + name + for name, site in trace.items() + if site['type'] == 'sample' and site['is_observed'] + ] + + def _get_dist_name(fn): + if isinstance( + fn, (dist.Independent, dist.ExpandedDistribution, dist.MaskedDistribution) + ): + return _get_dist_name(fn.base_dist) + return type(fn).__name__ + + sample_dist = { + name: _get_dist_name(site['fn']) + for name, site in trace.items() + if site['type'] == 'sample' + } + + sample_plates = { + name: [frame.name for frame in site['cond_indep_stack']] + for name, site in trace.items() + if site['type'] == 'sample' + } + plate_samples = { + k: {name for name, plates in sample_plates.items() if k in plates} + for k in trace + if trace[k]['type'] == 'plate' + } + + def _resolve_plate_samples(plate_samples): + for p, pv in plate_samples.items(): + for q, qv in plate_samples.items(): + if len(pv & qv) > 0 and len(pv - qv) > 0 and len(qv - pv) > 0: + plate_samples_ = plate_samples.copy() + plate_samples_[q] = pv & qv + plate_samples_[q + '__CLONE'] = qv - pv + return _resolve_plate_samples(plate_samples_) + return plate_samples + + plate_samples = _resolve_plate_samples(plate_samples) + # convert set to list to keep order of variables + plate_samples = { + k: [name for name in trace if name in v] for k, v in plate_samples.items() + } + + def get_log_probs(sample, seed=0): + with handlers.trace() as tr, handlers.seed(model, seed), handlers.substitute( + data=sample + ): + model(*model_args, **model_kwargs) + return { + name: site['fn'].log_prob(site['value']) + for name, site in tr.items() + if site['type'] == 'sample' + } + + samples = { + name: site['value'] + for name, site in trace.items() + if site['type'] == 'sample' + and not site['is_observed'] + and not site['fn'].is_discrete + } + log_prob_grads = jax.jacobian(get_log_probs)(samples) + sample_deps = {} + for name, grads in log_prob_grads.items(): + sample_deps[name] = {n for n in grads if n != name and (grads[n] != 0).any()} + + # find discrete -> continuous dependency + samples = { + name: site['value'] for name, site in trace.items() if site['type'] == 'sample' + } + discrete_sites = [ + name + for name, site in trace.items() + if site['type'] == 'sample' + and not site['is_observed'] + and site['fn'].is_discrete + ] + log_probs_prototype = get_log_probs(samples) + for name in discrete_sites: + samples_ = samples.copy() + samples_.pop(name) + for i in range(num_tries): + log_probs = get_log_probs(samples_, seed=i + 1) + for var in samples: + if var == name: + continue + if (log_probs[var] != log_probs_prototype[var]).any(): + sample_deps[var] |= {name} + sample_sample = {} + for name in samples: + sample_sample[name] = [var for var in samples if var in sample_deps[name]] + return { + 'sample_sample': sample_sample, + 'sample_dist': sample_dist, + 'plate_sample': plate_samples, + 'observed': obs_sites, + } + + +def generate_graph_specification(model_relations): + """ + Convert model relations into data structure which can be readily + converted into a network. + """ + # group nodes by plate + plate_groups = dict(model_relations['plate_sample']) + plate_rvs = {rv for rvs in plate_groups.values() for rv in rvs} + plate_groups[None] = [ + rv for rv in model_relations['sample_sample'] if rv not in plate_rvs + ] # RVs which are in no plate + + # retain node metadata + node_data = {} + for rv in model_relations['sample_sample']: + node_data[rv] = { + 'is_observed': rv in model_relations['observed'], + 'distribution': model_relations['sample_dist'][rv], + } + + # infer plate structure + # (when the order of plates cannot be determined from subset relations, + # it follows the order in which plates appear in trace) + plate_data = {} + for plate1, plate2 in list(itertools.combinations(plate_groups, 2)): + if plate1 is None or plate2 is None: + continue + + if set(plate_groups[plate1]) < set(plate_groups[plate2]): + plate_data[plate1] = {'parent': plate2} + elif set(plate_groups[plate1]) >= set(plate_groups[plate2]): + plate_data[plate2] = {'parent': plate1} + + for plate in plate_groups: + if plate is None: + continue + + if plate not in plate_data: + plate_data[plate] = {'parent': None} + + # infer RV edges + edge_list = [] + for target, source_list in model_relations['sample_sample'].items(): + edge_list.extend([(source, target) for source in source_list]) + + return { + 'plate_groups': plate_groups, + 'plate_data': plate_data, + 'node_data': node_data, + 'edge_list': edge_list, + } + + +def render_graph(graph_specification, render_distributions=False): + """ + Create a graphviz object given a graph specification. + + :param bool render_distributions: Show distribution of each RV in plot. + """ + try: + import graphviz # noqa: F401 + except ImportError as e: + raise ImportError( + 'Looks like you want to use graphviz (https://graphviz.org/) ' + 'to render your model. ' + 'You need to install `graphviz` to be able to use this feature. ' + 'It can be installed with `pip install graphviz`.' + ) from e + + plate_groups = graph_specification['plate_groups'] + plate_data = graph_specification['plate_data'] + node_data = graph_specification['node_data'] + edge_list = graph_specification['edge_list'] + + graph = graphviz.Digraph() + + # add plates + plate_graph_dict = { + plate: graphviz.Digraph(name=f'cluster_{plate}') + for plate in plate_groups + if plate is not None + } + for plate, plate_graph in plate_graph_dict.items(): + plate_graph.attr(label=plate.split('__CLONE')[0], labeljust='r', labelloc='b') + + plate_graph_dict[None] = graph + + # add nodes + for plate, rv_list in plate_groups.items(): + cur_graph = plate_graph_dict[plate] + + for rv in rv_list: + color = 'grey' if node_data[rv]['is_observed'] else 'white' + cur_graph.node( + rv, label=rv, shape='ellipse', style='filled', fillcolor=color + ) + + # add leaf nodes first + while len(plate_data) >= 1: + for plate, data in plate_data.items(): + parent_plate = data['parent'] + is_leaf = True + + for plate2, data2 in plate_data.items(): + if plate == data2['parent']: + is_leaf = False + break + + if is_leaf: + plate_graph_dict[parent_plate].subgraph(plate_graph_dict[plate]) + plate_data.pop(plate) + break + + # add edges + for source, target in edge_list: + graph.edge(source, target) + + # render distributions if requested + if render_distributions: + dist_label = '' + for rv, data in node_data.items(): + rv_dist = data['distribution'] + dist_label += rf'{rv} ~ {rv_dist}\l' + + graph.node('distribution_description_node', label=dist_label, shape='plaintext') + + # return whole graph + return graph + + +def render_model( + model, + model_args=None, + model_kwargs=None, + filename=None, + render_distributions=False, + num_tries=10, +): + """ + Wrap all functions needed to automatically render a model. + + .. warning:: This utility does not support the + :func:``~numpyro.contrib.control_flow.scan` primitive yet. + + .. warning:: Currently, this utility uses a heuristic approach, + which will work for most cases, to detect dependencies in a NumPyro model. + + :param model: Model to render. + :param model_args: Positional arguments to pass to the model. + :param model_kwargs: Keyword arguments to pass to the model. + :param str filename: File to save rendered model in. + :param bool render_distributions: Whether to include RV distribution annotations in the plot. + :param int num_tries: Times to trace model to detect discrete -> continuous dependency. + """ + relations = get_model_relations( + model, + model_args=model_args, + model_kwargs=model_kwargs, + num_tries=num_tries, + ) + graph_spec = generate_graph_specification(relations) + graph = render_graph(graph_spec, render_distributions=render_distributions) + + if filename is not None: + filename = Path(filename) + graph.render( + filename.stem, + view=False, + cleanup=True, + format=filename.suffix[1:], # remove leading period from suffix + ) + + return graph diff --git a/setup.py b/setup.py index 452d2eee6..e8f71f41c 100644 --- a/setup.py +++ b/setup.py @@ -53,8 +53,9 @@ 'ipython', 'isort', 'tensorflow_probability', + 'graphviz', ], - 'examples': ['matplotlib', 'seaborn', 'graphviz', 'arviz'], + 'examples': ['matplotlib', 'seaborn', 'arviz'], }, long_description=long_description, long_description_content_type='text/markdown', diff --git a/test/test_model_rendering.py b/test/test_model_rendering.py new file mode 100644 index 000000000..848edbe94 --- /dev/null +++ b/test/test_model_rendering.py @@ -0,0 +1,91 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import pytest + +import jax.numpy as jnp + +import numpyro +import numpyro.distributions as dist +from numpyro.contrib.render import get_model_relations, generate_graph_specification + + +def simple(data): + x = numpyro.sample('x', dist.Normal(0, 1)) + sd = numpyro.sample('sd', dist.LogNormal(x, 1)) + with numpyro.plate('N', len(data)): + numpyro.sample('obs', dist.Normal(x, sd), obs=data) + + +def plate_improper_subsets(): + with numpyro.plate('N', 10): + with numpyro.plate('M', 10): + numpyro.sample('x', dist.Normal(0, 1)) + + +def nested_plates(): + N_plate = numpyro.plate('N', 10, dim=-2) + M_plate = numpyro.plate('M', 5, dim=-1) + with N_plate: + numpyro.sample('x', dist.Normal(0, 1)) + with M_plate: + numpyro.sample('y', dist.Normal(0, 1)) + with M_plate: + numpyro.sample('z', dist.Normal(0, 1)) + + +def discrete_to_continuous(probs, locs): + c = numpyro.sample('c', dist.Categorical(probs)) + numpyro.sample('x', dist.Normal(locs[c], 0.5)) + + +@pytest.mark.parametrize('test_model,model_kwargs,expected_graph_spec', [ + (simple, dict(data=jnp.ones(10)), { + 'plate_groups': {'N': ['obs'], None: ['x', 'sd']}, + 'plate_data': {'N': {'parent': None}}, + 'node_data': { + 'x': {'is_observed': False, 'distribution': 'Normal'}, + 'sd': {'is_observed': False, 'distribution': 'LogNormal'}, + 'obs': {'is_observed': True, 'distribution': 'Normal'}, + }, + 'edge_list': [('x', 'sd'), ('x', 'obs'), ('sd', 'obs')], + }), + (plate_improper_subsets, dict(), { + 'plate_groups': {'N': ['x'], 'M': ['x'], None: []}, + 'plate_data': {'N': {'parent': None}, 'M': {'parent': 'N'}}, + 'node_data': {'x': {'is_observed': False, 'distribution': 'Normal'}}, + 'edge_list': [], + }), + (nested_plates, dict(), { + 'plate_groups': {'N': ['x', 'y'], 'M': ['y'], 'M__CLONE': ['z'], None: []}, + 'plate_data': { + 'N': {'parent': None}, + 'M': {'parent': 'N'}, + 'M__CLONE': {'parent': None}, + }, + 'node_data': { + 'x': {'is_observed': False, 'distribution': 'Normal'}, + 'y': {'is_observed': False, 'distribution': 'Normal'}, + 'z': {'is_observed': False, 'distribution': 'Normal'}, + }, + 'edge_list': [], + }), + ( + discrete_to_continuous, + dict(probs=jnp.array([0.15, 0.3, 0.3, 0.25]), locs=jnp.array([-2, 0, 2, 4])), + { + 'plate_groups': {None: ['c', 'x']}, + 'plate_data': {}, + 'node_data': { + 'c': {'is_observed': False, 'distribution': 'CategoricalProbs'}, + 'x': {'is_observed': False, 'distribution': 'Normal'}, + }, + 'edge_list': [('c', 'x')], + } + ), +]) +def test_model_transformation(test_model, model_kwargs, expected_graph_spec): + relations = get_model_relations(test_model, model_kwargs=model_kwargs) + graph_spec = generate_graph_specification(relations) + + assert graph_spec == expected_graph_spec From 7493e35ed921108d884a88f58ab92ec5565f845d Mon Sep 17 00:00:00 2001 From: Kim Date: Thu, 25 Mar 2021 21:22:30 +0100 Subject: [PATCH 084/222] Fix model rendering tutorial headers (#973) --- notebooks/source/model_rendering.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index bc99ca2c3..020251084 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -149,7 +149,7 @@ "id": "hungarian-indianapolis", "metadata": {}, "source": [ - "# Tweaking the visualization\n", + "## Tweaking the visualization\n", "\n", "As `numpyro.render_model` returns an object of type `graphviz.dot.Digraph`, you can further improve the visualization of this graph.\n", "For example, you could use the [unflatten preprocessor](https://graphviz.readthedocs.io/en/stable/api.html#graphviz.unflatten) to improve the layout aspect ratio for more complex models." @@ -431,7 +431,7 @@ "id": "industrial-customs", "metadata": {}, "source": [ - "# Distribution annotations\n", + "## Distribution annotations\n", "\n", "It is possible to display the distribution of each RV in the generated plot by providing `render_distributions=True` when calling `numpyro.render_model`." ] From b6acb194114ce8d0a0a864266dc0d67b8431c19b Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 28 Mar 2021 20:49:14 -0500 Subject: [PATCH 085/222] Fix a regression bug for `ExpandedDistribution` (#972) --- numpyro/distributions/distribution.py | 27 +++++++++++++++++++-------- test/test_distributions.py | 14 ++++++++++++++ 2 files changed, 33 insertions(+), 8 deletions(-) diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index d9a95488a..eaf24b12f 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -501,17 +501,28 @@ def _sample(self, sample_fn, key, sample_shape=()): interstitial_sizes = tuple(self._interstitial_sizes.values()) expanded_sizes = tuple(self._expanded_sizes.values()) batch_shape = expanded_sizes + interstitial_sizes + # shape = sample_shape + expanded_sizes + interstitial_sizes + base_dist.shape() samples, intermediates = sample_fn(key, sample_shape=sample_shape + batch_shape) + interstitial_dims = tuple(self._interstitial_sizes.keys()) + event_dim = len(self.event_shape) + batch_ndims = jnp.ndim(samples) - event_dim + interstitial_dims = tuple(batch_ndims + i for i in interstitial_dims) + interstitial_idx = len(sample_shape) + len(expanded_sizes) + interstitial_sample_dims = range(interstitial_idx, interstitial_idx + len(interstitial_dims)) + permutation = list(range(batch_ndims)) + for dim1, dim2 in zip(interstitial_dims, interstitial_sample_dims): + permutation[dim1], permutation[dim2] = permutation[dim2], permutation[dim1] + def reshape_sample(x): - """ Reshapes samples and intermediates to ensure that the output - shape is correct: This implicitly replaces the interstitial dims - of size 1 in the original batch_shape of base_dist with those - in the expanded dims. While it somewhat 'shuffles' over batch - dimensions, we don't care because they are considered independent.""" - subshape = x.shape[len(sample_shape) + len(batch_shape):] - # subshape == base_dist.batch_shape + event_shape of x (latter unknown for intermediates) - event_shape = subshape[len(self.base_dist.batch_shape):] + """ + Reshapes samples and intermediates to ensure that the output + shape is correct: This implicitly replaces the interstitial dims + of size 1 in the original batch_shape of base_dist with those + in the expanded dims. + """ + x = jnp.transpose(x, permutation + list(range(batch_ndims, jnp.ndim(x)))) + event_shape = jnp.shape(x)[batch_ndims:] return x.reshape(sample_shape + self.batch_shape + event_shape) intermediates = tree_util.tree_map(reshape_sample, intermediates) diff --git a/test/test_distributions.py b/test/test_distributions.py index 5b832b01e..720c84bb8 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1429,6 +1429,20 @@ def test_expand(jax_dist, sp_dist, params, prepend_shape, sample_shape): assert expanded_dist.expand((3,) + jax_dist.batch_shape) +@pytest.mark.parametrize('base_shape', [(2, 1, 5), (3, 1), (2, 1, 1), (1, 1, 5)]) +@pytest.mark.parametrize('event_dim', [0, 1, 2, 3]) +@pytest.mark.parametrize('sample_shape', [(1000,), (1000, 7, 1), (1000, 1, 7)]) +def test_expand_shuffle_regression(base_shape, event_dim, sample_shape): + expand_shape = (2, 3, 5) + event_dim = min(event_dim, len(base_shape)) + loc = random.normal(random.PRNGKey(0), base_shape) * 10 + base_dist = dist.Normal(loc, 0.1).to_event(event_dim) + expanded_dist = base_dist.expand(expand_shape[:len(expand_shape) - event_dim]) + samples = expanded_dist.sample(random.PRNGKey(1), sample_shape) + expected_mean = jnp.broadcast_to(loc, sample_shape[1:] + expanded_dist.shape()) + assert_allclose(samples.mean(0), expected_mean, atol=0.1) + + @pytest.mark.parametrize('batch_shape', [ (), (4,), From 7442ddedd8bd459f6799d40f6dcc006d23beb3e1 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 30 Mar 2021 12:53:27 -0500 Subject: [PATCH 086/222] Add infer_discrete (#977) --- docs/source/funsor.rst | 2 + numpyro/__init__.py | 2 +- numpyro/contrib/funsor/__init__.py | 2 + numpyro/contrib/funsor/discrete.py | 175 +++++++++++ numpyro/contrib/funsor/enum_messenger.py | 5 +- numpyro/contrib/funsor/infer_util.py | 14 +- setup.py | 2 +- test/contrib/test_funsor.py | 22 +- test/contrib/test_infer_discrete.py | 383 +++++++++++++++++++++++ test/test_model_rendering.py | 2 +- 10 files changed, 588 insertions(+), 21 deletions(-) create mode 100644 numpyro/contrib/funsor/discrete.py create mode 100644 test/contrib/test_infer_discrete.py diff --git a/docs/source/funsor.rst b/docs/source/funsor.rst index 7202c1bb8..18ec52ea5 100644 --- a/docs/source/funsor.rst +++ b/docs/source/funsor.rst @@ -41,6 +41,8 @@ Inference Utilities .. autofunction:: numpyro.contrib.funsor.infer_util.config_enumerate +.. autofunction:: numpyro.contrib.funsor.discrete.infer_discrete + .. autofunction:: numpyro.contrib.funsor.infer_util.log_density .. autofunction:: numpyro.contrib.funsor.infer_util.plate_to_enum_plate diff --git a/numpyro/__init__.py b/numpyro/__init__.py index d93db7c9b..2857f8590 100644 --- a/numpyro/__init__.py +++ b/numpyro/__init__.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 from numpyro import compat, diagnostics, distributions, handlers, infer, optim +from numpyro.contrib.render import render_model from numpyro.distributions.distribution import enable_validation, validation_enabled import numpyro.patch # noqa: F401 from numpyro.primitives import ( @@ -17,7 +18,6 @@ subsample ) from numpyro.util import enable_x64, set_host_device_count, set_platform -from numpyro.contrib.render import render_model from numpyro.version import __version__ set_platform("cpu") diff --git a/numpyro/contrib/funsor/__init__.py b/numpyro/contrib/funsor/__init__.py index e40844ad7..4f1d2b5b9 100644 --- a/numpyro/contrib/funsor/__init__.py +++ b/numpyro/contrib/funsor/__init__.py @@ -9,6 +9,7 @@ "You need to install `funsor` to be able to use this feature. " "It can be installed with `pip install funsor`.") from e +from numpyro.contrib.funsor.discrete import infer_discrete from numpyro.contrib.funsor.enum_messenger import enum, infer_config, markov, plate, to_data, to_funsor, trace from numpyro.contrib.funsor.infer_util import config_enumerate, log_density, plate_to_enum_plate @@ -19,6 +20,7 @@ "config_enumerate", "enum", "infer_config", + "infer_discrete", "log_density", "markov", "plate", diff --git a/numpyro/contrib/funsor/discrete.py b/numpyro/contrib/funsor/discrete.py new file mode 100644 index 000000000..33c50ae2e --- /dev/null +++ b/numpyro/contrib/funsor/discrete.py @@ -0,0 +1,175 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from collections import OrderedDict +import functools + +from jax import random + +import funsor +from numpyro.contrib.funsor.enum_messenger import enum +from numpyro.contrib.funsor.enum_messenger import trace as packed_trace +from numpyro.contrib.funsor.infer_util import plate_to_enum_plate +from numpyro.distributions.util import is_identically_one +from numpyro.handlers import block, replay, seed, trace +from numpyro.infer.util import _guess_max_plate_nesting + + +@functools.singledispatch +def _get_support_value(funsor_dist, name, **kwargs): + raise ValueError("Could not extract point from {} at name {}".format(funsor_dist, name)) + + +@_get_support_value.register(funsor.cnf.Contraction) +def _get_support_value_contraction(funsor_dist, name, **kwargs): + delta_terms = [v for v in funsor_dist.terms + if isinstance(v, funsor.delta.Delta) and name in v.fresh] + assert len(delta_terms) == 1 + return _get_support_value(delta_terms[0], name, **kwargs) + + +@_get_support_value.register(funsor.delta.Delta) +def _get_support_value_delta(funsor_dist, name, **kwargs): + assert name in funsor_dist.fresh + return OrderedDict(funsor_dist.terms)[name][0] + + +def terms_from_trace(tr): + """Helper function to extract elbo components from execution traces.""" + log_factors = {} + log_measures = {} + sum_vars, prod_vars = frozenset(), frozenset() + for site in tr.values(): + if site['type'] == 'sample': + value = site['value'] + intermediates = site['intermediates'] + scale = site['scale'] + if intermediates: + log_prob = site['fn'].log_prob(value, intermediates) + else: + log_prob = site['fn'].log_prob(value) + + if (scale is not None) and (not is_identically_one(scale)): + log_prob = scale * log_prob + + dim_to_name = site["infer"]["dim_to_name"] + log_prob_factor = funsor.to_funsor(log_prob, output=funsor.Real, dim_to_name=dim_to_name) + + if site['is_observed']: + log_factors[site["name"]] = log_prob_factor + else: + log_measures[site["name"]] = log_prob_factor + sum_vars |= frozenset({site['name']}) + prod_vars |= frozenset(f.name for f in site['cond_indep_stack'] if f.dim is not None) + + return {"log_factors": log_factors, "log_measures": log_measures, + "measure_vars": sum_vars, "plate_vars": prod_vars} + + +def _sample_posterior(model, first_available_dim, temperature, rng_key, *args, **kwargs): + + if temperature == 0: + sum_op, prod_op = funsor.ops.max, funsor.ops.add + approx = funsor.approximations.argmax_approximate + elif temperature == 1: + sum_op, prod_op = funsor.ops.logaddexp, funsor.ops.add + rng_key, sub_key = random.split(rng_key) + approx = funsor.montecarlo.MonteCarlo(rng_key=sub_key) + else: + raise ValueError("temperature must be 0 (map) or 1 (sample) for now") + + if first_available_dim is None: + with block(): + model_trace = trace(seed(model, rng_key)).get_trace(*args, **kwargs) + first_available_dim = -_guess_max_plate_nesting(model_trace) - 1 + + with block(), enum(first_available_dim=first_available_dim): + with plate_to_enum_plate(): + model_tr = packed_trace(model).get_trace(*args, **kwargs) + + terms = terms_from_trace(model_tr) + # terms["log_factors"] = [log p(x) for each observed or latent sample site x] + # terms["log_measures"] = [log p(z) or other Dice factor + # for each latent sample site z] + + with funsor.interpretations.lazy: + log_prob = funsor.sum_product.sum_product( + sum_op, prod_op, + list(terms["log_factors"].values()) + list(terms["log_measures"].values()), + eliminate=terms["measure_vars"] | terms["plate_vars"], + plates=terms["plate_vars"] + ) + log_prob = funsor.optimizer.apply_optimizer(log_prob) + + with approx: + approx_factors = funsor.adjoint.adjoint(sum_op, prod_op, log_prob) + + # construct a result trace to replay against the model + sample_tr = model_tr.copy() + sample_subs = {} + for name, node in sample_tr.items(): + if node["type"] != "sample": + continue + if node["is_observed"]: + # "observed" values may be collapsed samples that depend on enumerated + # values, so we have to slice them down + # TODO this should really be handled entirely under the hood by adjoint + output = funsor.Reals[node["fn"].event_shape] + value = funsor.to_funsor(node["value"], output, dim_to_name=node["infer"]["dim_to_name"]) + value = value(**sample_subs) + node["value"] = funsor.to_data(value, name_to_dim=node["infer"]["name_to_dim"]) + else: + log_measure = approx_factors[terms["log_measures"][name]] + sample_subs[name] = _get_support_value(log_measure, name) + node["value"] = funsor.to_data(sample_subs[name], name_to_dim=node["infer"]["name_to_dim"]) + + with replay(guide_trace=sample_tr): + return model(*args, **kwargs) + + +def infer_discrete(fn=None, first_available_dim=None, temperature=1, rng_key=None): + """ + A handler that samples discrete sites marked with + ``site["infer"]["enumerate"] = "parallel"`` from the posterior, + conditioned on observations. + + Example:: + + @infer_discrete(first_available_dim=-1, temperature=0) + @config_enumerate + def viterbi_decoder(data, hidden_dim=10): + transition = 0.3 / hidden_dim + 0.7 * jnp.eye(hidden_dim) + means = jnp.arange(float(hidden_dim)) + states = [0] + for t in markov(range(len(data))): + states.append(numpyro.sample("states_{}".format(t), + dist.Categorical(transition[states[-1]]))) + numpyro.sample("obs_{}".format(t), + dist.Normal(means[states[-1]], 1.), + obs=data[t]) + return states # returns maximum likelihood states + + .. warning: This does not yet support :func:`numpyro.contrib.control_flow.scan` + primitive. + + .. warning: The ``log_prob``s of the inferred model's trace are not + meaningful, and may be changed in a future release. + + :param fn: a stochastic function (callable containing NumPyro primitive calls) + :param int first_available_dim: The first tensor dimension (counting + from the right) that is available for parallel enumeration. This + dimension and all dimensions left may be used internally by Pyro. + This should be a negative integer. + :param int temperature: Either 1 (sample via forward-filter backward-sample) + or 0 (optimize via Viterbi-like MAP inference). Defaults to 1 (sample). + :param jax.random.PRNGKey rng_key: a random number generator key, to be used in + cases ``temperature=1`` or ``first_available_dim is None``. + """ + if temperature == 1 or first_available_dim is None: + assert rng_key is not None + if fn is None: # support use as a decorator + return functools.partial(infer_discrete, + first_available_dim=first_available_dim, + temperature=temperature, + rng_key=rng_key) + return functools.partial(_sample_posterior, fn, first_available_dim, temperature, rng_key) diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index aa9eb900c..c347c9d36 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -446,7 +446,7 @@ def __init__(self, name, size, subsample_size=None, dim=None): self.subsample_size = indices.shape[0] self._indices = funsor.Tensor( indices, - OrderedDict([(self.name, funsor.bint(self.subsample_size))]), + OrderedDict([(self.name, funsor.Bint[self.subsample_size])]), self.subsample_size ) super(plate, self).__init__(None) @@ -528,7 +528,7 @@ def process_message(self, msg): raw_value = jnp.arange(0, size) funsor_value = funsor.Tensor( raw_value, - OrderedDict([(msg["name"], funsor.bint(size))]), + OrderedDict([(msg["name"], funsor.Bint[size])]), size ) @@ -551,6 +551,7 @@ def postprocess_message(self, msg): jnp.shape(msg["value"])[:jnp.ndim(msg["value"]) - msg["fn"].event_dim] ) msg["infer"]["dim_to_name"] = NamedMessenger._get_dim_to_name(total_batch_shape) + msg["infer"]["name_to_dim"] = {name: dim for dim, name in msg["infer"]["dim_to_name"].items()} if msg["type"] in ("sample", "param"): super().postprocess_message(msg) diff --git a/numpyro/contrib/funsor/infer_util.py b/numpyro/contrib/funsor/infer_util.py index 4a880febe..a450d2760 100644 --- a/numpyro/contrib/funsor/infer_util.py +++ b/numpyro/contrib/funsor/infer_util.py @@ -3,6 +3,7 @@ from collections import defaultdict from contextlib import contextmanager +import functools import re import funsor @@ -39,7 +40,7 @@ def plate_to_enum_plate(): numpyro.plate.__new__ = lambda *args, **kwargs: object.__new__(numpyro.plate) -def config_enumerate(fn, default='parallel'): +def config_enumerate(fn=None, default='parallel'): """ Configures enumeration for all relevant sites in a NumPyro model. @@ -63,6 +64,9 @@ def model(*args, **kwargs): :param str default: Which enumerate strategy to use, one of "sequential", "parallel", or None. Defaults to "parallel". """ + if fn is None: # support use as a decorator + return functools.partial(config_enumerate, default=default) + def config_fn(site): if site['type'] == 'sample' and (not site['is_observed']) \ and site['fn'].has_enumerate_support: @@ -102,7 +106,7 @@ def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_di # we eliminate all plate and enum dimensions not available at markov sites. eliminate_vars = (sum_vars | prod_vars) - time_to_markov_dims[time_var] - with funsor.interpreter.interpretation(funsor.terms.lazy): + with funsor.interpretations.lazy: lazy_result = funsor.sum_product.sum_product( funsor.ops.logaddexp, funsor.ops.add, log_factors, eliminate=eliminate_vars, plates=prod_vars) @@ -167,12 +171,12 @@ def model(*args, **kwargs): log_prob = scale * log_prob dim_to_name = site["infer"]["dim_to_name"] - log_prob_factor = funsor.to_funsor(log_prob, output=funsor.reals(), dim_to_name=dim_to_name) + log_prob_factor = funsor.to_funsor(log_prob, output=funsor.Real, dim_to_name=dim_to_name) time_dim = None for dim, name in dim_to_name.items(): if name.startswith("_time"): - time_dim = funsor.Variable(name, funsor.domains.bint(log_prob.shape[dim])) + time_dim = funsor.Variable(name, funsor.Bint[log_prob.shape[dim]]) time_to_factors[time_dim].append(log_prob_factor) history = max(history, max(_get_shift(s) for s in dim_to_name.values())) time_to_init_vars[time_dim] |= frozenset( @@ -197,7 +201,7 @@ def model(*args, **kwargs): time_to_markov_dims, sum_vars, prod_vars, history) log_factors = log_factors + markov_factors - with funsor.interpreter.interpretation(funsor.terms.lazy): + with funsor.interpretations.lazy: lazy_result = funsor.sum_product.sum_product( funsor.ops.logaddexp, funsor.ops.add, log_factors, eliminate=sum_vars | prod_vars, plates=prod_vars) diff --git a/setup.py b/setup.py index e8f71f41c..316fd77dc 100644 --- a/setup.py +++ b/setup.py @@ -49,7 +49,7 @@ 'dev': [ 'dm-haiku', 'flax', - 'funsor', + 'funsor @ git+https://github.com/pyro-ppl/funsor.git@d5574988665dd822ec64e41f2b54b9dc929959dc', 'ipython', 'isort', 'tensorflow_probability', diff --git a/test/contrib/test_funsor.py b/test/contrib/test_funsor.py index ea7d54a2a..b990d604e 100644 --- a/test/contrib/test_funsor.py +++ b/test/contrib/test_funsor.py @@ -11,7 +11,7 @@ from jax import random import jax.numpy as jnp -from funsor import Tensor, bint, reals +from funsor import Bint, Real, Tensor import numpyro from numpyro.contrib.control_flow import scan from numpyro.contrib.funsor import config_enumerate, enum, markov, to_data, to_funsor @@ -136,10 +136,10 @@ def test_iteration(): def testing(): for i in markov(range(5)): - v1 = to_data(Tensor(jnp.ones(2), OrderedDict([(str(i), bint(2))]), 'real')) - v2 = to_data(Tensor(jnp.zeros(2), OrderedDict([('a', bint(2))]), 'real')) - fv1 = to_funsor(v1, reals()) - fv2 = to_funsor(v2, reals()) + v1 = to_data(Tensor(jnp.ones(2), OrderedDict([(str(i), Bint[2])]), 'real')) + v2 = to_data(Tensor(jnp.zeros(2), OrderedDict([('a', Bint[2])]), 'real')) + fv1 = to_funsor(v1, Real) + fv2 = to_funsor(v2, Real) print(i, v1.shape) # shapes should alternate if i % 2 == 0: assert v1.shape == (2,) @@ -159,22 +159,22 @@ def test_nesting(): def testing(): with markov(): - v1 = to_data(Tensor(jnp.ones(2), OrderedDict([("1", bint(2))]), 'real')) + v1 = to_data(Tensor(jnp.ones(2), OrderedDict([("1", Bint[2])]), 'real')) print(1, v1.shape) # shapes should alternate assert v1.shape == (2,) with markov(): - v2 = to_data(Tensor(jnp.ones(2), OrderedDict([("2", bint(2))]), 'real')) + v2 = to_data(Tensor(jnp.ones(2), OrderedDict([("2", Bint[2])]), 'real')) print(2, v2.shape) # shapes should alternate assert v2.shape == (2, 1) with markov(): - v3 = to_data(Tensor(jnp.ones(2), OrderedDict([("3", bint(2))]), 'real')) + v3 = to_data(Tensor(jnp.ones(2), OrderedDict([("3", Bint[2])]), 'real')) print(3, v3.shape) # shapes should alternate assert v3.shape == (2,) with markov(): - v4 = to_data(Tensor(jnp.ones(2), OrderedDict([("4", bint(2))]), 'real')) + v4 = to_data(Tensor(jnp.ones(2), OrderedDict([("4", Bint[2])]), 'real')) print(4, v4.shape) # shapes should alternate assert v4.shape == (2, 1) @@ -188,8 +188,8 @@ def test_staggered(): def testing(): for i in markov(range(12)): if i % 4 == 0: - v2 = to_data(Tensor(jnp.zeros(2), OrderedDict([('a', bint(2))]), 'real')) - fv2 = to_funsor(v2, reals()) + v2 = to_data(Tensor(jnp.zeros(2), OrderedDict([('a', Bint[2])]), 'real')) + fv2 = to_funsor(v2, Real) assert v2.shape == (2,) print('a', v2.shape) print('a', fv2.inputs) diff --git a/test/contrib/test_infer_discrete.py b/test/contrib/test_infer_discrete.py new file mode 100644 index 000000000..a3b48b2d1 --- /dev/null +++ b/test/contrib/test_infer_discrete.py @@ -0,0 +1,383 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import logging + +import numpy as np +from numpy.testing import assert_allclose +import pytest + +from jax import random +import jax.numpy as jnp + +import numpyro +from numpyro import handlers, infer +import numpyro.distributions as dist +from numpyro.distributions.util import is_identically_one + +# put all funsor-related imports here, so test collection works without funsor +try: + import funsor + from numpyro.contrib.funsor import config_enumerate, infer_discrete, markov + + funsor.set_backend("jax") +except ImportError: + pytestmark = pytest.mark.skip(reason="funsor is not installed") + +logger = logging.getLogger(__name__) + + +def log_prob_sum(trace): + log_joint = jnp.zeros(()) + for site in trace.values(): + if site['type'] == 'sample': + value = site['value'] + intermediates = site['intermediates'] + scale = site['scale'] + if intermediates: + log_prob = site['fn'].log_prob(value, intermediates) + else: + log_prob = site['fn'].log_prob(value) + + if (scale is not None) and (not is_identically_one(scale)): + log_prob = scale * log_prob + + log_prob = jnp.sum(log_prob) + log_joint = log_joint + log_prob + return log_joint + + +@pytest.mark.parametrize('length', [1, 2, 10]) +@pytest.mark.parametrize('temperature', [0, 1]) +def test_hmm_smoke(length, temperature): + + # This should match the example in the infer_discrete docstring. + def hmm(data, hidden_dim=10): + transition = 0.3 / hidden_dim + 0.7 * jnp.eye(hidden_dim) + means = jnp.arange(float(hidden_dim)) + states = [0] + for t in markov(range(len(data))): + states.append(numpyro.sample("states_{}".format(t), + dist.Categorical(transition[states[-1]]))) + data[t] = numpyro.sample("obs_{}".format(t), + dist.Normal(means[states[-1]], 1.), + obs=data[t]) + return states, data + + true_states, data = handlers.seed(hmm, 0)([None] * length) + assert len(data) == length + assert len(true_states) == 1 + len(data) + + decoder = infer_discrete(config_enumerate(hmm), temperature=temperature, rng_key=random.PRNGKey(1)) + inferred_states, _ = decoder(data) + assert len(inferred_states) == len(true_states) + + logger.info("true states: {}".format(list(map(int, true_states)))) + logger.info("inferred states: {}".format(list(map(int, inferred_states)))) + + +def vectorize_model(model, size, dim): + def fn(*args, **kwargs): + with numpyro.plate("particles", size=size, dim=dim): + return model(*args, **kwargs) + + return fn + + +@pytest.mark.parametrize("temperature", [0, 1]) +def test_distribution_1(temperature): + # +-------+ + # z --|--> x | + # +-------+ + num_particles = 10000 + data = np.array([1., 2., 3.]) + + @config_enumerate + def model(z=None): + p = numpyro.param("p", np.array([0.75, 0.25])) + iz = numpyro.sample("z", dist.Categorical(p), obs=z) + z = jnp.array([0., 1.])[iz] + logger.info("z.shape = {}".format(z.shape)) + with numpyro.plate("data", 3): + numpyro.sample("x", dist.Normal(z, 1.), obs=data) + + first_available_dim = -3 + vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + sampled_model = infer_discrete( + vectorized_model, + first_available_dim, + temperature, + rng_key=random.PRNGKey(1), + ) + sampled_trace = handlers.trace(sampled_model).get_trace() + conditioned_traces = {z: handlers.trace(model).get_trace(z=np.array(z)) for z in [0, 1]} + + # Check posterior over z. + actual_z_mean = sampled_trace["z"]["value"].astype(float).mean() + if temperature: + expected_z_mean = 1 / (1 + np.exp(log_prob_sum(conditioned_traces[0]) - + log_prob_sum(conditioned_traces[1]))) + else: + expected_z_mean = (log_prob_sum(conditioned_traces[1]) > + log_prob_sum(conditioned_traces[0])).astype(float) + expected_max = max(log_prob_sum(t) for t in conditioned_traces.values()) + actual_max = log_prob_sum(sampled_trace) + assert_allclose(expected_max, actual_max, atol=1e-5) + assert_allclose(actual_z_mean, expected_z_mean, atol=1e-2 if temperature else 1e-5) + + +@pytest.mark.parametrize("temperature", [0, 1]) +def test_distribution_2(temperature): + # +--------+ + # z1 --|--> x1 | + # | | | + # V | | + # z2 --|--> x2 | + # +--------+ + num_particles = 10000 + data = np.array([[-1., -1., 0.], [-1., 1., 1.]]) + + @config_enumerate + def model(z1=None, z2=None): + p = numpyro.param("p", jnp.array([[0.25, 0.75], [0.1, 0.9]])) + loc = numpyro.param("loc", jnp.array([-1., 1.])) + z1 = numpyro.sample("z1", dist.Categorical(p[0]), obs=z1) + z2 = numpyro.sample("z2", dist.Categorical(p[z1]), obs=z2) + logger.info("z1.shape = {}".format(z1.shape)) + logger.info("z2.shape = {}".format(z2.shape)) + with numpyro.plate("data", 3): + numpyro.sample("x1", dist.Normal(loc[z1], 1.), obs=data[0]) + numpyro.sample("x2", dist.Normal(loc[z2], 1.), obs=data[1]) + + first_available_dim = -3 + vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + sampled_model = infer_discrete( + vectorized_model, + first_available_dim, + temperature, + rng_key=random.PRNGKey(1), + ) + sampled_trace = handlers.trace(sampled_model).get_trace() + conditioned_traces = {(z1, z2): handlers.trace(model).get_trace(z1=np.array(z1), + z2=np.array(z2)) + for z1 in [0, 1] for z2 in [0, 1]} + + # Check joint posterior over (z1, z2). + actual_probs = np.zeros((2, 2)) + expected_probs = np.zeros((2, 2)) + for (z1, z2), tr in conditioned_traces.items(): + expected_probs[z1, z2] = np.exp(log_prob_sum(tr)) + actual_probs[z1, z2] = ((sampled_trace["z1"]["value"] == z1) & + (sampled_trace["z2"]["value"] == z2)).astype(float).mean() + + if temperature: + expected_probs = expected_probs / expected_probs.sum() + else: + argmax = np.argmax(expected_probs.reshape(-1)) + expected_max = expected_probs.reshape(-1)[argmax] + actual_max = log_prob_sum(sampled_trace) + assert_allclose(np.log(expected_max), actual_max, atol=1e-5) + expected_probs[:] = 0 + expected_probs.reshape(-1)[argmax] = 1 + assert_allclose(expected_probs, actual_probs, atol=1e-2 if temperature else 1e-5) + + +@pytest.mark.parametrize("temperature", [0, 1]) +def test_distribution_3_simple(temperature): + # +---------------+ + # | z2 ---> x2 | + # | 2 | + # +---------------+ + num_particles = 10000 + data = np.array([-1., 1.]) + + @config_enumerate + def model(z2=None): + p = numpyro.param("p", np.array([0.25, 0.75])) + loc = numpyro.param("loc", jnp.array([-1., 1.])) + with numpyro.plate("data", 2): + z2 = numpyro.sample("z2", dist.Categorical(p), obs=z2) + numpyro.sample("x2", dist.Normal(loc[z2], 1.), obs=data) + + first_available_dim = -3 + vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + sampled_model = infer_discrete( + vectorized_model, + first_available_dim, + temperature, + random.PRNGKey(1), + ) + sampled_trace = handlers.trace(sampled_model).get_trace() + conditioned_traces = {(z20, z21): handlers.trace(model).get_trace(z2=np.array([z20, z21])) + for z20 in [0, 1] for z21 in [0, 1]} + + # Check joint posterior over (z2[0], z2[1]). + actual_probs = np.zeros((2, 2)) + expected_probs = np.zeros((2, 2)) + for (z20, z21), tr in conditioned_traces.items(): + expected_probs[z20, z21] = np.exp(log_prob_sum(tr)) + actual_probs[z20, z21] = ((sampled_trace["z2"]["value"][..., :1] == z20) & + (sampled_trace["z2"]["value"][..., 1:] == z21)).astype(float).mean() + if temperature: + expected_probs = expected_probs / expected_probs.sum() + else: + argmax = np.argmax(expected_probs.reshape(-1)) + expected_max = expected_probs.reshape(-1)[argmax] + actual_max = log_prob_sum(sampled_trace) + assert_allclose(np.log(expected_max), actual_max, atol=1e-5) + expected_probs[:] = 0 + expected_probs.reshape(-1)[argmax] = 1 + assert_allclose(expected_probs.reshape(-1), actual_probs.reshape(-1), atol=1e-2) + + +@pytest.mark.parametrize("temperature", [0, 1]) +def test_distribution_3(temperature): + # +---------+ +---------------+ + # z1 --|--> x1 | | z2 ---> x2 | + # | 3 | | 2 | + # +---------+ +---------------+ + num_particles = 10000 + data = [np.array([-1., -1., 0.]), np.array([-1., 1.])] + + @config_enumerate + def model(z1=None, z2=None): + p = numpyro.param("p", np.array([0.25, 0.75])) + loc = numpyro.param("loc", jnp.array([-1., 1.])) + z1 = numpyro.sample("z1", dist.Categorical(p), obs=z1) + with numpyro.plate("data[0]", 3): + numpyro.sample("x1", dist.Normal(loc[z1], 1.), obs=data[0]) + with numpyro.plate("data[1]", 2): + z2 = numpyro.sample("z2", dist.Categorical(p), obs=z2) + numpyro.sample("x2", dist.Normal(loc[z2], 1.), obs=data[1]) + + first_available_dim = -3 + vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + sampled_model = infer_discrete( + vectorized_model, + first_available_dim, + temperature, + rng_key=random.PRNGKey(1), + ) + sampled_trace = handlers.trace(sampled_model).get_trace() + conditioned_traces = {(z1, z20, z21): handlers.trace(model).get_trace(z1=np.array(z1), + z2=np.array([z20, z21])) + for z1 in [0, 1] for z20 in [0, 1] for z21 in [0, 1]} + + # Check joint posterior over (z1, z2[0], z2[1]). + actual_probs = np.zeros((2, 2, 2)) + expected_probs = np.zeros((2, 2, 2)) + for (z1, z20, z21), tr in conditioned_traces.items(): + expected_probs[z1, z20, z21] = jnp.exp(log_prob_sum(tr)) + actual_probs[z1, z20, z21] = ((sampled_trace["z1"]["value"] == z1) & + (sampled_trace["z2"]["value"][..., :1] == z20) & + (sampled_trace["z2"]["value"][..., 1:] == z21)).astype(float).mean() + if temperature: + expected_probs = expected_probs / expected_probs.sum() + else: + argmax = expected_probs.reshape(-1).argmax() + expected_max = expected_probs.reshape(-1)[argmax] + actual_max = np.exp(log_prob_sum(sampled_trace)) + assert_allclose(expected_max, actual_max, atol=1e-5) + expected_probs[:] = 0 + expected_probs.reshape(-1)[argmax] = 1 + assert_allclose(expected_probs.reshape(-1), actual_probs.reshape(-1), atol=1e-2) + + +def model_zzxx(): + # loc,scale + # / \ + # +-------/-+ +--------\------+ + # z1 --|--> x1 | | z2 ---> x2 | + # | 3 | | 2 | + # +---------+ +---------------+ + data = [np.array([-1., -1., 0.]), np.array([-1., 1.])] + p = numpyro.param("p", np.array([0.25, 0.75])) + loc = numpyro.sample("loc", dist.Normal(0, 1).expand([2]).to_event(1)) + # FIXME results in infinite loop in transformeddist_to_funsor. + # scale = numpyro.sample("scale", dist.LogNormal(0, 1)) + scale = jnp.exp(numpyro.sample("scale", dist.Normal(0, 1))) + z1 = numpyro.sample("z1", dist.Categorical(p)) + with numpyro.plate("data[0]", 3): + numpyro.sample("x1", dist.Normal(loc[z1], scale), obs=data[0]) + with numpyro.plate("data[1]", 2): + z2 = numpyro.sample("z2", dist.Categorical(p)) + numpyro.sample("x2", dist.Normal(loc[z2], scale), obs=data[1]) + + +def model2(): + + data = [np.array([-1., -1., 0.]), np.array([-1., 1.])] + p = numpyro.param("p", np.array([0.25, 0.75])) + loc = numpyro.sample("loc", dist.Normal(0, 1).expand([2]).to_event(1)) + # FIXME results in infinite loop in transformeddist_to_funsor. + # scale = numpyro.sample("scale", dist.LogNormal(0, 1)) + z1 = numpyro.sample("z1", dist.Categorical(p)) + scale = numpyro.sample("scale", dist.LogNormal(jnp.array([0., 1.])[z1], 1)) + with numpyro.plate("data[0]", 3): + numpyro.sample("x1", dist.Normal(loc[z1], scale), obs=data[0]) + with numpyro.plate("data[1]", 2): + z2 = numpyro.sample("z2", dist.Categorical(p)) + numpyro.sample("x2", dist.Normal(loc[z2], scale), obs=data[1]) + + +@pytest.mark.parametrize("model", [model_zzxx, model2]) +@pytest.mark.parametrize("temperature", [0, 1]) +def test_mcmc_model_side_enumeration(model, temperature): + mcmc = infer.MCMC(infer.NUTS(model), 0, 1) + mcmc.run(random.PRNGKey(0)) + mcmc_data = {k: v[0] for k, v in mcmc.get_samples().items() if k in ["loc", "scale"]} + + # MAP estimate discretes, conditioned on posterior sampled continous latents. + model = handlers.seed(model, rng_seed=1) + actual_trace = handlers.trace( + infer_discrete( + # TODO support replayed sites in infer_discrete. + # handlers.replay(config_enumerate(model), mcmc_trace), + handlers.condition(config_enumerate(model), mcmc_data), + temperature=temperature, + rng_key=random.PRNGKey(1), + ), + ).get_trace() + + # Check site names and shapes. + expected_trace = handlers.trace(model).get_trace() + assert set(actual_trace) == set(expected_trace) + + +@pytest.mark.parametrize('temperature', [0, 1]) +def test_distribution_masked(temperature): + # +-------+ + # z --|--> x | + # +-------+ + num_particles = 10000 + data = np.array([1., 2., 3.]) + mask = np.array([True, False, False]) + + @config_enumerate + def model(z=None): + p = numpyro.param("p", np.array([0.75, 0.25])) + z = numpyro.sample("z", dist.Categorical(p), obs=z) + logger.info("z.shape = {}".format(z.shape)) + with numpyro.plate("data", 3), handlers.mask(mask=mask): + numpyro.sample("x", dist.Normal(z, 1.), obs=data) + + first_available_dim = -3 + vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + sampled_model = infer_discrete( + vectorized_model, + first_available_dim, + temperature, + rng_key=random.PRNGKey(1), + ) + sampled_trace = handlers.trace(sampled_model).get_trace() + conditioned_traces = {z: handlers.trace(model).get_trace(z=np.array(z)) for z in [0., 1.]} + + # Check posterior over z. + actual_z_mean = sampled_trace["z"]["value"].astype(float).mean() + if temperature: + expected_z_mean = 1 / (1 + jnp.exp(log_prob_sum(conditioned_traces[0]) - + log_prob_sum(conditioned_traces[1]))) + else: + expected_z_mean = (log_prob_sum(conditioned_traces[1]) > + log_prob_sum(conditioned_traces[0])).astype(float) + assert_allclose(actual_z_mean, expected_z_mean, atol=1e-2) diff --git a/test/test_model_rendering.py b/test/test_model_rendering.py index 848edbe94..edbcc9a40 100644 --- a/test/test_model_rendering.py +++ b/test/test_model_rendering.py @@ -6,8 +6,8 @@ import jax.numpy as jnp import numpyro +from numpyro.contrib.render import generate_graph_specification, get_model_relations import numpyro.distributions as dist -from numpyro.contrib.render import get_model_relations, generate_graph_specification def simple(data): From fd3c55f63dc32ee13690a2f5cc956673babd7497 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 30 Mar 2021 15:16:10 -0500 Subject: [PATCH 087/222] Raise errors on CI for doctest (#975) * various changes to make doctest run properly * install ipython to make doctest pass on CI * move ipython from dev to test * try to install ghostscript * try imagemagick * try gsfonts to see if ci passes * gsfonts works * fix sp500 dataset issue Co-authored-by: Fritz Obermeyer --- .github/workflows/ci.yml | 2 +- docs/Makefile | 8 +++-- docs/requirements.txt | 4 +-- docs/source/utilities.rst | 2 +- examples/stochastic_volatility.py | 2 +- ...esian_hierarchical_linear_regression.ipynb | 4 ++- notebooks/source/bayesian_imputation.ipynb | 2 +- notebooks/source/model_rendering.ipynb | 34 ++++++++++--------- numpyro/contrib/render.py | 2 +- numpyro/distributions/continuous.py | 3 +- numpyro/distributions/discrete.py | 4 +-- numpyro/distributions/transforms.py | 3 +- numpyro/distributions/util.py | 7 ++-- numpyro/examples/datasets.py | 14 ++++---- numpyro/handlers.py | 4 +-- numpyro/infer/hmc.py | 8 ++--- numpyro/infer/svi.py | 3 +- numpyro/primitives.py | 4 +-- setup.py | 1 + 19 files changed, 59 insertions(+), 52 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 0ab485249..2fa9ec0f7 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,7 +24,7 @@ jobs: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | - sudo apt install -y pandoc + sudo apt install -y pandoc gsfonts python -m pip install --upgrade pip pip install https://github.com/pyro-ppl/funsor/archive/master.zip pip install jaxlib diff --git a/docs/Makefile b/docs/Makefile index c81a709d8..fd9ca6798 100644 --- a/docs/Makefile +++ b/docs/Makefile @@ -2,7 +2,7 @@ # # You can set these variables from the command line. -SPHINXOPTS = +SPHINXOPTS = -W SPHINXBUILD = sphinx-build SPHINXPROJ = numpyro SOURCEDIR = source @@ -17,5 +17,7 @@ help: # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile - -@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) - git clean -dfx source/ + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + git clean -dfx source/examples + git clean -dfx source/tutorials + git clean -f source/getting_started.rst diff --git a/docs/requirements.txt b/docs/requirements.txt index 6452ff6ce..fecea923c 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -3,7 +3,7 @@ flax funsor jax>=0.1.65 jaxlib>=0.1.45 -nbsphinx +nbsphinx==0.8.1 sphinx-gallery -tfp_nightly # TODO: change this to stable release +tensorflow-probability tqdm diff --git a/docs/source/utilities.rst b/docs/source/utilities.rst index e16d53c1e..bdf92f145 100644 --- a/docs/source/utilities.rst +++ b/docs/source/utilities.rst @@ -99,4 +99,4 @@ Visualization Utilities render_model ------------ -.. autofunction:: numpyro.util.render_model +.. autofunction:: numpyro.contrib.render.render_model diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index 3ce8bbe68..0d7242081 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -68,7 +68,7 @@ def _print_row(values, row_name=''): row_name_fmt = '{:>8}' header_format = row_name_fmt + '{:>12}' * 5 row_format = row_name_fmt + '{:>12.3f}' * 5 - columns = ['(p{})'.format(q * 100) for q in quantiles] + columns = ['(p{})'.format(int(q * 100)) for q in quantiles] q_values = jnp.quantile(values, quantiles, axis=0) print(header_format.format('', *columns)) print(row_format.format(row_name, *q_values)) diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index 1e50bdcb8..7f05fe207 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -231,7 +231,9 @@ "import numpyro\n", "from numpyro.infer import MCMC, NUTS, Predictive\n", "import numpyro.distributions as dist\n", - "from jax import random" + "from jax import random\n", + "\n", + "assert numpyro.__version__.startswith('0.6.0')" ] }, { diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index 3498618ec..da6bc5e9a 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -46,7 +46,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith(\"0.5.0\")" + "assert numpyro.__version__.startswith('0.6.0')" ] }, { diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index 020251084..e04816698 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "induced-highlight", + "id": "renewable-moment", "metadata": {}, "source": [ "# Automatic rendering of NumPyro models\n", @@ -13,7 +13,7 @@ { "cell_type": "code", "execution_count": 1, - "id": "recreational-forestry", + "id": "structured-foster", "metadata": {}, "outputs": [], "source": [ @@ -21,12 +21,14 @@ "import jax.numpy as jnp\n", "\n", "import numpyro\n", - "import numpyro.distributions as dist" + "import numpyro.distributions as dist\n", + "\n", + "assert numpyro.__version__.startswith('0.6.0')" ] }, { "cell_type": "markdown", - "id": "after-origin", + "id": "civil-template", "metadata": {}, "source": [ "## A Simple Example\n", @@ -37,7 +39,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "continued-rebate", + "id": "designing-listening", "metadata": {}, "outputs": [], "source": [ @@ -51,7 +53,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "impaired-solid", + "id": "disturbed-vocabulary", "metadata": {}, "outputs": [ { @@ -127,7 +129,7 @@ }, { "cell_type": "markdown", - "id": "false-qualification", + "id": "suited-millennium", "metadata": {}, "source": [ "The visualization can be saved to a file by providing `filename='path'` to `numpyro.render_model`. You can use different formats such as PDF or PNG by changing the filename's suffix.\n", @@ -137,7 +139,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "favorite-animal", + "id": "olive-cooler", "metadata": {}, "outputs": [], "source": [ @@ -146,7 +148,7 @@ }, { "cell_type": "markdown", - "id": "hungarian-indianapolis", + "id": "unexpected-definition", "metadata": {}, "source": [ "## Tweaking the visualization\n", @@ -158,7 +160,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "curious-commission", + "id": "developmental-florence", "metadata": {}, "outputs": [], "source": [ @@ -219,7 +221,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "champion-consultation", + "id": "bottom-enlargement", "metadata": {}, "outputs": [ { @@ -324,7 +326,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "portable-looking", + "id": "filled-cardiff", "metadata": {}, "outputs": [ { @@ -428,7 +430,7 @@ }, { "cell_type": "markdown", - "id": "industrial-customs", + "id": "mighty-prospect", "metadata": {}, "source": [ "## Distribution annotations\n", @@ -439,7 +441,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "inclusive-clear", + "id": "palestinian-motion", "metadata": {}, "outputs": [], "source": [ @@ -453,7 +455,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "derived-degree", + "id": "international-ethnic", "metadata": {}, "outputs": [ { @@ -551,7 +553,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/numpyro/contrib/render.py b/numpyro/contrib/render.py index 98c4fcb3e..b92936c3a 100644 --- a/numpyro/contrib/render.py +++ b/numpyro/contrib/render.py @@ -267,7 +267,7 @@ def render_model( Wrap all functions needed to automatically render a model. .. warning:: This utility does not support the - :func:``~numpyro.contrib.control_flow.scan` primitive yet. + :func:`~numpyro.contrib.control_flow.scan` primitive yet. .. warning:: Currently, this utility uses a heuristic approach, which will work for most cases, to detect dependencies in a NumPyro model. diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 4d6977ba1..7567fa86b 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -26,12 +26,13 @@ # POSSIBILITY OF SUCH DAMAGE. -from jax import lax, ops, tree_map +from jax import lax, ops import jax.nn as nn import jax.numpy as jnp import jax.random as random from jax.scipy.linalg import cho_solve, solve_triangular from jax.scipy.special import betainc, expit, gammaln, logit, logsumexp, multigammaln, ndtr, ndtri +from jax.tree_util import tree_map from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution, TransformedDistribution diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 76bf5ad82..0724fba3f 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -29,7 +29,7 @@ import numpy as np -from jax import device_put, lax +from jax import lax from jax.nn import softmax, softplus import jax.numpy as jnp import jax.random as random @@ -578,7 +578,7 @@ def sample(self, key, sample_shape=()): key_bern, key_poisson = random.split(key) shape = sample_shape + self.batch_shape mask = random.bernoulli(key_bern, self.gate, shape) - samples = random.poisson(key_poisson, device_put(self.rate), shape) + samples = random.poisson(key_poisson, self.rate, shape) return jnp.where(mask, 0, samples) @validate_sample diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index f71af1f58..7747cd83b 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -7,12 +7,13 @@ import numpy as np -from jax import lax, ops, tree_flatten, tree_map, vmap +from jax import lax, ops, vmap from jax.flatten_util import ravel_pytree from jax.nn import softplus import jax.numpy as jnp from jax.scipy.linalg import solve_triangular from jax.scipy.special import expit, logit +from jax.tree_util import tree_flatten, tree_map from numpyro.distributions import constraints from numpyro.distributions.util import matrix_to_tril_vec, signed_stick_breaking_tril, sum_rightmost, vec_to_tril_matrix diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index 79aaeab06..bc7e82188 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -2,16 +2,15 @@ # SPDX-License-Identifier: Apache-2.0 from collections import namedtuple -from functools import update_wrapper +from functools import partial, update_wrapper import math import numpy as np +import jax from jax import jit, lax, random, vmap -from jax.lib import xla_bridge import jax.numpy as jnp from jax.scipy.linalg import solve_triangular -from jax.util import partial # Parameters for Transformed Rejection with Squeeze (TRS) algorithm - page 3. _tr_params = namedtuple('tr_params', ['c', 'b', 'a', 'alpha', 'u_r', 'v_r', 'm', 'log_p', 'log1_p', 'log_h']) @@ -151,7 +150,7 @@ def _binomial(key, p, n, shape): p = jnp.reshape(jnp.broadcast_to(p, shape), -1) n = jnp.reshape(jnp.broadcast_to(n, shape), -1) key = random.split(key, jnp.size(p)) - if xla_bridge.get_backend().platform == 'cpu': + if jax.default_backend() == 'cpu': ret = lax.map(lambda x: _binomial_dispatch(*x), (key, p, n)) else: diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index b008f4ba4..f25dab872 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -15,8 +15,7 @@ import numpy as np -from jax import device_put, lax -from jax.interpreters.xla import DeviceArray +from jax import lax if 'CI' in os.environ: DATA_DIR = os.path.expanduser('~/.data') @@ -90,7 +89,7 @@ def train_test_split(file): train.append(np.array([int(at_bats), int(hits)])) season_at_bats, season_hits = row['SeasonAt-Bats'], row['SeasonHits'] test.append(np.array([int(season_at_bats), int(season_hits)])) - return np.stack(train), np.stack(test), np.array(player_names) + return np.stack(train), np.stack(test), player_names train, test, player_names = train_test_split(os.path.join(DATA_DIR, 'EfronMorrisBB.txt')) return {'train': (train, player_names), @@ -132,13 +131,13 @@ def read_label(file): with gzip.open(file, 'rb') as f: f.read(8) data = np.frombuffer(f.read(), dtype=np.int8) / np.float32(255.) - return device_put(data) + return data def read_img(file): with gzip.open(file, 'rb') as f: _, _, nrows, ncols = struct.unpack(">IIII", f.read(16)) data = np.frombuffer(f.read(), dtype=np.uint8) / np.float32(255.) - return device_put(data.reshape(-1, nrows, ncols)) + return data.reshape(-1, nrows, ncols) files = [os.path.join(DATA_DIR, os.path.basename(urlparse(url).path)) for url in MNIST.urls] @@ -155,7 +154,6 @@ def _load_sp500(): for row in csv_reader: date.append(row['DATE']) value.append(float(row['VALUE'])) - date = np.stack(date) value = np.stack(value) return {'train': (date, value)} @@ -307,7 +305,7 @@ def init(): def get_batch(i=0, idxs=idxs): ret_idx = lax.dynamic_slice_in_dim(idxs, i * batch_size, batch_size) - return tuple(lax.index_take(a, (ret_idx,), axes=(0,)) if isinstance(a, DeviceArray) - else np.take(a, ret_idx, axis=0) for a in arrays) + return tuple(np.take(a, ret_idx, axis=0) if isinstance(a, list) + else lax.index_take(a, (ret_idx,), axes=(0,)) for a in arrays) return init, get_batch diff --git a/numpyro/handlers.py b/numpyro/handlers.py index a041f3c5b..8814143e8 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -81,7 +81,7 @@ import numpy as np -from jax import lax, random +from jax import random import jax.numpy as jnp import numpyro @@ -477,7 +477,7 @@ class mask(Messenger): """ def __init__(self, fn=None, mask=True): - if lax.dtype(mask) != 'bool': + if jnp.result_type(mask) != 'bool': raise ValueError("`mask` should be a bool array.") self.mask = mask super().__init__(fn) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 325579781..f1cc6c1b2 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -215,13 +215,13 @@ def init_kernel(init_params, possible specifications and corresponding mass matrix structures are as follows: + dense_mass=[("x", "y")]: use a dense mass matrix for the joint - (x, y) and a diagonal mass matrix for z + (x, y) and a diagonal mass matrix for z + dense_mass=[] (equivalent to dense_mass=False): use a diagonal mass - matrix for the joint (x, y, z) + matrix for the joint (x, y, z) + dense_mass=[("x", "y", "z")] (equivalent to full_mass=True): - use a dense mass matrix for the joint (x, y, z) + use a dense mass matrix for the joint (x, y, z) + dense_mass=[("x",), ("y",), ("z")]: use dense mass matrices for - each of x, y, and z (i.e. block-diagonal with 3 blocks) + each of x, y, and z (i.e. block-diagonal with 3 blocks) :type dense_mass: bool or list :param float target_accept_prob: Target acceptance probability for step size diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index fbfe80cbd..313a9fad1 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -5,8 +5,9 @@ import tqdm -from jax import jit, lax, random, tree_map +from jax import jit, lax, random import jax.numpy as jnp +from jax.tree_util import tree_map from numpyro.distributions import constraints from numpyro.distributions.transforms import biject_to diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 60d23dfd9..df928c72b 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -6,8 +6,8 @@ import functools import warnings +import jax from jax import lax, ops, random -from jax.lib import xla_bridge import jax.numpy as jnp import numpyro @@ -300,7 +300,7 @@ def module(name, nn, input_shape=None): def _subsample_fn(size, subsample_size, rng_key=None): assert rng_key is not None, "Missing random key to generate subsample indices." - if xla_bridge.get_backend().platform == 'cpu': + if jax.default_backend() == 'cpu': # ref: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm rng_keys = random.split(rng_key, subsample_size) diff --git a/setup.py b/setup.py index 316fd77dc..7b37dbd33 100644 --- a/setup.py +++ b/setup.py @@ -42,6 +42,7 @@ 'doc': ['nbsphinx', 'sphinx', 'sphinx_rtd_theme', 'sphinx-gallery'], 'test': [ 'flake8', + 'ipython', 'pytest>=4.1', 'pyro-api>=0.1.1', 'scipy>=1.1', From 60996fe1e3fe03c970adbe21239e942663258f65 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 30 Mar 2021 16:33:18 -0500 Subject: [PATCH 088/222] Using black in numpyro (#971) --- CONTRIBUTING.md | 5 +- Makefile | 5 +- docs/source/conf.py | 129 +- examples/annotation.py | 116 +- examples/baseball.py | 88 +- examples/bnn.py | 60 +- examples/capture_recapture.py | 124 +- examples/covtype.py | 158 ++- examples/funnel.py | 73 +- examples/gp.py | 80 +- examples/hmcecs.py | 94 +- examples/hmm.py | 198 ++- examples/hmm_enum.py | 177 +-- examples/minipyro.py | 10 +- examples/neutra.py | 139 +- examples/ode.py | 41 +- examples/proportion_test.py | 120 +- examples/sparse_regression.py | 191 ++- examples/stochastic_volatility.py | 78 +- examples/ucbadmit.py | 74 +- examples/vae.py | 97 +- notebooks/source/conf.py | 75 +- numpyro/__init__.py | 2 +- numpyro/compat/infer.py | 203 +-- numpyro/compat/ops.py | 9 +- numpyro/compat/optim.py | 22 +- numpyro/compat/pyro.py | 11 +- numpyro/compat/util.py | 1 + numpyro/contrib/control_flow/__init__.py | 2 +- numpyro/contrib/control_flow/scan.py | 206 ++- numpyro/contrib/einstein/kernels.py | 159 ++- numpyro/contrib/einstein/utils.py | 23 +- numpyro/contrib/funsor/__init__.py | 26 +- numpyro/contrib/funsor/discrete.py | 81 +- numpyro/contrib/funsor/enum_messenger.py | 253 ++-- numpyro/contrib/funsor/infer_util.py | 123 +- numpyro/contrib/indexing.py | 1 + numpyro/contrib/module.py | 46 +- numpyro/contrib/render.py | 116 +- numpyro/contrib/tfp/__init__.py | 6 +- numpyro/contrib/tfp/distributions.py | 50 +- numpyro/contrib/tfp/mcmc.py | 98 +- numpyro/diagnostics.py | 79 +- numpyro/distributions/__init__.py | 143 +- numpyro/distributions/conjugate.py | 88 +- numpyro/distributions/constraints.py | 134 +- numpyro/distributions/continuous.py | 739 ++++++---- numpyro/distributions/directional.py | 60 +- numpyro/distributions/discrete.py | 253 ++-- numpyro/distributions/distribution.py | 241 +++- numpyro/distributions/flows.py | 27 +- numpyro/distributions/gof.py | 27 +- numpyro/distributions/kl.py | 38 +- numpyro/distributions/transforms.py | 258 ++-- numpyro/distributions/util.py | 233 ++-- numpyro/examples/datasets.py | 222 +-- numpyro/handlers.py | 182 +-- numpyro/infer/__init__.py | 48 +- numpyro/infer/autoguide.py | 473 +++++-- numpyro/infer/barker.py | 145 +- numpyro/infer/elbo.py | 89 +- numpyro/infer/hmc.py | 426 ++++-- numpyro/infer/hmc_gibbs.py | 444 ++++-- numpyro/infer/hmc_util.py | 646 ++++++--- numpyro/infer/initialization.py | 35 +- numpyro/infer/mcmc.py | 218 ++- numpyro/infer/mixed_hmc.py | 181 ++- numpyro/infer/reparam.py | 76 +- numpyro/infer/sa.py | 135 +- numpyro/infer/svi.py | 101 +- numpyro/infer/util.py | 453 +++++-- numpyro/nn/__init__.py | 6 +- numpyro/nn/auto_reg_nn.py | 32 +- numpyro/nn/block_neural_arn.py | 35 +- numpyro/nn/masked_dense.py | 1 + numpyro/optim.py | 65 +- numpyro/patch.py | 4 +- numpyro/primitives.py | 217 +-- numpyro/util.py | 128 +- numpyro/version.py | 2 +- scripts/update_headers.py | 7 +- scripts/update_version.py | 5 +- setup.cfg | 4 +- setup.py | 89 +- test/conftest.py | 8 +- .../contrib/einstein/test_einstein_kernels.py | 111 +- test/contrib/test_control_flow.py | 59 +- test/contrib/test_funsor.py | 250 +++- test/contrib/test_indexing.py | 168 +-- test/contrib/test_infer_discrete.py | 218 +-- test/contrib/test_module.py | 77 +- test/contrib/test_tfp.py | 116 +- test/infer/test_autoguide.py | 216 +-- test/infer/test_hmc_gibbs.py | 243 ++-- test/infer/test_hmc_util.py | 309 +++-- test/infer/test_infer_util.py | 273 ++-- test/infer/test_mcmc.py | 676 ++++++---- test/infer/test_reparam.py | 69 +- test/infer/test_svi.py | 106 +- test/pyroapi/test_pyroapi.py | 6 +- test/test_compile.py | 16 +- test/test_diagnostics.py | 51 +- test/test_distributions.py | 1193 +++++++++++------ test/test_distributions_util.py | 79 +- test/test_example_utils.py | 19 +- test/test_examples.py | 62 +- test/test_flows.py | 43 +- test/test_handlers.py | 425 +++--- test/test_model_rendering.py | 138 +- test/test_nn.py | 43 +- test/test_optimizers.py | 52 +- test/test_util.py | 79 +- 112 files changed, 9935 insertions(+), 5529 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 563fda9a7..c7c6c4044 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -12,14 +12,15 @@ To set up local development environment, install NumPyro from source: ```sh git clone https://github.com/pyro-ppl/numpyro.git # install jax/jaxlib first for CUDA support -pip install -e .[dev] # contains additional dependencies for NumPyro development +pip install -e .[dev,test] # contains additional dependencies for NumPyro development ``` # Testing Before submitting a pull request, please autoformat code and ensure that unit tests pass locally ```sh -make format # runs isort +make lint # linting +make format # runs black and isort make test # linting and unit tests make doctest # test module's docstrings ``` diff --git a/Makefile b/Makefile index b9a69c0f8..fcdad2f4b 100644 --- a/Makefile +++ b/Makefile @@ -2,13 +2,16 @@ all: test lint: FORCE flake8 + black --check . + isort --check . python scripts/update_headers.py --check license: FORCE python scripts/update_headers.py format: license FORCE - isort -rc . + black . + isort . install: FORCE pip install -e .[dev,doc,test,examples] diff --git a/docs/source/conf.py b/docs/source/conf.py index ad61d11d7..66b6a6d73 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -25,10 +25,10 @@ # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # -sys.path.insert(0, os.path.abspath('../..')) +sys.path.insert(0, os.path.abspath("../..")) -os.environ['SPHINX_BUILD'] = '1' +os.environ["SPHINX_BUILD"] = "1" # HACK: This is to ensure that local functions are documented by sphinx. from numpyro.infer.hmc import hmc # noqa: E402 @@ -37,18 +37,19 @@ # -- Project information ----------------------------------------------------- -project = u'NumPyro' -copyright = u'2019, Uber Technologies, Inc' -author = u'Uber AI Labs' +project = u"NumPyro" +copyright = u"2019, Uber Technologies, Inc" +author = u"Uber AI Labs" -version = '' +version = "" -if 'READTHEDOCS' not in os.environ: +if "READTHEDOCS" not in os.environ: # if developing locally, use numpyro.__version__ as version from numpyro import __version__ # noqaE402 + version = __version__ - html_context = {'github_version': 'master'} + html_context = {"github_version": "master"} # release version release = version @@ -64,14 +65,14 @@ # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ - 'nbsphinx', - 'sphinx.ext.autodoc', - 'sphinx.ext.doctest', - 'sphinx.ext.imgconverter', - 'sphinx.ext.intersphinx', - 'sphinx.ext.mathjax', - 'sphinx.ext.viewcode', - 'sphinx_gallery.gen_gallery', + "nbsphinx", + "sphinx.ext.autodoc", + "sphinx.ext.doctest", + "sphinx.ext.imgconverter", + "sphinx.ext.intersphinx", + "sphinx.ext.mathjax", + "sphinx.ext.viewcode", + "sphinx_gallery.gen_gallery", ] # Enable documentation inheritance @@ -87,22 +88,22 @@ # } # Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] +templates_path = ["_templates"] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] -source_suffix = ['.rst', '.ipynb'] +source_suffix = [".rst", ".ipynb"] # do not execute cells -nbsphinx_execute = 'never' +nbsphinx_execute = "never" # Don't add .txt suffix to source files: -html_sourcelink_suffix = '' +html_sourcelink_suffix = "" # The master toctree document. -master_doc = 'index' +master_doc = "index" # The language for content autogenerated by Sphinx. Refer to documentation # for a list of supported languages. @@ -115,14 +116,14 @@ # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path . exclude_patterns = [ - '.ipynb_checkpoints', - 'tutorials/logistic_regression.ipynb', - 'examples/*ipynb', - 'examples/*py' + ".ipynb_checkpoints", + "tutorials/logistic_regression.ipynb", + "examples/*ipynb", + "examples/*py", ] # The name of the Pygments (syntax highlighting) style to use. -pygments_style = 'sphinx' +pygments_style = "sphinx" # do not prepend module name to functions @@ -151,7 +152,7 @@ # -- Copy README files # replace "# NumPyro" by "# Getting Started with NumPyro" -with open('../../README.md', 'rt') as f: +with open("../../README.md", "rt") as f: lines = f.readlines() for i, line in enumerate(lines): if "# NumPyro" == line.rstrip(): @@ -160,23 +161,23 @@ lines[0] = "# Getting Started with NumPyro\n" text = "\n".join(lines) -with open('getting_started.rst', 'wt') as f: +with open("getting_started.rst", "wt") as f: f.write(nbsphinx.markdown2rst(text)) # -- Copy notebook files -if not os.path.exists('tutorials'): - os.makedirs('tutorials') +if not os.path.exists("tutorials"): + os.makedirs("tutorials") -for src_file in glob.glob('../../notebooks/source/*.ipynb'): - dst_file = os.path.join('tutorials', src_file.split("/")[-1]) - shutil.copy(src_file, 'tutorials/') +for src_file in glob.glob("../../notebooks/source/*.ipynb"): + dst_file = os.path.join("tutorials", src_file.split("/")[-1]) + shutil.copy(src_file, "tutorials/") # add index file to `tutorials` path, `:orphan:` is used to # tell sphinx that this rst file needs not to be appeared in toctree -with open('../../notebooks/source/index.rst', 'rt') as f1: - with open('tutorials/index.rst', 'wt') as f2: +with open("../../notebooks/source/index.rst", "rt") as f1: + with open("tutorials/index.rst", "wt") as f2: f2.write(":orphan:\n\n") f2.write(f1.read()) @@ -184,13 +185,13 @@ # -- Convert scripts to notebooks sphinx_gallery_conf = { - 'examples_dirs': ['../../examples'], - 'gallery_dirs': ['examples'], + "examples_dirs": ["../../examples"], + "gallery_dirs": ["examples"], # only execute files beginning with plot_ - 'filename_pattern': '/plot_', - 'ignore_pattern': '(minipyro|__init__)', + "filename_pattern": "/plot_", + "ignore_pattern": "(minipyro|__init__)", # not display Total running time of the script because we do not execute it - 'min_reported_time': 1 + "min_reported_time": 1, } @@ -198,7 +199,9 @@ nbsphinx_thumbnails = {} -for src_file in (glob.glob('../../notebooks/source/*.ipynb') + glob.glob('../../examples/*.py')): +for src_file in glob.glob("../../notebooks/source/*.ipynb") + glob.glob( + "../../examples/*.py" +): toctree_path = "tutorials/" if src_file.endswith("ipynb") else "examples/" filename = os.path.splitext(src_file.split("/")[-1])[0] png_path = "_static/img/" + toctree_path + filename + ".png" @@ -211,10 +214,10 @@ # -- Options for HTML output ------------------------------------------------- # logo -html_logo = '_static/img/pyro_logo_wide.png' +html_logo = "_static/img/pyro_logo_wide.png" # logo -html_favicon = '_static/img/favicon/favicon.ico' +html_favicon = "_static/img/favicon/favicon.ico" # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. @@ -231,8 +234,8 @@ # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] -html_style = 'css/pyro.css' +html_static_path = ["_static"] +html_style = "css/pyro.css" # Custom sidebar templates, must be a dictionary that maps document names # to template names. @@ -248,7 +251,7 @@ # -- Options for HTMLHelp output --------------------------------------------- # Output file base name for HTML help builder. -htmlhelp_basename = 'numpyrodoc' +htmlhelp_basename = "numpyrodoc" # -- Options for LaTeX output ------------------------------------------------ @@ -257,18 +260,15 @@ # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', - # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', - # Additional stuff for the LaTeX preamble. # - 'preamble': r''' + "preamble": r""" \usepackage{pmboxdraw} \usepackage{alphabeta} - ''', - + """, # Latex figure (float) alignment # # 'figure_align': 'htbp', @@ -278,17 +278,14 @@ # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ - (master_doc, 'NumPyro.tex', u'NumPyro Documentation', u'Uber AI Labs', 'manual'), + (master_doc, "NumPyro.tex", u"NumPyro Documentation", u"Uber AI Labs", "manual") ] # -- Options for manual page output ------------------------------------------ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). -man_pages = [ - (master_doc, 'NumPyro', u'NumPyro Documentation', - [author], 1) -] +man_pages = [(master_doc, "NumPyro", u"NumPyro Documentation", [author], 1)] # -- Options for Texinfo output ---------------------------------------------- @@ -296,9 +293,15 @@ # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ - (master_doc, 'NumPyro', u'NumPyro Documentation', - author, 'NumPyro', 'Pyro PPL on Numpy', - 'Miscellaneous'), + ( + master_doc, + "NumPyro", + u"NumPyro Documentation", + author, + "NumPyro", + "Pyro PPL on Numpy", + "Miscellaneous", + ) ] @@ -308,8 +311,8 @@ # Example configuration for intersphinx: refer to the Python standard library. intersphinx_mapping = { - 'python': ('https://docs.python.org/3/', None), - 'numpy': ('http://docs.scipy.org/doc/numpy/', None), - 'jax': ('https://jax.readthedocs.io/en/latest/', None), - 'pyro': ('http://docs.pyro.ai/en/stable/', None), + "python": ("https://docs.python.org/3/", None), + "numpy": ("http://docs.scipy.org/doc/numpy/", None), + "jax": ("https://jax.readthedocs.io/en/latest/", None), + "pyro": ("http://docs.pyro.ai/en/stable/", None), } diff --git a/examples/annotation.py b/examples/annotation.py index e14e30eae..e4691c1b1 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -57,29 +57,55 @@ def get_data(): """ # NB: the first annotator assessed each item 3 times positions = np.array([1, 1, 1, 2, 3, 4, 5]) - annotations = np.array([ - [1, 3, 1, 2, 2, 2, 1, 3, 2, 2, 4, 2, 1, 2, 1, - 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 1, 1, - 1, 3, 1, 2, 2, 4, 2, 2, 3, 1, 1, 1, 2, 1, 2], - [1, 3, 1, 2, 2, 2, 2, 3, 2, 3, 4, 2, 1, 2, 2, - 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 3, 1, 1, 1, - 1, 3, 1, 2, 2, 3, 2, 3, 3, 1, 1, 2, 3, 2, 2], - [1, 3, 2, 2, 2, 2, 2, 3, 2, 2, 4, 2, 1, 2, 1, - 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 2, 1, 1, 2, - 1, 3, 1, 2, 2, 3, 1, 2, 3, 1, 1, 1, 2, 1, 2], - [1, 4, 2, 3, 3, 3, 2, 3, 2, 2, 4, 3, 1, 3, 1, - 2, 1, 1, 2, 1, 2, 2, 3, 2, 1, 1, 2, 1, 1, 1, - 1, 3, 1, 2, 3, 4, 2, 3, 3, 1, 1, 2, 2, 1, 2], - [1, 3, 1, 1, 2, 3, 1, 4, 2, 2, 4, 3, 1, 2, 1, - 1, 1, 1, 2, 3, 2, 2, 2, 2, 1, 1, 2, 1, 1, 1, - 1, 2, 1, 2, 2, 3, 2, 2, 4, 1, 1, 1, 2, 1, 2], - [1, 3, 2, 2, 2, 2, 1, 3, 2, 2, 4, 4, 1, 1, 1, - 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 1, 2, - 1, 3, 1, 2, 3, 4, 3, 3, 3, 1, 1, 1, 2, 1, 2], - [1, 4, 2, 1, 2, 2, 1, 3, 3, 3, 4, 3, 1, 2, 1, - 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1, - 1, 3, 1, 2, 2, 3, 2, 3, 2, 1, 1, 1, 2, 1, 2], - ]).T + annotations = np.array( + [ + [1, 1, 1, 1, 1, 1, 1], + [3, 3, 3, 4, 3, 3, 4], + [1, 1, 2, 2, 1, 2, 2], + [2, 2, 2, 3, 1, 2, 1], + [2, 2, 2, 3, 2, 2, 2], + [2, 2, 2, 3, 3, 2, 2], + [1, 2, 2, 2, 1, 1, 1], + [3, 3, 3, 3, 4, 3, 3], + [2, 2, 2, 2, 2, 2, 3], + [2, 3, 2, 2, 2, 2, 3], + [4, 4, 4, 4, 4, 4, 4], + [2, 2, 2, 3, 3, 4, 3], + [1, 1, 1, 1, 1, 1, 1], + [2, 2, 2, 3, 2, 1, 2], + [1, 2, 1, 1, 1, 1, 1], + [1, 1, 1, 2, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1], + [2, 2, 2, 2, 2, 2, 1], + [2, 2, 2, 1, 3, 2, 2], + [2, 2, 2, 2, 2, 2, 2], + [2, 2, 2, 2, 2, 2, 1], + [2, 2, 2, 3, 2, 2, 2], + [2, 2, 1, 2, 2, 2, 2], + [1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1], + [2, 3, 2, 2, 2, 2, 2], + [1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1], + [1, 1, 2, 1, 1, 2, 1], + [1, 1, 1, 1, 1, 1, 1], + [3, 3, 3, 3, 2, 3, 3], + [1, 1, 1, 1, 1, 1, 1], + [2, 2, 2, 2, 2, 2, 2], + [2, 2, 2, 3, 2, 3, 2], + [4, 3, 3, 4, 3, 4, 3], + [2, 2, 1, 2, 2, 3, 2], + [2, 3, 2, 3, 2, 3, 3], + [3, 3, 3, 3, 4, 3, 2], + [1, 1, 1, 1, 1, 1, 1], + [1, 1, 1, 1, 1, 1, 1], + [1, 2, 1, 2, 1, 1, 1], + [2, 3, 2, 2, 2, 2, 2], + [1, 2, 1, 1, 1, 1, 1], + [2, 2, 2, 2, 2, 2, 2], + ] + ) # we minus 1 because in Python, the first index is 0 return positions - 1, annotations - 1 @@ -123,7 +149,9 @@ def dawid_skene(positions, annotations): # here we use Vindex to allow broadcasting for the second index `c` # ref: http://num.pyro.ai/en/latest/utilities.html#numpyro.contrib.indexing.vindex with numpyro.plate("position", num_positions): - numpyro.sample("y", dist.Categorical(Vindex(beta)[positions, c, :]), obs=annotations) + numpyro.sample( + "y", dist.Categorical(Vindex(beta)[positions, c, :]), obs=annotations + ) def mace(positions, annotations): @@ -145,7 +173,9 @@ def mace(positions, annotations): with numpyro.plate("position", num_positions): s = numpyro.sample("s", dist.Bernoulli(1 - theta[positions])) - probs = jnp.where(s[..., None] == 0, nn.one_hot(c, num_classes), epsilon[positions]) + probs = jnp.where( + s[..., None] == 0, nn.one_hot(c, num_classes), epsilon[positions] + ) numpyro.sample("y", dist.Categorical(probs), obs=annotations) @@ -161,8 +191,12 @@ def hierarchical_dawid_skene(positions, annotations): # NB: we define `beta` as the `logits` of `y` likelihood; but `logits` is # invariant up to a constant, so we'll follow [1]: fix the last term of `beta` # to 0 and only define hyperpriors for the first `num_classes - 1` terms. - zeta = numpyro.sample("zeta", dist.Normal(0, 1).expand([num_classes - 1]).to_event(1)) - omega = numpyro.sample("Omega", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1)) + zeta = numpyro.sample( + "zeta", dist.Normal(0, 1).expand([num_classes - 1]).to_event(1) + ) + omega = numpyro.sample( + "Omega", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1) + ) with numpyro.plate("annotator", num_annotators, dim=-2): with numpyro.plate("class", num_classes): @@ -190,8 +224,12 @@ def item_difficulty(annotations): num_items, num_positions = annotations.shape with numpyro.plate("class", num_classes): - eta = numpyro.sample("eta", dist.Normal(0, 1).expand([num_classes - 1]).to_event(1)) - chi = numpyro.sample("Chi", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1)) + eta = numpyro.sample( + "eta", dist.Normal(0, 1).expand([num_classes - 1]).to_event(1) + ) + chi = numpyro.sample( + "Chi", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1) + ) pi = numpyro.sample("pi", dist.Dirichlet(jnp.ones(num_classes))) @@ -215,9 +253,15 @@ def logistic_random_effects(positions, annotations): num_items, num_positions = annotations.shape with numpyro.plate("class", num_classes): - zeta = numpyro.sample("zeta", dist.Normal(0, 1).expand([num_classes - 1]).to_event(1)) - omega = numpyro.sample("Omega", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1)) - chi = numpyro.sample("Chi", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1)) + zeta = numpyro.sample( + "zeta", dist.Normal(0, 1).expand([num_classes - 1]).to_event(1) + ) + omega = numpyro.sample( + "Omega", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1) + ) + chi = numpyro.sample( + "Chi", dist.HalfNormal(1).expand([num_classes - 1]).to_event(1) + ) with numpyro.plate("annotator", num_annotators, dim=-2): with numpyro.plate("class", num_classes): @@ -252,7 +296,11 @@ def logistic_random_effects(positions, annotations): def main(args): annotators, annotations = get_data() model = NAME_TO_MODEL[args.model] - data = (annotations,) if model in [multinomial, item_difficulty] else (annotators, annotations) + data = ( + (annotations,) + if model in [multinomial, item_difficulty] + else (annotators, annotations) + ) mcmc = MCMC( NUTS(model), @@ -266,7 +314,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="Bayesian Models of Annotation") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/baseball.py b/examples/baseball.py index 45c5c47f0..5372ab452 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -143,69 +143,89 @@ def run_inference(model, at_bats, hits, rng_key, args): kernel = HMC(model) elif args.algo == "SA": kernel = SA(model) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if ( - "NUMPYRO_SPHINXBUILD" in os.environ or args.disable_progbar) else True) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False + if ("NUMPYRO_SPHINXBUILD" in os.environ or args.disable_progbar) + else True, + ) mcmc.run(rng_key, at_bats, hits) return mcmc.get_samples() def predict(model, at_bats, hits, z, rng_key, player_names, train=True): - header = model.__name__ + (' - TRAIN' if train else ' - TEST') - predictions = Predictive(model, posterior_samples=z)(rng_key, at_bats)['obs'] - print_results('=' * 30 + header + '=' * 30, - predictions, - player_names, - at_bats, - hits) + header = model.__name__ + (" - TRAIN" if train else " - TEST") + predictions = Predictive(model, posterior_samples=z)(rng_key, at_bats)["obs"] + print_results( + "=" * 30 + header + "=" * 30, predictions, player_names, at_bats, hits + ) if not train: - post_loglik = log_likelihood(model, z, at_bats, hits)['obs'] + post_loglik = log_likelihood(model, z, at_bats, hits)["obs"] # computes expected log predictive density at each data point - exp_log_density = logsumexp(post_loglik, axis=0) - jnp.log(jnp.shape(post_loglik)[0]) + exp_log_density = logsumexp(post_loglik, axis=0) - jnp.log( + jnp.shape(post_loglik)[0] + ) # reports log predictive density of all test points - print('\nLog pointwise predictive density: {:.2f}\n'.format(exp_log_density.sum())) + print( + "\nLog pointwise predictive density: {:.2f}\n".format(exp_log_density.sum()) + ) def print_results(header, preds, player_names, at_bats, hits): - columns = ['', 'At-bats', 'ActualHits', 'Pred(p25)', 'Pred(p50)', 'Pred(p75)'] - header_format = '{:>20} {:>10} {:>10} {:>10} {:>10} {:>10}' - row_format = '{:>20} {:>10.0f} {:>10.0f} {:>10.2f} {:>10.2f} {:>10.2f}' + columns = ["", "At-bats", "ActualHits", "Pred(p25)", "Pred(p50)", "Pred(p75)"] + header_format = "{:>20} {:>10} {:>10} {:>10} {:>10} {:>10}" + row_format = "{:>20} {:>10.0f} {:>10.0f} {:>10.2f} {:>10.2f} {:>10.2f}" quantiles = jnp.quantile(preds, jnp.array([0.25, 0.5, 0.75]), axis=0) - print('\n', header, '\n') + print("\n", header, "\n") print(header_format.format(*columns)) for i, p in enumerate(player_names): - print(row_format.format(p, at_bats[i], hits[i], *quantiles[:, i]), '\n') + print(row_format.format(p, at_bats[i], hits[i], *quantiles[:, i]), "\n") def main(args): - _, fetch_train = load_dataset(BASEBALL, split='train', shuffle=False) + _, fetch_train = load_dataset(BASEBALL, split="train", shuffle=False) train, player_names = fetch_train() - _, fetch_test = load_dataset(BASEBALL, split='test', shuffle=False) + _, fetch_test = load_dataset(BASEBALL, split="test", shuffle=False) test, _ = fetch_test() at_bats, hits = train[:, 0], train[:, 1] season_at_bats, season_hits = test[:, 0], test[:, 1] - for i, model in enumerate((fully_pooled, - not_pooled, - partially_pooled, - partially_pooled_with_logit, - )): + for i, model in enumerate( + (fully_pooled, not_pooled, partially_pooled, partially_pooled_with_logit) + ): rng_key, rng_key_predict = random.split(random.PRNGKey(i + 1)) zs = run_inference(model, at_bats, hits, rng_key, args) predict(model, at_bats, hits, zs, rng_key_predict, player_names) - predict(model, season_at_bats, season_hits, zs, rng_key_predict, player_names, train=False) + predict( + model, + season_at_bats, + season_hits, + zs, + rng_key_predict, + player_names, + train=False, + ) if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="Baseball batting average using MCMC") parser.add_argument("-n", "--num-samples", nargs="?", default=3000, type=int) - parser.add_argument("--num-warmup", nargs='?', default=1500, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument('--algo', default='NUTS', type=str, - help='whether to run "HMC", "NUTS", or "SA"') - parser.add_argument('-dp', '--disable-progbar', action="store_true", default=False, - help="whether to disable progress bar") - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') + parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument( + "--algo", default="NUTS", type=str, help='whether to run "HMC", "NUTS", or "SA"' + ) + parser.add_argument( + "-dp", + "--disable-progbar", + action="store_true", + default=False, + help="whether to disable progress bar", + ) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/bnn.py b/examples/bnn.py index b72c75cfe..4aa48bb49 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -29,7 +29,7 @@ import numpyro.distributions as dist from numpyro.infer import MCMC, NUTS -matplotlib.use('Agg') # noqa: E402 +matplotlib.use("Agg") # noqa: E402 # the non-linearity we use in our neural network @@ -45,15 +45,21 @@ def model(X, Y, D_H): D_X, D_Y = X.shape[1], 1 # sample first layer (we put unit normal priors on all weights) - w1 = numpyro.sample("w1", dist.Normal(jnp.zeros((D_X, D_H)), jnp.ones((D_X, D_H)))) # D_X D_H - z1 = nonlin(jnp.matmul(X, w1)) # N D_H <= first layer of activations + w1 = numpyro.sample( + "w1", dist.Normal(jnp.zeros((D_X, D_H)), jnp.ones((D_X, D_H))) + ) # D_X D_H + z1 = nonlin(jnp.matmul(X, w1)) # N D_H <= first layer of activations # sample second layer - w2 = numpyro.sample("w2", dist.Normal(jnp.zeros((D_H, D_H)), jnp.ones((D_H, D_H)))) # D_H D_H + w2 = numpyro.sample( + "w2", dist.Normal(jnp.zeros((D_H, D_H)), jnp.ones((D_H, D_H))) + ) # D_H D_H z2 = nonlin(jnp.matmul(z1, w2)) # N D_H <= second layer of activations # sample final layer of weights and neural network output - w3 = numpyro.sample("w3", dist.Normal(jnp.zeros((D_H, D_Y)), jnp.ones((D_H, D_Y)))) # D_H D_Y + w3 = numpyro.sample( + "w3", dist.Normal(jnp.zeros((D_H, D_Y)), jnp.ones((D_H, D_Y))) + ) # D_H D_Y z3 = jnp.matmul(z2, w3) # N D_Y <= output of the neural network # we put a prior on the observation noise @@ -68,11 +74,16 @@ def model(X, Y, D_H): def run_inference(model, args, rng_key, X, Y, D_H): start = time.time() kernel = NUTS(model) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key, X, Y, D_H) mcmc.print_summary() - print('\nMCMC elapsed time:', time.time() - start) + print("\nMCMC elapsed time:", time.time() - start) return mcmc.get_samples() @@ -81,7 +92,7 @@ def predict(model, rng_key, samples, X, D_H): model = handlers.substitute(handlers.seed(model, rng_key), samples) # note that Y will be sampled in the model because we pass Y=None here model_trace = handlers.trace(model).get_trace(X=X, Y=None, D_H=D_H) - return model_trace['Y']['value'] + return model_trace["Y"]["value"] # create artificial regression dataset @@ -115,8 +126,13 @@ def main(args): samples = run_inference(model, args, rng_key, X, Y, D_H) # predict Y_test at inputs X_test - vmap_args = (samples, random.split(rng_key_predict, args.num_samples * args.num_chains)) - predictions = vmap(lambda samples, rng_key: predict(model, rng_key, samples, X_test, D_H))(*vmap_args) + vmap_args = ( + samples, + random.split(rng_key_predict, args.num_samples * args.num_chains), + ) + predictions = vmap( + lambda samples, rng_key: predict(model, rng_key, samples, X_test, D_H) + )(*vmap_args) predictions = predictions[..., 0] # compute mean prediction and confidence interval around median @@ -127,25 +143,27 @@ def main(args): fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) # plot training data - ax.plot(X[:, 1], Y[:, 0], 'kx') + ax.plot(X[:, 1], Y[:, 0], "kx") # plot 90% confidence level of predictions - ax.fill_between(X_test[:, 1], percentiles[0, :], percentiles[1, :], color='lightblue') + ax.fill_between( + X_test[:, 1], percentiles[0, :], percentiles[1, :], color="lightblue" + ) # plot mean prediction - ax.plot(X_test[:, 1], mean_prediction, 'blue', ls='solid', lw=2.0) + ax.plot(X_test[:, 1], mean_prediction, "blue", ls="solid", lw=2.0) ax.set(xlabel="X", ylabel="Y", title="Mean predictions with 90% CI") - plt.savefig('bnn_plot.pdf') + plt.savefig("bnn_plot.pdf") if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="Bayesian neural network example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) - parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument("--num-data", nargs='?', default=100, type=int) - parser.add_argument("--num-hidden", nargs='?', default=5, type=int) - parser.add_argument("--device", default='cpu', type=str, help='use "cpu" or "gpu".') + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--num-data", nargs="?", default=100, type=int) + parser.add_argument("--num-hidden", nargs="?", default=5, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/capture_recapture.py b/examples/capture_recapture.py index fd16f5fbb..e13a515c7 100644 --- a/examples/capture_recapture.py +++ b/examples/capture_recapture.py @@ -74,7 +74,9 @@ def transition_fn(carry, y): # NumPyro exactly sums out the discrete states z_t. z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) mu_y_t = rho * z - numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + numpyro.sample( + "y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y + ) first_capture_mask = first_capture_mask | y.astype(bool) return (first_capture_mask, z), None @@ -84,7 +86,11 @@ def transition_fn(carry, y): # that arise for a given individual before its first capture. first_capture_mask = capture_history[:, 0].astype(bool) # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it - scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + scan( + transition_fn, + (first_capture_mask, z), + jnp.swapaxes(capture_history[:, 1:], 0, 1), + ) # %% @@ -108,7 +114,9 @@ def transition_fn(carry, y): # NumPyro exactly sums out the discrete states z_t. z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) mu_y_t = rho * z - numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + numpyro.sample( + "y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y + ) first_capture_mask = first_capture_mask | y.astype(bool) return (first_capture_mask, z), None @@ -118,7 +126,11 @@ def transition_fn(carry, y): # that arise for a given individual before its first capture. first_capture_mask = capture_history[:, 0].astype(bool) # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it - scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + scan( + transition_fn, + (first_capture_mask, z), + jnp.swapaxes(capture_history[:, 1:], 0, 1), + ) # %% @@ -129,7 +141,9 @@ def transition_fn(carry, y): def model_3(capture_history, sex): N, T = capture_history.shape - phi_mean = numpyro.sample("phi_mean", dist.Uniform(0.0, 1.0)) # mean survival probability + phi_mean = numpyro.sample( + "phi_mean", dist.Uniform(0.0, 1.0) + ) # mean survival probability phi_logit_mean = logit(phi_mean) # controls temporal variability of survival probability phi_sigma = numpyro.sample("phi_sigma", dist.Uniform(0.0, 10.0)) @@ -138,7 +152,9 @@ def model_3(capture_history, sex): def transition_fn(carry, y): first_capture_mask, z = carry with handlers.reparam(config={"phi_logit": LocScaleReparam(0)}): - phi_logit_t = numpyro.sample("phi_logit", dist.Normal(phi_logit_mean, phi_sigma)) + phi_logit_t = numpyro.sample( + "phi_logit", dist.Normal(phi_logit_mean, phi_sigma) + ) phi_t = expit(phi_logit_t) with numpyro.plate("animals", N, dim=-1): with handlers.mask(mask=first_capture_mask): @@ -146,7 +162,9 @@ def transition_fn(carry, y): # NumPyro exactly sums out the discrete states z_t. z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) mu_y_t = rho * z - numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + numpyro.sample( + "y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y + ) first_capture_mask = first_capture_mask | y.astype(bool) return (first_capture_mask, z), None @@ -156,7 +174,11 @@ def transition_fn(carry, y): # that arise for a given individual before its first capture. first_capture_mask = capture_history[:, 0].astype(bool) # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it - scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + scan( + transition_fn, + (first_capture_mask, z), + jnp.swapaxes(capture_history[:, 1:], 0, 1), + ) # %% @@ -182,7 +204,9 @@ def transition_fn(carry, y): # NumPyro exactly sums out the discrete states z_t. z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) mu_y_t = rho * z - numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + numpyro.sample( + "y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y + ) first_capture_mask = first_capture_mask | y.astype(bool) return (first_capture_mask, z), None @@ -192,7 +216,11 @@ def transition_fn(carry, y): # that arise for a given individual before its first capture. first_capture_mask = capture_history[:, 0].astype(bool) # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it - scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + scan( + transition_fn, + (first_capture_mask, z), + jnp.swapaxes(capture_history[:, 1:], 0, 1), + ) # %% @@ -223,7 +251,9 @@ def transition_fn(carry, y): # NumPyro exactly sums out the discrete states z_t. z = numpyro.sample("z", dist.Bernoulli(dist.util.clamp_probs(mu_z_t))) mu_y_t = rho * z - numpyro.sample("y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y) + numpyro.sample( + "y", dist.Bernoulli(dist.util.clamp_probs(mu_y_t)), obs=y + ) first_capture_mask = first_capture_mask | y.astype(bool) return (first_capture_mask, z), None @@ -233,16 +263,22 @@ def transition_fn(carry, y): # that arise for a given individual before its first capture. first_capture_mask = capture_history[:, 0].astype(bool) # NB swapaxes: we move time dimension of `capture_history` to the front to scan over it - scan(transition_fn, (first_capture_mask, z), jnp.swapaxes(capture_history[:, 1:], 0, 1)) + scan( + transition_fn, + (first_capture_mask, z), + jnp.swapaxes(capture_history[:, 1:], 0, 1), + ) # %% # Do inference -models = {name[len('model_'):]: model - for name, model in globals().items() - if name.startswith('model_')} +models = { + name[len("model_") :]: model + for name, model in globals().items() + if name.startswith("model_") +} def run_inference(model, capture_history, sex, rng_key, args): @@ -250,8 +286,13 @@ def run_inference(model, capture_history, sex, rng_key, args): kernel = NUTS(model) elif args.algo == "HMC": kernel = HMC(model) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key, capture_history, sex) mcmc.print_summary() return mcmc.get_samples() @@ -260,35 +301,52 @@ def run_inference(model, capture_history, sex, rng_key, args): def main(args): # load data if args.dataset == "dipper": - capture_history, sex = load_dataset(DIPPER_VOLE, split='dipper', shuffle=False)[1]() + capture_history, sex = load_dataset(DIPPER_VOLE, split="dipper", shuffle=False)[ + 1 + ]() elif args.dataset == "vole": if args.model in ["4", "5"]: - raise ValueError("Cannot run model_{} on meadow voles data, since we lack sex " - "information for these animals.".format(args.model)) - capture_history, = load_dataset(DIPPER_VOLE, split='vole', shuffle=False)[1]() + raise ValueError( + "Cannot run model_{} on meadow voles data, since we lack sex " + "information for these animals.".format(args.model) + ) + (capture_history,) = load_dataset(DIPPER_VOLE, split="vole", shuffle=False)[1]() sex = None else: - raise ValueError("Available datasets are \'dipper\' and \'vole\'.") + raise ValueError("Available datasets are 'dipper' and 'vole'.") N, T = capture_history.shape - print("Loaded {} capture history for {} individuals collected over {} time periods.".format( - args.dataset, N, T)) + print( + "Loaded {} capture history for {} individuals collected over {} time periods.".format( + args.dataset, N, T + ) + ) model = models[args.model] rng_key = random.PRNGKey(args.rng_seed) run_inference(model, capture_history, sex, rng_key, args) -if __name__ == '__main__': - parser = argparse.ArgumentParser(description="CJS capture-recapture model for ecological data") - parser.add_argument("-m", "--model", default="1", type=str, - help="one of: {}".format(", ".join(sorted(models.keys())))) +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="CJS capture-recapture model for ecological data" + ) + parser.add_argument( + "-m", + "--model", + default="1", + type=str, + help="one of: {}".format(", ".join(sorted(models.keys()))), + ) parser.add_argument("-d", "--dataset", default="dipper", type=str) parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) - parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument('--rng_seed', default=0, type=int, help='random number generator seed') - parser.add_argument('--algo', default='NUTS', type=str, - help='whether to run "NUTS" or "HMC"') + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument( + "--rng_seed", default=0, type=int, help="random number generator seed" + ) + parser.add_argument( + "--algo", default="NUTS", type=str, help='whether to run "NUTS" or "HMC"' + ) args = parser.parse_args() main(args) diff --git a/examples/covtype.py b/examples/covtype.py index e81a62b70..2393cef6c 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -51,21 +51,24 @@ def _load_dataset(): # make binary feature _, counts = jnp.unique(labels, return_counts=True) specific_category = jnp.argmax(counts) - labels = (labels == specific_category) + labels = labels == specific_category N, dim = features.shape print("Data shape:", features.shape) - print("Label distribution: {} has label 1, {} has label 0" - .format(labels.sum(), N - labels.sum())) + print( + "Label distribution: {} has label 1, {} has label 0".format( + labels.sum(), N - labels.sum() + ) + ) return features, labels def model(data, labels, subsample_size=None): dim = data.shape[1] - coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) with numpyro.plate("N", data.shape[0], subsample_size=subsample_size) as idx: logits = jnp.dot(data[idx], coefs) - return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels[idx]) + return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels[idx]) def benchmark_hmc(args, features, labels): @@ -73,41 +76,99 @@ def benchmark_hmc(args, features, labels): start = time.time() # a MAP estimate at the following source # https://github.com/google/edward2/blob/master/examples/no_u_turn_sampler/logistic_regression.py#L117 - ref_params = {"coefs": jnp.array([ - +2.03420663e+00, -3.53567265e-02, -1.49223924e-01, -3.07049364e-01, - -1.00028366e-01, -1.46827862e-01, -1.64167881e-01, -4.20344204e-01, - +9.47479829e-02, -1.12681836e-02, +2.64442056e-01, -1.22087866e-01, - -6.00568838e-02, -3.79419506e-01, -1.06668741e-01, -2.97053963e-01, - -2.05253899e-01, -4.69537191e-02, -2.78072730e-02, -1.43250525e-01, - -6.77954629e-02, -4.34899796e-03, +5.90927452e-02, +7.23133609e-02, - +1.38526391e-02, -1.24497898e-01, -1.50733739e-02, -2.68872194e-02, - -1.80925727e-02, +3.47936489e-02, +4.03552800e-02, -9.98773426e-03, - +6.20188080e-02, +1.15002751e-01, +1.32145107e-01, +2.69109547e-01, - +2.45785132e-01, +1.19035013e-01, -2.59744357e-02, +9.94279515e-04, - +3.39266285e-02, -1.44057125e-02, -6.95222765e-02, -7.52013028e-02, - +1.21171586e-01, +2.29205526e-02, +1.47308692e-01, -8.34354162e-02, - -9.34122875e-02, -2.97472421e-02, -3.03937674e-01, -1.70958012e-01, - -1.59496680e-01, -1.88516974e-01, -1.20889175e+00])} + ref_params = { + "coefs": jnp.array( + [ + +2.03420663e00, + -3.53567265e-02, + -1.49223924e-01, + -3.07049364e-01, + -1.00028366e-01, + -1.46827862e-01, + -1.64167881e-01, + -4.20344204e-01, + +9.47479829e-02, + -1.12681836e-02, + +2.64442056e-01, + -1.22087866e-01, + -6.00568838e-02, + -3.79419506e-01, + -1.06668741e-01, + -2.97053963e-01, + -2.05253899e-01, + -4.69537191e-02, + -2.78072730e-02, + -1.43250525e-01, + -6.77954629e-02, + -4.34899796e-03, + +5.90927452e-02, + +7.23133609e-02, + +1.38526391e-02, + -1.24497898e-01, + -1.50733739e-02, + -2.68872194e-02, + -1.80925727e-02, + +3.47936489e-02, + +4.03552800e-02, + -9.98773426e-03, + +6.20188080e-02, + +1.15002751e-01, + +1.32145107e-01, + +2.69109547e-01, + +2.45785132e-01, + +1.19035013e-01, + -2.59744357e-02, + +9.94279515e-04, + +3.39266285e-02, + -1.44057125e-02, + -6.95222765e-02, + -7.52013028e-02, + +1.21171586e-01, + +2.29205526e-02, + +1.47308692e-01, + -8.34354162e-02, + -9.34122875e-02, + -2.97472421e-02, + -3.03937674e-01, + -1.70958012e-01, + -1.59496680e-01, + -1.88516974e-01, + -1.20889175e00, + ] + ) + } if args.algo == "HMC": step_size = jnp.sqrt(0.5 / features.shape[0]) trajectory_length = step_size * args.num_steps - kernel = HMC(model, step_size=step_size, trajectory_length=trajectory_length, adapt_step_size=False, - dense_mass=args.dense_mass) + kernel = HMC( + model, + step_size=step_size, + trajectory_length=trajectory_length, + adapt_step_size=False, + dense_mass=args.dense_mass, + ) subsample_size = None elif args.algo == "NUTS": kernel = NUTS(model, dense_mass=args.dense_mass) subsample_size = None elif args.algo == "HMCECS": subsample_size = 1000 - inner_kernel = NUTS(model, init_strategy=init_to_value(values=ref_params), - dense_mass=args.dense_mass) + inner_kernel = NUTS( + model, + init_strategy=init_to_value(values=ref_params), + dense_mass=args.dense_mass, + ) # note: if num_blocks=100, we'll update 10 index at each MCMC step # so it took 50000 MCMC steps to iterative the whole dataset - kernel = HMCECS(inner_kernel, num_blocks=100, proxy=HMCECS.taylor_proxy(ref_params)) + kernel = HMCECS( + inner_kernel, num_blocks=100, proxy=HMCECS.taylor_proxy(ref_params) + ) elif args.algo == "SA": # NB: this kernel requires large num_warmup and num_samples # and running on GPU is much faster than on CPU - kernel = SA(model, adapt_state_size=1000, init_strategy=init_to_value(values=ref_params)) + kernel = SA( + model, adapt_state_size=1000, init_strategy=init_to_value(values=ref_params) + ) subsample_size = None elif args.algo == "FlowHMCECS": subsample_size = 1000 @@ -121,16 +182,21 @@ def benchmark_hmc(args, features, labels): neutra_model = neutra.reparam(model) neutra_ref_params = {"auto_shared_latent": jnp.zeros(55)} # no need to adapt mass matrix if the flow does a good job - inner_kernel = NUTS(neutra_model, init_strategy=init_to_value(values=neutra_ref_params), - adapt_mass_matrix=False) - kernel = HMCECS(inner_kernel, num_blocks=100, proxy=HMCECS.taylor_proxy(neutra_ref_params)) + inner_kernel = NUTS( + neutra_model, + init_strategy=init_to_value(values=neutra_ref_params), + adapt_mass_matrix=False, + ) + kernel = HMCECS( + inner_kernel, num_blocks=100, proxy=HMCECS.taylor_proxy(neutra_ref_params) + ) else: raise ValueError("Invalid algorithm, either 'HMC', 'NUTS', or 'HMCECS'.") mcmc = MCMC(kernel, args.num_warmup, args.num_samples) mcmc.run(rng_key, features, labels, subsample_size, extra_fields=("accept_prob",)) print("Mean accept prob:", jnp.mean(mcmc.get_extra_fields()["accept_prob"])) mcmc.print_summary(exclude_deterministic=False) - print('\nMCMC elapsed time:', time.time() - start) + print("\nMCMC elapsed time:", time.time() - start) def main(args): @@ -138,18 +204,28 @@ def main(args): benchmark_hmc(args, features, labels) -if __name__ == '__main__': - assert numpyro.__version__.startswith('0.6.0') +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="parse args") - parser.add_argument('-n', '--num-samples', default=1000, type=int, help='number of samples') - parser.add_argument('--num-warmup', default=1000, type=int, help='number of warmup steps') - parser.add_argument('--num-steps', default=10, type=int, help='number of steps (for "HMC")') - parser.add_argument('--num-chains', nargs='?', default=1, type=int) - parser.add_argument('--algo', default='HMCECS', type=str, - help='whether to run "HMC", "NUTS", "HMCECS", "SA" or "FlowHMCECS"') - parser.add_argument('--dense-mass', action="store_true") - parser.add_argument('--x64', action="store_true") - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') + parser.add_argument( + "-n", "--num-samples", default=1000, type=int, help="number of samples" + ) + parser.add_argument( + "--num-warmup", default=1000, type=int, help="number of warmup steps" + ) + parser.add_argument( + "--num-steps", default=10, type=int, help='number of steps (for "HMC")' + ) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument( + "--algo", + default="HMCECS", + type=str, + help='whether to run "HMC", "NUTS", "HMCECS", "SA" or "FlowHMCECS"', + ) + parser.add_argument("--dense-mass", action="store_true") + parser.add_argument("--x64", action="store_true") + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/funnel.py b/examples/funnel.py index add3288f4..e0346e427 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -42,17 +42,22 @@ def model(dim=10): - y = numpyro.sample('y', dist.Normal(0, 3)) - numpyro.sample('x', dist.Normal(jnp.zeros(dim - 1), jnp.exp(y / 2))) + y = numpyro.sample("y", dist.Normal(0, 3)) + numpyro.sample("x", dist.Normal(jnp.zeros(dim - 1), jnp.exp(y / 2))) -reparam_model = reparam(model, config={'x': LocScaleReparam(0)}) +reparam_model = reparam(model, config={"x": LocScaleReparam(0)}) def run_inference(model, args, rng_key): kernel = NUTS(model) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key) mcmc.print_summary(exclude_deterministic=False) return mcmc.get_samples() @@ -62,37 +67,55 @@ def main(args): rng_key = random.PRNGKey(0) # do inference with centered parameterization - print("============================= Centered Parameterization ==============================") + print( + "============================= Centered Parameterization ==============================" + ) samples = run_inference(model, args, rng_key) # do inference with non-centered parameterization - print("\n=========================== Non-centered Parameterization ============================") + print( + "\n=========================== Non-centered Parameterization ============================" + ) reparam_samples = run_inference(reparam_model, args, rng_key) # collect deterministic sites - reparam_samples = Predictive(reparam_model, reparam_samples, return_sites=['x', 'y'])( - random.PRNGKey(1)) + reparam_samples = Predictive( + reparam_model, reparam_samples, return_sites=["x", "y"] + )(random.PRNGKey(1)) # make plots - fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 8), constrained_layout=True) - - ax1.plot(samples['x'][:, 0], samples['y'], "go", alpha=0.3) - ax1.set(xlim=(-20, 20), ylim=(-9, 9), ylabel='y', - title='Funnel samples with centered parameterization') - - ax2.plot(reparam_samples['x'][:, 0], reparam_samples['y'], "go", alpha=0.3) - ax2.set(xlim=(-20, 20), ylim=(-9, 9), xlabel='x[0]', ylabel='y', - title='Funnel samples with non-centered parameterization') - - plt.savefig('funnel_plot.pdf') + fig, (ax1, ax2) = plt.subplots( + 2, 1, sharex=True, figsize=(8, 8), constrained_layout=True + ) + + ax1.plot(samples["x"][:, 0], samples["y"], "go", alpha=0.3) + ax1.set( + xlim=(-20, 20), + ylim=(-9, 9), + ylabel="y", + title="Funnel samples with centered parameterization", + ) + + ax2.plot(reparam_samples["x"][:, 0], reparam_samples["y"], "go", alpha=0.3) + ax2.set( + xlim=(-20, 20), + ylim=(-9, 9), + xlabel="x[0]", + ylabel="y", + title="Funnel samples with non-centered parameterization", + ) + + plt.savefig("funnel_plot.pdf") if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') - parser = argparse.ArgumentParser(description="Non-centered reparameterization example") + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser( + description="Non-centered reparameterization example" + ) parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) - parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument("--device", default='cpu', type=str, help='use "cpu" or "gpu".') + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/gp.py b/examples/gp.py index a64405d83..0c4eed324 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -27,9 +27,17 @@ import numpyro import numpyro.distributions as dist -from numpyro.infer import MCMC, NUTS, init_to_feasible, init_to_median, init_to_sample, init_to_uniform, init_to_value +from numpyro.infer import ( + MCMC, + NUTS, + init_to_feasible, + init_to_median, + init_to_sample, + init_to_uniform, + init_to_value, +) -matplotlib.use('Agg') # noqa: E402 +matplotlib.use("Agg") # noqa: E402 # squared exponential kernel with diagonal noise term @@ -51,8 +59,11 @@ def model(X, Y): k = kernel(X, X, var, length, noise) # sample Y according to the standard gaussian process formula - numpyro.sample("Y", dist.MultivariateNormal(loc=jnp.zeros(X.shape[0]), covariance_matrix=k), - obs=Y) + numpyro.sample( + "Y", + dist.MultivariateNormal(loc=jnp.zeros(X.shape[0]), covariance_matrix=k), + obs=Y, + ) # helper function for doing hmc inference @@ -60,7 +71,9 @@ def run_inference(model, args, rng_key, X, Y): start = time.time() # demonstrate how to use different HMC initialization strategies if args.init_strategy == "value": - init_strategy = init_to_value(values={"kernel_var": 1.0, "kernel_noise": 0.05, "kernel_length": 0.5}) + init_strategy = init_to_value( + values={"kernel_var": 1.0, "kernel_noise": 0.05, "kernel_length": 0.5} + ) elif args.init_strategy == "median": init_strategy = init_to_median(num_samples=10) elif args.init_strategy == "feasible": @@ -70,11 +83,17 @@ def run_inference(model, args, rng_key, X, Y): elif args.init_strategy == "uniform": init_strategy = init_to_uniform(radius=1) kernel = NUTS(model, init_strategy=init_strategy) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, thinning=args.thinning, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + thinning=args.thinning, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key, X, Y) mcmc.print_summary() - print('\nMCMC elapsed time:', time.time() - start) + print("\nMCMC elapsed time:", time.time() - start) return mcmc.get_samples() @@ -87,7 +106,9 @@ def predict(rng_key, X, Y, X_test, var, length, noise): k_XX = kernel(X, X, var, length, noise, include_noise=True) K_xx_inv = jnp.linalg.inv(k_XX) K = k_pp - jnp.matmul(k_pX, jnp.matmul(K_xx_inv, jnp.transpose(k_pX))) - sigma_noise = jnp.sqrt(jnp.clip(jnp.diag(K), a_min=0.)) * jax.random.normal(rng_key, X_test.shape[:1]) + sigma_noise = jnp.sqrt(jnp.clip(jnp.diag(K), a_min=0.0)) * jax.random.normal( + rng_key, X_test.shape[:1] + ) mean = jnp.matmul(k_pX, jnp.matmul(K_xx_inv, Y)) # we return both the mean function and a sample from the posterior predictive for the # given set of hyperparameters @@ -119,10 +140,17 @@ def main(args): samples = run_inference(model, args, rng_key, X, Y) # do prediction - vmap_args = (random.split(rng_key_predict, samples['kernel_var'].shape[0]), - samples['kernel_var'], samples['kernel_length'], samples['kernel_noise']) - means, predictions = vmap(lambda rng_key, var, length, noise: - predict(rng_key, X, Y, X_test, var, length, noise))(*vmap_args) + vmap_args = ( + random.split(rng_key_predict, samples["kernel_var"].shape[0]), + samples["kernel_var"], + samples["kernel_length"], + samples["kernel_noise"], + ) + means, predictions = vmap( + lambda rng_key, var, length, noise: predict( + rng_key, X, Y, X_test, var, length, noise + ) + )(*vmap_args) mean_prediction = np.mean(means, axis=0) percentiles = np.percentile(predictions, [5.0, 95.0], axis=0) @@ -131,27 +159,31 @@ def main(args): fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) # plot training data - ax.plot(X, Y, 'kx') + ax.plot(X, Y, "kx") # plot 90% confidence level of predictions - ax.fill_between(X_test, percentiles[0, :], percentiles[1, :], color='lightblue') + ax.fill_between(X_test, percentiles[0, :], percentiles[1, :], color="lightblue") # plot mean prediction - ax.plot(X_test, mean_prediction, 'blue', ls='solid', lw=2.0) + ax.plot(X_test, mean_prediction, "blue", ls="solid", lw=2.0) ax.set(xlabel="X", ylabel="Y", title="Mean predictions with 90% CI") plt.savefig("gp_plot.pdf") if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) - parser.add_argument("--num-warmup", nargs='?', default=1000, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument("--thinning", nargs='?', default=2, type=int) - parser.add_argument("--num-data", nargs='?', default=25, type=int) - parser.add_argument("--device", default='cpu', type=str, help='use "cpu" or "gpu".') - parser.add_argument("--init-strategy", default='median', type=str, - choices=['median', 'feasible', 'value', 'uniform', 'sample']) + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--thinning", nargs="?", default=2, type=int) + parser.add_argument("--num-data", nargs="?", default=25, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') + parser.add_argument( + "--init-strategy", + default="median", + type=str, + choices=["median", "feasible", "value", "uniform", "sample"], + ) args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/hmcecs.py b/examples/hmcecs.py index 3548516c0..c6abdc4ed 100644 --- a/examples/hmcecs.py +++ b/examples/hmcecs.py @@ -34,11 +34,13 @@ def model(data, obs, subsample_size): n, m = data.shape - theta = numpyro.sample('theta', dist.Normal(jnp.zeros(m), .5 * jnp.ones(m))) - with numpyro.plate('N', n, subsample_size=subsample_size): + theta = numpyro.sample("theta", dist.Normal(jnp.zeros(m), 0.5 * jnp.ones(m))) + with numpyro.plate("N", n, subsample_size=subsample_size): batch_feats = numpyro.subsample(data, event_dim=1) batch_obs = numpyro.subsample(obs, event_dim=0) - numpyro.sample('obs', dist.Bernoulli(logits=theta @ batch_feats.T), obs=batch_obs) + numpyro.sample( + "obs", dist.Bernoulli(logits=theta @ batch_feats.T), obs=batch_obs + ) def run_hmcecs(hmcecs_key, args, data, obs, inner_kernel): @@ -48,8 +50,10 @@ def run_hmcecs(hmcecs_key, args, data, obs, inner_kernel): optimizer = numpyro.optim.Adam(step_size=1e-3) guide = autoguide.AutoDelta(model) svi = SVI(model, guide, optimizer, loss=Trace_ELBO()) - params, losses = svi.run(svi_key, args.num_svi_steps, data, obs, args.subsample_size) - ref_params = {'theta': params['theta_auto_loc']} + params, losses = svi.run( + svi_key, args.num_svi_steps, data, obs, args.subsample_size + ) + ref_params = {"theta": params["theta_auto_loc"]} # taylor proxy estimates log likelihood (ll) by # taylor_expansion(ll, theta_curr) + @@ -72,10 +76,14 @@ def run_hmc(mcmc_key, args, data, obs, kernel): def main(args): - assert 11_000_000 >= args.num_datapoints, "11,000,000 data points in the Higgs dataset" + assert ( + 11_000_000 >= args.num_datapoints + ), "11,000,000 data points in the Higgs dataset" # full dataset takes hours for plain hmc! - if args.dataset == 'higgs': - _, fetch = load_dataset(HIGGS, shuffle=False, num_datapoints=args.num_datapoints) + if args.dataset == "higgs": + _, fetch = load_dataset( + HIGGS, shuffle=False, num_datapoints=args.num_datapoints + ) data, obs = fetch() else: data, obs = (np.random.normal(size=(10, 28)), np.ones(10)) @@ -83,7 +91,7 @@ def main(args): hmcecs_key, hmc_key = random.split(random.PRNGKey(args.rng_seed)) # choose inner_kernel - if args.inner_kernel == 'hmc': + if args.inner_kernel == "hmc": inner_kernel = HMC(model) else: inner_kernel = NUTS(model) @@ -101,48 +109,56 @@ def main(args): def summary_plot(losses, hmc_samples, hmcecs_samples, hmc_runtime, hmcecs_runtime): fig, ax = plt.subplots(2, 2) - ax[0, 0].plot(losses, 'r') - ax[0, 0].set_title('SVI losses') - ax[0, 0].set_ylabel('ELBO') + ax[0, 0].plot(losses, "r") + ax[0, 0].set_title("SVI losses") + ax[0, 0].set_ylabel("ELBO") if hmc_runtime > hmcecs_runtime: - ax[0, 1].bar([0], hmc_runtime, label='hmc', color='b') - ax[0, 1].bar([0], hmcecs_runtime, label='hmcecs', color='r') + ax[0, 1].bar([0], hmc_runtime, label="hmc", color="b") + ax[0, 1].bar([0], hmcecs_runtime, label="hmcecs", color="r") else: - ax[0, 1].bar([0], hmcecs_runtime, label='hmcecs', color='r') - ax[0, 1].bar([0], hmc_runtime, label='hmc', color='b') - ax[0, 1].set_title('Runtime') - ax[0, 1].set_ylabel('Seconds') + ax[0, 1].bar([0], hmcecs_runtime, label="hmcecs", color="r") + ax[0, 1].bar([0], hmc_runtime, label="hmc", color="b") + ax[0, 1].set_title("Runtime") + ax[0, 1].set_ylabel("Seconds") ax[0, 1].legend() ax[0, 1].set_xticks([]) - ax[1, 0].plot(jnp.sort(hmc_samples['theta'].mean(0)), 'or') - ax[1, 0].plot(jnp.sort(hmcecs_samples['theta'].mean(0)), 'b') - ax[1, 0].set_title(r'$\mathrm{\mathbb{E}}[\theta]$') + ax[1, 0].plot(jnp.sort(hmc_samples["theta"].mean(0)), "or") + ax[1, 0].plot(jnp.sort(hmcecs_samples["theta"].mean(0)), "b") + ax[1, 0].set_title(r"$\mathrm{\mathbb{E}}[\theta]$") - ax[1, 1].plot(jnp.sort(hmc_samples['theta'].var(0)), 'or') - ax[1, 1].plot(jnp.sort(hmcecs_samples['theta'].var(0)), 'b') - ax[1, 1].set_title(r'Var$[\theta]$') + ax[1, 1].plot(jnp.sort(hmc_samples["theta"].var(0)), "or") + ax[1, 1].plot(jnp.sort(hmcecs_samples["theta"].var(0)), "b") + ax[1, 1].set_title(r"Var$[\theta]$") for a in ax[1, :]: a.set_xticks([]) fig.tight_layout() - fig.savefig('hmcecs_plot.pdf', bbox_inches='tight') - - -if __name__ == '__main__': - parser = argparse.ArgumentParser("Hamiltonian Monte Carlo with Energy Conserving Subsampling") - parser.add_argument('--subsample_size', type=int, default=1300) - parser.add_argument('--num_svi_steps', type=int, default=5000) - parser.add_argument('--num_blocks', type=int, default=100) - parser.add_argument('--num_warmup', type=int, default=500) - parser.add_argument('--num_samples', type=int, default=500) - parser.add_argument('--num_datapoints', type=int, default=1_500_000) - parser.add_argument('--dataset', type=str, choices=['higgs', 'mock'], default='higgs') - parser.add_argument('--inner_kernel', type=str, choices=['nuts', 'hmc'], default='nuts') - parser.add_argument('--device', default='cpu', type=str, choices=['cpu', 'gpu']) - parser.add_argument('--rng_seed', default=37, type=int, help='random number generator seed') + fig.savefig("hmcecs_plot.pdf", bbox_inches="tight") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + "Hamiltonian Monte Carlo with Energy Conserving Subsampling" + ) + parser.add_argument("--subsample_size", type=int, default=1300) + parser.add_argument("--num_svi_steps", type=int, default=5000) + parser.add_argument("--num_blocks", type=int, default=100) + parser.add_argument("--num_warmup", type=int, default=500) + parser.add_argument("--num_samples", type=int, default=500) + parser.add_argument("--num_datapoints", type=int, default=1_500_000) + parser.add_argument( + "--dataset", type=str, choices=["higgs", "mock"], default="higgs" + ) + parser.add_argument( + "--inner_kernel", type=str, choices=["nuts", "hmc"], default="nuts" + ) + parser.add_argument("--device", default="cpu", type=str, choices=["cpu", "gpu"]) + parser.add_argument( + "--rng_seed", default=37, type=int, help="random number generator seed" + ) args = parser.parse_args() diff --git a/examples/hmm.py b/examples/hmm.py index 7be0f19b5..95f3c94c8 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -46,25 +46,31 @@ from numpyro.infer import MCMC, NUTS -def simulate_data(rng_key, num_categories, num_words, num_supervised_data, num_unsupervised_data): +def simulate_data( + rng_key, num_categories, num_words, num_supervised_data, num_unsupervised_data +): rng_key, rng_key_transition, rng_key_emission = random.split(rng_key, 3) transition_prior = jnp.ones(num_categories) emission_prior = jnp.repeat(0.1, num_words) - transition_prob = dist.Dirichlet(transition_prior).sample(key=rng_key_transition, - sample_shape=(num_categories,)) - emission_prob = dist.Dirichlet(emission_prior).sample(key=rng_key_emission, - sample_shape=(num_categories,)) + transition_prob = dist.Dirichlet(transition_prior).sample( + key=rng_key_transition, sample_shape=(num_categories,) + ) + emission_prob = dist.Dirichlet(emission_prior).sample( + key=rng_key_emission, sample_shape=(num_categories,) + ) - start_prob = jnp.repeat(1. / num_categories, num_categories) + start_prob = jnp.repeat(1.0 / num_categories, num_categories) categories, words = [], [] for t in range(num_supervised_data + num_unsupervised_data): rng_key, rng_key_transition, rng_key_emission = random.split(rng_key, 3) if t == 0 or t == num_supervised_data: category = dist.Categorical(start_prob).sample(key=rng_key_transition) else: - category = dist.Categorical(transition_prob[category]).sample(key=rng_key_transition) + category = dist.Categorical(transition_prob[category]).sample( + key=rng_key_transition + ) word = dist.Categorical(emission_prob[category]).sample(key=rng_key_emission) categories.append(category) words.append(word) @@ -74,8 +80,15 @@ def simulate_data(rng_key, num_categories, num_words, num_supervised_data, num_u supervised_categories = categories[:num_supervised_data] supervised_words = words[:num_supervised_data] unsupervised_words = words[num_supervised_data:] - return (transition_prior, emission_prior, transition_prob, emission_prob, - supervised_categories, supervised_words, unsupervised_words) + return ( + transition_prior, + emission_prior, + transition_prob, + emission_prob, + supervised_categories, + supervised_words, + unsupervised_words, + ) def forward_one_step(prev_log_prob, curr_word, transition_log_prob, emission_log_prob): @@ -84,7 +97,9 @@ def forward_one_step(prev_log_prob, curr_word, transition_log_prob, emission_log return logsumexp(log_prob, axis=0) -def forward_log_prob(init_log_prob, words, transition_log_prob, emission_log_prob, unroll_loop=False): +def forward_log_prob( + init_log_prob, words, transition_log_prob, emission_log_prob, unroll_loop=False +): # Note: The following naive implementation will make it very slow to compile # and do inference. So we use lax.scan instead. # @@ -92,87 +107,137 @@ def forward_log_prob(init_log_prob, words, transition_log_prob, emission_log_pro # >>> for word in words: # ... log_prob = forward_one_step(log_prob, word, transition_log_prob, emission_log_prob) def scan_fn(log_prob, word): - return forward_one_step(log_prob, word, transition_log_prob, emission_log_prob), jnp.zeros((0,)) + return ( + forward_one_step(log_prob, word, transition_log_prob, emission_log_prob), + None, # we don't need to collect during scan + ) if unroll_loop: log_prob = init_log_prob for word in words: - log_prob = forward_one_step(log_prob, word, transition_log_prob, emission_log_prob) + log_prob = forward_one_step( + log_prob, word, transition_log_prob, emission_log_prob + ) else: log_prob, _ = lax.scan(scan_fn, init_log_prob, words) return log_prob -def semi_supervised_hmm(transition_prior, emission_prior, - supervised_categories, supervised_words, - unsupervised_words, unroll_loop=False): +def semi_supervised_hmm( + transition_prior, + emission_prior, + supervised_categories, + supervised_words, + unsupervised_words, + unroll_loop=False, +): num_categories, num_words = transition_prior.shape[0], emission_prior.shape[0] - transition_prob = numpyro.sample('transition_prob', dist.Dirichlet( - jnp.broadcast_to(transition_prior, (num_categories, num_categories)))) - emission_prob = numpyro.sample('emission_prob', dist.Dirichlet( - jnp.broadcast_to(emission_prior, (num_categories, num_words)))) + transition_prob = numpyro.sample( + "transition_prob", + dist.Dirichlet( + jnp.broadcast_to(transition_prior, (num_categories, num_categories)) + ), + ) + emission_prob = numpyro.sample( + "emission_prob", + dist.Dirichlet(jnp.broadcast_to(emission_prior, (num_categories, num_words))), + ) # models supervised data; # here we don't make any assumption about the first supervised category, in other words, # we place a flat/uniform prior on it. - numpyro.sample('supervised_categories', dist.Categorical(transition_prob[supervised_categories[:-1]]), - obs=supervised_categories[1:]) - numpyro.sample('supervised_words', dist.Categorical(emission_prob[supervised_categories]), - obs=supervised_words) + numpyro.sample( + "supervised_categories", + dist.Categorical(transition_prob[supervised_categories[:-1]]), + obs=supervised_categories[1:], + ) + numpyro.sample( + "supervised_words", + dist.Categorical(emission_prob[supervised_categories]), + obs=supervised_words, + ) # computes log prob of unsupervised data transition_log_prob = jnp.log(transition_prob) emission_log_prob = jnp.log(emission_prob) init_log_prob = emission_log_prob[:, unsupervised_words[0]] - log_prob = forward_log_prob(init_log_prob, unsupervised_words[1:], - transition_log_prob, emission_log_prob, unroll_loop) + log_prob = forward_log_prob( + init_log_prob, + unsupervised_words[1:], + transition_log_prob, + emission_log_prob, + unroll_loop, + ) log_prob = logsumexp(log_prob, axis=0, keepdims=True) # inject log_prob to potential function - numpyro.factor('forward_log_prob', log_prob) + numpyro.factor("forward_log_prob", log_prob) def print_results(posterior, transition_prob, emission_prob): - header = semi_supervised_hmm.__name__ + ' - TRAIN' - columns = ['', 'ActualProb', 'Pred(p25)', 'Pred(p50)', 'Pred(p75)'] - header_format = '{:>20} {:>10} {:>10} {:>10} {:>10}' - row_format = '{:>20} {:>10.2f} {:>10.2f} {:>10.2f} {:>10.2f}' - print('\n', '=' * 20 + header + '=' * 20, '\n') + header = semi_supervised_hmm.__name__ + " - TRAIN" + columns = ["", "ActualProb", "Pred(p25)", "Pred(p50)", "Pred(p75)"] + header_format = "{:>20} {:>10} {:>10} {:>10} {:>10}" + row_format = "{:>20} {:>10.2f} {:>10.2f} {:>10.2f} {:>10.2f}" + print("\n", "=" * 20 + header + "=" * 20, "\n") print(header_format.format(*columns)) - quantiles = np.quantile(posterior['transition_prob'], [0.25, 0.5, 0.75], axis=0) + quantiles = np.quantile(posterior["transition_prob"], [0.25, 0.5, 0.75], axis=0) for i in range(transition_prob.shape[0]): for j in range(transition_prob.shape[1]): - idx = 'transition[{},{}]'.format(i, j) - print(row_format.format(idx, transition_prob[i, j], *quantiles[:, i, j]), '\n') + idx = "transition[{},{}]".format(i, j) + print( + row_format.format(idx, transition_prob[i, j], *quantiles[:, i, j]), "\n" + ) - quantiles = np.quantile(posterior['emission_prob'], [0.25, 0.5, 0.75], axis=0) + quantiles = np.quantile(posterior["emission_prob"], [0.25, 0.5, 0.75], axis=0) for i in range(emission_prob.shape[0]): for j in range(emission_prob.shape[1]): - idx = 'emission[{},{}]'.format(i, j) - print(row_format.format(idx, emission_prob[i, j], *quantiles[:, i, j]), '\n') + idx = "emission[{},{}]".format(i, j) + print( + row_format.format(idx, emission_prob[i, j], *quantiles[:, i, j]), "\n" + ) def main(args): - print('Simulating data...') - (transition_prior, emission_prior, transition_prob, emission_prob, - supervised_categories, supervised_words, unsupervised_words) = simulate_data( + print("Simulating data...") + ( + transition_prior, + emission_prior, + transition_prob, + emission_prob, + supervised_categories, + supervised_words, + unsupervised_words, + ) = simulate_data( random.PRNGKey(1), num_categories=args.num_categories, num_words=args.num_words, num_supervised_data=args.num_supervised, num_unsupervised_data=args.num_unsupervised, ) - print('Starting inference...') + print("Starting inference...") rng_key = random.PRNGKey(2) start = time.time() kernel = NUTS(semi_supervised_hmm) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) - mcmc.run(rng_key, transition_prior, emission_prior, supervised_categories, - supervised_words, unsupervised_words, args.unroll_loop) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) + mcmc.run( + rng_key, + transition_prior, + emission_prior, + supervised_categories, + supervised_words, + unsupervised_words, + args.unroll_loop, + ) samples = mcmc.get_samples() print_results(samples, transition_prob, emission_prob) - print('\nMCMC elapsed time:', time.time() - start) + print("\nMCMC elapsed time:", time.time() - start) # make plots fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) @@ -180,28 +245,35 @@ def main(args): x = np.linspace(0, 1, 101) for i in range(transition_prob.shape[0]): for j in range(transition_prob.shape[1]): - ax.plot(x, gaussian_kde(samples['transition_prob'][:, i, j])(x), - label="trans_prob[{}, {}], true value = {:.2f}" - .format(i, j, transition_prob[i, j])) - ax.set(xlabel="Probability", ylabel="Frequency", - title="Transition probability posterior") + ax.plot( + x, + gaussian_kde(samples["transition_prob"][:, i, j])(x), + label="trans_prob[{}, {}], true value = {:.2f}".format( + i, j, transition_prob[i, j] + ), + ) + ax.set( + xlabel="Probability", + ylabel="Frequency", + title="Transition probability posterior", + ) ax.legend() plt.savefig("hmm_plot.pdf") -if __name__ == '__main__': - assert numpyro.__version__.startswith('0.6.0') - parser = argparse.ArgumentParser(description='Semi-supervised Hidden Markov Model') - parser.add_argument('--num-categories', default=3, type=int) - parser.add_argument('--num-words', default=10, type=int) - parser.add_argument('--num-supervised', default=100, type=int) - parser.add_argument('--num-unsupervised', default=500, type=int) - parser.add_argument('-n', '--num-samples', nargs='?', default=1000, type=int) - parser.add_argument('--num-warmup', nargs='?', default=500, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument("--unroll-loop", action='store_true') - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser(description="Semi-supervised Hidden Markov Model") + parser.add_argument("--num-categories", default=3, type=int) + parser.add_argument("--num-words", default=10, type=int) + parser.add_argument("--num-supervised", default=100, type=int) + parser.add_argument("--num-unsupervised", default=500, type=int) + parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=500, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--unroll-loop", action="store_true") + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/hmm_enum.py b/examples/hmm_enum.py index 5a52f192a..636aa0b86 100644 --- a/examples/hmm_enum.py +++ b/examples/hmm_enum.py @@ -82,13 +82,13 @@ def model_1(sequences, lengths, args, include_prior=True): num_sequences, max_length, data_dim = sequences.shape with mask(mask=include_prior): - probs_x = numpyro.sample("probs_x", - dist.Dirichlet(0.9 * jnp.eye(args.hidden_dim) + 0.1) - .to_event(1)) - probs_y = numpyro.sample("probs_y", - dist.Beta(0.1, 0.9) - .expand([args.hidden_dim, data_dim]) - .to_event(2)) + probs_x = numpyro.sample( + "probs_x", dist.Dirichlet(0.9 * jnp.eye(args.hidden_dim) + 0.1).to_event(1) + ) + probs_y = numpyro.sample( + "probs_y", + dist.Beta(0.1, 0.9).expand([args.hidden_dim, data_dim]).to_event(2), + ) def transition_fn(carry, y): x_prev, t = carry @@ -114,14 +114,14 @@ def transition_fn(carry, y): def model_2(sequences, lengths, args, include_prior=True): num_sequences, max_length, data_dim = sequences.shape with mask(mask=include_prior): - probs_x = numpyro.sample("probs_x", - dist.Dirichlet(0.9 * jnp.eye(args.hidden_dim) + 0.1) - .to_event(1)) + probs_x = numpyro.sample( + "probs_x", dist.Dirichlet(0.9 * jnp.eye(args.hidden_dim) + 0.1).to_event(1) + ) - probs_y = numpyro.sample("probs_y", - dist.Beta(0.1, 0.9) - .expand([args.hidden_dim, 2, data_dim]) - .to_event(3)) + probs_y = numpyro.sample( + "probs_y", + dist.Beta(0.1, 0.9).expand([args.hidden_dim, 2, data_dim]).to_event(3), + ) def transition_fn(carry, y): x_prev, y_prev, t = carry @@ -132,9 +132,9 @@ def transition_fn(carry, y): # we also need a final tensor for the tones dimension. This is conveniently # provided by the plate associated with that dimension. with numpyro.plate("tones", data_dim, dim=-1) as tones: - y = numpyro.sample("y", - dist.Bernoulli(probs_y[x, y_prev, tones]), - obs=y) + y = numpyro.sample( + "y", dist.Bernoulli(probs_y[x, y_prev, tones]), obs=y + ) return (x, y, t + 1), None x_init = jnp.zeros((num_sequences, 1), dtype=jnp.int32) @@ -160,16 +160,16 @@ def model_3(sequences, lengths, args, include_prior=True): num_sequences, max_length, data_dim = sequences.shape hidden_dim = int(args.hidden_dim ** 0.5) # split between w and x with mask(mask=include_prior): - probs_w = numpyro.sample("probs_w", - dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1) - .to_event(1)) - probs_x = numpyro.sample("probs_x", - dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1) - .to_event(1)) - probs_y = numpyro.sample("probs_y", - dist.Beta(0.1, 0.9) - .expand([args.hidden_dim, 2, data_dim]) - .to_event(3)) + probs_w = numpyro.sample( + "probs_w", dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1).to_event(1) + ) + probs_x = numpyro.sample( + "probs_x", dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1).to_event(1) + ) + probs_y = numpyro.sample( + "probs_y", + dist.Beta(0.1, 0.9).expand([args.hidden_dim, 2, data_dim]).to_event(3), + ) def transition_fn(carry, y): w_prev, x_prev, t = carry @@ -181,9 +181,7 @@ def transition_fn(carry, y): # we also need a final tensor for the tones dimension. This is conveniently # provided by the plate associated with that dimension. with numpyro.plate("tones", data_dim, dim=-1) as tones: - numpyro.sample("y", - dist.Bernoulli(probs_y[w, x, tones]), - obs=y) + numpyro.sample("y", dist.Bernoulli(probs_y[w, x, tones]), obs=y) return (w, x, t + 1), None w_init = jnp.zeros((num_sequences, 1), dtype=jnp.int32) @@ -208,17 +206,19 @@ def model_4(sequences, lengths, args, include_prior=True): num_sequences, max_length, data_dim = sequences.shape hidden_dim = int(args.hidden_dim ** 0.5) # split between w and x with mask(mask=include_prior): - probs_w = numpyro.sample("probs_w", - dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1) - .to_event(1)) - probs_x = numpyro.sample("probs_x", - dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1) - .expand_by([hidden_dim]) - .to_event(2)) - probs_y = numpyro.sample("probs_y", - dist.Beta(0.1, 0.9) - .expand([hidden_dim, hidden_dim, data_dim]) - .to_event(3)) + probs_w = numpyro.sample( + "probs_w", dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1).to_event(1) + ) + probs_x = numpyro.sample( + "probs_x", + dist.Dirichlet(0.9 * jnp.eye(hidden_dim) + 0.1) + .expand_by([hidden_dim]) + .to_event(2), + ) + probs_y = numpyro.sample( + "probs_y", + dist.Beta(0.1, 0.9).expand([hidden_dim, hidden_dim, data_dim]).to_event(3), + ) def transition_fn(carry, y): w_prev, x_prev, t = carry @@ -227,9 +227,7 @@ def transition_fn(carry, y): w = numpyro.sample("w", dist.Categorical(probs_w[w_prev])) x = numpyro.sample("x", dist.Categorical(Vindex(probs_x)[w, x_prev])) with numpyro.plate("tones", data_dim, dim=-1) as tones: - numpyro.sample("y", - dist.Bernoulli(probs_y[w, x, tones]), - obs=y) + numpyro.sample("y", dist.Bernoulli(probs_y[w, x, tones]), obs=y) return (w, x, t + 1), None w_init = jnp.zeros((num_sequences, 1), dtype=jnp.int32) @@ -259,27 +257,29 @@ def model_6(sequences, lengths, args, include_prior=False): with mask(mask=include_prior): # Explicitly parameterize the full tensor of transition probabilities, which # has hidden_dim cubed entries. - probs_x = numpyro.sample("probs_x", - dist.Dirichlet(0.9 * jnp.eye(args.hidden_dim) + 0.1) - .expand([args.hidden_dim, args.hidden_dim]) - .to_event(2)) - - probs_y = numpyro.sample("probs_y", - dist.Beta(0.1, 0.9) - .expand([args.hidden_dim, data_dim]) - .to_event(2)) + probs_x = numpyro.sample( + "probs_x", + dist.Dirichlet(0.9 * jnp.eye(args.hidden_dim) + 0.1) + .expand([args.hidden_dim, args.hidden_dim]) + .to_event(2), + ) + + probs_y = numpyro.sample( + "probs_y", + dist.Beta(0.1, 0.9).expand([args.hidden_dim, data_dim]).to_event(2), + ) def transition_fn(carry, y): x_prev, x_curr, t = carry with numpyro.plate("sequences", num_sequences, dim=-2): with mask(mask=(t < lengths)[..., None]): probs_x_t = Vindex(probs_x)[x_prev, x_curr] - x_prev, x_curr = x_curr, numpyro.sample("x", dist.Categorical(probs_x_t)) + x_prev, x_curr = x_curr, numpyro.sample( + "x", dist.Categorical(probs_x_t) + ) with numpyro.plate("tones", data_dim, dim=-1): probs_y_t = probs_y[x_curr.squeeze(-1)] - numpyro.sample("y", - dist.Bernoulli(probs_y_t), - obs=y) + numpyro.sample("y", dist.Bernoulli(probs_y_t), obs=y) return (x_prev, x_curr, t + 1), None x_prev = jnp.zeros((num_sequences, 1), dtype=jnp.int32) @@ -290,58 +290,69 @@ def transition_fn(carry, y): # %% # Do inference -models = {name[len('model_'):]: model - for name, model in globals().items() - if name.startswith('model_')} +models = { + name[len("model_") :]: model + for name, model in globals().items() + if name.startswith("model_") +} def main(args): model = models[args.model] - _, fetch = load_dataset(JSB_CHORALES, split='train', shuffle=False) + _, fetch = load_dataset(JSB_CHORALES, split="train", shuffle=False) lengths, sequences = fetch() if args.num_sequences: - sequences = sequences[0:args.num_sequences] - lengths = lengths[0:args.num_sequences] + sequences = sequences[0 : args.num_sequences] + lengths = lengths[0 : args.num_sequences] - logger.info('-' * 40) - logger.info('Training {} on {} sequences'.format( - model.__name__, len(sequences))) + logger.info("-" * 40) + logger.info("Training {} on {} sequences".format(model.__name__, len(sequences))) # find all the notes that are present at least once in the training set - present_notes = ((sequences == 1).sum(0).sum(0) > 0) + present_notes = (sequences == 1).sum(0).sum(0) > 0 # remove notes that are never played (we remove 37/88 notes with default args) sequences = sequences[..., present_notes] if args.truncate: lengths = lengths.clip(0, args.truncate) - sequences = sequences[:, :args.truncate] + sequences = sequences[:, : args.truncate] - logger.info('Each sequence has shape {}'.format(sequences[0].shape)) - logger.info('Starting inference...') + logger.info("Each sequence has shape {}".format(sequences[0].shape)) + logger.info("Starting inference...") rng_key = random.PRNGKey(2) start = time.time() - kernel = {'nuts': NUTS, 'hmc': HMC}[args.kernel](model) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + kernel = {"nuts": NUTS, "hmc": HMC}[args.kernel](model) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key, sequences, lengths, args=args) mcmc.print_summary() - logger.info('\nMCMC elapsed time: {}'.format(time.time() - start)) + logger.info("\nMCMC elapsed time: {}".format(time.time() - start)) -if __name__ == '__main__': +if __name__ == "__main__": parser = argparse.ArgumentParser(description="HMC for HMMs") - parser.add_argument("-m", "--model", default="1", type=str, - help="one of: {}".format(", ".join(sorted(models.keys())))) - parser.add_argument('-n', '--num-samples', nargs='?', default=1000, type=int) + parser.add_argument( + "-m", + "--model", + default="1", + type=str, + help="one of: {}".format(", ".join(sorted(models.keys()))), + ) + parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("-d", "--hidden-dim", default=16, type=int) - parser.add_argument('-t', "--truncate", type=int) + parser.add_argument("-t", "--truncate", type=int) parser.add_argument("--num-sequences", type=int) - parser.add_argument("--kernel", default='nuts', type=str) - parser.add_argument('--num-warmup', nargs='?', default=500, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') + parser.add_argument("--kernel", default="nuts", type=str) + parser.add_argument("--num-warmup", nargs="?", default=500, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() diff --git a/examples/minipyro.py b/examples/minipyro.py index db5ca14e5..b54c5f08e 100644 --- a/examples/minipyro.py +++ b/examples/minipyro.py @@ -15,15 +15,15 @@ def model(data): - loc = numpyro.sample("loc", dist.Normal(0., 1.)) - numpyro.sample("obs", dist.Normal(loc, 1.), obs=data) + loc = numpyro.sample("loc", dist.Normal(0.0, 1.0)) + numpyro.sample("obs", dist.Normal(loc, 1.0), obs=data) # Define a guide (i.e. variational distribution) with a Normal # distribution over the latent random variable `loc`. def guide(data): - guide_loc = numpyro.param("guide_loc", 0.) - guide_scale = jnp.exp(numpyro.param("guide_scale_log", 0.)) + guide_loc = numpyro.param("guide_loc", 0.0) + guide_scale = jnp.exp(numpyro.param("guide_scale_log", 0.0)) numpyro.sample("loc", dist.Normal(guide_loc, guide_scale)) @@ -58,7 +58,7 @@ def body_fn(i, val): if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="Mini Pyro demo") parser.add_argument("-f", "--full-pyro", action="store_true", default=False) parser.add_argument("-n", "--num-steps", default=1001, type=int) diff --git a/examples/neutra.py b/examples/neutra.py index 848179aa2..6a2536e01 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -50,39 +50,52 @@ def sample(self, key, sample_shape=()): def log_prob(self, x): term1 = 0.5 * ((jnp.linalg.norm(x, axis=-1) - 2) / 0.4) ** 2 - term2 = -0.5 * ((x[..., :1] + jnp.array([-2., 2.])) / 0.6) ** 2 + term2 = -0.5 * ((x[..., :1] + jnp.array([-2.0, 2.0])) / 0.6) ** 2 pe = term1 - logsumexp(term2, axis=-1) return -pe def dual_moon_model(): - numpyro.sample('x', DualMoonDistribution()) + numpyro.sample("x", DualMoonDistribution()) def main(args): print("Start vanilla HMC...") nuts_kernel = NUTS(dual_moon_model) - mcmc = MCMC(nuts_kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + nuts_kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(random.PRNGKey(0)) mcmc.print_summary() - vanilla_samples = mcmc.get_samples()['x'].copy() + vanilla_samples = mcmc.get_samples()["x"].copy() - guide = AutoBNAFNormal(dual_moon_model, hidden_factors=[args.hidden_factor, args.hidden_factor]) + guide = AutoBNAFNormal( + dual_moon_model, hidden_factors=[args.hidden_factor, args.hidden_factor] + ) svi = SVI(dual_moon_model, guide, optim.Adam(0.003), Trace_ELBO()) print("Start training guide...") svi_result = svi.run(random.PRNGKey(1), args.num_iters) print("Finish training guide. Extract samples...") - guide_samples = guide.sample_posterior(random.PRNGKey(2), svi_result.params, - sample_shape=(args.num_samples,))['x'].copy() + guide_samples = guide.sample_posterior( + random.PRNGKey(2), svi_result.params, sample_shape=(args.num_samples,) + )["x"].copy() print("\nStart NeuTra HMC...") neutra = NeuTraReparam(guide, svi_result.params) neutra_model = neutra.reparam(dual_moon_model) nuts_kernel = NUTS(neutra_model) - mcmc = MCMC(nuts_kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + nuts_kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(random.PRNGKey(3)) mcmc.print_summary() zs = mcmc.get_samples(group_by_chain=True)["auto_shared_latent"] @@ -90,13 +103,15 @@ def main(args): samples = neutra.transform_sample(zs) print_summary(samples) zs = zs.reshape(-1, 2) - samples = samples['x'].reshape(-1, 2).copy() + samples = samples["x"].reshape(-1, 2).copy() # make plots # guide samples (for plotting) - guide_base_samples = dist.Normal(jnp.zeros(2), 1.).sample(random.PRNGKey(4), (1000,)) - guide_trans_samples = neutra.transform_sample(guide_base_samples)['x'] + guide_base_samples = dist.Normal(jnp.zeros(2), 1.0).sample( + random.PRNGKey(4), (1000,) + ) + guide_trans_samples = neutra.transform_sample(guide_base_samples)["x"] x1 = jnp.linspace(-3, 3, 100) x2 = jnp.linspace(-3, 3, 100) @@ -113,47 +128,83 @@ def main(args): ax6 = fig.add_subplot(gs[1, 2]) ax1.plot(svi_result.losses[1000:]) - ax1.set_title('Autoguide training loss\n(after 1000 steps)') + ax1.set_title("Autoguide training loss\n(after 1000 steps)") - ax2.contourf(X1, X2, P, cmap='OrRd') + ax2.contourf(X1, X2, P, cmap="OrRd") sns.kdeplot(x=guide_samples[:, 0], y=guide_samples[:, 1], n_levels=30, ax=ax2) - ax2.set(xlim=[-3, 3], ylim=[-3, 3], - xlabel='x0', ylabel='x1', title='Posterior using\nAutoBNAFNormal guide') - - sns.scatterplot(x=guide_base_samples[:, 0], y=guide_base_samples[:, 1], ax=ax3, - hue=guide_trans_samples[:, 0] < 0.) - ax3.set(xlim=[-3, 3], ylim=[-3, 3], - xlabel='x0', ylabel='x1', title='AutoBNAFNormal base samples\n(True=left moon; False=right moon)') - - ax4.contourf(X1, X2, P, cmap='OrRd') + ax2.set( + xlim=[-3, 3], + ylim=[-3, 3], + xlabel="x0", + ylabel="x1", + title="Posterior using\nAutoBNAFNormal guide", + ) + + sns.scatterplot( + x=guide_base_samples[:, 0], + y=guide_base_samples[:, 1], + ax=ax3, + hue=guide_trans_samples[:, 0] < 0.0, + ) + ax3.set( + xlim=[-3, 3], + ylim=[-3, 3], + xlabel="x0", + ylabel="x1", + title="AutoBNAFNormal base samples\n(True=left moon; False=right moon)", + ) + + ax4.contourf(X1, X2, P, cmap="OrRd") sns.kdeplot(x=vanilla_samples[:, 0], y=vanilla_samples[:, 1], n_levels=30, ax=ax4) - ax4.plot(vanilla_samples[-50:, 0], vanilla_samples[-50:, 1], 'bo-', alpha=0.5) - ax4.set(xlim=[-3, 3], ylim=[-3, 3], - xlabel='x0', ylabel='x1', title='Posterior using\nvanilla HMC sampler') - - sns.scatterplot(x=zs[:, 0], y=zs[:, 1], ax=ax5, hue=samples[:, 0] < 0., - s=30, alpha=0.5, edgecolor="none") - ax5.set(xlim=[-5, 5], ylim=[-5, 5], - xlabel='x0', ylabel='x1', title='Samples from the\nwarped posterior - p(z)') - - ax6.contourf(X1, X2, P, cmap='OrRd') + ax4.plot(vanilla_samples[-50:, 0], vanilla_samples[-50:, 1], "bo-", alpha=0.5) + ax4.set( + xlim=[-3, 3], + ylim=[-3, 3], + xlabel="x0", + ylabel="x1", + title="Posterior using\nvanilla HMC sampler", + ) + + sns.scatterplot( + x=zs[:, 0], + y=zs[:, 1], + ax=ax5, + hue=samples[:, 0] < 0.0, + s=30, + alpha=0.5, + edgecolor="none", + ) + ax5.set( + xlim=[-5, 5], + ylim=[-5, 5], + xlabel="x0", + ylabel="x1", + title="Samples from the\nwarped posterior - p(z)", + ) + + ax6.contourf(X1, X2, P, cmap="OrRd") sns.kdeplot(x=samples[:, 0], y=samples[:, 1], n_levels=30, ax=ax6) - ax6.plot(samples[-50:, 0], samples[-50:, 1], 'bo-', alpha=0.2) - ax6.set(xlim=[-3, 3], ylim=[-3, 3], - xlabel='x0', ylabel='x1', title='Posterior using\nNeuTra HMC sampler') + ax6.plot(samples[-50:, 0], samples[-50:, 1], "bo-", alpha=0.2) + ax6.set( + xlim=[-3, 3], + ylim=[-3, 3], + xlabel="x0", + ylabel="x1", + title="Posterior using\nNeuTra HMC sampler", + ) plt.savefig("neutra.pdf") if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="NeuTra HMC") - parser.add_argument('-n', '--num-samples', nargs='?', default=4000, type=int) - parser.add_argument('--num-warmup', nargs='?', default=1000, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument('--hidden-factor', nargs='?', default=8, type=int) - parser.add_argument('--num-iters', nargs='?', default=10000, type=int) - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') + parser.add_argument("-n", "--num-samples", nargs="?", default=4000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--hidden-factor", nargs="?", default=8, type=int) + parser.add_argument("--num-iters", nargs="?", default=10000, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/ode.py b/examples/ode.py index a4c167a58..a453a38de 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -36,7 +36,7 @@ from numpyro.examples.datasets import LYNXHARE, load_dataset from numpyro.infer import MCMC, NUTS, Predictive -matplotlib.use('Agg') # noqa: E402 +matplotlib.use("Agg") # noqa: E402 def dz_dt(z, t, theta): @@ -46,7 +46,12 @@ def dz_dt(z, t, theta): """ u = z[0] v = z[1] - alpha, beta, gamma, delta = theta[..., 0], theta[..., 1], theta[..., 2], theta[..., 3] + alpha, beta, gamma, delta = ( + theta[..., 0], + theta[..., 1], + theta[..., 2], + theta[..., 3], + ) du_dt = (alpha - beta * v) * u dv_dt = (-gamma + delta * u) * v return jnp.stack([du_dt, dv_dt]) @@ -64,8 +69,12 @@ def model(N, y=None): # parameters alpha, beta, gamma, delta of dz_dt theta = numpyro.sample( "theta", - dist.TruncatedNormal(low=0., loc=jnp.array([1.0, 0.05, 1.0, 0.05]), - scale=jnp.array([0.5, 0.05, 0.5, 0.05]))) + dist.TruncatedNormal( + low=0.0, + loc=jnp.array([1.0, 0.05, 1.0, 0.05]), + scale=jnp.array([0.5, 0.05, 0.5, 0.05]), + ), + ) # integrate dz/dt, the result will have shape N x 2 z = odeint(dz_dt, z_init, ts, theta, rtol=1e-6, atol=1e-5, mxstep=1000) # measurement errors @@ -79,9 +88,13 @@ def main(args): year, data = fetch() # data is in hare -> lynx order # use dense_mass for better mixing rate - mcmc = MCMC(NUTS(model, dense_mass=True), - args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + NUTS(model, dense_mass=True), + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(PRNGKey(1), N=data.shape[0], y=data) mcmc.print_summary() @@ -102,13 +115,13 @@ def main(args): plt.savefig("ode_plot.pdf") -if __name__ == '__main__': - assert numpyro.__version__.startswith('0.6.0') - parser = argparse.ArgumentParser(description='Predator-Prey Model') - parser.add_argument('-n', '--num-samples', nargs='?', default=1000, type=int) - parser.add_argument('--num-warmup', nargs='?', default=1000, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser(description="Predator-Prey Model") + parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index 359f9c17d..64affcd7e 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -41,16 +41,26 @@ def make_dataset(rng_key) -> Tuple[jnp.ndarray, jnp.ndarray]: num_calls = 51342 num_no_calls = 48658 - made_purchase_got_called = dist.Bernoulli(0.084).sample(key1, sample_shape=(num_calls,)) - made_purchase_no_calls = dist.Bernoulli(0.061).sample(key2, sample_shape=(num_no_calls,)) + made_purchase_got_called = dist.Bernoulli(0.084).sample( + key1, sample_shape=(num_calls,) + ) + made_purchase_no_calls = dist.Bernoulli(0.061).sample( + key2, sample_shape=(num_no_calls,) + ) made_purchase = jnp.concatenate([made_purchase_got_called, made_purchase_no_calls]) - is_female = dist.Bernoulli(0.5).sample(key3, sample_shape=(num_calls + num_no_calls,)) + is_female = dist.Bernoulli(0.5).sample( + key3, sample_shape=(num_calls + num_no_calls,) + ) got_called = jnp.concatenate([jnp.ones(num_calls), jnp.zeros(num_no_calls)]) - design_matrix = jnp.hstack([jnp.ones((num_no_calls + num_calls, 1)), - got_called.reshape(-1, 1), - is_female.reshape(-1, 1)]) + design_matrix = jnp.hstack( + [ + jnp.ones((num_no_calls + num_calls, 1)), + got_called.reshape(-1, 1), + is_female.reshape(-1, 1), + ] + ) return design_matrix, made_purchase @@ -65,12 +75,16 @@ def model(design_matrix: jnp.ndarray, outcome: jnp.ndarray = None) -> None: customer made a purchase. """ - beta = numpyro.sample('coefficients', dist.MultivariateNormal(loc=0., - covariance_matrix=jnp.eye(design_matrix.shape[1]))) + beta = numpyro.sample( + "coefficients", + dist.MultivariateNormal( + loc=0.0, covariance_matrix=jnp.eye(design_matrix.shape[1]) + ), + ) logits = design_matrix.dot(beta) - with numpyro.plate('data', design_matrix.shape[0]): - numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=outcome) + with numpyro.plate("data", design_matrix.shape[0]): + numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=outcome) def print_results(coef: jnp.ndarray, interval_size: float = 0.95) -> None: @@ -82,59 +96,77 @@ def print_results(coef: jnp.ndarray, interval_size: float = 0.95) -> None: baseline_response = expit(coef[:, 0]) response_with_calls = expit(coef[:, 0] + coef[:, 1]) - impact_on_probability = hpdi(response_with_calls - baseline_response, prob=interval_size) + impact_on_probability = hpdi( + response_with_calls - baseline_response, prob=interval_size + ) effect_of_gender = hpdi(coef[:, 2], prob=interval_size) - print(f"There is a {interval_size * 100}% probability that calling customers " - "increases the chance they'll make a purchase by " - f"{(100 * impact_on_probability[0]):.2} to {(100 * impact_on_probability[1]):.2} percentage points." - ) - - print(f"There is a {interval_size * 100}% probability the effect of gender on the log odds of conversion " - f"lies in the interval ({effect_of_gender[0]:.2}, {effect_of_gender[1]:.2f})." - " Since this interval contains 0, we can conclude gender does not impact the conversion rate.") - - -def run_inference(design_matrix: jnp.ndarray, outcome: jnp.ndarray, - rng_key: jnp.ndarray, - num_warmup: int, - num_samples: int, num_chains: int, - interval_size: float = 0.95) -> None: + print( + f"There is a {interval_size * 100}% probability that calling customers " + "increases the chance they'll make a purchase by " + f"{(100 * impact_on_probability[0]):.2} to {(100 * impact_on_probability[1]):.2} percentage points." + ) + + print( + f"There is a {interval_size * 100}% probability the effect of gender on the log odds of conversion " + f"lies in the interval ({effect_of_gender[0]:.2}, {effect_of_gender[1]:.2f})." + " Since this interval contains 0, we can conclude gender does not impact the conversion rate." + ) + + +def run_inference( + design_matrix: jnp.ndarray, + outcome: jnp.ndarray, + rng_key: jnp.ndarray, + num_warmup: int, + num_samples: int, + num_chains: int, + interval_size: float = 0.95, +) -> None: """ Estimate the effect size. """ kernel = NUTS(model) - mcmc = MCMC(kernel, num_warmup, num_samples, num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + kernel, + num_warmup, + num_samples, + num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key, design_matrix, outcome) # 0th column is intercept (not getting called) # 1st column is effect of getting called # 2nd column is effect of gender (should be none since assigned at random) - coef = mcmc.get_samples()['coefficients'] + coef = mcmc.get_samples()["coefficients"] print_results(coef, interval_size) def main(args): rng_key, _ = random.split(random.PRNGKey(3)) design_matrix, response = make_dataset(rng_key) - run_inference(design_matrix, response, rng_key, - args.num_warmup, - args.num_samples, - args.num_chains, - args.interval_size) - - -if __name__ == '__main__': - assert numpyro.__version__.startswith('0.6.0') - parser = argparse.ArgumentParser(description='Testing whether ') - parser.add_argument('-n', '--num-samples', nargs='?', default=500, type=int) - parser.add_argument('--num-warmup', nargs='?', default=1500, type=int) - parser.add_argument('--num-chains', nargs='?', default=1, type=int) - parser.add_argument('--interval-size', nargs='?', default=0.95, type=float) - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') + run_inference( + design_matrix, + response, + rng_key, + args.num_warmup, + args.num_samples, + args.num_chains, + args.interval_size, + ) + + +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser(description="Testing whether ") + parser.add_argument("-n", "--num-samples", nargs="?", default=500, type=int) + parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--interval-size", nargs="?", default=0.95, type=float) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index f95135feb..26ac7d0e8 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -58,14 +58,14 @@ def kernel(X, Z, eta1, eta2, c, jitter=1.0e-4): # Most of the model code is concerned with constructing the sparsity inducing prior. def model(X, Y, hypers): - S, P, N = hypers['expected_sparsity'], X.shape[1], X.shape[0] + S, P, N = hypers["expected_sparsity"], X.shape[1], X.shape[0] - sigma = numpyro.sample("sigma", dist.HalfNormal(hypers['alpha3'])) + sigma = numpyro.sample("sigma", dist.HalfNormal(hypers["alpha3"])) phi = sigma * (S / jnp.sqrt(N)) / (P - S) eta1 = numpyro.sample("eta1", dist.HalfCauchy(phi)) - msq = numpyro.sample("msq", dist.InverseGamma(hypers['alpha1'], hypers['beta1'])) - xisq = numpyro.sample("xisq", dist.InverseGamma(hypers['alpha2'], hypers['beta2'])) + msq = numpyro.sample("msq", dist.InverseGamma(hypers["alpha1"], hypers["beta1"])) + xisq = numpyro.sample("xisq", dist.InverseGamma(hypers["alpha2"], hypers["beta2"])) eta2 = jnp.square(eta1) * jnp.sqrt(xisq) / msq @@ -74,12 +74,15 @@ def model(X, Y, hypers): # compute kernel kX = kappa * X - k = kernel(kX, kX, eta1, eta2, hypers['c']) + sigma ** 2 * jnp.eye(N) + k = kernel(kX, kX, eta1, eta2, hypers["c"]) + sigma ** 2 * jnp.eye(N) assert k.shape == (N, N) # sample Y according to the standard gaussian process formula - numpyro.sample("Y", dist.MultivariateNormal(loc=jnp.zeros(X.shape[0]), covariance_matrix=k), - obs=Y) + numpyro.sample( + "Y", + dist.MultivariateNormal(loc=jnp.zeros(X.shape[0]), covariance_matrix=k), + obs=Y, + ) # Compute the mean and variance of coefficient theta_i (where i = dimension) for a @@ -89,7 +92,9 @@ def compute_singleton_mean_variance(X, Y, dimension, msq, lam, eta1, xisq, c, si P, N = X.shape[1], X.shape[0] probe = jnp.zeros((2, P)) - probe = jax.ops.index_update(probe, jax.ops.index[:, dimension], jnp.array([1.0, -1.0])) + probe = jax.ops.index_update( + probe, jax.ops.index[:, dimension], jnp.array([1.0, -1.0]) + ) eta2 = jnp.square(eta1) * jnp.sqrt(xisq) / msq kappa = jnp.sqrt(msq) * lam / jnp.sqrt(msq + jnp.square(eta1 * lam)) @@ -119,8 +124,12 @@ def compute_pairwise_mean_variance(X, Y, dim1, dim2, msq, lam, eta1, xisq, c, si P, N = X.shape[1], X.shape[0] probe = jnp.zeros((4, P)) - probe = jax.ops.index_update(probe, jax.ops.index[:, dim1], jnp.array([1.0, 1.0, -1.0, -1.0])) - probe = jax.ops.index_update(probe, jax.ops.index[:, dim2], jnp.array([1.0, -1.0, 1.0, -1.0])) + probe = jax.ops.index_update( + probe, jax.ops.index[:, dim1], jnp.array([1.0, 1.0, -1.0, -1.0]) + ) + probe = jax.ops.index_update( + probe, jax.ops.index[:, dim2], jnp.array([1.0, -1.0, 1.0, -1.0]) + ) eta2 = jnp.square(eta1) * jnp.sqrt(xisq) / msq kappa = jnp.sqrt(msq) * lam / jnp.sqrt(msq + jnp.square(eta1 * lam)) @@ -159,8 +168,12 @@ def sample_theta_space(X, Y, active_dims, msq, lam, eta1, xisq, c, sigma): start2 = 0 for dim in range(P): - probe = jax.ops.index_update(probe, jax.ops.index[start1:start1 + 2, dim], jnp.array([1.0, -1.0])) - vec = jax.ops.index_update(vec, jax.ops.index[start2, start1:start1 + 2], jnp.array([0.5, -0.5])) + probe = jax.ops.index_update( + probe, jax.ops.index[start1 : start1 + 2, dim], jnp.array([1.0, -1.0]) + ) + vec = jax.ops.index_update( + vec, jax.ops.index[start2, start1 : start1 + 2], jnp.array([0.5, -0.5]) + ) start1 += 2 start2 += 1 @@ -168,12 +181,21 @@ def sample_theta_space(X, Y, active_dims, msq, lam, eta1, xisq, c, sigma): for dim2 in active_dims: if dim1 >= dim2: continue - probe = jax.ops.index_update(probe, jax.ops.index[start1:start1 + 4, dim1], - jnp.array([1.0, 1.0, -1.0, -1.0])) - probe = jax.ops.index_update(probe, jax.ops.index[start1:start1 + 4, dim2], - jnp.array([1.0, -1.0, 1.0, -1.0])) - vec = jax.ops.index_update(vec, jax.ops.index[start2, start1:start1 + 4], - jnp.array([0.25, -0.25, -0.25, 0.25])) + probe = jax.ops.index_update( + probe, + jax.ops.index[start1 : start1 + 4, dim1], + jnp.array([1.0, 1.0, -1.0, -1.0]), + ) + probe = jax.ops.index_update( + probe, + jax.ops.index[start1 : start1 + 4, dim2], + jnp.array([1.0, -1.0, 1.0, -1.0]), + ) + vec = jax.ops.index_update( + vec, + jax.ops.index[start2, start1 : start1 + 4], + jnp.array([0.25, -0.25, -0.25, 0.25]), + ) start1 += 4 start2 += 1 @@ -206,11 +228,16 @@ def sample_theta_space(X, Y, active_dims, msq, lam, eta1, xisq, c, sigma): def run_inference(model, args, rng_key, X, Y, hypers): start = time.time() kernel = NUTS(model) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, num_chains=args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key, X, Y, hypers) mcmc.print_summary() - print('\nMCMC elapsed time:', time.time() - start) + print("\nMCMC elapsed time:", time.time() - start) return mcmc.get_samples() @@ -232,7 +259,11 @@ def get_data(N=20, S=2, P=10, sigma_obs=0.05): # generate S coefficients with non-negligible magnitude W = 0.5 + 2.5 * np.random.rand(S) # generate data using the S coefficients and a single pairwise interaction - Y = np.sum(X[:, 0:S] * W, axis=-1) + X[:, 0] * X[:, 1] + sigma_obs * np.random.randn(N) + Y = ( + np.sum(X[:, 0:S] * W, axis=-1) + + X[:, 0] * X[:, 1] + + sigma_obs * np.random.randn(N) + ) Y -= jnp.mean(Y) Y_std = jnp.std(Y) @@ -244,10 +275,18 @@ def get_data(N=20, S=2, P=10, sigma_obs=0.05): # Helper function for analyzing the posterior statistics for coefficient theta_i def analyze_dimension(samples, X, Y, dimension, hypers): - vmap_args = (samples['msq'], samples['lambda'], samples['eta1'], samples['xisq'], samples['sigma']) - mus, variances = vmap(lambda msq, lam, eta1, xisq, sigma: - compute_singleton_mean_variance(X, Y, dimension, msq, lam, - eta1, xisq, hypers['c'], sigma))(*vmap_args) + vmap_args = ( + samples["msq"], + samples["lambda"], + samples["eta1"], + samples["xisq"], + samples["sigma"], + ) + mus, variances = vmap( + lambda msq, lam, eta1, xisq, sigma: compute_singleton_mean_variance( + X, Y, dimension, msq, lam, eta1, xisq, hypers["c"], sigma + ) + )(*vmap_args) mean, variance = gaussian_mixture_stats(mus, variances) std = jnp.sqrt(variance) return mean, std @@ -255,34 +294,57 @@ def analyze_dimension(samples, X, Y, dimension, hypers): # Helper function for analyzing the posterior statistics for coefficient theta_ij def analyze_pair_of_dimensions(samples, X, Y, dim1, dim2, hypers): - vmap_args = (samples['msq'], samples['lambda'], samples['eta1'], samples['xisq'], samples['sigma']) - mus, variances = vmap(lambda msq, lam, eta1, xisq, sigma: - compute_pairwise_mean_variance(X, Y, dim1, dim2, msq, lam, - eta1, xisq, hypers['c'], sigma))(*vmap_args) + vmap_args = ( + samples["msq"], + samples["lambda"], + samples["eta1"], + samples["xisq"], + samples["sigma"], + ) + mus, variances = vmap( + lambda msq, lam, eta1, xisq, sigma: compute_pairwise_mean_variance( + X, Y, dim1, dim2, msq, lam, eta1, xisq, hypers["c"], sigma + ) + )(*vmap_args) mean, variance = gaussian_mixture_stats(mus, variances) std = jnp.sqrt(variance) return mean, std def main(args): - X, Y, expected_thetas, expected_pairwise = get_data(N=args.num_data, P=args.num_dimensions, - S=args.active_dimensions) + X, Y, expected_thetas, expected_pairwise = get_data( + N=args.num_data, P=args.num_dimensions, S=args.active_dimensions + ) # setup hyperparameters - hypers = {'expected_sparsity': max(1.0, args.num_dimensions / 10), - 'alpha1': 3.0, 'beta1': 1.0, - 'alpha2': 3.0, 'beta2': 1.0, - 'alpha3': 1.0, 'c': 1.0} + hypers = { + "expected_sparsity": max(1.0, args.num_dimensions / 10), + "alpha1": 3.0, + "beta1": 1.0, + "alpha2": 3.0, + "beta2": 1.0, + "alpha3": 1.0, + "c": 1.0, + } # do inference rng_key = random.PRNGKey(0) samples = run_inference(model, args, rng_key, X, Y, hypers) # compute the mean and square root variance of each coefficient theta_i - means, stds = vmap(lambda dim: analyze_dimension(samples, X, Y, dim, hypers))(jnp.arange(args.num_dimensions)) - - print("Coefficients theta_1 to theta_%d used to generate the data:" % args.active_dimensions, expected_thetas) - print("The single quadratic coefficient theta_{1,2} used to generate the data:", expected_pairwise) + means, stds = vmap(lambda dim: analyze_dimension(samples, X, Y, dim, hypers))( + jnp.arange(args.num_dimensions) + ) + + print( + "Coefficients theta_1 to theta_%d used to generate the data:" + % args.active_dimensions, + expected_thetas, + ) + print( + "The single quadratic coefficient theta_{1,2} used to generate the data:", + expected_pairwise, + ) active_dimensions = [] for dim, (mean, std) in enumerate(zip(means, stds)): @@ -291,17 +353,27 @@ def main(args): inactive = "inactive" if lower < 0.0 and upper > 0.0 else "active" if inactive == "active": active_dimensions.append(dim) - print("[dimension %02d/%02d] %s:\t%.2e +- %.2e" % (dim + 1, args.num_dimensions, inactive, mean, std)) + print( + "[dimension %02d/%02d] %s:\t%.2e +- %.2e" + % (dim + 1, args.num_dimensions, inactive, mean, std) + ) - print("Identified a total of %d active dimensions; expected %d." % (len(active_dimensions), - args.active_dimensions)) + print( + "Identified a total of %d active dimensions; expected %d." + % (len(active_dimensions), args.active_dimensions) + ) # Compute the mean and square root variance of coefficients theta_ij for i,j active dimensions. # Note that the resulting numbers are only meaningful for i != j. if len(active_dimensions) > 0: - dim_pairs = jnp.array(list(itertools.product(active_dimensions, active_dimensions))) - means, stds = vmap(lambda dim_pair: analyze_pair_of_dimensions(samples, X, Y, - dim_pair[0], dim_pair[1], hypers))(dim_pairs) + dim_pairs = jnp.array( + list(itertools.product(active_dimensions, active_dimensions)) + ) + means, stds = vmap( + lambda dim_pair: analyze_pair_of_dimensions( + samples, X, Y, dim_pair[0], dim_pair[1], hypers + ) + )(dim_pairs) for dim_pair, mean, std in zip(dim_pairs, means, stds): dim1, dim2 = dim_pair if dim1 >= dim2: @@ -314,21 +386,30 @@ def main(args): # Draw a single sample of coefficients theta from the posterior, where we return all singleton # coefficients theta_i and pairwise coefficients theta_ij for i, j active dimensions. We use the # final MCMC sample obtained from the HMC sampler. - thetas = sample_theta_space(X, Y, active_dimensions, samples['msq'][-1], samples['lambda'][-1], - samples['eta1'][-1], samples['xisq'][-1], hypers['c'], samples['sigma'][-1]) + thetas = sample_theta_space( + X, + Y, + active_dimensions, + samples["msq"][-1], + samples["lambda"][-1], + samples["eta1"][-1], + samples["xisq"][-1], + hypers["c"], + samples["sigma"][-1], + ) print("Single posterior sample theta:\n", thetas) if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) - parser.add_argument("--num-warmup", nargs='?', default=500, type=int) - parser.add_argument("--num-chains", nargs='?', default=1, type=int) - parser.add_argument("--num-data", nargs='?', default=100, type=int) - parser.add_argument("--num-dimensions", nargs='?', default=20, type=int) - parser.add_argument("--active-dimensions", nargs='?', default=3, type=int) - parser.add_argument("--device", default='cpu', type=str, help='use "cpu" or "gpu".') + parser.add_argument("--num-warmup", nargs="?", default=500, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--num-data", nargs="?", default=100, type=int) + parser.add_argument("--num-dimensions", nargs="?", default=20, type=int) + parser.add_argument("--active-dimensions", nargs="?", default=3, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index 0d7242081..ad4b1c64c 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -51,36 +51,39 @@ from numpyro.infer.util import initialize_model from numpyro.util import fori_collect -matplotlib.use('Agg') # noqa: E402 +matplotlib.use("Agg") # noqa: E402 def model(returns): - step_size = numpyro.sample('sigma', dist.Exponential(50.)) - s = numpyro.sample('s', dist.GaussianRandomWalk(scale=step_size, num_steps=jnp.shape(returns)[0])) - nu = numpyro.sample('nu', dist.Exponential(.1)) - return numpyro.sample('r', dist.StudentT(df=nu, loc=0., scale=jnp.exp(s)), - obs=returns) + step_size = numpyro.sample("sigma", dist.Exponential(50.0)) + s = numpyro.sample( + "s", dist.GaussianRandomWalk(scale=step_size, num_steps=jnp.shape(returns)[0]) + ) + nu = numpyro.sample("nu", dist.Exponential(0.1)) + return numpyro.sample( + "r", dist.StudentT(df=nu, loc=0.0, scale=jnp.exp(s)), obs=returns + ) def print_results(posterior, dates): - def _print_row(values, row_name=''): + def _print_row(values, row_name=""): quantiles = jnp.array([0.2, 0.4, 0.5, 0.6, 0.8]) - row_name_fmt = '{:>8}' - header_format = row_name_fmt + '{:>12}' * 5 - row_format = row_name_fmt + '{:>12.3f}' * 5 - columns = ['(p{})'.format(int(q * 100)) for q in quantiles] + row_name_fmt = "{:>8}" + header_format = row_name_fmt + "{:>12}" * 5 + row_format = row_name_fmt + "{:>12.3f}" * 5 + columns = ["(p{})".format(int(q * 100)) for q in quantiles] q_values = jnp.quantile(values, quantiles, axis=0) - print(header_format.format('', *columns)) + print(header_format.format("", *columns)) print(row_format.format(row_name, *q_values)) - print('\n') + print("\n") - print('=' * 20, 'sigma', '=' * 20) - _print_row(posterior['sigma']) - print('=' * 20, 'nu', '=' * 20) - _print_row(posterior['nu']) - print('=' * 20, 'volatility', '=' * 20) + print("=" * 20, "sigma", "=" * 20) + _print_row(posterior["sigma"]) + print("=" * 20, "nu", "=" * 20) + _print_row(posterior["nu"]) + print("=" * 20, "volatility", "=" * 20) for i in range(0, len(dates), 180): - _print_row(jnp.exp(posterior['s'][:, i]), dates[i]) + _print_row(jnp.exp(posterior["s"][:, i]), dates[i]) def main(args): @@ -88,11 +91,18 @@ def main(args): dates, returns = fetch() init_rng_key, sample_rng_key = random.split(random.PRNGKey(args.rng_seed)) model_info = initialize_model(init_rng_key, model, model_args=(returns,)) - init_kernel, sample_kernel = hmc(model_info.potential_fn, algo='NUTS') - hmc_state = init_kernel(model_info.param_info, args.num_warmup, rng_key=sample_rng_key) - hmc_states = fori_collect(args.num_warmup, args.num_warmup + args.num_samples, sample_kernel, hmc_state, - transform=lambda hmc_state: model_info.postprocess_fn(hmc_state.z), - progbar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + init_kernel, sample_kernel = hmc(model_info.potential_fn, algo="NUTS") + hmc_state = init_kernel( + model_info.param_info, args.num_warmup, rng_key=sample_rng_key + ) + hmc_states = fori_collect( + args.num_warmup, + args.num_warmup + args.num_samples, + sample_kernel, + hmc_state, + transform=lambda hmc_state: model_info.postprocess_fn(hmc_state.z), + progbar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) print_results(hmc_states, dates) fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) @@ -100,24 +110,26 @@ def main(args): ax.plot(dates, returns, lw=0.5) # format the ticks ax.xaxis.set_major_locator(mdates.YearLocator()) - ax.xaxis.set_major_formatter(mdates.DateFormatter('%Y')) + ax.xaxis.set_major_formatter(mdates.DateFormatter("%Y")) ax.xaxis.set_minor_locator(mdates.MonthLocator()) - ax.plot(dates, jnp.exp(hmc_states['s'].T), 'r', alpha=0.01) - legend = ax.legend(['returns', 'volatility'], loc='upper right') + ax.plot(dates, jnp.exp(hmc_states["s"].T), "r", alpha=0.01) + legend = ax.legend(["returns", "volatility"], loc="upper right") legend.legendHandles[1].set_alpha(0.6) - ax.set(xlabel='time', ylabel='returns', title='Volatility of S&P500 over time') + ax.set(xlabel="time", ylabel="returns", title="Volatility of S&P500 over time") plt.savefig("stochastic_volatility_plot.pdf") if __name__ == "__main__": - assert numpyro.__version__.startswith('0.6.0') + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="Stochastic Volatility Model") - parser.add_argument('-n', '--num-samples', nargs='?', default=600, type=int) - parser.add_argument('--num-warmup', nargs='?', default=600, type=int) - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') - parser.add_argument('--rng_seed', default=21, type=int, help='random number generator seed') + parser.add_argument("-n", "--num-samples", nargs="?", default=600, type=int) + parser.add_argument("--num-warmup", nargs="?", default=600, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') + parser.add_argument( + "--rng_seed", default=21, type=int, help="random number generator seed" + ) args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index eef87f06d..55f080d0a 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -70,73 +70,95 @@ def glmm(dept, male, applications, admit=None): - v_mu = numpyro.sample('v_mu', dist.Normal(0, jnp.array([4., 1.]))) + v_mu = numpyro.sample("v_mu", dist.Normal(0, jnp.array([4.0, 1.0]))) - sigma = numpyro.sample('sigma', dist.HalfNormal(jnp.ones(2))) - L_Rho = numpyro.sample('L_Rho', dist.LKJCholesky(2, concentration=2)) + sigma = numpyro.sample("sigma", dist.HalfNormal(jnp.ones(2))) + L_Rho = numpyro.sample("L_Rho", dist.LKJCholesky(2, concentration=2)) scale_tril = sigma[..., jnp.newaxis] * L_Rho # non-centered parameterization num_dept = len(np.unique(dept)) - z = numpyro.sample('z', dist.Normal(jnp.zeros((num_dept, 2)), 1)) + z = numpyro.sample("z", dist.Normal(jnp.zeros((num_dept, 2)), 1)) v = jnp.dot(scale_tril, z.T).T logits = v_mu[0] + v[dept, 0] + (v_mu[1] + v[dept, 1]) * male if admit is None: # we use a Delta site to record probs for predictive distribution probs = expit(logits) - numpyro.sample('probs', dist.Delta(probs), obs=probs) - numpyro.sample('admit', dist.Binomial(applications, logits=logits), obs=admit) + numpyro.sample("probs", dist.Delta(probs), obs=probs) + numpyro.sample("admit", dist.Binomial(applications, logits=logits), obs=admit) def run_inference(dept, male, applications, admit, rng_key, args): kernel = NUTS(glmm) - mcmc = MCMC(kernel, args.num_warmup, args.num_samples, args.num_chains, - progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True) + mcmc = MCMC( + kernel, + args.num_warmup, + args.num_samples, + args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) mcmc.run(rng_key, dept, male, applications, admit) return mcmc.get_samples() def print_results(header, preds, dept, male, probs): - columns = ['Dept', 'Male', 'ActualProb', 'Pred(p25)', 'Pred(p50)', 'Pred(p75)'] - header_format = '{:>10} {:>10} {:>10} {:>10} {:>10} {:>10}' - row_format = '{:>10.0f} {:>10.0f} {:>10.2f} {:>10.2f} {:>10.2f} {:>10.2f}' + columns = ["Dept", "Male", "ActualProb", "Pred(p25)", "Pred(p50)", "Pred(p75)"] + header_format = "{:>10} {:>10} {:>10} {:>10} {:>10} {:>10}" + row_format = "{:>10.0f} {:>10.0f} {:>10.2f} {:>10.2f} {:>10.2f} {:>10.2f}" quantiles = jnp.quantile(preds, jnp.array([0.25, 0.5, 0.75]), axis=0) - print('\n', header, '\n') + print("\n", header, "\n") print(header_format.format(*columns)) for i in range(len(dept)): - print(row_format.format(dept[i], male[i], probs[i], *quantiles[:, i]), '\n') + print(row_format.format(dept[i], male[i], probs[i], *quantiles[:, i]), "\n") def main(args): - _, fetch_train = load_dataset(UCBADMIT, split='train', shuffle=False) + _, fetch_train = load_dataset(UCBADMIT, split="train", shuffle=False) dept, male, applications, admit = fetch_train() rng_key, rng_key_predict = random.split(random.PRNGKey(1)) zs = run_inference(dept, male, applications, admit, rng_key, args) - pred_probs = Predictive(glmm, zs)(rng_key_predict, dept, male, applications)['probs'] - header = '=' * 30 + 'glmm - TRAIN' + '=' * 30 + pred_probs = Predictive(glmm, zs)(rng_key_predict, dept, male, applications)[ + "probs" + ] + header = "=" * 30 + "glmm - TRAIN" + "=" * 30 print_results(header, pred_probs, dept, male, admit / applications) # make plots fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) ax.plot(range(1, 13), admit / applications, "o", ms=7, label="actual rate") - ax.errorbar(range(1, 13), jnp.mean(pred_probs, 0), jnp.std(pred_probs, 0), - fmt="o", c="k", mfc="none", ms=7, elinewidth=1, label=r"mean $\pm$ std") + ax.errorbar( + range(1, 13), + jnp.mean(pred_probs, 0), + jnp.std(pred_probs, 0), + fmt="o", + c="k", + mfc="none", + ms=7, + elinewidth=1, + label=r"mean $\pm$ std", + ) ax.plot(range(1, 13), jnp.percentile(pred_probs, 5, 0), "k+") ax.plot(range(1, 13), jnp.percentile(pred_probs, 95, 0), "k+") - ax.set(xlabel="cases", ylabel="admit rate", title="Posterior Predictive Check with 90% CI") + ax.set( + xlabel="cases", + ylabel="admit rate", + title="Posterior Predictive Check with 90% CI", + ) ax.legend() plt.savefig("ucbadmit_plot.pdf") -if __name__ == '__main__': - assert numpyro.__version__.startswith('0.6.0') - parser = argparse.ArgumentParser(description='UCBadmit gender discrimination using HMC') - parser.add_argument('-n', '--num-samples', nargs='?', default=2000, type=int) - parser.add_argument('--num-warmup', nargs='?', default=500, type=int) - parser.add_argument('--num-chains', nargs='?', default=1, type=int) - parser.add_argument('--device', default='cpu', type=str, help='use "cpu" or "gpu".') +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser( + description="UCBadmit gender discrimination using HMC" + ) + parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=500, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') args = parser.parse_args() numpyro.set_platform(args.device) diff --git a/examples/vae.py b/examples/vae.py index 247f8a6e8..c82a7cfdc 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -24,42 +24,48 @@ from numpyro.examples.datasets import MNIST, load_dataset from numpyro.infer import SVI, Trace_ELBO -RESULTS_DIR = os.path.abspath(os.path.join(os.path.dirname(inspect.getfile(lambda: None)), - '.results')) +RESULTS_DIR = os.path.abspath( + os.path.join(os.path.dirname(inspect.getfile(lambda: None)), ".results") +) os.makedirs(RESULTS_DIR, exist_ok=True) def encoder(hidden_dim, z_dim): return stax.serial( - stax.Dense(hidden_dim, W_init=stax.randn()), stax.Softplus, + stax.Dense(hidden_dim, W_init=stax.randn()), + stax.Softplus, stax.FanOut(2), - stax.parallel(stax.Dense(z_dim, W_init=stax.randn()), - stax.serial(stax.Dense(z_dim, W_init=stax.randn()), stax.Exp)), + stax.parallel( + stax.Dense(z_dim, W_init=stax.randn()), + stax.serial(stax.Dense(z_dim, W_init=stax.randn()), stax.Exp), + ), ) def decoder(hidden_dim, out_dim): return stax.serial( - stax.Dense(hidden_dim, W_init=stax.randn()), stax.Softplus, - stax.Dense(out_dim, W_init=stax.randn()), stax.Sigmoid, + stax.Dense(hidden_dim, W_init=stax.randn()), + stax.Softplus, + stax.Dense(out_dim, W_init=stax.randn()), + stax.Sigmoid, ) def model(batch, hidden_dim=400, z_dim=100): batch = jnp.reshape(batch, (batch.shape[0], -1)) batch_dim, out_dim = jnp.shape(batch) - decode = numpyro.module('decoder', decoder(hidden_dim, out_dim), (batch_dim, z_dim)) - z = numpyro.sample('z', dist.Normal(jnp.zeros((z_dim,)), jnp.ones((z_dim,)))) + decode = numpyro.module("decoder", decoder(hidden_dim, out_dim), (batch_dim, z_dim)) + z = numpyro.sample("z", dist.Normal(jnp.zeros((z_dim,)), jnp.ones((z_dim,)))) img_loc = decode(z) - return numpyro.sample('obs', dist.Bernoulli(img_loc), obs=batch) + return numpyro.sample("obs", dist.Bernoulli(img_loc), obs=batch) def guide(batch, hidden_dim=400, z_dim=100): batch = jnp.reshape(batch, (batch.shape[0], -1)) batch_dim, out_dim = jnp.shape(batch) - encode = numpyro.module('encoder', encoder(hidden_dim, z_dim), (batch_dim, out_dim)) + encode = numpyro.module("encoder", encoder(hidden_dim, z_dim), (batch_dim, out_dim)) z_loc, z_std = encode(batch) - z = numpyro.sample('z', dist.Normal(z_loc, z_std)) + z = numpyro.sample("z", dist.Normal(z_loc, z_std)) return z @@ -72,10 +78,16 @@ def main(args): encoder_nn = encoder(args.hidden_dim, args.z_dim) decoder_nn = decoder(args.hidden_dim, 28 * 28) adam = optim.Adam(args.learning_rate) - svi = SVI(model, guide, adam, Trace_ELBO(), hidden_dim=args.hidden_dim, z_dim=args.z_dim) + svi = SVI( + model, guide, adam, Trace_ELBO(), hidden_dim=args.hidden_dim, z_dim=args.z_dim + ) rng_key = PRNGKey(0) - train_init, train_fetch = load_dataset(MNIST, batch_size=args.batch_size, split='train') - test_init, test_fetch = load_dataset(MNIST, batch_size=args.batch_size, split='test') + train_init, train_fetch = load_dataset( + MNIST, batch_size=args.batch_size, split="train" + ) + test_init, test_fetch = load_dataset( + MNIST, batch_size=args.batch_size, split="test" + ) num_train, train_idx = train_init() rng_key, rng_key_binarize, rng_key_init = random.split(rng_key, 3) sample_batch = binarize(rng_key_binarize, train_fetch(0, train_idx)[0]) @@ -91,7 +103,7 @@ def body_fn(i, val): loss_sum += loss return loss_sum, svi_state - return lax.fori_loop(0, num_train, body_fn, (0., svi_state)) + return lax.fori_loop(0, num_train, body_fn, (0.0, svi_state)) @jit def eval_test(svi_state, rng_key, test_idx): @@ -103,23 +115,35 @@ def body_fun(i, loss_sum): loss_sum += loss return loss_sum - loss = lax.fori_loop(0, num_test, body_fun, 0.) + loss = lax.fori_loop(0, num_test, body_fun, 0.0) loss = loss / num_test return loss def reconstruct_img(epoch, rng_key): img = test_fetch(0, test_idx)[0][0] - plt.imsave(os.path.join(RESULTS_DIR, 'original_epoch={}.png'.format(epoch)), img, cmap='gray') + plt.imsave( + os.path.join(RESULTS_DIR, "original_epoch={}.png".format(epoch)), + img, + cmap="gray", + ) rng_key_binarize, rng_key_sample = random.split(rng_key) test_sample = binarize(rng_key_binarize, img) params = svi.get_params(svi_state) - z_mean, z_var = encoder_nn[1](params['encoder$params'], test_sample.reshape([1, -1])) + z_mean, z_var = encoder_nn[1]( + params["encoder$params"], test_sample.reshape([1, -1]) + ) z = dist.Normal(z_mean, z_var).sample(rng_key_sample) - img_loc = decoder_nn[1](params['decoder$params'], z).reshape([28, 28]) - plt.imsave(os.path.join(RESULTS_DIR, 'recons_epoch={}.png'.format(epoch)), img_loc, cmap='gray') + img_loc = decoder_nn[1](params["decoder$params"], z).reshape([28, 28]) + plt.imsave( + os.path.join(RESULTS_DIR, "recons_epoch={}.png".format(epoch)), + img_loc, + cmap="gray", + ) for i in range(args.num_epochs): - rng_key, rng_key_train, rng_key_test, rng_key_reconstruct = random.split(rng_key, 4) + rng_key, rng_key_train, rng_key_test, rng_key_reconstruct = random.split( + rng_key, 4 + ) t_start = time.time() num_train, train_idx = train_init() _, svi_state = epoch_train(svi_state, rng_key_train, train_idx) @@ -127,16 +151,29 @@ def reconstruct_img(epoch, rng_key): num_test, test_idx = test_init() test_loss = eval_test(svi_state, rng_key_test, test_idx) reconstruct_img(i, rng_key_reconstruct) - print("Epoch {}: loss = {} ({:.2f} s.)".format(i, test_loss, time.time() - t_start)) + print( + "Epoch {}: loss = {} ({:.2f} s.)".format( + i, test_loss, time.time() - t_start + ) + ) -if __name__ == '__main__': - assert numpyro.__version__.startswith('0.6.0') +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") parser = argparse.ArgumentParser(description="parse args") - parser.add_argument('-n', '--num-epochs', default=15, type=int, help='number of training epochs') - parser.add_argument('-lr', '--learning-rate', default=1.0e-3, type=float, help='learning rate') - parser.add_argument('-batch-size', default=128, type=int, help='batch size') - parser.add_argument('-z-dim', default=50, type=int, help='size of latent') - parser.add_argument('-hidden-dim', default=400, type=int, help='size of hidden layer in encoder/decoder networks') + parser.add_argument( + "-n", "--num-epochs", default=15, type=int, help="number of training epochs" + ) + parser.add_argument( + "-lr", "--learning-rate", default=1.0e-3, type=float, help="learning rate" + ) + parser.add_argument("-batch-size", default=128, type=int, help="batch size") + parser.add_argument("-z-dim", default=50, type=int, help="size of latent") + parser.add_argument( + "-hidden-dim", + default=400, + type=int, + help="size of hidden layer in encoder/decoder networks", + ) args = parser.parse_args() main(args) diff --git a/notebooks/source/conf.py b/notebooks/source/conf.py index 77a67161b..9d221f450 100644 --- a/notebooks/source/conf.py +++ b/notebooks/source/conf.py @@ -37,47 +37,49 @@ # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. -extensions = ['sphinx.ext.intersphinx', - 'sphinx.ext.todo', - 'sphinx.ext.mathjax', - 'sphinx.ext.githubpages', - 'nbsphinx', - 'sphinx.ext.autodoc', - 'IPython.sphinxext.ipython_console_highlighting', - ] +extensions = [ + "sphinx.ext.intersphinx", + "sphinx.ext.todo", + "sphinx.ext.mathjax", + "sphinx.ext.githubpages", + "nbsphinx", + "sphinx.ext.autodoc", + "IPython.sphinxext.ipython_console_highlighting", +] # Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] +templates_path = ["_templates"] # The suffix(es) of source filenames. # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] -source_suffix = ['.rst', '.ipynb'] +source_suffix = [".rst", ".ipynb"] # do not execute cells -nbsphinx_execute = 'never' +nbsphinx_execute = "never" # allow errors because not all tutorials build nbsphinx_allow_errors = True # The master toctree document. -master_doc = 'index' +master_doc = "index" # General information about the project. -project = u'NumPyro Tutorials' -copyright = u'2019, Uber Technologies, Inc' -author = u'Uber AI Labs' +project = u"NumPyro Tutorials" +copyright = u"2019, Uber Technologies, Inc" +author = u"Uber AI Labs" # The version info for the project you're documenting, acts as replacement for # |version| and |release|, also used in various other places throughout the # built documents. -version = '' +version = "" -if 'READTHEDOCS' not in os.environ: +if "READTHEDOCS" not in os.environ: # if developing locally, use numpyro.__version__ as version from numpyro import __version__ # noqaE402 + version = __version__ # release version @@ -93,10 +95,10 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This patterns also effect to html_static_path and html_extra_path -exclude_patterns = ['.ipynb_checkpoints', 'logistic_regression.ipynb'] +exclude_patterns = [".ipynb_checkpoints", "logistic_regression.ipynb"] # The name of the Pygments (syntax highlighting) style to use. -pygments_style = 'sphinx' +pygments_style = "sphinx" # If true, `todo` and `todoList` produce output, else they produce nothing. todo_include_todos = False @@ -113,7 +115,7 @@ html_theme = "sphinx_rtd_theme" html_theme_path = [sphinx_rtd_theme.get_html_theme_path()] # logo -html_logo = '_static/img/pyro_logo_wide.png' +html_logo = "_static/img/pyro_logo_wide.png" # Theme options are theme-specific and customize the look and feel of a theme # further. For a list of options available for each theme, see the @@ -126,8 +128,8 @@ # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] -html_style = 'css/pyro.css' +html_static_path = ["_static"] +html_style = "css/pyro.css" # html_favicon = '../img/favicon/favicon.ico' @@ -135,7 +137,7 @@ # -- Options for HTMLHelp output ------------------------------------------ # Output file base name for HTML help builder. -htmlhelp_basename = 'NumPyroTutorialsDoc' +htmlhelp_basename = "NumPyroTutorialsDoc" # -- Options for LaTeX output --------------------------------------------- @@ -144,15 +146,12 @@ # The paper size ('letterpaper' or 'a4paper'). # # 'papersize': 'letterpaper', - # The font size ('10pt', '11pt' or '12pt'). # # 'pointsize': '10pt', - # Additional stuff for the LaTeX preamble. # # 'preamble': '', - # Latex figure (float) alignment # # 'figure_align': 'htbp', @@ -162,8 +161,13 @@ # (source start file, target name, title, # author, documentclass [howto, manual, or own class]). latex_documents = [ - (master_doc, 'NumPyroTutorials.tex', u'Numpyro Examples and Tutorials', - u'Uber AI Labs', 'manual'), + ( + master_doc, + "NumPyroTutorials.tex", + u"Numpyro Examples and Tutorials", + u"Uber AI Labs", + "manual", + ) ] @@ -172,8 +176,7 @@ # One entry per manual page. List of tuples # (source start file, name, description, authors, manual section). man_pages = [ - (master_doc, 'NumPyroTutorials', u'Numpyro Examples and Tutorials', - [author], 1) + (master_doc, "NumPyroTutorials", u"Numpyro Examples and Tutorials", [author], 1) ] @@ -183,7 +186,13 @@ # (source start file, target name, title, author, # dir menu entry, description, category) texinfo_documents = [ - (master_doc, 'NumPyroTutorials', u'NumPyro Examples and Tutorials', - author, 'NumPyroTutorials', 'One line description of project.', - 'Miscellaneous'), + ( + master_doc, + "NumPyroTutorials", + u"NumPyro Examples and Tutorials", + author, + "NumPyroTutorials", + "One line description of project.", + "Miscellaneous", + ) ] diff --git a/numpyro/__init__.py b/numpyro/__init__.py index 2857f8590..81c1461b3 100644 --- a/numpyro/__init__.py +++ b/numpyro/__init__.py @@ -15,7 +15,7 @@ plate_stack, prng_key, sample, - subsample + subsample, ) from numpyro.util import enable_x64, set_host_device_count, set_platform from numpyro.version import __version__ diff --git a/numpyro/compat/infer.py b/numpyro/compat/infer.py index 81d6a70f3..2182a9c97 100644 --- a/numpyro/compat/infer.py +++ b/numpyro/compat/infer.py @@ -11,82 +11,96 @@ class HMC(hmc.HMC): - def __init__(self, - model=None, - potential_fn=None, - step_size=1, - adapt_step_size=True, - adapt_mass_matrix=True, - full_mass=False, - use_multinomial_sampling=True, - transforms=None, - max_plate_nesting=None, - jit_compile=False, - jit_options=None, - ignore_jit_warnings=False, - trajectory_length=2 * math.pi, - target_accept_prob=0.8): - super(HMC, self).__init__(model=model, - potential_fn=potential_fn, - step_size=step_size, - adapt_step_size=adapt_step_size, - adapt_mass_matrix=adapt_mass_matrix, - dense_mass=full_mass, - target_accept_prob=target_accept_prob, - trajectory_length=trajectory_length) + def __init__( + self, + model=None, + potential_fn=None, + step_size=1, + adapt_step_size=True, + adapt_mass_matrix=True, + full_mass=False, + use_multinomial_sampling=True, + transforms=None, + max_plate_nesting=None, + jit_compile=False, + jit_options=None, + ignore_jit_warnings=False, + trajectory_length=2 * math.pi, + target_accept_prob=0.8, + ): + super(HMC, self).__init__( + model=model, + potential_fn=potential_fn, + step_size=step_size, + adapt_step_size=adapt_step_size, + adapt_mass_matrix=adapt_mass_matrix, + dense_mass=full_mass, + target_accept_prob=target_accept_prob, + trajectory_length=trajectory_length, + ) class NUTS(hmc.NUTS): - def __init__(self, - model=None, - potential_fn=None, - step_size=1, - adapt_step_size=True, - adapt_mass_matrix=True, - full_mass=False, - use_multinomial_sampling=True, - transforms=None, - max_plate_nesting=None, - jit_compile=False, - jit_options=None, - ignore_jit_warnings=False, - trajectory_length=2 * math.pi, - target_accept_prob=0.8, - max_tree_depth=10): + def __init__( + self, + model=None, + potential_fn=None, + step_size=1, + adapt_step_size=True, + adapt_mass_matrix=True, + full_mass=False, + use_multinomial_sampling=True, + transforms=None, + max_plate_nesting=None, + jit_compile=False, + jit_options=None, + ignore_jit_warnings=False, + trajectory_length=2 * math.pi, + target_accept_prob=0.8, + max_tree_depth=10, + ): if potential_fn is not None: - raise ValueError('Only `model` argument is supported in generic module;' - ' `potential_fn` is not supported.') - super(NUTS, self).__init__(model=model, - potential_fn=potential_fn, - step_size=step_size, - adapt_step_size=adapt_step_size, - adapt_mass_matrix=adapt_mass_matrix, - dense_mass=full_mass, - target_accept_prob=target_accept_prob, - trajectory_length=trajectory_length, - max_tree_depth=max_tree_depth) + raise ValueError( + "Only `model` argument is supported in generic module;" + " `potential_fn` is not supported." + ) + super(NUTS, self).__init__( + model=model, + potential_fn=potential_fn, + step_size=step_size, + adapt_step_size=adapt_step_size, + adapt_mass_matrix=adapt_mass_matrix, + dense_mass=full_mass, + target_accept_prob=target_accept_prob, + trajectory_length=trajectory_length, + max_tree_depth=max_tree_depth, + ) class MCMC(object): - def __init__(self, - kernel, - num_samples, - warmup_steps=None, - initial_params=None, - num_chains=1, - hook_fn=None, - mp_context=None, - disable_progbar=False, - disable_validation=True, - transforms=None): + def __init__( + self, + kernel, + num_samples, + warmup_steps=None, + initial_params=None, + num_chains=1, + hook_fn=None, + mp_context=None, + disable_progbar=False, + disable_validation=True, + transforms=None, + ): if warmup_steps is None: warmup_steps = num_samples self._initial_params = initial_params - self._mcmc = mcmc.MCMC(kernel, - warmup_steps, - num_samples, - num_chains=num_chains, - progress_bar=(not disable_progbar)) + self._mcmc = mcmc.MCMC( + kernel, + warmup_steps, + num_samples, + num_chains=num_chains, + progress_bar=(not disable_progbar), + ) def run(self, *args, rng_key=None, **kwargs): if rng_key is None: @@ -95,7 +109,7 @@ def run(self, *args, rng_key=None, **kwargs): def get_samples(self, num_samples=None, group_by_chain=False): if num_samples is not None: - raise ValueError('`num_samples` arg unsupported in NumPyro.') + raise ValueError("`num_samples` arg unsupported in NumPyro.") return self._mcmc.get_samples(group_by_chain=group_by_chain) def summary(self, prob=0.9): @@ -103,19 +117,18 @@ def summary(self, prob=0.9): class SVI(svi.SVI): - def __init__(self, - model, - guide, - optim, - loss, - loss_and_grads=None, - num_samples=10, - num_steps=0, - **kwargs): - super(SVI, self).__init__(model=model, - guide=guide, - optim=optim, - loss=loss) + def __init__( + self, + model, + guide, + optim, + loss, + loss_and_grads=None, + num_samples=10, + num_steps=0, + **kwargs + ): + super(SVI, self).__init__(model=model, guide=guide, optim=optim, loss=loss) self.svi_state = None def evaluate_loss(self, *args, **kwargs): @@ -129,9 +142,11 @@ def step(self, *args, rng_key=None, **kwargs): try: self.svi_state, loss = jit(self.update)(self.svi_state, *args, **kwargs) except TypeError as e: - if 'not a valid JAX type' in str(e): - raise TypeError('NumPyro backend requires args, kwargs to be arrays or tuples, ' - 'dicts of arrays.') from e + if "not a valid JAX type" in str(e): + raise TypeError( + "NumPyro backend requires args, kwargs to be arrays or tuples, " + "dicts of arrays." + ) from e else: raise e params = jit(super(SVI, self).get_params)(self.svi_state) @@ -143,16 +158,18 @@ def get_params(self): class Trace_ELBO(elbo.Trace_ELBO): - def __init__(self, - num_particles=1, - max_plate_nesting=float('inf'), - max_iarange_nesting=None, # DEPRECATED - vectorize_particles=False, - strict_enumeration_warning=True, - ignore_jit_warnings=False, - jit_options=None, - retain_graph=None, - tail_adaptive_beta=-1.0): + def __init__( + self, + num_particles=1, + max_plate_nesting=float("inf"), + max_iarange_nesting=None, # DEPRECATED + vectorize_particles=False, + strict_enumeration_warning=True, + ignore_jit_warnings=False, + jit_options=None, + retain_graph=None, + tail_adaptive_beta=-1.0, + ): super(Trace_ELBO, self).__init__(num_particles=num_particles) diff --git a/numpyro/compat/ops.py b/numpyro/compat/ops.py index 676b1ec28..1ceff04ba 100644 --- a/numpyro/compat/ops.py +++ b/numpyro/compat/ops.py @@ -15,23 +15,24 @@ # of using *sizes. e.g. ops.ones(2, 3) as well as ops.ones((2, 3)) can # be used to initialize an array of ones with shape (2, 3). + def ones(*sizes, **kwargs): if len(sizes) == 0: - raise ValueError('Positional `size` argument not provided.') + raise ValueError("Positional `size` argument not provided.") elif len(sizes) == 1: if isinstance(sizes[0], (tuple, list)): sizes = sizes[0] if not np.all([isinstance(s, int) for s in sizes]): - raise ValueError('Invalid data type for `size` provided.') + raise ValueError("Invalid data type for `size` provided.") return jnp.ones(sizes, **kwargs) def zeros(*sizes, **kwargs): if len(sizes) == 0: - raise ValueError('Positional `size` argument not provided.') + raise ValueError("Positional `size` argument not provided.") elif len(sizes) == 1: if isinstance(sizes[0], (tuple, list)): sizes = sizes[0] if not np.all([isinstance(s, int) for s in sizes]): - raise ValueError('Invalid data type for `size` provided.') + raise ValueError("Invalid data type for `size` provided.") return jnp.ones(sizes, **kwargs) diff --git a/numpyro/compat/optim.py b/numpyro/compat/optim.py index 0bcc8e54b..db0889f7e 100644 --- a/numpyro/compat/optim.py +++ b/numpyro/compat/optim.py @@ -5,20 +5,24 @@ def Adam(kwargs): - step_size = kwargs.pop('lr') - b1, b2 = kwargs.pop('betas', (0.9, 0.999)) - eps = kwargs.pop('eps', 1.e-8) + step_size = kwargs.pop("lr") + b1, b2 = kwargs.pop("betas", (0.9, 0.999)) + eps = kwargs.pop("eps", 1.0e-8) return optim.Adam(step_size=step_size, b1=b1, b2=b2, eps=eps) def ClippedAdam(kwargs): - step_size = kwargs.pop('lr') - b1, b2 = kwargs.pop('betas', (0.9, 0.999)) - eps = kwargs.pop('eps', 1.e-8) - clip_norm = kwargs.pop('clip_norm', 10.) - lrd = kwargs.pop('lrd', None) + step_size = kwargs.pop("lr") + b1, b2 = kwargs.pop("betas", (0.9, 0.999)) + eps = kwargs.pop("eps", 1.0e-8) + clip_norm = kwargs.pop("clip_norm", 10.0) + lrd = kwargs.pop("lrd", None) init_lr = step_size if lrd is not None: + def step_size(i): return init_lr * lrd ** i - return optim.ClippedAdam(step_size=step_size, b1=b1, b2=b2, eps=eps, clip_norm=clip_norm) + + return optim.ClippedAdam( + step_size=step_size, b1=b1, b2=b2, eps=eps, clip_norm=clip_norm + ) diff --git a/numpyro/compat/pyro.py b/numpyro/compat/pyro.py index 81d2a2730..47f805596 100644 --- a/numpyro/compat/pyro.py +++ b/numpyro/compat/pyro.py @@ -4,16 +4,17 @@ import warnings from numpyro.compat.util import UnsupportedAPIWarning - -from numpyro.primitives import module, param as _param, plate, sample # noqa: F401 isort:skip +from numpyro.primitives import module, param as _param, plate, sample # noqa: F401 _PARAM_STORE = {} def get_param_store(): - warnings.warn('A limited parameter store is provided for compatibility with Pyro. ' - 'Value of SVI parameters should be obtained via SVI.get_params() method.', - category=UnsupportedAPIWarning) + warnings.warn( + "A limited parameter store is provided for compatibility with Pyro. " + "Value of SVI parameters should be obtained via SVI.get_params() method.", + category=UnsupportedAPIWarning, + ) # Return an empty dict for compatibility return _PARAM_STORE diff --git a/numpyro/compat/util.py b/numpyro/compat/util.py index dee070180..7d8b014b3 100644 --- a/numpyro/compat/util.py +++ b/numpyro/compat/util.py @@ -8,4 +8,5 @@ class UnsupportedAPIWarning(Warning): in NumPyro. Unlike raising NotImplementedError, it might be possible in such cases to return a dummy object and recover. """ + pass diff --git a/numpyro/contrib/control_flow/__init__.py b/numpyro/contrib/control_flow/__init__.py index cd5e425a3..6fde52c57 100644 --- a/numpyro/contrib/control_flow/__init__.py +++ b/numpyro/contrib/control_flow/__init__.py @@ -4,5 +4,5 @@ from numpyro.contrib.control_flow.scan import scan __all__ = [ - 'scan', + "scan", ] diff --git a/numpyro/contrib/control_flow/scan.py b/numpyro/contrib/control_flow/scan.py index 1c1e4dc6b..35ffb1dd7 100644 --- a/numpyro/contrib/control_flow/scan.py +++ b/numpyro/contrib/control_flow/scan.py @@ -4,7 +4,15 @@ from collections import OrderedDict from functools import partial -from jax import device_put, lax, random, tree_flatten, tree_map, tree_multimap, tree_unflatten +from jax import ( + device_put, + lax, + random, + tree_flatten, + tree_map, + tree_multimap, + tree_unflatten, +) import jax.numpy as jnp from jax.tree_util import register_pytree_node_class @@ -21,13 +29,13 @@ def __init__(self, trace): def tree_flatten(self): trace, aux_trace = {}, {} for name, site in self.trace.items(): - if site['type'] in ['sample', 'deterministic']: - trace[name], aux_trace[name] = {}, {'_control_flow_done': True} + if site["type"] in ["sample", "deterministic"]: + trace[name], aux_trace[name] = {}, {"_control_flow_done": True} for key in site: - if key in ['fn', 'args', 'value', 'intermediates']: + if key in ["fn", "args", "value", "intermediates"]: trace[name][key] = site[key] # scanned sites have stop field because we trace them inside a block handler - elif key != 'stop': + elif key != "stop": aux_trace[name][key] = site[key] # keep the site order information because in JAX, flatten and unflatten do not preserve # the order of keys in a dict @@ -37,7 +45,7 @@ def tree_flatten(self): @classmethod def tree_unflatten(cls, aux_data, children): aux_trace, site_names = aux_data - trace, = children + (trace,) = children trace_with_aux = {} for name in site_names: trace[name].update(aux_trace[name]) @@ -47,17 +55,21 @@ def tree_unflatten(cls, aux_data, children): def _subs_wrapper(subs_map, i, length, site): value = None - if isinstance(subs_map, dict) and site['name'] in subs_map: - value = subs_map[site['name']] + if isinstance(subs_map, dict) and site["name"] in subs_map: + value = subs_map[site["name"]] elif callable(subs_map): - rng_key = site['kwargs'].get('rng_key') - subs_map = handlers.seed(subs_map, rng_seed=rng_key) if rng_key is not None else subs_map + rng_key = site["kwargs"].get("rng_key") + subs_map = ( + handlers.seed(subs_map, rng_seed=rng_key) + if rng_key is not None + else subs_map + ) value = subs_map(site) if value is not None: value_ndim = jnp.ndim(value) - sample_shape = site['kwargs']['sample_shape'] - fn_ndim = len(sample_shape + site['fn'].shape()) + sample_shape = site["kwargs"]["sample_shape"] + fn_ndim = len(sample_shape + site["fn"].shape()) if value_ndim == fn_ndim: # this branch happens when substitute_fn is init_strategy, # where we apply init_strategy to each element in the scanned series @@ -68,23 +80,29 @@ def _subs_wrapper(subs_map, i, length, site): if shape[0] == length: return value[i] elif shape[0] < length: - rng_key = site['kwargs']['rng_key'] + rng_key = site["kwargs"]["rng_key"] assert rng_key is not None # we use the substituted values if i < shape[0] # and generate a new sample otherwise - return lax.cond(i < shape[0], - (value, i), - lambda val: val[0][val[1]], - rng_key, - lambda val: site['fn'](rng_key=val, sample_shape=sample_shape)) + return lax.cond( + i < shape[0], + (value, i), + lambda val: val[0][val[1]], + rng_key, + lambda val: site["fn"](rng_key=val, sample_shape=sample_shape), + ) else: - raise RuntimeError(f"Substituted value for site {site['name']} " - "requires length less than or equal to scan length." - f" Expected length <= {length}, but got {shape[0]}.") + raise RuntimeError( + f"Substituted value for site {site['name']} " + "requires length less than or equal to scan length." + f" Expected length <= {length}, but got {shape[0]}." + ) else: - raise RuntimeError(f"Something goes wrong. Expected ndim = {fn_ndim} or {fn_ndim+1}," - f" but got {value_ndim}. This might happen when you use nested scan," - " which is currently not supported. Please report the issue to us!") + raise RuntimeError( + f"Something goes wrong. Expected ndim = {fn_ndim} or {fn_ndim+1}," + f" but got {value_ndim}. This might happen when you use nested scan," + " which is currently not supported. Please report the issue to us!" + ) class _promote_fn_shapes(Messenger): @@ -98,7 +116,9 @@ def postprocess_message(self, msg): fn_batch_ndim = len(fn.batch_shape) if fn_batch_ndim < value_batch_ndims: prepend_shapes = (1,) * (value_batch_ndims - fn_batch_ndim) - msg["fn"] = tree_map(lambda x: jnp.reshape(x, prepend_shapes + jnp.shape(x)), fn) + msg["fn"] = tree_map( + lambda x: jnp.reshape(x, prepend_shapes + jnp.shape(x)), fn + ) def _promote_scanned_value_shapes(value, fn): @@ -109,15 +129,30 @@ def _promote_scanned_value_shapes(value, fn): fn_batch_ndim = len(fn.batch_shape) if fn_batch_ndim > value_batch_ndims: prepend_shapes = (1,) * (fn_batch_ndim - value_batch_ndims) - return jnp.reshape(value, jnp.shape(value)[:1] + prepend_shapes + jnp.shape(value)[1:]) + return jnp.reshape( + value, jnp.shape(value)[:1] + prepend_shapes + jnp.shape(value)[1:] + ) else: return value -def scan_enum(f, init, xs, length, reverse, rng_key=None, substitute_stack=None, history=1, - first_available_dim=None): - from numpyro.contrib.funsor import config_enumerate, enum, markov - from numpyro.contrib.funsor import trace as packed_trace +def scan_enum( + f, + init, + xs, + length, + reverse, + rng_key=None, + substitute_stack=None, + history=1, + first_available_dim=None, +): + from numpyro.contrib.funsor import ( + config_enumerate, + enum, + markov, + trace as packed_trace, + ) # amount number of steps to unroll history = min(history, length) @@ -138,19 +173,19 @@ def body_fn(wrapped_carry, x, prefix=None): # we need to tell unconstrained messenger in potential energy computation # that only the item at time `i` is needed when transforming - fn = handlers.infer_config(f, config_fn=lambda msg: {'_scan_current_index': i}) + fn = handlers.infer_config(f, config_fn=lambda msg: {"_scan_current_index": i}) seeded_fn = handlers.seed(fn, subkey) if subkey is not None else fn for subs_type, subs_map in substitute_stack: subs_fn = partial(_subs_wrapper, subs_map, i, length) - if subs_type == 'condition': + if subs_type == "condition": seeded_fn = handlers.condition(seeded_fn, condition_fn=subs_fn) - elif subs_type == 'substitute': + elif subs_type == "substitute": seeded_fn = handlers.substitute(seeded_fn, substitute_fn=subs_fn) if init: # handler the name to match the pattern of sakkar_bilmes product - with handlers.scope(prefix='_PREV_' * (unroll_steps - i), divider=''): + with handlers.scope(prefix="_PREV_" * (unroll_steps - i), divider=""): new_carry, y = config_enumerate(seeded_fn)(carry, x) trace = {} else: @@ -171,26 +206,34 @@ def body_fn(wrapped_carry, x, prefix=None): carry_shapes.append([jnp.shape(x) for x in tree_flatten(new_carry)[0]]) # make new_carry have the same shape as carry # FIXME: is this rigorous? - new_carry = tree_multimap(lambda a, b: jnp.reshape(a, jnp.shape(b)), - new_carry, carry) + new_carry = tree_multimap( + lambda a, b: jnp.reshape(a, jnp.shape(b)), new_carry, carry + ) return (i + 1, rng_key, new_carry), (PytreeTrace(trace), y) - with handlers.block(hide_fn=lambda site: not site["name"].startswith("_PREV_")), \ - enum(first_available_dim=first_available_dim): + with handlers.block( + hide_fn=lambda site: not site["name"].startswith("_PREV_") + ), enum(first_available_dim=first_available_dim): wrapped_carry = (0, rng_key, init) y0s = [] # We run unroll_steps + 1 where the last step is used for rolling with `lax.scan` for i in markov(range(unroll_steps + 1), history=history): if i < unroll_steps: - wrapped_carry, (_, y0) = body_fn(wrapped_carry, tree_map(lambda z: z[i], x0)) + wrapped_carry, (_, y0) = body_fn( + wrapped_carry, tree_map(lambda z: z[i], x0) + ) if i > 0: # reshape y1, y2,... to have the same shape as y0 - y0 = tree_multimap(lambda z0, z: jnp.reshape(z, jnp.shape(z0)), y0s[0], y0) + y0 = tree_multimap( + lambda z0, z: jnp.reshape(z, jnp.shape(z0)), y0s[0], y0 + ) y0s.append(y0) # shapes of the first `history - 1` steps are not useful to interpret the last carry # shape so we don't need to record them here if (i >= history - 1) and (len(carry_shapes) < history + 1): - carry_shapes.append(jnp.shape(x) for x in tree_flatten(wrapped_carry[-1])[0]) + carry_shapes.append( + jnp.shape(x) for x in tree_flatten(wrapped_carry[-1])[0] + ) else: # this is the last rolling step y0s = tree_multimap(lambda *z: jnp.stack(z, axis=0), *y0s) @@ -198,14 +241,15 @@ def body_fn(wrapped_carry, x, prefix=None): if length == unroll_steps: return wrapped_carry, (PytreeTrace({}), y0s) wrapped_carry = device_put(wrapped_carry) - wrapped_carry, (pytree_trace, ys) = lax.scan(body_fn, wrapped_carry, xs_, - length - unroll_steps, reverse) + wrapped_carry, (pytree_trace, ys) = lax.scan( + body_fn, wrapped_carry, xs_, length - unroll_steps, reverse + ) first_var = None for name, site in pytree_trace.trace.items(): # currently, we only record sample or deterministic in the trace # we don't need to adjust `dim_to_name` for deterministic site - if site['type'] not in ('sample',): + if site["type"] not in ("sample",): continue # add `time` dimension, the name will be '_time_{first variable in the trace}' if first_var is None: @@ -216,11 +260,15 @@ def body_fn(wrapped_carry, x, prefix=None): # XXX: site['infer']['dim_to_name'] is not enough to determine leftmost dimension because # we don't record 1-size dimensions in this field - time_dim = -min(len(site['fn'].batch_shape), jnp.ndim(site['value']) - site['fn'].event_dim) - site['infer']['dim_to_name'][time_dim] = '_time_{}'.format(first_var) + time_dim = -min( + len(site["fn"].batch_shape), jnp.ndim(site["value"]) - site["fn"].event_dim + ) + site["infer"]["dim_to_name"][time_dim] = "_time_{}".format(first_var) # similar to carry, we need to reshape due to shape alternating in markov - ys = tree_multimap(lambda z0, z: jnp.reshape(z, z.shape[:1] + jnp.shape(z0)[1:]), y0s, ys) + ys = tree_multimap( + lambda z0, z: jnp.reshape(z, z.shape[:1] + jnp.shape(z0)[1:]), y0s, ys + ) # then join with y0s ys = tree_multimap(lambda z0, z: jnp.concatenate([z0, z], axis=0), y0s, ys) # we also need to reshape `carry` to match sequential behavior @@ -228,21 +276,41 @@ def body_fn(wrapped_carry, x, prefix=None): t, rng_key, carry = wrapped_carry carry_shape = carry_shapes[i] flatten_carry, treedef = tree_flatten(carry) - flatten_carry = [jnp.reshape(x, t1_shape) - for x, t1_shape in zip(flatten_carry, carry_shape)] + flatten_carry = [ + jnp.reshape(x, t1_shape) for x, t1_shape in zip(flatten_carry, carry_shape) + ] carry = tree_unflatten(treedef, flatten_carry) wrapped_carry = (t, rng_key, carry) return wrapped_carry, (pytree_trace, ys) -def scan_wrapper(f, init, xs, length, reverse, rng_key=None, substitute_stack=[], enum=False, - history=1, first_available_dim=None): +def scan_wrapper( + f, + init, + xs, + length, + reverse, + rng_key=None, + substitute_stack=[], + enum=False, + history=1, + first_available_dim=None, +): if length is None: length = tree_flatten(xs)[0][0].shape[0] if enum and history > 0: - return scan_enum(f, init, xs, length, reverse, rng_key, substitute_stack, history, - first_available_dim) + return scan_enum( + f, + init, + xs, + length, + reverse, + rng_key, + substitute_stack, + history, + first_available_dim, + ) def body_fn(wrapped_carry, x): i, rng_key, carry = wrapped_carry @@ -252,14 +320,16 @@ def body_fn(wrapped_carry, x): # we need to tell unconstrained messenger in potential energy computation # that only the item at time `i` is needed when transforming - fn = handlers.infer_config(f, config_fn=lambda msg: {'_scan_current_index': i}) + fn = handlers.infer_config( + f, config_fn=lambda msg: {"_scan_current_index": i} + ) seeded_fn = handlers.seed(fn, subkey) if subkey is not None else fn for subs_type, subs_map in substitute_stack: subs_fn = partial(_subs_wrapper, subs_map, i, length) - if subs_type == 'condition': + if subs_type == "condition": seeded_fn = handlers.condition(seeded_fn, condition_fn=subs_fn) - elif subs_type == 'substitute': + elif subs_type == "substitute": seeded_fn = handlers.substitute(seeded_fn, substitute_fn=subs_fn) with handlers.trace() as trace: @@ -379,22 +449,21 @@ def g(*args, **kwargs): # if there are no active Messengers, we just run and return it as expected: if not _PYRO_STACK: (length, rng_key, carry), (pytree_trace, ys) = scan_wrapper( - f, init, xs, length=length, reverse=reverse) + f, init, xs, length=length, reverse=reverse + ) else: # Otherwise, we initialize a message... initial_msg = { - 'type': 'control_flow', - 'fn': scan_wrapper, - 'args': (f, init, xs, length, reverse), - 'kwargs': {'rng_key': None, - 'substitute_stack': [], - 'history': history}, - 'value': None, + "type": "control_flow", + "fn": scan_wrapper, + "args": (f, init, xs, length, reverse), + "kwargs": {"rng_key": None, "substitute_stack": [], "history": history}, + "value": None, } # ...and use apply_stack to send it to the Messengers msg = apply_stack(initial_msg) - (length, rng_key, carry), (pytree_trace, ys) = msg['value'] + (length, rng_key, carry), (pytree_trace, ys) = msg["value"] if not msg["kwargs"].get("enum", False): for msg in pytree_trace.trace.values(): @@ -406,7 +475,12 @@ def g(*args, **kwargs): for msg in pytree_trace.trace.values(): with LocalNamedMessenger(): dim_to_name = msg["infer"].get("dim_to_name") - to_funsor(msg["value"], dim_to_name=OrderedDict([(k, dim_to_name[k]) for k in sorted(dim_to_name)])) + to_funsor( + msg["value"], + dim_to_name=OrderedDict( + [(k, dim_to_name[k]) for k in sorted(dim_to_name)] + ), + ) apply_stack(msg) return carry, ys diff --git a/numpyro/contrib/einstein/kernels.py b/numpyro/contrib/einstein/kernels.py index d14261fe2..b162e5451 100644 --- a/numpyro/contrib/einstein/kernels.py +++ b/numpyro/contrib/einstein/kernels.py @@ -37,8 +37,12 @@ def mode(self): raise NotImplementedError @abstractmethod - def compute(self, particles: jnp.ndarray, particle_info: Dict[str, Tuple[int, int]], - loss_fn: Callable[[jnp.ndarray], float]): + def compute( + self, + particles: jnp.ndarray, + particle_info: Dict[str, Tuple[int, int]], + loss_fn: Callable[[jnp.ndarray], float], + ): """ Computes the kernel function given the input Stein particles @@ -68,19 +72,27 @@ class RBFKernel(SteinKernel): :param bandwidth_factor: A multiplier to the bandwidth based on data size n (default 1/log(n)) """ - def __init__(self, mode='norm', matrix_mode='norm_diag', - bandwidth_factor: Callable[[float], float] = lambda n: 1 / jnp.log(n)): - assert mode == 'norm' or mode == 'vector' or mode == 'matrix' - assert matrix_mode == 'norm_diag' or matrix_mode == 'vector_diag' + def __init__( + self, + mode="norm", + matrix_mode="norm_diag", + bandwidth_factor: Callable[[float], float] = lambda n: 1 / jnp.log(n), + ): + assert mode == "norm" or mode == "vector" or mode == "matrix" + assert matrix_mode == "norm_diag" or matrix_mode == "vector_diag" self._mode = mode self.matrix_mode = matrix_mode self.bandwidth_factor = bandwidth_factor def _normed(self): - return self._mode == 'norm' or (self.mode == 'matrix' and self.matrix_mode == 'norm_diag') + return self._mode == "norm" or ( + self.mode == "matrix" and self.matrix_mode == "norm_diag" + ) def compute(self, particles, particle_info, loss_fn): - diffs = jnp.expand_dims(particles, axis=0) - jnp.expand_dims(particles, axis=1) # N x N (x D) + diffs = jnp.expand_dims(particles, axis=0) - jnp.expand_dims( + particles, axis=1 + ) # N x N (x D) if self._normed() and particles.ndim == 2: diffs = safe_norm(diffs, ord=2, axis=-1) # N x D -> N diffs = jnp.reshape(diffs, (diffs.shape[0] * diffs.shape[1], -1)) # N * N (x D) @@ -93,9 +105,9 @@ def compute(self, particles, particle_info, loss_fn): def kernel(x, y): diff = safe_norm(x - y, ord=2) if self._normed() and x.ndim >= 1 else x - y - kernel_res = jnp.exp(- diff ** 2 / bandwidth) - if self._mode == 'matrix': - if self.matrix_mode == 'norm_diag': + kernel_res = jnp.exp(-(diff ** 2) / bandwidth) + if self._mode == "matrix": + if self.matrix_mode == "norm_diag": return kernel_res * jnp.identity(x.shape[0]) else: return jnp.diag(kernel_res) @@ -124,8 +136,8 @@ class IMQKernel(SteinKernel): :param float expon: Inverse exponent (beta) between (-1, 0) """ - def __init__(self, mode='norm', const=1.0, expon=-0.5): - assert mode == 'norm' or mode == 'vector' + def __init__(self, mode="norm", const=1.0, expon=-0.5): + assert mode == "norm" or mode == "vector" assert 0.0 < const assert -1.0 < expon < 0.0 self._mode = mode @@ -138,7 +150,7 @@ def mode(self): def compute(self, particles, particle_info, loss_fn): def kernel(x, y): - diff = safe_norm(x - y, ord=2, axis=-1) if self._mode == 'norm' else x - y + diff = safe_norm(x - y, ord=2, axis=-1) if self._mode == "norm" else x - y return (self.const ** 2 + diff ** 2) ** self.expon return kernel @@ -154,9 +166,9 @@ class LinearKernel(SteinKernel): 1. Stein Variational Gradient Descent as Moment Matching" by Liu and Wang """ - def __init__(self, mode='norm'): - assert mode == 'norm' - self._mode = 'norm' + def __init__(self, mode="norm"): + assert mode == "norm" + self._mode = "norm" @property def mode(self): @@ -190,11 +202,16 @@ class RandomFeatureKernel(SteinKernel): """ - def __init__(self, mode='norm', bandwidth_subset=None, random_indices=None, - bandwidth_factor: Callable[[float], float] = lambda n: 1 / jnp.log(n)): + def __init__( + self, + mode="norm", + bandwidth_subset=None, + random_indices=None, + bandwidth_factor: Callable[[float], float] = lambda n: 1 / jnp.log(n), + ): assert bandwidth_subset is None or bandwidth_subset > 0 - assert mode == 'norm' - self._mode = 'norm' + assert mode == "norm" + self._mode = "norm" self.bandwidth_subset = bandwidth_subset self.random_indices = None self.bandwidth_factor = bandwidth_factor @@ -212,7 +229,9 @@ def compute(self, particles, particle_info, loss_fn): factor = self.bandwidth_factor(particles.shape[0]) if self.bandwidth_subset is not None: particles = particles[npr.choice(particles.shape[0], self.bandwidth_subset)] - diffs = jnp.expand_dims(particles, axis=0) - jnp.expand_dims(particles, axis=1) # N x N x D + diffs = jnp.expand_dims(particles, axis=0) - jnp.expand_dims( + particles, axis=1 + ) # N x N x D if particles.ndim == 2: diffs = safe_norm(diffs, ord=2, axis=-1) # N x N x D -> N x N diffs = jnp.reshape(diffs, (diffs.shape[0] * diffs.shape[1], -1)) # N * N x 1 @@ -227,9 +246,19 @@ def feature(x, w, b): return jnp.sqrt(2) * jnp.cos((x @ w + b) / bandwidth) def kernel(x, y): - ws = self._random_weights if self.random_indices is None else self._random_weights[self.random_indices] - bs = self._random_biases if self.random_indices is None else self._random_biases[self.random_indices] - return jnp.sum(jax.vmap(lambda w, b: feature(x, w, b) * feature(y, w, b))(ws, bs)) + ws = ( + self._random_weights + if self.random_indices is None + else self._random_weights[self.random_indices] + ) + bs = ( + self._random_biases + if self.random_indices is None + else self._random_biases[self.random_indices] + ) + return jnp.sum( + jax.vmap(lambda w, b: feature(x, w, b) * feature(y, w, b))(ws, bs) + ) return kernel @@ -246,7 +275,7 @@ class MixtureKernel(SteinKernel): :param kernel_fns: Different kernel functions to mix together """ - def __init__(self, ws: List[float], kernel_fns: List[SteinKernel], mode='norm', ): + def __init__(self, ws: List[float], kernel_fns: List[SteinKernel], mode="norm"): assert len(ws) == len(kernel_fns) assert len(kernel_fns) > 1 assert all(kf.mode == mode for kf in kernel_fns) @@ -258,7 +287,9 @@ def mode(self): return self.kernel_fns[0].mode def compute(self, particles, particle_info, loss_fn): - kernels = [kf.compute(particles, particle_info, loss_fn) for kf in self.kernel_fns] + kernels = [ + kf.compute(particles, particle_info, loss_fn) for kf in self.kernel_fns + ] def kernel(x, y): res = self.ws[0] * kernels[0](x, y) @@ -299,21 +330,25 @@ class PrecondMatrixKernel(SteinKernel): or as mixture with anchor points ('anchor_points') """ - def __init__(self, precond_matrix_fn: PrecondMatrix, inner_kernel_fn: SteinKernel, - precond_mode='anchor_points'): - assert inner_kernel_fn.mode == 'matrix' - assert precond_mode == 'const' or precond_mode == 'anchor_points' + def __init__( + self, + precond_matrix_fn: PrecondMatrix, + inner_kernel_fn: SteinKernel, + precond_mode="anchor_points", + ): + assert inner_kernel_fn.mode == "matrix" + assert precond_mode == "const" or precond_mode == "anchor_points" self.precond_matrix_fn = precond_matrix_fn self.inner_kernel_fn = inner_kernel_fn self.precond_mode = precond_mode @property def mode(self): - return 'matrix' + return "matrix" def compute(self, particles, particle_info, loss_fn): qs = self.precond_matrix_fn.compute(particles, loss_fn) - if self.precond_mode == 'const': + if self.precond_mode == "const": qs = jnp.expand_dims(jnp.mean(qs, axis=0), axis=0) qs_inv = jnp.linalg.inv(qs) qs_sqrt = sqrth(qs) @@ -321,17 +356,32 @@ def compute(self, particles, particle_info, loss_fn): inner_kernel = self.inner_kernel_fn.compute(particles, particle_info, loss_fn) def kernel(x, y): - if self.precond_mode == 'const': - wxs = jnp.array([1.]) - wys = jnp.array([1.]) + if self.precond_mode == "const": + wxs = jnp.array([1.0]) + wys = jnp.array([1.0]) else: wxs = jax.nn.softmax( - jax.vmap(lambda z, q_inv: dist.MultivariateNormal(z, posdef(q_inv)).log_prob(x))(particles, qs_inv)) + jax.vmap( + lambda z, q_inv: dist.MultivariateNormal( + z, posdef(q_inv) + ).log_prob(x) + )(particles, qs_inv) + ) wys = jax.nn.softmax( - jax.vmap(lambda z, q_inv: dist.MultivariateNormal(z, posdef(q_inv)).log_prob(y))(particles, qs_inv)) + jax.vmap( + lambda z, q_inv: dist.MultivariateNormal( + z, posdef(q_inv) + ).log_prob(y) + )(particles, qs_inv) + ) return jnp.sum( - jax.vmap(lambda qs, qis, wx, wy: wx * wy * (qis @ inner_kernel(qs @ x, qs @ y) @ qis.transpose()))( - qs_sqrt, qs_inv_sqrt, wxs, wys), axis=0) + jax.vmap( + lambda qs, qis, wx, wy: wx + * wy + * (qis @ inner_kernel(qs @ x, qs @ y) @ qis.transpose()) + )(qs_sqrt, qs_inv_sqrt, wxs, wys), + axis=0, + ) return kernel @@ -350,38 +400,49 @@ class GraphicalKernel(SteinKernel): :param default_kernel_fn: The default choice of kernel function when none is specified for a particular parameter """ - def __init__(self, mode='matrix', local_kernel_fns: Dict[str, SteinKernel] = None, - default_kernel_fn: SteinKernel = RBFKernel()): - assert mode == 'matrix' + def __init__( + self, + mode="matrix", + local_kernel_fns: Dict[str, SteinKernel] = None, + default_kernel_fn: SteinKernel = RBFKernel(), + ): + assert mode == "matrix" self.local_kernel_fns = local_kernel_fns if local_kernel_fns is not None else {} self.default_kernel_fn = default_kernel_fn @property def mode(self): - return 'matrix' + return "matrix" def compute(self, particles, particle_info, loss_fn): def pk_loss_fn(start, end): def fn(ps): - return loss_fn(jnp.concatenate([particles[:, :start], ps, particles[:, end:]], axis=-1)) + return loss_fn( + jnp.concatenate( + [particles[:, :start], ps, particles[:, end:]], axis=-1 + ) + ) return fn local_kernels = [] for pk, (start_idx, end_idx) in particle_info.items(): pk_kernel_fn = self.local_kernel_fns.get(pk, self.default_kernel_fn) - pk_kernel = pk_kernel_fn.compute(particles[:, start_idx:end_idx], {pk: (0, end_idx - start_idx)}, - pk_loss_fn(start_idx, end_idx)) + pk_kernel = pk_kernel_fn.compute( + particles[:, start_idx:end_idx], + {pk: (0, end_idx - start_idx)}, + pk_loss_fn(start_idx, end_idx), + ) local_kernels.append((pk_kernel, pk_kernel_fn.mode, start_idx, end_idx)) def kernel(x, y): kernel_res = [] for kernel, mode, start_idx, end_idx in local_kernels: v = kernel(x[start_idx:end_idx], y[start_idx:end_idx]) - if mode == 'norm': + if mode == "norm": v = v * jnp.identity(end_idx - start_idx) - elif mode == 'vector': + elif mode == "vector": v = jnp.diag(v) kernel_res.append(v) return jax.scipy.linalg.block_diag(*kernel_res) diff --git a/numpyro/contrib/einstein/utils.py b/numpyro/contrib/einstein/utils.py index 24f7c22e7..fd5b0b01b 100644 --- a/numpyro/contrib/einstein/utils.py +++ b/numpyro/contrib/einstein/utils.py @@ -9,8 +9,10 @@ def posdef(m): """ Map a matrix to a positive definite matrix, where all eigenvalues are >= 1e-5. """ mlambda, mvec = jnp.linalg.eigh(m) if jnp.ndim(mlambda) >= 2: - mlambda = jax.vmap(lambda ml: jnp.diag(jnp.maximum(ml, 1e-5)), in_axes=tuple(range(jnp.ndim(mlambda) - 1)))( - mlambda) + mlambda = jax.vmap( + lambda ml: jnp.diag(jnp.maximum(ml, 1e-5)), + in_axes=tuple(range(jnp.ndim(mlambda) - 1)), + )(mlambda) else: mlambda = jnp.diag(jnp.maximum(mlambda, 1e-5)) return mvec @ mlambda @ jnp.swapaxes(mvec, -2, -1) @@ -20,8 +22,10 @@ def sqrth(m): """ Map a matrix to a positive definite matrix and square root it. """ mlambda, mvec = jnp.linalg.eigh(m) if jnp.ndim(mlambda) >= 2: - mlambdasqrt = jax.vmap(lambda ml: jnp.diag(jnp.maximum(ml, 1e-5) ** 0.5), - in_axes=tuple(range(jnp.ndim(mlambda) - 1)))(mlambda) + mlambdasqrt = jax.vmap( + lambda ml: jnp.diag(jnp.maximum(ml, 1e-5) ** 0.5), + in_axes=tuple(range(jnp.ndim(mlambda) - 1)), + )(mlambda) msqrt = mvec @ mlambdasqrt @ jnp.swapaxes(mvec, -2, -1) else: mlambdasqrt = jnp.diag(jnp.maximum(mlambda, 1e-5) ** 0.5) @@ -32,9 +36,12 @@ def sqrth(m): def safe_norm(a, ord=2, axis=None): if axis is not None: - is_zero = jnp.expand_dims(jnp.isclose(jnp.sum(a, axis=axis), 0.), axis=axis) + is_zero = jnp.expand_dims(jnp.isclose(jnp.sum(a, axis=axis), 0.0), axis=axis) else: - is_zero = jnp.ones_like(a, dtype='bool') - norm = jnp.linalg.norm(a + jnp.where(is_zero, jnp.ones_like(a) * 1e-5 ** ord, jnp.zeros_like(a)), ord=ord, - axis=axis) + is_zero = jnp.ones_like(a, dtype="bool") + norm = jnp.linalg.norm( + a + jnp.where(is_zero, jnp.ones_like(a) * 1e-5 ** ord, jnp.zeros_like(a)), + ord=ord, + axis=axis, + ) return norm diff --git a/numpyro/contrib/funsor/__init__.py b/numpyro/contrib/funsor/__init__.py index 4f1d2b5b9..53027ae12 100644 --- a/numpyro/contrib/funsor/__init__.py +++ b/numpyro/contrib/funsor/__init__.py @@ -4,14 +4,28 @@ try: import funsor except ImportError as e: - raise ImportError("Looking like you want to do inference for models with " - "discrete latent variables. This is an experimental feature. " - "You need to install `funsor` to be able to use this feature. " - "It can be installed with `pip install funsor`.") from e + raise ImportError( + "Looking like you want to do inference for models with " + "discrete latent variables. This is an experimental feature. " + "You need to install `funsor` to be able to use this feature. " + "It can be installed with `pip install funsor`." + ) from e from numpyro.contrib.funsor.discrete import infer_discrete -from numpyro.contrib.funsor.enum_messenger import enum, infer_config, markov, plate, to_data, to_funsor, trace -from numpyro.contrib.funsor.infer_util import config_enumerate, log_density, plate_to_enum_plate +from numpyro.contrib.funsor.enum_messenger import ( + enum, + infer_config, + markov, + plate, + to_data, + to_funsor, + trace, +) +from numpyro.contrib.funsor.infer_util import ( + config_enumerate, + log_density, + plate_to_enum_plate, +) funsor.set_backend("jax") diff --git a/numpyro/contrib/funsor/discrete.py b/numpyro/contrib/funsor/discrete.py index 33c50ae2e..59ed4513a 100644 --- a/numpyro/contrib/funsor/discrete.py +++ b/numpyro/contrib/funsor/discrete.py @@ -7,8 +7,7 @@ from jax import random import funsor -from numpyro.contrib.funsor.enum_messenger import enum -from numpyro.contrib.funsor.enum_messenger import trace as packed_trace +from numpyro.contrib.funsor.enum_messenger import enum, trace as packed_trace from numpyro.contrib.funsor.infer_util import plate_to_enum_plate from numpyro.distributions.util import is_identically_one from numpyro.handlers import block, replay, seed, trace @@ -17,13 +16,18 @@ @functools.singledispatch def _get_support_value(funsor_dist, name, **kwargs): - raise ValueError("Could not extract point from {} at name {}".format(funsor_dist, name)) + raise ValueError( + "Could not extract point from {} at name {}".format(funsor_dist, name) + ) @_get_support_value.register(funsor.cnf.Contraction) def _get_support_value_contraction(funsor_dist, name, **kwargs): - delta_terms = [v for v in funsor_dist.terms - if isinstance(v, funsor.delta.Delta) and name in v.fresh] + delta_terms = [ + v + for v in funsor_dist.terms + if isinstance(v, funsor.delta.Delta) and name in v.fresh + ] assert len(delta_terms) == 1 return _get_support_value(delta_terms[0], name, **kwargs) @@ -40,33 +44,43 @@ def terms_from_trace(tr): log_measures = {} sum_vars, prod_vars = frozenset(), frozenset() for site in tr.values(): - if site['type'] == 'sample': - value = site['value'] - intermediates = site['intermediates'] - scale = site['scale'] + if site["type"] == "sample": + value = site["value"] + intermediates = site["intermediates"] + scale = site["scale"] if intermediates: - log_prob = site['fn'].log_prob(value, intermediates) + log_prob = site["fn"].log_prob(value, intermediates) else: - log_prob = site['fn'].log_prob(value) + log_prob = site["fn"].log_prob(value) if (scale is not None) and (not is_identically_one(scale)): log_prob = scale * log_prob dim_to_name = site["infer"]["dim_to_name"] - log_prob_factor = funsor.to_funsor(log_prob, output=funsor.Real, dim_to_name=dim_to_name) + log_prob_factor = funsor.to_funsor( + log_prob, output=funsor.Real, dim_to_name=dim_to_name + ) - if site['is_observed']: + if site["is_observed"]: log_factors[site["name"]] = log_prob_factor else: log_measures[site["name"]] = log_prob_factor - sum_vars |= frozenset({site['name']}) - prod_vars |= frozenset(f.name for f in site['cond_indep_stack'] if f.dim is not None) + sum_vars |= frozenset({site["name"]}) + prod_vars |= frozenset( + f.name for f in site["cond_indep_stack"] if f.dim is not None + ) - return {"log_factors": log_factors, "log_measures": log_measures, - "measure_vars": sum_vars, "plate_vars": prod_vars} + return { + "log_factors": log_factors, + "log_measures": log_measures, + "measure_vars": sum_vars, + "plate_vars": prod_vars, + } -def _sample_posterior(model, first_available_dim, temperature, rng_key, *args, **kwargs): +def _sample_posterior( + model, first_available_dim, temperature, rng_key, *args, **kwargs +): if temperature == 0: sum_op, prod_op = funsor.ops.max, funsor.ops.add @@ -94,10 +108,11 @@ def _sample_posterior(model, first_available_dim, temperature, rng_key, *args, * with funsor.interpretations.lazy: log_prob = funsor.sum_product.sum_product( - sum_op, prod_op, + sum_op, + prod_op, list(terms["log_factors"].values()) + list(terms["log_measures"].values()), eliminate=terms["measure_vars"] | terms["plate_vars"], - plates=terms["plate_vars"] + plates=terms["plate_vars"], ) log_prob = funsor.optimizer.apply_optimizer(log_prob) @@ -115,13 +130,19 @@ def _sample_posterior(model, first_available_dim, temperature, rng_key, *args, * # values, so we have to slice them down # TODO this should really be handled entirely under the hood by adjoint output = funsor.Reals[node["fn"].event_shape] - value = funsor.to_funsor(node["value"], output, dim_to_name=node["infer"]["dim_to_name"]) + value = funsor.to_funsor( + node["value"], output, dim_to_name=node["infer"]["dim_to_name"] + ) value = value(**sample_subs) - node["value"] = funsor.to_data(value, name_to_dim=node["infer"]["name_to_dim"]) + node["value"] = funsor.to_data( + value, name_to_dim=node["infer"]["name_to_dim"] + ) else: log_measure = approx_factors[terms["log_measures"][name]] sample_subs[name] = _get_support_value(log_measure, name) - node["value"] = funsor.to_data(sample_subs[name], name_to_dim=node["infer"]["name_to_dim"]) + node["value"] = funsor.to_data( + sample_subs[name], name_to_dim=node["infer"]["name_to_dim"] + ) with replay(guide_trace=sample_tr): return model(*args, **kwargs) @@ -168,8 +189,12 @@ def viterbi_decoder(data, hidden_dim=10): if temperature == 1 or first_available_dim is None: assert rng_key is not None if fn is None: # support use as a decorator - return functools.partial(infer_discrete, - first_available_dim=first_available_dim, - temperature=temperature, - rng_key=rng_key) - return functools.partial(_sample_posterior, fn, first_available_dim, temperature, rng_key) + return functools.partial( + infer_discrete, + first_available_dim=first_available_dim, + temperature=temperature, + rng_key=rng_key, + ) + return functools.partial( + _sample_posterior, fn, first_available_dim, temperature, rng_key + ) diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index c347c9d36..c84f25b05 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -9,23 +9,13 @@ import jax.numpy as jnp import funsor -from numpyro.handlers import infer_config -from numpyro.handlers import trace as OrigTraceMessenger -from numpyro.primitives import Messenger, apply_stack -from numpyro.primitives import plate as OrigPlateMessenger +from numpyro.handlers import infer_config, trace as OrigTraceMessenger +from numpyro.primitives import Messenger, apply_stack, plate as OrigPlateMessenger funsor.set_backend("jax") -__all__ = [ - "enum", - "infer_config", - "markov", - "plate", - "to_data", - "to_funsor", - "trace", -] +__all__ = ["enum", "infer_config", "markov", "plate", "to_data", "to_funsor", "trace"] ################################## @@ -33,14 +23,11 @@ ################################## # name_to_dim : dict, dim_to_name : dict, parents : tuple, iter_parents : tuple -class StackFrame(namedtuple('StackFrame', [ - 'name_to_dim', - 'dim_to_name', - 'parents', - 'iter_parents', - 'keep', - ])): - +class StackFrame( + namedtuple( + "StackFrame", ["name_to_dim", "dim_to_name", "parents", "iter_parents", "keep"] + ) +): def read(self, name, dim): found_name = self.dim_to_name.get(dim, name) found_dim = self.name_to_dim.get(name, dim) @@ -60,14 +47,15 @@ def free(self, name, dim): class DimType(Enum): """Enumerates the possible types of dimensions to allocate""" + LOCAL = 0 GLOBAL = 1 VISIBLE = 2 -DimRequest = namedtuple('DimRequest', ['dim', 'dim_type']) +DimRequest = namedtuple("DimRequest", ["dim", "dim_type"]) DimRequest.__new__.__defaults__ = (None, DimType.LOCAL) -NameRequest = namedtuple('NameRequest', ['name', 'dim_type']) +NameRequest = namedtuple("NameRequest", ["name", "dim_type"]) NameRequest.__new__.__defaults__ = (None, DimType.LOCAL) @@ -78,11 +66,17 @@ class DimStack: Replaces the plate DimAllocator, the enum EnumAllocator, the stack in MarkovMessenger, _param_dims and _value_dims in EnumMessenger, and dim_to_symbol in msg['infer'] """ + def __init__(self): - self._stack = [StackFrame( - name_to_dim=OrderedDict(), dim_to_name=OrderedDict(), - parents=(), iter_parents=(), keep=False, - )] + self._stack = [ + StackFrame( + name_to_dim=OrderedDict(), + dim_to_name=OrderedDict(), + parents=(), + iter_parents=(), + keep=False, + ) + ] self._first_available_dim = -1 self.outermost = None @@ -109,7 +103,9 @@ def global_frame(self): return self._stack[0] def _gendim(self, name_request, dim_request): - assert isinstance(name_request, NameRequest) and isinstance(dim_request, DimRequest) + assert isinstance(name_request, NameRequest) and isinstance( + dim_request, DimRequest + ) dim_type = dim_request.dim_type if name_request.name is None: @@ -117,8 +113,11 @@ def _gendim(self, name_request, dim_request): else: fresh_name = name_request.name - conflict_frames = (self.current_frame, self.global_frame) + \ - self.current_frame.parents + self.current_frame.iter_parents + conflict_frames = ( + (self.current_frame, self.global_frame) + + self.current_frame.parents + + self.current_frame.iter_parents + ) if dim_request.dim is None: fresh_dim = self._first_available_dim if dim_type != DimType.VISIBLE else -1 fresh_dim = -1 if fresh_dim is None else fresh_dim @@ -127,9 +126,11 @@ def _gendim(self, name_request, dim_request): else: fresh_dim = dim_request.dim - if fresh_dim < self.MAX_DIM or \ - any(fresh_dim in p.dim_to_name for p in conflict_frames) or \ - (dim_type == DimType.VISIBLE and fresh_dim <= self._first_available_dim): + if ( + fresh_dim < self.MAX_DIM + or any(fresh_dim in p.dim_to_name for p in conflict_frames) + or (dim_type == DimType.VISIBLE and fresh_dim <= self._first_available_dim) + ): raise ValueError(f"Ran out of free dims during allocation for {fresh_name}") return fresh_name, fresh_dim @@ -141,8 +142,14 @@ def request(self, name, dim): elif isinstance(name, NameRequest): name, dim_type = name.name, name.dim_type - read_frames = (self.global_frame,) if dim_type != DimType.LOCAL else \ - (self.current_frame,) + self.current_frame.parents + self.current_frame.iter_parents + (self.global_frame,) + read_frames = ( + (self.global_frame,) + if dim_type != DimType.LOCAL + else (self.current_frame,) + + self.current_frame.parents + + self.current_frame.iter_parents + + (self.global_frame,) + ) # read dimension for frame in read_frames: @@ -152,10 +159,16 @@ def request(self, name, dim): # generate fresh name or dimension if not found: - name, dim = self._gendim(NameRequest(name, dim_type), DimRequest(dim, dim_type)) + name, dim = self._gendim( + NameRequest(name, dim_type), DimRequest(dim, dim_type) + ) - write_frames = (self.global_frame,) if dim_type != DimType.LOCAL else \ - (self.current_frame,) + (self.current_frame.parents if self.current_frame.keep else ()) + write_frames = ( + (self.global_frame,) + if dim_type != DimType.LOCAL + else (self.current_frame,) + + (self.current_frame.parents if self.current_frame.keep else ()) + ) # store the fresh dimension for frame in write_frames: @@ -171,6 +184,7 @@ def request(self, name, dim): # Messengers that implement guts of enumeration ################################################# + class ReentrantMessenger(Messenger): def __init__(self, fn=None): self._ref_count = 0 @@ -192,7 +206,6 @@ def __exit__(self, exc_type, exc_value, traceback): class DimStackCleanupMessenger(ReentrantMessenger): - def __init__(self, fn=None): self._saved_dims = () return super().__init__(fn) @@ -208,13 +221,14 @@ def __enter__(self): def __exit__(self, *args, **kwargs): if self._ref_count == 1 and _DIM_STACK.outermost is self: _DIM_STACK.outermost = None - for name, dim in reversed(tuple(_DIM_STACK.global_frame.name_to_dim.items())): + for name, dim in reversed( + tuple(_DIM_STACK.global_frame.name_to_dim.items()) + ): self._saved_dims += (_DIM_STACK.global_frame.free(name, dim),) return super().__exit__(*args, **kwargs) class NamedMessenger(DimStackCleanupMessenger): - def process_message(self, msg): if msg["type"] == "to_funsor": self._pyro_to_funsor(msg) @@ -228,7 +242,9 @@ def _get_name_to_dim(batch_names, name_to_dim=None, dim_type=DimType.LOCAL): # interpret all names/dims as requests since we only run this function once for name in batch_names: dim = name_to_dim.get(name, None) - name_to_dim[name] = dim if isinstance(dim, DimRequest) else DimRequest(dim, dim_type) + name_to_dim[name] = ( + dim if isinstance(dim, DimRequest) else DimRequest(dim, dim_type) + ) # read dimensions and allocate fresh dimensions as necessary for name, dim_request in name_to_dim.items(): @@ -239,13 +255,17 @@ def _get_name_to_dim(batch_names, name_to_dim=None, dim_type=DimType.LOCAL): @classmethod # only depends on the global _DIM_STACK state, not self def _pyro_to_data(cls, msg): - funsor_value, = msg["args"] + (funsor_value,) = msg["args"] name_to_dim = msg["kwargs"].setdefault("name_to_dim", OrderedDict()) dim_type = msg["kwargs"].setdefault("dim_type", DimType.LOCAL) batch_names = tuple(funsor_value.inputs.keys()) - name_to_dim.update(cls._get_name_to_dim(batch_names, name_to_dim=name_to_dim, dim_type=dim_type)) + name_to_dim.update( + cls._get_name_to_dim( + batch_names, name_to_dim=name_to_dim, dim_type=dim_type + ) + ) msg["stop"] = True # only need to run this once per to_data call @staticmethod @@ -260,7 +280,9 @@ def _get_dim_to_name(batch_shape, dim_to_name=None, dim_type=DimType.LOCAL): # before they have been assigned a name if batch_shape[dim] == 1 and name is None: continue - dim_to_name[dim] = name if isinstance(name, NameRequest) else NameRequest(name, dim_type) + dim_to_name[dim] = ( + name if isinstance(name, NameRequest) else NameRequest(name, dim_type) + ) for dim, name_request in dim_to_name.items(): dim_to_name[dim] = _DIM_STACK.request(name_request, dim)[0] @@ -282,9 +304,13 @@ def _pyro_to_funsor(cls, msg): try: batch_shape = raw_value.batch_shape # TODO make make this more robust except AttributeError: - batch_shape = raw_value.shape[:len(raw_value.shape) - event_dim] + batch_shape = raw_value.shape[: len(raw_value.shape) - event_dim] - dim_to_name.update(cls._get_dim_to_name(batch_shape, dim_to_name=dim_to_name, dim_type=dim_type)) + dim_to_name.update( + cls._get_dim_to_name( + batch_shape, dim_to_name=dim_to_name, dim_type=dim_type + ) + ) msg["stop"] = True # only need to run this once per to_funsor call @@ -300,6 +326,7 @@ class LocalNamedMessenger(NamedMessenger): level can depend on each other; if ``keep=False``, neighboring branches are independent (conditioned on their shared ancestors). """ + def __init__(self, fn=None, history=1, keep=False): self.history = history self.keep = keep @@ -336,10 +363,13 @@ def __enter__(self): name_to_dim, dim_to_name = OrderedDict(), OrderedDict() frame = StackFrame( - name_to_dim=name_to_dim, dim_to_name=dim_to_name, - parents=tuple(reversed(_DIM_STACK._stack[len(_DIM_STACK._stack) - self.history:])), + name_to_dim=name_to_dim, + dim_to_name=dim_to_name, + parents=tuple( + reversed(_DIM_STACK._stack[len(_DIM_STACK._stack) - self.history :]) + ), iter_parents=tuple(self._iter_parents), - keep=self.keep + keep=self.keep, ) _DIM_STACK.push(frame) @@ -350,8 +380,11 @@ def __exit__(self, *args, **kwargs): # don't keep around references to other frames old_frame = _DIM_STACK.pop() saved_frame = StackFrame( - name_to_dim=old_frame.name_to_dim, dim_to_name=old_frame.dim_to_name, - parents=(), iter_parents=(), keep=self.keep + name_to_dim=old_frame.name_to_dim, + dim_to_name=old_frame.dim_to_name, + parents=(), + iter_parents=(), + keep=self.keep, ) self._saved_frames.append(saved_frame) else: @@ -360,7 +393,6 @@ def __exit__(self, *args, **kwargs): class GlobalNamedMessenger(NamedMessenger): - def __init__(self, fn=None): self._saved_globals = () super().__init__(fn) @@ -387,26 +419,35 @@ def postprocess_message(self, msg): def _pyro_post_to_funsor(self, msg): if msg["kwargs"]["dim_type"] in (DimType.GLOBAL, DimType.VISIBLE): for name in msg["value"].inputs: - self._saved_globals += ((name, _DIM_STACK.global_frame.name_to_dim[name]),) + self._saved_globals += ( + (name, _DIM_STACK.global_frame.name_to_dim[name]), + ) def _pyro_post_to_data(self, msg): if msg["kwargs"]["dim_type"] in (DimType.GLOBAL, DimType.VISIBLE): for name in msg["args"][0].inputs: - self._saved_globals += ((name, _DIM_STACK.global_frame.name_to_dim[name]),) + self._saved_globals += ( + (name, _DIM_STACK.global_frame.name_to_dim[name]), + ) class BaseEnumMessenger(NamedMessenger): """ Handles first_available_dim management, enum effects should inherit from this """ + def __init__(self, fn=None, first_available_dim=None): - assert first_available_dim is None or first_available_dim < 0, first_available_dim + assert ( + first_available_dim is None or first_available_dim < 0 + ), first_available_dim self.first_available_dim = first_available_dim super().__init__(fn) def __enter__(self): if self._ref_count == 0 and self.first_available_dim is not None: - self._prev_first_dim = _DIM_STACK.set_first_available_dim(self.first_available_dim) + self._prev_first_dim = _DIM_STACK.set_first_available_dim( + self.first_available_dim + ) return super().__enter__() def __exit__(self, *args, **kwargs): @@ -419,6 +460,7 @@ def __exit__(self, *args, **kwargs): # User-facing handler implementations ########################################## + class plate(GlobalNamedMessenger): """ An alternative implementation of :class:`numpyro.primitives.plate` primitive. Note @@ -437,24 +479,33 @@ class plate(GlobalNamedMessenger): is used as the plate dim. If `None` (default), the leftmost available dim is allocated. """ + def __init__(self, name, size, subsample_size=None, dim=None): self.name = name self.size = size if dim is not None and dim >= 0: - raise ValueError('dim arg must be negative.') - self.dim, indices = OrigPlateMessenger._subsample(self.name, self.size, subsample_size, dim) + raise ValueError("dim arg must be negative.") + self.dim, indices = OrigPlateMessenger._subsample( + self.name, self.size, subsample_size, dim + ) self.subsample_size = indices.shape[0] self._indices = funsor.Tensor( indices, OrderedDict([(self.name, funsor.Bint[self.subsample_size])]), - self.subsample_size + self.subsample_size, ) super(plate, self).__init__(None) def __enter__(self): super().__enter__() # do this first to take care of globals recycling - name_to_dim = OrderedDict([(self.name, self.dim)]) if self.dim is not None else OrderedDict() - indices = to_data(self._indices, name_to_dim=name_to_dim, dim_type=DimType.VISIBLE) + name_to_dim = ( + OrderedDict([(self.name, self.dim)]) + if self.dim is not None + else OrderedDict() + ) + indices = to_data( + self._indices, name_to_dim=name_to_dim, dim_type=DimType.VISIBLE + ) # extract the dimension allocated by to_data to match plate's current behavior self.dim, self.indices = -len(indices.shape), indices.squeeze() return self.indices @@ -486,12 +537,18 @@ def postprocess_message(self, msg): if len(shape) >= -dim and shape[dim] != 1: if shape[dim] != self.size: if msg["type"] == "param": - statement = "numpyro.param({}, ..., event_dim={})".format(msg["name"], event_dim) + statement = "numpyro.param({}, ..., event_dim={})".format( + msg["name"], event_dim + ) else: - statement = "numpyro.subsample(..., event_dim={})".format(event_dim) + statement = "numpyro.subsample(..., event_dim={})".format( + event_dim + ) raise ValueError( - "Inside numpyro.plate({}, {}, dim={}) invalid shape of {}: {}" - .format(self.name, self.size, self.dim, statement, shape)) + "Inside numpyro.plate({}, {}, dim={}) invalid shape of {}: {}".format( + self.name, self.size, self.dim, statement, shape + ) + ) if self.subsample_size < self.size: value = msg["value"] new_value = jnp.take(value, self.indices, dim) @@ -509,10 +566,16 @@ class enum(BaseEnumMessenger): dimension and all dimensions left may be used internally by Pyro. This should be a negative integer or None. """ + def process_message(self, msg): - if msg["type"] != "sample" or \ - msg.get("done", False) or msg["is_observed"] or msg["infer"].get("expand", False) or \ - msg["infer"].get("enumerate") != "parallel" or (not msg["fn"].has_enumerate_support): + if ( + msg["type"] != "sample" + or msg.get("done", False) + or msg["is_observed"] + or msg["infer"].get("expand", False) + or msg["infer"].get("enumerate") != "parallel" + or (not msg["fn"].has_enumerate_support) + ): if msg["type"] == "control_flow": msg["kwargs"]["enum"] = True msg["kwargs"]["first_available_dim"] = self.first_available_dim @@ -527,9 +590,7 @@ def process_message(self, msg): size = msg["fn"].enumerate_support(expand=False).shape[0] raw_value = jnp.arange(0, size) funsor_value = funsor.Tensor( - raw_value, - OrderedDict([(msg["name"], funsor.Bint[size])]), - size + raw_value, OrderedDict([(msg["name"], funsor.Bint[size])]), size ) msg["value"] = to_data(funsor_value) @@ -544,14 +605,19 @@ class trace(OrigTraceMessenger): Each sample site is annotated with a "dim_to_name" dictionary, which can be passed directly to :func:`to_funsor`. """ + def postprocess_message(self, msg): if msg["type"] == "sample": total_batch_shape = lax.broadcast_shapes( tuple(msg["fn"].batch_shape), - jnp.shape(msg["value"])[:jnp.ndim(msg["value"]) - msg["fn"].event_dim] + jnp.shape(msg["value"])[: jnp.ndim(msg["value"]) - msg["fn"].event_dim], + ) + msg["infer"]["dim_to_name"] = NamedMessenger._get_dim_to_name( + total_batch_shape ) - msg["infer"]["dim_to_name"] = NamedMessenger._get_dim_to_name(total_batch_shape) - msg["infer"]["name_to_dim"] = {name: dim for dim, name in msg["infer"]["dim_to_name"].items()} + msg["infer"]["name_to_dim"] = { + name: dim for dim, name in msg["infer"]["dim_to_name"].items() + } if msg["type"] in ("sample", "param"): super().postprocess_message(msg) @@ -572,7 +638,9 @@ def markov(fn=None, history=1, keep=False): are independent (conditioned on their shared ancestors). """ if fn is not None and not callable(fn): # Used as a generator - return LocalNamedMessenger(fn=None, history=history, keep=keep).generator(iterable=fn) + return LocalNamedMessenger(fn=None, history=history, keep=keep).generator( + iterable=fn + ) return LocalNamedMessenger(fn, history=history, keep=keep) @@ -580,6 +648,7 @@ def markov(fn=None, history=1, keep=False): # New primitives #################### + def to_funsor(x, output=None, dim_to_name=None, dim_type=DimType.LOCAL): """ A primitive to convert a Python object to a :class:`~funsor.terms.Funsor`. @@ -598,16 +667,18 @@ def to_funsor(x, output=None, dim_to_name=None, dim_type=DimType.LOCAL): dim_to_name = OrderedDict() if dim_to_name is None else dim_to_name initial_msg = { - 'type': 'to_funsor', - 'fn': lambda x, output, dim_to_name, dim_type: funsor.to_funsor(x, output=output, dim_to_name=dim_to_name), - 'args': (x,), - 'kwargs': {"output": output, "dim_to_name": dim_to_name, "dim_type": dim_type}, - 'value': None, - 'mask': None, + "type": "to_funsor", + "fn": lambda x, output, dim_to_name, dim_type: funsor.to_funsor( + x, output=output, dim_to_name=dim_to_name + ), + "args": (x,), + "kwargs": {"output": output, "dim_to_name": dim_to_name, "dim_type": dim_type}, + "value": None, + "mask": None, } msg = apply_stack(initial_msg) - return msg['value'] + return msg["value"] def to_data(x, name_to_dim=None, dim_type=DimType.LOCAL): @@ -625,13 +696,15 @@ def to_data(x, name_to_dim=None, dim_type=DimType.LOCAL): name_to_dim = OrderedDict() if name_to_dim is None else name_to_dim initial_msg = { - 'type': 'to_data', - 'fn': lambda x, name_to_dim, dim_type: funsor.to_data(x, name_to_dim=name_to_dim), - 'args': (x,), - 'kwargs': {"name_to_dim": name_to_dim, "dim_type": dim_type}, - 'value': None, - 'mask': None, + "type": "to_data", + "fn": lambda x, name_to_dim, dim_type: funsor.to_data( + x, name_to_dim=name_to_dim + ), + "args": (x,), + "kwargs": {"name_to_dim": name_to_dim, "dim_type": dim_type}, + "value": None, + "mask": None, } msg = apply_stack(initial_msg) - return msg['value'] + return msg["value"] diff --git a/numpyro/contrib/funsor/infer_util.py b/numpyro/contrib/funsor/infer_util.py index a450d2760..09d94b88f 100644 --- a/numpyro/contrib/funsor/infer_util.py +++ b/numpyro/contrib/funsor/infer_util.py @@ -8,9 +8,11 @@ import funsor import numpyro -from numpyro.contrib.funsor.enum_messenger import infer_config -from numpyro.contrib.funsor.enum_messenger import plate as enum_plate -from numpyro.contrib.funsor.enum_messenger import trace as packed_trace +from numpyro.contrib.funsor.enum_messenger import ( + infer_config, + plate as enum_plate, + trace as packed_trace, +) from numpyro.distributions.util import is_identically_one from numpyro.handlers import substitute @@ -40,7 +42,7 @@ def plate_to_enum_plate(): numpyro.plate.__new__ = lambda *args, **kwargs: object.__new__(numpyro.plate) -def config_enumerate(fn=None, default='parallel'): +def config_enumerate(fn=None, default="parallel"): """ Configures enumeration for all relevant sites in a NumPyro model. @@ -68,9 +70,12 @@ def model(*args, **kwargs): return functools.partial(config_enumerate, default=default) def config_fn(site): - if site['type'] == 'sample' and (not site['is_observed']) \ - and site['fn'].has_enumerate_support: - return {'enumerate': site['infer'].get('enumerate', default)} + if ( + site["type"] == "sample" + and (not site["is_observed"]) + and site["fn"].has_enumerate_support + ): + return {"enumerate": site["infer"].get("enumerate", default)} return {} return infer_config(fn, config_fn) @@ -88,8 +93,14 @@ def _shift_name(name, t): return name.replace("_PREV_" * -t, "", 1) -def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_dims, - sum_vars, prod_vars, history): +def compute_markov_factors( + time_to_factors, + time_to_init_vars, + time_to_markov_dims, + sum_vars, + prod_vars, + history, +): """ :param dict time_to_factors: a map from time variable to the log prob factors. :param dict time_to_init_vars: a map from time variable to init discrete sites. @@ -108,22 +119,34 @@ def compute_markov_factors(time_to_factors, time_to_init_vars, time_to_markov_di eliminate_vars = (sum_vars | prod_vars) - time_to_markov_dims[time_var] with funsor.interpretations.lazy: lazy_result = funsor.sum_product.sum_product( - funsor.ops.logaddexp, funsor.ops.add, log_factors, - eliminate=eliminate_vars, plates=prod_vars) + funsor.ops.logaddexp, + funsor.ops.add, + log_factors, + eliminate=eliminate_vars, + plates=prod_vars, + ) trans = funsor.optimizer.apply_optimizer(lazy_result) if history > 1: - global_vars = frozenset(set(trans.inputs) - {time_var.name} - prev_vars - - {_shift_name(k, -_get_shift(k)) for k in prev_vars}) - markov_factors.append(funsor.sum_product.sarkka_bilmes_product( - funsor.ops.logaddexp, funsor.ops.add, trans, time_var, global_vars - )) + global_vars = frozenset( + set(trans.inputs) + - {time_var.name} + - prev_vars + - {_shift_name(k, -_get_shift(k)) for k in prev_vars} + ) + markov_factors.append( + funsor.sum_product.sarkka_bilmes_product( + funsor.ops.logaddexp, funsor.ops.add, trans, time_var, global_vars + ) + ) else: # remove `_PREV_` prefix to convert prev to curr prev_to_curr = {k: _shift_name(k, -_get_shift(k)) for k in prev_vars} - markov_factors.append(funsor.sum_product.sequential_sum_product( - funsor.ops.logaddexp, funsor.ops.add, trans, time_var, prev_to_curr - )) + markov_factors.append( + funsor.sum_product.sequential_sum_product( + funsor.ops.logaddexp, funsor.ops.add, trans, time_var, prev_to_curr + ) + ) return markov_factors @@ -158,56 +181,78 @@ def model(*args, **kwargs): sum_vars, prod_vars = frozenset(), frozenset() history = 1 for site in model_trace.values(): - if site['type'] == 'sample': - value = site['value'] - intermediates = site['intermediates'] - scale = site['scale'] + if site["type"] == "sample": + value = site["value"] + intermediates = site["intermediates"] + scale = site["scale"] if intermediates: - log_prob = site['fn'].log_prob(value, intermediates) + log_prob = site["fn"].log_prob(value, intermediates) else: - log_prob = site['fn'].log_prob(value) + log_prob = site["fn"].log_prob(value) if (scale is not None) and (not is_identically_one(scale)): log_prob = scale * log_prob dim_to_name = site["infer"]["dim_to_name"] - log_prob_factor = funsor.to_funsor(log_prob, output=funsor.Real, dim_to_name=dim_to_name) + log_prob_factor = funsor.to_funsor( + log_prob, output=funsor.Real, dim_to_name=dim_to_name + ) time_dim = None for dim, name in dim_to_name.items(): if name.startswith("_time"): time_dim = funsor.Variable(name, funsor.Bint[log_prob.shape[dim]]) time_to_factors[time_dim].append(log_prob_factor) - history = max(history, max(_get_shift(s) for s in dim_to_name.values())) + history = max( + history, max(_get_shift(s) for s in dim_to_name.values()) + ) time_to_init_vars[time_dim] |= frozenset( - s for s in dim_to_name.values() if s.startswith("_PREV_")) + s for s in dim_to_name.values() if s.startswith("_PREV_") + ) break if time_dim is None: log_factors.append(log_prob_factor) - if not site['is_observed']: - sum_vars |= frozenset({site['name']}) - prod_vars |= frozenset(f.name for f in site['cond_indep_stack'] if f.dim is not None) + if not site["is_observed"]: + sum_vars |= frozenset({site["name"]}) + prod_vars |= frozenset( + f.name for f in site["cond_indep_stack"] if f.dim is not None + ) for time_dim, init_vars in time_to_init_vars.items(): for var in init_vars: curr_var = _shift_name(var, -_get_shift(var)) dim_to_name = model_trace[curr_var]["infer"]["dim_to_name"] if var in dim_to_name.values(): # i.e. _PREV_* (i.e. prev) in dim_to_name - time_to_markov_dims[time_dim] |= frozenset(name for name in dim_to_name.values()) + time_to_markov_dims[time_dim] |= frozenset( + name for name in dim_to_name.values() + ) if len(time_to_factors) > 0: - markov_factors = compute_markov_factors(time_to_factors, time_to_init_vars, - time_to_markov_dims, sum_vars, prod_vars, history) + markov_factors = compute_markov_factors( + time_to_factors, + time_to_init_vars, + time_to_markov_dims, + sum_vars, + prod_vars, + history, + ) log_factors = log_factors + markov_factors with funsor.interpretations.lazy: lazy_result = funsor.sum_product.sum_product( - funsor.ops.logaddexp, funsor.ops.add, log_factors, - eliminate=sum_vars | prod_vars, plates=prod_vars) + funsor.ops.logaddexp, + funsor.ops.add, + log_factors, + eliminate=sum_vars | prod_vars, + plates=prod_vars, + ) result = funsor.optimizer.apply_optimizer(lazy_result) if len(result.inputs) > 0: - raise ValueError("Expected the joint log density is a scalar, but got {}. " - "There seems to be something wrong at the following sites: {}." - .format(result.data.shape, {k.split("__BOUND")[0] for k in result.inputs})) + raise ValueError( + "Expected the joint log density is a scalar, but got {}. " + "There seems to be something wrong at the following sites: {}.".format( + result.data.shape, {k.split("__BOUND")[0] for k in result.inputs} + ) + ) return result.data, model_trace diff --git a/numpyro/contrib/indexing.py b/numpyro/contrib/indexing.py index fb0e775f5..a62a64ddf 100644 --- a/numpyro/contrib/indexing.py +++ b/numpyro/contrib/indexing.py @@ -139,6 +139,7 @@ class Vindex: :param jnp.ndarray tensor: A tensor to be indexed. :return: An object with a special :meth:`__getitem__` method. """ + def __init__(self, tensor): self._tensor = tensor diff --git a/numpyro/contrib/module.py b/numpyro/contrib/module.py index 50622d707..ffdad805f 100644 --- a/numpyro/contrib/module.py +++ b/numpyro/contrib/module.py @@ -11,10 +11,10 @@ import numpyro __all__ = [ - 'flax_module', - 'haiku_module', - 'random_flax_module', - 'random_haiku_module', + "flax_module", + "haiku_module", + "random_flax_module", + "random_haiku_module", ] @@ -37,11 +37,13 @@ def flax_module(name, nn_module, *, input_shape=None, **kwargs): try: import flax # noqa: F401 except ImportError as e: - raise ImportError("Looking like you want to use flax to declare " - "nn modules. This is an experimental feature. " - "You need to install `flax` to be able to use this feature. " - "It can be installed with `pip install flax`.") from e - module_key = name + '$params' + raise ImportError( + "Looking like you want to use flax to declare " + "nn modules. This is an experimental feature. " + "You need to install `flax` to be able to use this feature. " + "It can be installed with `pip install flax`." + ) from e + module_key = name + "$params" nn_params = numpyro.param(module_key) if nn_params is None: args = (jnp.ones(input_shape),) if input_shape is not None else () @@ -74,12 +76,14 @@ def haiku_module(name, nn_module, *, input_shape=None, **kwargs): try: import haiku # noqa: F401 except ImportError as e: - raise ImportError("Looking like you want to use haiku to declare " - "nn modules. This is an experimental feature. " - "You need to install `haiku` to be able to use this feature. " - "It can be installed with `pip install dm-haiku`.") from e - - module_key = name + '$params' + raise ImportError( + "Looking like you want to use haiku to declare " + "nn modules. This is an experimental feature. " + "You need to install `haiku` to be able to use this feature. " + "It can be installed with `pip install dm-haiku`." + ) from e + + module_key = name + "$params" nn_params = numpyro.param(module_key) if nn_params is None: args = (jnp.ones(input_shape),) if input_shape is not None else () @@ -100,10 +104,12 @@ def haiku_module(name, nn_module, *, input_shape=None, **kwargs): # so that the optimizer can skip optimize this parameter, while # it still provides shape information for priors ParamShape = namedtuple("ParamShape", ["shape"]) -register_pytree_node(ParamShape, lambda x: ((None,), x.shape), lambda shape, x: ParamShape(shape)) +register_pytree_node( + ParamShape, lambda x: ((None,), x.shape), lambda shape, x: ParamShape(shape) +) -def _update_params(params, new_params, prior, prefix=''): +def _update_params(params, new_params, prior, prefix=""): """ A helper to recursively set prior to new_params. """ @@ -120,9 +126,11 @@ def _update_params(params, new_params, prior, prefix=''): else: param_shape = jnp.shape(params[name]) params[name] = ParamShape(param_shape) - param_batch_shape = param_shape[:len(param_shape) - d.event_dim] + param_batch_shape = param_shape[: len(param_shape) - d.event_dim] # XXX: here we set all dimensions of prior to event dimensions. - new_params[name] = numpyro.sample(flatten_name, d.expand(param_batch_shape).to_event()) + new_params[name] = numpyro.sample( + flatten_name, d.expand(param_batch_shape).to_event() + ) def random_flax_module(name, nn_module, prior, *, input_shape=None, **kwargs): diff --git a/numpyro/contrib/render.py b/numpyro/contrib/render.py index b92936c3a..bb877f7ae 100644 --- a/numpyro/contrib/render.py +++ b/numpyro/contrib/render.py @@ -26,7 +26,7 @@ def get_model_relations(model, model_args=None, model_kwargs=None, num_tries=10) obs_sites = [ name for name, site in trace.items() - if site['type'] == 'sample' and site['is_observed'] + if site["type"] == "sample" and site["is_observed"] ] def _get_dist_name(fn): @@ -37,20 +37,20 @@ def _get_dist_name(fn): return type(fn).__name__ sample_dist = { - name: _get_dist_name(site['fn']) + name: _get_dist_name(site["fn"]) for name, site in trace.items() - if site['type'] == 'sample' + if site["type"] == "sample" } sample_plates = { - name: [frame.name for frame in site['cond_indep_stack']] + name: [frame.name for frame in site["cond_indep_stack"]] for name, site in trace.items() - if site['type'] == 'sample' + if site["type"] == "sample" } plate_samples = { k: {name for name, plates in sample_plates.items() if k in plates} for k in trace - if trace[k]['type'] == 'plate' + if trace[k]["type"] == "plate" } def _resolve_plate_samples(plate_samples): @@ -59,7 +59,7 @@ def _resolve_plate_samples(plate_samples): if len(pv & qv) > 0 and len(pv - qv) > 0 and len(qv - pv) > 0: plate_samples_ = plate_samples.copy() plate_samples_[q] = pv & qv - plate_samples_[q + '__CLONE'] = qv - pv + plate_samples_[q + "__CLONE"] = qv - pv return _resolve_plate_samples(plate_samples_) return plate_samples @@ -75,17 +75,17 @@ def get_log_probs(sample, seed=0): ): model(*model_args, **model_kwargs) return { - name: site['fn'].log_prob(site['value']) + name: site["fn"].log_prob(site["value"]) for name, site in tr.items() - if site['type'] == 'sample' + if site["type"] == "sample" } samples = { - name: site['value'] + name: site["value"] for name, site in trace.items() - if site['type'] == 'sample' - and not site['is_observed'] - and not site['fn'].is_discrete + if site["type"] == "sample" + and not site["is_observed"] + and not site["fn"].is_discrete } log_prob_grads = jax.jacobian(get_log_probs)(samples) sample_deps = {} @@ -94,14 +94,14 @@ def get_log_probs(sample, seed=0): # find discrete -> continuous dependency samples = { - name: site['value'] for name, site in trace.items() if site['type'] == 'sample' + name: site["value"] for name, site in trace.items() if site["type"] == "sample" } discrete_sites = [ name for name, site in trace.items() - if site['type'] == 'sample' - and not site['is_observed'] - and site['fn'].is_discrete + if site["type"] == "sample" + and not site["is_observed"] + and site["fn"].is_discrete ] log_probs_prototype = get_log_probs(samples) for name in discrete_sites: @@ -118,10 +118,10 @@ def get_log_probs(sample, seed=0): for name in samples: sample_sample[name] = [var for var in samples if var in sample_deps[name]] return { - 'sample_sample': sample_sample, - 'sample_dist': sample_dist, - 'plate_sample': plate_samples, - 'observed': obs_sites, + "sample_sample": sample_sample, + "sample_dist": sample_dist, + "plate_sample": plate_samples, + "observed": obs_sites, } @@ -131,18 +131,18 @@ def generate_graph_specification(model_relations): converted into a network. """ # group nodes by plate - plate_groups = dict(model_relations['plate_sample']) + plate_groups = dict(model_relations["plate_sample"]) plate_rvs = {rv for rvs in plate_groups.values() for rv in rvs} plate_groups[None] = [ - rv for rv in model_relations['sample_sample'] if rv not in plate_rvs + rv for rv in model_relations["sample_sample"] if rv not in plate_rvs ] # RVs which are in no plate # retain node metadata node_data = {} - for rv in model_relations['sample_sample']: + for rv in model_relations["sample_sample"]: node_data[rv] = { - 'is_observed': rv in model_relations['observed'], - 'distribution': model_relations['sample_dist'][rv], + "is_observed": rv in model_relations["observed"], + "distribution": model_relations["sample_dist"][rv], } # infer plate structure @@ -154,27 +154,27 @@ def generate_graph_specification(model_relations): continue if set(plate_groups[plate1]) < set(plate_groups[plate2]): - plate_data[plate1] = {'parent': plate2} + plate_data[plate1] = {"parent": plate2} elif set(plate_groups[plate1]) >= set(plate_groups[plate2]): - plate_data[plate2] = {'parent': plate1} + plate_data[plate2] = {"parent": plate1} for plate in plate_groups: if plate is None: continue if plate not in plate_data: - plate_data[plate] = {'parent': None} + plate_data[plate] = {"parent": None} # infer RV edges edge_list = [] - for target, source_list in model_relations['sample_sample'].items(): + for target, source_list in model_relations["sample_sample"].items(): edge_list.extend([(source, target) for source in source_list]) return { - 'plate_groups': plate_groups, - 'plate_data': plate_data, - 'node_data': node_data, - 'edge_list': edge_list, + "plate_groups": plate_groups, + "plate_data": plate_data, + "node_data": node_data, + "edge_list": edge_list, } @@ -188,27 +188,27 @@ def render_graph(graph_specification, render_distributions=False): import graphviz # noqa: F401 except ImportError as e: raise ImportError( - 'Looks like you want to use graphviz (https://graphviz.org/) ' - 'to render your model. ' - 'You need to install `graphviz` to be able to use this feature. ' - 'It can be installed with `pip install graphviz`.' + "Looks like you want to use graphviz (https://graphviz.org/) " + "to render your model. " + "You need to install `graphviz` to be able to use this feature. " + "It can be installed with `pip install graphviz`." ) from e - plate_groups = graph_specification['plate_groups'] - plate_data = graph_specification['plate_data'] - node_data = graph_specification['node_data'] - edge_list = graph_specification['edge_list'] + plate_groups = graph_specification["plate_groups"] + plate_data = graph_specification["plate_data"] + node_data = graph_specification["node_data"] + edge_list = graph_specification["edge_list"] graph = graphviz.Digraph() # add plates plate_graph_dict = { - plate: graphviz.Digraph(name=f'cluster_{plate}') + plate: graphviz.Digraph(name=f"cluster_{plate}") for plate in plate_groups if plate is not None } for plate, plate_graph in plate_graph_dict.items(): - plate_graph.attr(label=plate.split('__CLONE')[0], labeljust='r', labelloc='b') + plate_graph.attr(label=plate.split("__CLONE")[0], labeljust="r", labelloc="b") plate_graph_dict[None] = graph @@ -217,19 +217,19 @@ def render_graph(graph_specification, render_distributions=False): cur_graph = plate_graph_dict[plate] for rv in rv_list: - color = 'grey' if node_data[rv]['is_observed'] else 'white' + color = "grey" if node_data[rv]["is_observed"] else "white" cur_graph.node( - rv, label=rv, shape='ellipse', style='filled', fillcolor=color + rv, label=rv, shape="ellipse", style="filled", fillcolor=color ) # add leaf nodes first while len(plate_data) >= 1: for plate, data in plate_data.items(): - parent_plate = data['parent'] + parent_plate = data["parent"] is_leaf = True for plate2, data2 in plate_data.items(): - if plate == data2['parent']: + if plate == data2["parent"]: is_leaf = False break @@ -244,12 +244,12 @@ def render_graph(graph_specification, render_distributions=False): # render distributions if requested if render_distributions: - dist_label = '' + dist_label = "" for rv, data in node_data.items(): - rv_dist = data['distribution'] - dist_label += rf'{rv} ~ {rv_dist}\l' + rv_dist = data["distribution"] + dist_label += rf"{rv} ~ {rv_dist}\l" - graph.node('distribution_description_node', label=dist_label, shape='plaintext') + graph.node("distribution_description_node", label=dist_label, shape="plaintext") # return whole graph return graph @@ -280,10 +280,7 @@ def render_model( :param int num_tries: Times to trace model to detect discrete -> continuous dependency. """ relations = get_model_relations( - model, - model_args=model_args, - model_kwargs=model_kwargs, - num_tries=num_tries, + model, model_args=model_args, model_kwargs=model_kwargs, num_tries=num_tries ) graph_spec = generate_graph_specification(relations) graph = render_graph(graph_spec, render_distributions=render_distributions) @@ -291,10 +288,7 @@ def render_model( if filename is not None: filename = Path(filename) graph.render( - filename.stem, - view=False, - cleanup=True, - format=filename.suffix[1:], # remove leading period from suffix - ) + filename.stem, view=False, cleanup=True, format=filename.suffix[1:] + ) # remove leading period from suffix return graph diff --git a/numpyro/contrib/tfp/__init__.py b/numpyro/contrib/tfp/__init__.py index 2d4993ea3..c3fe18f31 100644 --- a/numpyro/contrib/tfp/__init__.py +++ b/numpyro/contrib/tfp/__init__.py @@ -4,5 +4,7 @@ try: import tensorflow_probability.substrates.jax as tfp # noqa: F401 except ImportError as e: - raise ImportError("To use this module, please install TensorFlow Probability. It can be" - " installed with `pip install tensorflow_probability`") from e + raise ImportError( + "To use this module, please install TensorFlow Probability. It can be" + " installed with `pip install tensorflow_probability`" + ) from e diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index cb5ce0a0d..30b24f532 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -4,12 +4,10 @@ import numpy as np import jax.numpy as jnp -from tensorflow_probability.substrates.jax import bijectors as tfb -from tensorflow_probability.substrates.jax import distributions as tfd +from tensorflow_probability.substrates.jax import bijectors as tfb, distributions as tfd import numpyro.distributions as numpyro_dist -from numpyro.distributions import Distribution as NumPyroDistribution -from numpyro.distributions import constraints +from numpyro.distributions import Distribution as NumPyroDistribution, constraints from numpyro.distributions.transforms import Transform, biject_to from numpyro.util import not_jax_tracer @@ -43,6 +41,7 @@ class BijectorConstraint(constraints.Constraint): :param ~tensorflow_probability.substrates.jax.bijectors.Bijector bijector: a TensorFlow bijector """ + def __init__(self, bijector): self.bijector = bijector @@ -65,6 +64,7 @@ class BijectorTransform(Transform): :param ~tensorflow_probability.substrates.jax.bijectors.Bijector bijector: a TensorFlow bijector """ + def __init__(self, bijector): self.bijector = bijector @@ -88,13 +88,13 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): def forward_shape(self, shape): out_shape = self.bijector.forward_event_shape(shape) in_event_shape = self.bijector.inverse_event_shape(out_shape) - batch_shape = shape[:len(shape) - len(in_event_shape)] + batch_shape = shape[: len(shape) - len(in_event_shape)] return batch_shape + out_shape def inverse_shape(self, shape): in_shape = self.bijector.inverse_event_shape(shape) out_event_shape = self.bijector.forward_event_shape(in_shape) - batch_shape = shape[:len(shape) - len(out_event_shape)] + batch_shape = shape[: len(shape) - len(out_event_shape)] return batch_shape + in_shape @@ -124,13 +124,14 @@ class TFPDistributionMixin(NumPyroDistribution, metaclass=_TFPMixinMeta): A mixin layer to make TensorFlow Probability (TFP) distribution compatible with NumPyro internal. """ + def __init_subclass__(cls, **kwargs): # skip register pytree because TFP distributions are already pytrees super(object, cls).__init_subclass__(**kwargs) def __call__(self, *args, **kwargs): - key = kwargs.pop('rng_key') - sample_intermediates = kwargs.pop('sample_intermediates', False) + key = kwargs.pop("rng_key") + sample_intermediates = kwargs.pop("sample_intermediates", False) if sample_intermediates: return self.sample(*args, seed=key, **kwargs), [] return self.sample(*args, seed=key, **kwargs) @@ -150,7 +151,10 @@ def is_discrete(self): class InverseGamma(tfd.InverseGamma, TFPDistributionMixin): - arg_constraints = {"concentration": constraints.positive, "scale": constraints.positive} + arg_constraints = { + "concentration": constraints.positive, + "scale": constraints.positive, + } class OneHotCategorical(tfd.OneHotCategorical, TFPDistributionMixin): @@ -173,10 +177,13 @@ class OrderedLogistic(tfd.OrderedLogistic, TFPDistributionMixin): class Pareto(tfd.Pareto, TFPDistributionMixin): - arg_constraints = {"concentration": constraints.positive, "scale": constraints.positive} + arg_constraints = { + "concentration": constraints.positive, + "scale": constraints.positive, + } -__all__ = ['BijectorConstraint', 'BijectorTransform', 'TFPDistributionMixin'] +__all__ = ["BijectorConstraint", "BijectorTransform", "TFPDistributionMixin"] _len_all = len(__all__) for _name, _Dist in tfd.__dict__.items(): if not isinstance(_Dist, type): @@ -203,21 +210,26 @@ class Pareto(tfd.Pareto, TFPDistributionMixin): _PyroDist.enumerate_support = numpyro_dist_class.enumerate_support locals()[_name] = _PyroDist - _PyroDist.__doc__ = ''' + _PyroDist.__doc__ = """ Wraps `{}.{} `_ with :class:`~numpyro.contrib.tfp.distributions.TFPDistributionMixin`. - '''.format(_Dist.__module__, _Dist.__name__, _Dist.__name__) + """.format( + _Dist.__module__, _Dist.__name__, _Dist.__name__ + ) __all__.append(_name) # Create sphinx documentation. -__doc__ = '\n\n'.join([ - - ''' +__doc__ = "\n\n".join( + [ + """ {0} ---------------------------------------------------------------- .. autoclass:: numpyro.contrib.tfp.distributions.{0} - '''.format(_name) - for _name in __all__[:_len_all] + sorted(__all__[_len_all:]) -]) + """.format( + _name + ) + for _name in __all__[:_len_all] + sorted(__all__[_len_all:]) + ] +) diff --git a/numpyro/contrib/tfp/mcmc.py b/numpyro/contrib/tfp/mcmc.py index 8a0d71d01..5873fb966 100644 --- a/numpyro/contrib/tfp/mcmc.py +++ b/numpyro/contrib/tfp/mcmc.py @@ -15,11 +15,10 @@ from numpyro.infer.util import initialize_model from numpyro.util import identity -TFPKernelState = namedtuple('TFPKernelState', ['z', 'kernel_results', 'rng_key']) +TFPKernelState = namedtuple("TFPKernelState", ["z", "kernel_results", "rng_key"]) def _extract_kernel_functions(kernel): - def init_fn(z, rng_key): z_flat, _ = ravel_pytree(z) results = kernel.bootstrap_results(z_flat) @@ -28,24 +27,27 @@ def init_fn(z, rng_key): def sample_fn(state, model_args=(), model_kwargs=None): rng_key, rng_key_transition = random.split(state.rng_key) z_flat, unravel_fn = ravel_pytree(state.z) - z_new_flat, results = kernel.one_step(z_flat, state.kernel_results, seed=rng_key_transition) + z_new_flat, results = kernel.one_step( + z_flat, state.kernel_results, seed=rng_key_transition + ) return TFPKernelState(unravel_fn(z_new_flat), results, rng_key) return init_fn, sample_fn def _make_log_prob_fn(potential_fn, unravel_fn): - def log_prob_fn(x): # we deal with batched x in case the kernel is ReplicaExchangeMC batch_shape = jnp.shape(x)[:-1] if batch_shape: flatten_result = vmap(lambda a: -potential_fn(unravel_fn(a)))( - jnp.reshape(x, (-1,) + jnp.shape(x)[-1:])) - return tree_map(lambda a: jnp.reshape(a, batch_shape + jnp.shape(a)[1:]), - flatten_result) + jnp.reshape(x, (-1,) + jnp.shape(x)[-1:]) + ) + return tree_map( + lambda a: jnp.reshape(a, batch_shape + jnp.shape(a)[1:]), flatten_result + ) else: - return - potential_fn(unravel_fn(x)) + return -potential_fn(unravel_fn(x)) return log_prob_fn @@ -53,8 +55,9 @@ def log_prob_fn(x): class _TFPKernelMeta(ABCMeta): def __getitem__(cls, kernel_class): assert issubclass(kernel_class, tfp.mcmc.TransitionKernel) - assert 'target_log_prob_fn' in inspect.getfullargspec(kernel_class).args, \ - f"the first argument of {kernel_class} must be `target_log_prob_fn`" + assert ( + "target_log_prob_fn" in inspect.getfullargspec(kernel_class).args + ), f"the first argument of {kernel_class} must be `target_log_prob_fn`" _PyroKernel = type(kernel_class.__name__, (TFPKernel,), {}) _PyroKernel.kernel_class = kernel_class @@ -89,12 +92,18 @@ class TFPKernel(MCMCKernel, metaclass=_TFPKernelMeta): See :ref:`init_strategy` section for available functions. :param kernel_kwargs: other arguments to be passed to TFP kernel constructor. """ + kernel_class = None - def __init__(self, model=None, potential_fn=None, init_strategy=init_to_uniform, - **kernel_kwargs): + def __init__( + self, + model=None, + potential_fn=None, + init_strategy=init_to_uniform, + **kernel_kwargs, + ): if not (model is None) ^ (potential_fn is None): - raise ValueError('Only one of `model` or `potential_fn` must be specified.') + raise ValueError("Only one of `model` or `potential_fn` must be specified.") self._model = model self._potential_fn = potential_fn self._kernel_kwargs = kernel_kwargs @@ -112,13 +121,17 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): init_strategy=self._init_strategy, dynamic_args=True, model_args=model_args, - model_kwargs=model_kwargs) + model_kwargs=model_kwargs, + ) init_params = init_params.z if self._init_fn is None: _, unravel_fn = ravel_pytree(init_params) kernel = self.kernel_class( - _make_log_prob_fn(potential_fn(*model_args, **model_kwargs), unravel_fn), - **self._kernel_kwargs) + _make_log_prob_fn( + potential_fn(*model_args, **model_kwargs), unravel_fn + ), + **self._kernel_kwargs, + ) # Uncalibrated... kernels have to used inside MetropolisHastings, see # https://www.tensorflow.org/probability/api_docs/python/tfp/substrates/jax/mcmc/UncalibratedLangevin if self.kernel_class.__name__.startswith("Uncalibrated"): @@ -128,8 +141,8 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): elif self._init_fn is None: _, unravel_fn = ravel_pytree(init_params) kernel = self.kernel_class( - _make_log_prob_fn(self._potential_fn, unravel_fn), - **self._kernel_kwargs) + _make_log_prob_fn(self._potential_fn, unravel_fn), **self._kernel_kwargs + ) if self.kernel_class.__name__.startswith("Uncalibrated"): kernel = tfp.mcmc.MetropolisHastings(kernel) self._init_fn, self._sample_fn = _extract_kernel_functions(kernel) @@ -141,30 +154,38 @@ def model(self): @property def sample_field(self): - return 'z' + return "z" @property def default_fields(self): - return ('z',) + return ("z",) def get_diagnostics_str(self, state): """ Given the current `state`, returns the diagnostics string to be added to progress bar for diagnostics purpose. """ - return '' + return "" - def init(self, rng_key, num_warmup, init_params=None, model_args=(), model_kwargs={}): + def init( + self, rng_key, num_warmup, init_params=None, model_args=(), model_kwargs={} + ): # non-vectorized if rng_key.ndim == 1: rng_key, rng_key_init_model = random.split(rng_key) # vectorized else: - rng_key, rng_key_init_model = jnp.swapaxes(vmap(random.split)(rng_key), 0, 1) - init_params = self._init_state(rng_key_init_model, model_args, model_kwargs, init_params) + rng_key, rng_key_init_model = jnp.swapaxes( + vmap(random.split)(rng_key), 0, 1 + ) + init_params = self._init_state( + rng_key_init_model, model_args, model_kwargs, init_params + ) if self._potential_fn and init_params is None: - raise ValueError('Valid value of `init_params` must be provided with' - ' `target_log_prob_fn`.') + raise ValueError( + "Valid value of `init_params` must be provided with" + " `target_log_prob_fn`." + ) if rng_key.ndim == 1: init_state = self._init_fn(init_params, rng_key) @@ -195,35 +216,40 @@ def sample(self, state, model_args, model_kwargs): return self._sample_fn(state, model_args, model_kwargs) -__all__ = ['TFPKernel'] +__all__ = ["TFPKernel"] for _name, _Kernel in tfp.mcmc.__dict__.items(): if not isinstance(_Kernel, type): continue if not issubclass(_Kernel, tfp.mcmc.TransitionKernel): continue - if 'target_log_prob_fn' not in inspect.getfullargspec(_Kernel).args: + if "target_log_prob_fn" not in inspect.getfullargspec(_Kernel).args: continue _PyroKernel = TFPKernel[_Kernel] _PyroKernel.__module__ = __name__ locals()[_name] = _PyroKernel - _PyroKernel.__doc__ = ''' + _PyroKernel.__doc__ = """ Wraps `{}.{} `_ with :class:`~numpyro.contrib.tfp.mcmc.TFPKernel`. The first argument `target_log_prob_fn` in TFP kernel construction is replaced by either `model` or `potential_fn`. - '''.format(_Kernel.__module__, _Kernel.__name__, _Kernel.__name__) + """.format( + _Kernel.__module__, _Kernel.__name__, _Kernel.__name__ + ) __all__.append(_name) # Create sphinx documentation. -__doc__ = '\n\n'.join([ - - ''' +__doc__ = "\n\n".join( + [ + """ {0} ---------------------------------------------------------------- .. autoclass:: numpyro.contrib.tfp.mcmc.{0} - '''.format(_name) - for _name in __all__[:1] + sorted(__all__[1:]) -]) + """.format( + _name + ) + for _name in __all__[:1] + sorted(__all__[1:]) + ] +) diff --git a/numpyro/diagnostics.py b/numpyro/diagnostics.py index ab2b9996d..d7762207f 100644 --- a/numpyro/diagnostics.py +++ b/numpyro/diagnostics.py @@ -14,13 +14,13 @@ from jax.tree_util import tree_flatten, tree_map __all__ = [ - 'autocorrelation', - 'autocovariance', - 'effective_sample_size', - 'gelman_rubin', - 'hpdi', - 'split_gelman_rubin', - 'print_summary', + "autocorrelation", + "autocovariance", + "effective_sample_size", + "gelman_rubin", + "hpdi", + "split_gelman_rubin", + "print_summary", ] @@ -127,7 +127,7 @@ def autocorrelation(x, axis=0): # truncate and normalize the result, then transpose back to original shape autocorr = autocorr[..., :N] - autocorr = autocorr / np.arange(N, 0., -1) + autocorr = autocorr / np.arange(N, 0.0, -1) with np.errstate(invalid="ignore", divide="ignore"): autocorr = autocorr / autocorr[..., :1] return np.swapaxes(autocorr, axis, -1) @@ -170,9 +170,9 @@ def effective_sample_size(x): # find autocorrelation at lag k (from Stan reference) var_within, var_estimator = _compute_chain_variance_stats(x) - rho_k = 1. - (var_within - gamma_k_c.mean(axis=0)) / var_estimator + rho_k = 1.0 - (var_within - gamma_k_c.mean(axis=0)) / var_estimator # correlation at lag 0 is always 1 - rho_k[0] = 1. + rho_k[0] = 1.0 # initial positive sequence (formula 1.18 in [1]) applied for autocorrelation Rho_k = rho_k[:-1:2, ...] + rho_k[1::2, ...] @@ -180,11 +180,14 @@ def effective_sample_size(x): # initial monotone (decreasing) sequence Rho_init = Rho_k[:1] Rho_k = np.concatenate( - [Rho_init, np.minimum.accumulate(np.clip(Rho_k[1:, ...], a_min=0, a_max=None), axis=0)], - axis=0 + [ + Rho_init, + np.minimum.accumulate(np.clip(Rho_k[1:, ...], a_min=0, a_max=None), axis=0), + ], + axis=0, ) - tau = -1. + 2. * Rho_k.sum(axis=0) + tau = -1.0 + 2.0 * Rho_k.sum(axis=0) n_eff = np.prod(x.shape[:2]) / tau return n_eff @@ -205,7 +208,7 @@ def hpdi(x, prob=0.90, axis=0): sorted_x = np.sort(x, axis=0) mass = x.shape[0] index_length = int(prob * mass) - intervals_left = sorted_x[:(mass - index_length)] + intervals_left = sorted_x[: (mass - index_length)] intervals_right = sorted_x[index_length:] intervals_length = intervals_right - intervals_left index_start = intervals_length.argmin(axis=0) @@ -237,7 +240,9 @@ def summary(samples, prob=0.90, group_by_chain=True): if not group_by_chain: samples = tree_map(lambda x: x[None, ...], samples) if not isinstance(samples, dict): - samples = {'Param:{}'.format(i): v for i, v in enumerate(tree_flatten(samples)[0])} + samples = { + "Param:{}".format(i): v for i, v in enumerate(tree_flatten(samples)[0]) + } summary_dict = {} for name, value in samples.items(): @@ -249,11 +254,19 @@ def summary(samples, prob=0.90, group_by_chain=True): hpd = hpdi(value_flat, prob=prob) n_eff = effective_sample_size(value) r_hat = split_gelman_rubin(value) - hpd_lower = '{:.1f}%'.format(50 * (1 - prob)) - hpd_upper = '{:.1f}%'.format(50 * (1 + prob)) - summary_dict[name] = OrderedDict([("mean", mean), ("std", std), ("median", median), - (hpd_lower, hpd[0]), (hpd_upper, hpd[1]), - ("n_eff", n_eff), ("r_hat", r_hat)]) + hpd_lower = "{:.1f}%".format(50 * (1 - prob)) + hpd_upper = "{:.1f}%".format(50 * (1 + prob)) + summary_dict[name] = OrderedDict( + [ + ("mean", mean), + ("std", std), + ("median", median), + (hpd_lower, hpd[0]), + (hpd_upper, hpd[1]), + ("n_eff", n_eff), + ("r_hat", r_hat), + ] + ) return summary_dict @@ -277,26 +290,34 @@ def print_summary(samples, prob=0.90, group_by_chain=True): if not group_by_chain: samples = tree_map(lambda x: x[None, ...], samples) if not isinstance(samples, dict): - samples = {'Param:{}'.format(i): v for i, v in enumerate(tree_flatten(samples)[0])} + samples = { + "Param:{}".format(i): v for i, v in enumerate(tree_flatten(samples)[0]) + } summary_dict = summary(samples, prob, group_by_chain=True) - row_names = {k: k + '[' + ','.join(map(lambda x: str(x - 1), v.shape[2:])) + ']' - for k, v in samples.items()} + row_names = { + k: k + "[" + ",".join(map(lambda x: str(x - 1), v.shape[2:])) + "]" + for k, v in samples.items() + } max_len = max(max(map(lambda x: len(x), row_names.values())), 10) - name_format = '{:>' + str(max_len) + '}' - header_format = name_format + ' {:>9}' * 7 - columns = [''] + list(list(summary_dict.values())[0].keys()) + name_format = "{:>" + str(max_len) + "}" + header_format = name_format + " {:>9}" * 7 + columns = [""] + list(list(summary_dict.values())[0].keys()) print() print(header_format.format(*columns)) - row_format = name_format + ' {:>9.2f}' * 7 + row_format = name_format + " {:>9.2f}" * 7 for name, stats_dict in summary_dict.items(): shape = stats_dict["mean"].shape if len(shape) == 0: print(row_format.format(name, *stats_dict.values())) else: for idx in product(*map(range, shape)): - idx_str = '[{}]'.format(','.join(map(str, idx))) - print(row_format.format(name + idx_str, *[v[idx] for v in stats_dict.values()])) + idx_str = "[{}]".format(",".join(map(str, idx))) + print( + row_format.format( + name + idx_str, *[v[idx] for v in stats_dict.values()] + ) + ) print() diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index fc436894d..9a2d73f60 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -1,7 +1,11 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -from numpyro.distributions.conjugate import BetaBinomial, DirichletMultinomial, GammaPoisson +from numpyro.distributions.conjugate import ( + BetaBinomial, + DirichletMultinomial, + GammaPoisson, +) from numpyro.distributions.continuous import ( LKJ, Beta, @@ -31,7 +35,7 @@ TruncatedNormal, TruncatedPolyaGamma, TwoSidedTruncatedDistribution, - Uniform + Uniform, ) from numpyro.distributions.directional import ProjectedNormal, VonMises from numpyro.distributions.discrete import ( @@ -53,7 +57,7 @@ OrderedLogistic, Poisson, PRNGIdentity, - ZeroInflatedPoisson + ZeroInflatedPoisson, ) from numpyro.distributions.distribution import ( Delta, @@ -63,7 +67,7 @@ Independent, MaskedDistribution, TransformedDistribution, - Unit + Unit, ) from numpyro.distributions.kl import kl_divergence from numpyro.distributions.transforms import biject_to @@ -71,70 +75,69 @@ from . import constraints, transforms __all__ = [ - 'biject_to', - 'constraints', - 'kl_divergence', - 'transforms', - 'Bernoulli', - 'BernoulliLogits', - 'BernoulliProbs', - 'Beta', - 'BetaBinomial', - 'Binomial', - 'BinomialLogits', - 'BinomialProbs', - 'Categorical', - 'CategoricalLogits', - 'CategoricalProbs', - 'Cauchy', - 'Chi2', - 'Delta', - 'Dirichlet', - 'DirichletMultinomial', - 'Distribution', - 'Exponential', - 'ExpandedDistribution', - 'Gamma', - 'GammaPoisson', - 'GaussianRandomWalk', - 'Geometric', - 'GeometricLogits', - 'GeometricProbs', - 'Gumbel', - 'HalfCauchy', - 'HalfNormal', - 'ImproperUniform', - 'Independent', - 'InverseGamma', - 'LKJ', - 'LKJCholesky', - 'Laplace', - 'LeftTruncatedDistribution', - 'Logistic', - 'LogNormal', - 'MaskedDistribution', - 'Multinomial', - 'MultinomialLogits', - 'MultinomialProbs', - 'MultivariateNormal', - 'LowRankMultivariateNormal', - 'Normal', - 'OrderedLogistic', - 'Pareto', - 'Poisson', - 'ProjectedNormal', - 'PRNGIdentity', - 'RightTruncatedDistribution', - 'StudentT', - 'TransformedDistribution', - 'TruncatedCauchy', - 'TruncatedDistribution', - 'TruncatedNormal', - 'TruncatedPolyaGamma', - 'TwoSidedTruncatedDistribution', - 'Uniform', - 'Unit', - 'VonMises', - 'ZeroInflatedPoisson', - + "biject_to", + "constraints", + "kl_divergence", + "transforms", + "Bernoulli", + "BernoulliLogits", + "BernoulliProbs", + "Beta", + "BetaBinomial", + "Binomial", + "BinomialLogits", + "BinomialProbs", + "Categorical", + "CategoricalLogits", + "CategoricalProbs", + "Cauchy", + "Chi2", + "Delta", + "Dirichlet", + "DirichletMultinomial", + "Distribution", + "Exponential", + "ExpandedDistribution", + "Gamma", + "GammaPoisson", + "GaussianRandomWalk", + "Geometric", + "GeometricLogits", + "GeometricProbs", + "Gumbel", + "HalfCauchy", + "HalfNormal", + "ImproperUniform", + "Independent", + "InverseGamma", + "LKJ", + "LKJCholesky", + "Laplace", + "LeftTruncatedDistribution", + "Logistic", + "LogNormal", + "MaskedDistribution", + "Multinomial", + "MultinomialLogits", + "MultinomialProbs", + "MultivariateNormal", + "LowRankMultivariateNormal", + "Normal", + "OrderedLogistic", + "Pareto", + "Poisson", + "ProjectedNormal", + "PRNGIdentity", + "RightTruncatedDistribution", + "StudentT", + "TransformedDistribution", + "TruncatedCauchy", + "TruncatedDistribution", + "TruncatedNormal", + "TruncatedPolyaGamma", + "TwoSidedTruncatedDistribution", + "Uniform", + "Unit", + "VonMises", + "ZeroInflatedPoisson", ] diff --git a/numpyro/distributions/conjugate.py b/numpyro/distributions/conjugate.py index 6771942d9..b671cedf6 100644 --- a/numpyro/distributions/conjugate.py +++ b/numpyro/distributions/conjugate.py @@ -30,18 +30,24 @@ class BetaBinomial(Distribution): Beta distribution. :param numpy.ndarray total_count: number of Bernoulli trials. """ - arg_constraints = {'concentration1': constraints.positive, 'concentration0': constraints.positive, - 'total_count': constraints.nonnegative_integer} + arg_constraints = { + "concentration1": constraints.positive, + "concentration0": constraints.positive, + "total_count": constraints.nonnegative_integer, + } has_enumerate_support = True is_discrete = True enumerate_support = BinomialProbs.enumerate_support - def __init__(self, concentration1, concentration0, total_count=1, validate_args=None): + def __init__( + self, concentration1, concentration0, total_count=1, validate_args=None + ): self.concentration1, self.concentration0, self.total_count = promote_shapes( concentration1, concentration0, total_count ) - batch_shape = lax.broadcast_shapes(jnp.shape(concentration1), jnp.shape(concentration0), - jnp.shape(total_count)) + batch_shape = lax.broadcast_shapes( + jnp.shape(concentration1), jnp.shape(concentration0), jnp.shape(total_count) + ) concentration1 = jnp.broadcast_to(concentration1, batch_shape) concentration0 = jnp.broadcast_to(concentration0, batch_shape) self._beta = Beta(concentration1, concentration0) @@ -51,13 +57,20 @@ def sample(self, key, sample_shape=()): assert is_prng_key(key) key_beta, key_binom = random.split(key) probs = self._beta.sample(key_beta, sample_shape) - return BinomialProbs(total_count=self.total_count, probs=probs).sample(key_binom) + return BinomialProbs(total_count=self.total_count, probs=probs).sample( + key_binom + ) @validate_sample def log_prob(self, value): - return (-_log_beta_1(self.total_count - value + 1, value) + - betaln(value + self.concentration1, self.total_count - value + self.concentration0) - - betaln(self.concentration0, self.concentration1)) + return ( + -_log_beta_1(self.total_count - value + 1, value) + + betaln( + value + self.concentration1, + self.total_count - value + self.concentration0, + ) + - betaln(self.concentration0, self.concentration1) + ) @property def mean(self): @@ -65,7 +78,11 @@ def mean(self): @property def variance(self): - return self._beta.variance * self.total_count * (self.concentration0 + self.concentration1 + self.total_count) + return ( + self._beta.variance + * self.total_count + * (self.concentration0 + self.concentration1 + self.total_count) + ) @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): @@ -84,34 +101,46 @@ class DirichletMultinomial(Distribution): Dirichlet distribution. :param numpy.ndarray total_count: number of Categorical trials. """ - arg_constraints = {'concentration': constraints.independent(constraints.positive, 1), - 'total_count': constraints.nonnegative_integer} + arg_constraints = { + "concentration": constraints.independent(constraints.positive, 1), + "total_count": constraints.nonnegative_integer, + } is_discrete = True def __init__(self, concentration, total_count=1, validate_args=None): if jnp.ndim(concentration) < 1: - raise ValueError("`concentration` parameter must be at least one-dimensional.") + raise ValueError( + "`concentration` parameter must be at least one-dimensional." + ) - batch_shape = lax.broadcast_shapes(jnp.shape(concentration)[:-1], jnp.shape(total_count)) + batch_shape = lax.broadcast_shapes( + jnp.shape(concentration)[:-1], jnp.shape(total_count) + ) concentration_shape = batch_shape + jnp.shape(concentration)[-1:] - self.concentration, = promote_shapes(concentration, shape=concentration_shape) - self.total_count, = promote_shapes(total_count, shape=batch_shape) + (self.concentration,) = promote_shapes(concentration, shape=concentration_shape) + (self.total_count,) = promote_shapes(total_count, shape=batch_shape) concentration = jnp.broadcast_to(self.concentration, concentration_shape) self._dirichlet = Dirichlet(concentration) super().__init__( - self._dirichlet.batch_shape, self._dirichlet.event_shape, validate_args=validate_args) + self._dirichlet.batch_shape, + self._dirichlet.event_shape, + validate_args=validate_args, + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) key_dirichlet, key_multinom = random.split(key) probs = self._dirichlet.sample(key_dirichlet, sample_shape) - return MultinomialProbs(total_count=self.total_count, probs=probs).sample(key_multinom) + return MultinomialProbs(total_count=self.total_count, probs=probs).sample( + key_multinom + ) @validate_sample def log_prob(self, value): alpha = self.concentration - return (_log_beta_1(alpha.sum(-1), value.sum(-1)) - - _log_beta_1(alpha, value).sum(-1)) + return _log_beta_1(alpha.sum(-1), value.sum(-1)) - _log_beta_1( + alpha, value + ).sum(-1) @property def mean(self): @@ -146,14 +175,19 @@ class GammaPoisson(Distribution): :param numpy.ndarray concentration: shape parameter (alpha) of the Gamma distribution. :param numpy.ndarray rate: rate parameter (beta) for the Gamma distribution. """ - arg_constraints = {'concentration': constraints.positive, 'rate': constraints.positive} + arg_constraints = { + "concentration": constraints.positive, + "rate": constraints.positive, + } support = constraints.nonnegative_integer is_discrete = True - def __init__(self, concentration, rate=1., validate_args=None): + def __init__(self, concentration, rate=1.0, validate_args=None): self.concentration, self.rate = promote_shapes(concentration, rate) self._gamma = Gamma(concentration, rate) - super(GammaPoisson, self).__init__(self._gamma.batch_shape, validate_args=validate_args) + super(GammaPoisson, self).__init__( + self._gamma.batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -164,8 +198,12 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): post_value = self.concentration + value - return -betaln(self.concentration, value + 1) - jnp.log(post_value) + \ - self.concentration * jnp.log(self.rate) - post_value * jnp.log1p(self.rate) + return ( + -betaln(self.concentration, value + 1) + - jnp.log(post_value) + + self.concentration * jnp.log(self.rate) + - post_value * jnp.log1p(self.rate) + ) @property def mean(self): diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index b2ccf3f4f..56734b127 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -27,30 +27,30 @@ __all__ = [ - 'boolean', - 'corr_cholesky', - 'corr_matrix', - 'dependent', - 'greater_than', - 'integer_interval', - 'integer_greater_than', - 'interval', - 'is_dependent', - 'less_than', - 'lower_cholesky', - 'multinomial', - 'nonnegative_integer', - 'positive', - 'positive_definite', - 'positive_integer', - 'real', - 'real_vector', - 'simplex', - 'sphere', - 'softplus_lower_cholesky', - 'softplus_positive', - 'unit_interval', - 'Constraint', + "boolean", + "corr_cholesky", + "corr_matrix", + "dependent", + "greater_than", + "integer_interval", + "integer_greater_than", + "interval", + "is_dependent", + "less_than", + "lower_cholesky", + "multinomial", + "nonnegative_integer", + "positive", + "positive_definite", + "positive_integer", + "real", + "real_vector", + "simplex", + "sphere", + "softplus_lower_cholesky", + "softplus_positive", + "unit_interval", + "Constraint", ] import numpy as np @@ -65,6 +65,7 @@ class Constraint(object): A constraint object represents a region over which a variable is valid, e.g. within which a variable can be optimized. """ + event_dim = 0 def __call__(self, x): @@ -98,14 +99,18 @@ class _CorrCholesky(Constraint): def __call__(self, x): jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy tril = jnp.tril(x) - lower_triangular = jnp.all(jnp.reshape(tril == x, x.shape[:-2] + (-1,)), axis=-1) + lower_triangular = jnp.all( + jnp.reshape(tril == x, x.shape[:-2] + (-1,)), axis=-1 + ) positive_diagonal = jnp.all(jnp.diagonal(x, axis1=-2, axis2=-1) > 0, axis=-1) x_norm = jnp.linalg.norm(x, axis=-1) unit_norm_row = jnp.all((x_norm <= 1) & (x_norm > 1 - 1e-6), axis=-1) return lower_triangular & positive_diagonal & unit_norm_row def feasible_like(self, prototype): - return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + return jax.numpy.broadcast_to( + jax.numpy.eye(prototype.shape[-1]), prototype.shape + ) class _CorrMatrix(Constraint): @@ -118,11 +123,15 @@ def __call__(self, x): # check for the smallest eigenvalue is positive positive = jnp.linalg.eigh(x)[0][..., 0] > 0 # check for diagonal equal to 1 - unit_variance = jnp.all(jnp.abs(jnp.diagonal(x, axis1=-2, axis2=-1) - 1) < 1e-6, axis=-1) + unit_variance = jnp.all( + jnp.abs(jnp.diagonal(x, axis1=-2, axis2=-1) - 1) < 1e-6, axis=-1 + ) return symmetric & positive & unit_variance def feasible_like(self, prototype): - return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + return jax.numpy.broadcast_to( + jax.numpy.eye(prototype.shape[-1]), prototype.shape + ) class _Dependent(Constraint): @@ -137,6 +146,7 @@ class _Dependent(Constraint): computed statically. If not provided, access to the ``.event_dim`` attribute will raise a NotImplementedError. """ + def __init__(self, *, is_discrete=NotImplemented, event_dim=NotImplemented): self._is_discrete = is_discrete self._event_dim = event_dim @@ -156,7 +166,7 @@ def event_dim(self): def __call__(self, x=None, *, is_discrete=NotImplemented, event_dim=NotImplemented): if x is not None: - raise ValueError('Cannot determine validity of dependent constraint') + raise ValueError("Cannot determine validity of dependent constraint") # Support for syntax to customize static attributes:: # constraints.dependent(is_discrete=True, event_dim=1) @@ -168,7 +178,9 @@ def __call__(self, x=None, *, is_discrete=NotImplemented, event_dim=NotImplement class dependent_property(property, _Dependent): - def __init__(self, fn=None, *, is_discrete=NotImplemented, event_dim=NotImplemented): + def __init__( + self, fn=None, *, is_discrete=NotImplemented, event_dim=NotImplemented + ): super().__init__(fn) self._is_discrete = is_discrete self._event_dim = event_dim @@ -181,7 +193,9 @@ def __call__(self, x): # @constraints.dependent_property(is_discrete=True, event_dim=1) # def support(self): # ... - return dependent_property(x, is_discrete=self._is_discrete, event_dim=self._event_dim) + return dependent_property( + x, is_discrete=self._is_discrete, event_dim=self._event_dim + ) def is_dependent(constraint): @@ -205,12 +219,15 @@ class _IndependentConstraint(Constraint): dims in :meth:`check`, so that an event is valid only if all its independent entries are valid. """ + def __init__(self, base_constraint, reinterpreted_batch_ndims): assert isinstance(base_constraint, Constraint) assert isinstance(reinterpreted_batch_ndims, int) assert reinterpreted_batch_ndims >= 0 if isinstance(base_constraint, _IndependentConstraint): - reinterpreted_batch_ndims = reinterpreted_batch_ndims + base_constraint.reinterpreted_batch_ndims + reinterpreted_batch_ndims = ( + reinterpreted_batch_ndims + base_constraint.reinterpreted_batch_ndims + ) base_constraint = base_constraint.base_constraint self.base_constraint = base_constraint self.reinterpreted_batch_ndims = reinterpreted_batch_ndims @@ -226,9 +243,15 @@ def __call__(self, value): return result elif jax.numpy.ndim(result) < self.reinterpreted_batch_ndims: expected = self.event_dim - raise ValueError(f"Expected value.dim() >= {expected} but got {jax.numpy.ndim(value)}") + raise ValueError( + f"Expected value.dim() >= {expected} but got {jax.numpy.ndim(value)}" + ) result = result.reshape( - jax.numpy.shape(result)[:jax.numpy.ndim(result) - self.reinterpreted_batch_ndims] + (-1,)) + jax.numpy.shape(result)[ + : jax.numpy.ndim(result) - self.reinterpreted_batch_ndims + ] + + (-1,) + ) result = result.all(-1) return result @@ -279,7 +302,9 @@ def __call__(self, x): return (x >= self.lower_bound) & (x <= self.upper_bound) def feasible_like(self, prototype): - return jax.numpy.broadcast_to((self.lower_bound + self.upper_bound) / 2, jax.numpy.shape(prototype)) + return jax.numpy.broadcast_to( + (self.lower_bound + self.upper_bound) / 2, jax.numpy.shape(prototype) + ) class _LowerCholesky(Constraint): @@ -288,12 +313,16 @@ class _LowerCholesky(Constraint): def __call__(self, x): jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy tril = jnp.tril(x) - lower_triangular = jnp.all(jnp.reshape(tril == x, x.shape[:-2] + (-1,)), axis=-1) + lower_triangular = jnp.all( + jnp.reshape(tril == x, x.shape[:-2] + (-1,)), axis=-1 + ) positive_diagonal = jnp.all(jnp.diagonal(x, axis1=-2, axis2=-1) > 0, axis=-1) return lower_triangular & positive_diagonal def feasible_like(self, prototype): - return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + return jax.numpy.broadcast_to( + jax.numpy.eye(prototype.shape[-1]), prototype.shape + ) class _Multinomial(Constraint): @@ -306,7 +335,9 @@ def __call__(self, x): return (x >= 0).all(axis=-1) & (x.sum(axis=-1) == self.upper_bound) def feasible_like(self, prototype): - pad_width = ((0, 0),) * jax.numpy.ndim(self.upper_bound) + ((0, prototype.shape[-1] - 1),) + pad_width = ((0, 0),) * jax.numpy.ndim(self.upper_bound) + ( + (0, prototype.shape[-1] - 1), + ) value = jax.numpy.pad(jax.numpy.expand_dims(self.upper_bound, -1), pad_width) return jax.numpy.broadcast_to(value, prototype.shape) @@ -318,7 +349,9 @@ def __call__(self, x): return (x[..., 1:] > x[..., :-1]).all(axis=-1) def feasible_like(self, prototype): - return jax.numpy.broadcast_to(jax.numpy.arange(float(prototype.shape[-1])), prototype.shape) + return jax.numpy.broadcast_to( + jax.numpy.arange(float(prototype.shape[-1])), prototype.shape + ) class _PositiveDefinite(Constraint): @@ -333,7 +366,9 @@ def __call__(self, x): return symmetric & positive def feasible_like(self, prototype): - return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]), prototype.shape) + return jax.numpy.broadcast_to( + jax.numpy.eye(prototype.shape[-1]), prototype.shape + ) class _PositiveOrderedVector(Constraint): @@ -341,20 +376,22 @@ class _PositiveOrderedVector(Constraint): Constrains to a positive real-valued tensor where the elements are monotonically increasing along the `event_shape` dimension. """ + event_dim = 1 def __call__(self, x): return ordered_vector.check(x) & independent(positive, 1).check(x) def feasible_like(self, prototype): - return jax.numpy.broadcast_to(jax.numpy.exp(jax.numpy.arange(float(prototype.shape[-1]))), - prototype.shape) + return jax.numpy.broadcast_to( + jax.numpy.exp(jax.numpy.arange(float(prototype.shape[-1]))), prototype.shape + ) class _Real(Constraint): def __call__(self, x): # XXX: consider to relax this condition to [-inf, inf] interval - return (x == x) & (x != float('inf')) & (x != float('-inf')) + return (x == x) & (x != float("inf")) & (x != float("-inf")) def feasible_like(self, prototype): return jax.numpy.zeros_like(prototype) @@ -381,15 +418,18 @@ def feasible_like(self, prototype): class _SoftplusLowerCholesky(_LowerCholesky): def feasible_like(self, prototype): - return jax.numpy.broadcast_to(jax.numpy.eye(prototype.shape[-1]) * np.log(2), prototype.shape) + return jax.numpy.broadcast_to( + jax.numpy.eye(prototype.shape[-1]) * np.log(2), prototype.shape + ) class _Sphere(Constraint): """ Constrain to the Euclidean sphere of any dimension. """ + event_dim = 1 - reltol = 10. # Relative to finfo.eps. + reltol = 10.0 # Relative to finfo.eps. def __call__(self, x): jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy @@ -419,7 +459,7 @@ def feasible_like(self, prototype): multinomial = _Multinomial nonnegative_integer = _IntegerGreaterThan(0) ordered_vector = _OrderedVector() -positive = _GreaterThan(0.) +positive = _GreaterThan(0.0) positive_definite = _PositiveDefinite() positive_integer = _IntegerGreaterThan(1) positive_ordered_vector = _PositiveOrderedVector() @@ -429,4 +469,4 @@ def feasible_like(self, prototype): softplus_lower_cholesky = _SoftplusLowerCholesky() softplus_positive = _SoftplusPositive() sphere = _Sphere() -unit_interval = _Interval(0., 1.) +unit_interval = _Interval(0.0, 1.0) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 7567fa86b..d14e3b12b 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -31,12 +31,26 @@ import jax.numpy as jnp import jax.random as random from jax.scipy.linalg import cho_solve, solve_triangular -from jax.scipy.special import betainc, expit, gammaln, logit, logsumexp, multigammaln, ndtr, ndtri +from jax.scipy.special import ( + betainc, + expit, + gammaln, + logit, + logsumexp, + multigammaln, + ndtr, + ndtri, +) from jax.tree_util import tree_map from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution, TransformedDistribution -from numpyro.distributions.transforms import AffineTransform, CorrMatrixCholeskyTransform, ExpTransform, PowerTransform +from numpyro.distributions.transforms import ( + AffineTransform, + CorrMatrixCholeskyTransform, + ExpTransform, + PowerTransform, +) from numpyro.distributions.util import ( cholesky_of_inverse, is_prng_key, @@ -45,24 +59,32 @@ promote_shapes, signed_stick_breaking_tril, validate_sample, - vec_to_tril_matrix + vec_to_tril_matrix, ) EULER_MASCHERONI = 0.5772156649015328606065120900824024310421 class Beta(Distribution): - arg_constraints = {'concentration1': constraints.positive, 'concentration0': constraints.positive} - reparametrized_params = ['concentration1', 'concentration0'] + arg_constraints = { + "concentration1": constraints.positive, + "concentration0": constraints.positive, + } + reparametrized_params = ["concentration1", "concentration0"] support = constraints.unit_interval def __init__(self, concentration1, concentration0, validate_args=None): - self.concentration1, self.concentration0 = promote_shapes(concentration1, concentration0) - batch_shape = lax.broadcast_shapes(jnp.shape(concentration1), jnp.shape(concentration0)) + self.concentration1, self.concentration0 = promote_shapes( + concentration1, concentration0 + ) + batch_shape = lax.broadcast_shapes( + jnp.shape(concentration1), jnp.shape(concentration0) + ) concentration1 = jnp.broadcast_to(concentration1, batch_shape) concentration0 = jnp.broadcast_to(concentration0, batch_shape) - self._dirichlet = Dirichlet(jnp.stack([concentration1, concentration0], - axis=-1)) + self._dirichlet = Dirichlet( + jnp.stack([concentration1, concentration0], axis=-1) + ) super(Beta, self).__init__(batch_shape=batch_shape, validate_args=validate_args) def sample(self, key, sample_shape=()): @@ -71,7 +93,7 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): - return self._dirichlet.log_prob(jnp.stack([value, 1. - value], -1)) + return self._dirichlet.log_prob(jnp.stack([value, 1.0 - value], -1)) @property def mean(self): @@ -87,14 +109,16 @@ def cdf(self, value): class Cauchy(Distribution): - arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} support = constraints.real - reparametrized_params = ['loc', 'scale'] + reparametrized_params = ["loc", "scale"] - def __init__(self, loc=0., scale=1., validate_args=None): + def __init__(self, loc=0.0, scale=1.0, validate_args=None): self.loc, self.scale = promote_shapes(loc, scale) batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) - super(Cauchy, self).__init__(batch_shape=batch_shape, validate_args=validate_args) + super(Cauchy, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -103,7 +127,11 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): - return - jnp.log(jnp.pi) - jnp.log(self.scale) - jnp.log1p(((value - self.loc) / self.scale) ** 2) + return ( + -jnp.log(jnp.pi) + - jnp.log(self.scale) + - jnp.log1p(((value - self.loc) / self.scale) ** 2) + ) @property def mean(self): @@ -122,18 +150,24 @@ def icdf(self, q): class Dirichlet(Distribution): - arg_constraints = {'concentration': constraints.independent(constraints.positive, 1)} - reparametrized_params = ['concentration'] + arg_constraints = { + "concentration": constraints.independent(constraints.positive, 1) + } + reparametrized_params = ["concentration"] support = constraints.simplex def __init__(self, concentration, validate_args=None): if jnp.ndim(concentration) < 1: - raise ValueError("`concentration` parameter must be at least one-dimensional.") + raise ValueError( + "`concentration` parameter must be at least one-dimensional." + ) self.concentration = concentration batch_shape, event_shape = concentration.shape[:-1], concentration.shape[-1:] - super(Dirichlet, self).__init__(batch_shape=batch_shape, - event_shape=event_shape, - validate_args=validate_args) + super(Dirichlet, self).__init__( + batch_shape=batch_shape, + event_shape=event_shape, + validate_args=validate_args, + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -148,14 +182,22 @@ def sample(self, key, sample_shape=()): # and apply softmax to get a dirichlet sample gamma_samples = random.gamma(key_gamma, self.concentration + 1, shape=shape) expon_samples = random.exponential(key_expon, shape=shape) - samples = nn.softmax(jnp.log(gamma_samples) - expon_samples / self.concentration, -1) - return jnp.clip(samples, a_min=jnp.finfo(samples).tiny, a_max=1 - jnp.finfo(samples).eps) + samples = nn.softmax( + jnp.log(gamma_samples) - expon_samples / self.concentration, -1 + ) + return jnp.clip( + samples, a_min=jnp.finfo(samples).tiny, a_max=1 - jnp.finfo(samples).eps + ) @validate_sample def log_prob(self, value): - normalize_term = (jnp.sum(gammaln(self.concentration), axis=-1) - - gammaln(jnp.sum(self.concentration, axis=-1))) - return jnp.sum(jnp.log(value) * (self.concentration - 1.), axis=-1) - normalize_term + normalize_term = jnp.sum(gammaln(self.concentration), axis=-1) - gammaln( + jnp.sum(self.concentration, axis=-1) + ) + return ( + jnp.sum(jnp.log(value) * (self.concentration - 1.0), axis=-1) + - normalize_term + ) @property def mean(self): @@ -164,7 +206,9 @@ def mean(self): @property def variance(self): con0 = jnp.sum(self.concentration, axis=-1, keepdims=True) - return self.concentration * (con0 - self.concentration) / (con0 ** 2 * (con0 + 1)) + return ( + self.concentration * (con0 - self.concentration) / (con0 ** 2 * (con0 + 1)) + ) @staticmethod def infer_shapes(concentration): @@ -174,17 +218,21 @@ def infer_shapes(concentration): class Exponential(Distribution): - reparametrized_params = ['rate'] - arg_constraints = {'rate': constraints.positive} + reparametrized_params = ["rate"] + arg_constraints = {"rate": constraints.positive} support = constraints.positive - def __init__(self, rate=1., validate_args=None): + def __init__(self, rate=1.0, validate_args=None): self.rate = rate - super(Exponential, self).__init__(batch_shape=jnp.shape(rate), validate_args=validate_args) + super(Exponential, self).__init__( + batch_shape=jnp.shape(rate), validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - return random.exponential(key, shape=sample_shape + self.batch_shape) / self.rate + return ( + random.exponential(key, shape=sample_shape + self.batch_shape) / self.rate + ) @validate_sample def log_prob(self, value): @@ -200,16 +248,19 @@ def variance(self): class Gamma(Distribution): - arg_constraints = {'concentration': constraints.positive, - 'rate': constraints.positive} + arg_constraints = { + "concentration": constraints.positive, + "rate": constraints.positive, + } support = constraints.positive - reparametrized_params = ['concentration', 'rate'] + reparametrized_params = ["concentration", "rate"] - def __init__(self, concentration, rate=1., validate_args=None): + def __init__(self, concentration, rate=1.0, validate_args=None): self.concentration, self.rate = promote_shapes(concentration, rate) batch_shape = lax.broadcast_shapes(jnp.shape(concentration), jnp.shape(rate)) - super(Gamma, self).__init__(batch_shape=batch_shape, - validate_args=validate_args) + super(Gamma, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -218,9 +269,14 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): - normalize_term = (gammaln(self.concentration) - - self.concentration * jnp.log(self.rate)) - return (self.concentration - 1) * jnp.log(value) - self.rate * value - normalize_term + normalize_term = gammaln(self.concentration) - self.concentration * jnp.log( + self.rate + ) + return ( + (self.concentration - 1) * jnp.log(value) + - self.rate * value + - normalize_term + ) @property def mean(self): @@ -232,8 +288,8 @@ def variance(self): class Chi2(Gamma): - arg_constraints = {'df': constraints.positive} - reparametrized_params = ['df'] + arg_constraints = {"df": constraints.positive} + reparametrized_params = ["df"] def __init__(self, df, validate_args=None): self.df = df @@ -241,17 +297,20 @@ def __init__(self, df, validate_args=None): class GaussianRandomWalk(Distribution): - arg_constraints = {'scale': constraints.positive} + arg_constraints = {"scale": constraints.positive} support = constraints.real_vector - reparametrized_params = ['scale'] + reparametrized_params = ["scale"] - def __init__(self, scale=1., num_steps=1, validate_args=None): - assert isinstance(num_steps, int) and num_steps > 0, \ - "`num_steps` argument should be an positive integer." + def __init__(self, scale=1.0, num_steps=1, validate_args=None): + assert ( + isinstance(num_steps, int) and num_steps > 0 + ), "`num_steps` argument should be an positive integer." self.scale = scale self.num_steps = num_steps batch_shape, event_shape = jnp.shape(scale), (num_steps,) - super(GaussianRandomWalk, self).__init__(batch_shape, event_shape, validate_args=validate_args) + super(GaussianRandomWalk, self).__init__( + batch_shape, event_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -261,7 +320,7 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): - init_prob = Normal(0., self.scale).log_prob(value[..., 0]) + init_prob = Normal(0.0, self.scale).log_prob(value[..., 0]) scale = jnp.expand_dims(self.scale, -1) step_probs = Normal(value[..., :-1], scale).log_prob(value[..., 1:]) return init_prob + jnp.sum(step_probs, axis=-1) @@ -272,8 +331,10 @@ def mean(self): @property def variance(self): - return jnp.broadcast_to(jnp.expand_dims(self.scale, -1) ** 2 * jnp.arange(1, self.num_steps + 1), - self.batch_shape + self.event_shape) + return jnp.broadcast_to( + jnp.expand_dims(self.scale, -1) ** 2 * jnp.arange(1, self.num_steps + 1), + self.batch_shape + self.event_shape, + ) def tree_flatten(self): return (self.scale,), self.num_steps @@ -284,14 +345,16 @@ def tree_unflatten(cls, aux_data, params): class HalfCauchy(Distribution): - reparametrized_params = ['scale'] + reparametrized_params = ["scale"] support = constraints.positive - arg_constraints = {'scale': constraints.positive} + arg_constraints = {"scale": constraints.positive} - def __init__(self, scale=1., validate_args=None): - self._cauchy = Cauchy(0., scale) + def __init__(self, scale=1.0, validate_args=None): + self._cauchy = Cauchy(0.0, scale) self.scale = scale - super(HalfCauchy, self).__init__(batch_shape=jnp.shape(scale), validate_args=validate_args) + super(HalfCauchy, self).__init__( + batch_shape=jnp.shape(scale), validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -311,14 +374,16 @@ def variance(self): class HalfNormal(Distribution): - reparametrized_params = ['scale'] + reparametrized_params = ["scale"] support = constraints.positive - arg_constraints = {'scale': constraints.positive} + arg_constraints = {"scale": constraints.positive} - def __init__(self, scale=1., validate_args=None): - self._normal = Normal(0., scale) + def __init__(self, scale=1.0, validate_args=None): + self._normal = Normal(0.0, scale) self.scale = scale - super(HalfNormal, self).__init__(batch_shape=jnp.shape(scale), validate_args=validate_args) + super(HalfNormal, self).__init__( + batch_shape=jnp.shape(scale), validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -343,16 +408,21 @@ class InverseGamma(TransformedDistribution): it plays the role of scale parameter of InverseGamma in literatures (e.g. wikipedia: https://en.wikipedia.org/wiki/Inverse-gamma_distribution) """ - arg_constraints = {'concentration': constraints.positive, 'rate': constraints.positive} + + arg_constraints = { + "concentration": constraints.positive, + "rate": constraints.positive, + } reparametrized_params = ["concentration", "rate"] support = constraints.positive - def __init__(self, concentration, rate=1., validate_args=None): + def __init__(self, concentration, rate=1.0, validate_args=None): base_dist = Gamma(concentration, rate) self.concentration = base_dist.concentration self.rate = base_dist.rate - super(InverseGamma, self).__init__(base_dist, PowerTransform(-1.0), - validate_args=validate_args) + super(InverseGamma, self).__init__( + base_dist, PowerTransform(-1.0), validate_args=validate_args + ) @property def mean(self): @@ -371,20 +441,23 @@ def tree_flatten(self): class Gumbel(Distribution): - arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} support = constraints.real - reparametrized_params = ['loc', 'scale'] + reparametrized_params = ["loc", "scale"] - def __init__(self, loc=0., scale=1., validate_args=None): + def __init__(self, loc=0.0, scale=1.0, validate_args=None): self.loc, self.scale = promote_shapes(loc, scale) batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) - super(Gumbel, self).__init__(batch_shape=batch_shape, - validate_args=validate_args) + super(Gumbel, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - standard_gumbel_sample = random.gumbel(key, shape=sample_shape + self.batch_shape + self.event_shape) + standard_gumbel_sample = random.gumbel( + key, shape=sample_shape + self.batch_shape + self.event_shape + ) return self.loc + self.scale * standard_gumbel_sample @validate_sample @@ -394,28 +467,32 @@ def log_prob(self, value): @property def mean(self): - return jnp.broadcast_to(self.loc + self.scale * EULER_MASCHERONI, - self.batch_shape) + return jnp.broadcast_to( + self.loc + self.scale * EULER_MASCHERONI, self.batch_shape + ) @property def variance(self): - return jnp.broadcast_to(jnp.pi**2 / 6. * self.scale**2, - self.batch_shape) + return jnp.broadcast_to(jnp.pi ** 2 / 6.0 * self.scale ** 2, self.batch_shape) class Laplace(Distribution): - arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} support = constraints.real - reparametrized_params = ['loc', 'scale'] + reparametrized_params = ["loc", "scale"] - def __init__(self, loc=0., scale=1., validate_args=None): + def __init__(self, loc=0.0, scale=1.0, validate_args=None): self.loc, self.scale = promote_shapes(loc, scale) batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) - super(Laplace, self).__init__(batch_shape=batch_shape, validate_args=validate_args) + super(Laplace, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - eps = random.laplace(key, shape=sample_shape + self.batch_shape + self.event_shape) + eps = random.laplace( + key, shape=sample_shape + self.batch_shape + self.event_shape + ) return self.loc + eps * self.scale @validate_sample @@ -466,20 +543,29 @@ class LKJ(TransformedDistribution): [1] `Generating random correlation matrices based on vines and extended onion method`, Daniel Lewandowski, Dorota Kurowicka, Harry Joe """ - arg_constraints = {'concentration': constraints.positive} + arg_constraints = {"concentration": constraints.positive} reparametrized_params = ["concentration"] support = constraints.corr_matrix - def __init__(self, dimension, concentration=1., sample_method='onion', validate_args=None): + def __init__( + self, dimension, concentration=1.0, sample_method="onion", validate_args=None + ): base_dist = LKJCholesky(dimension, concentration, sample_method) - self.dimension, self.concentration = base_dist.dimension, base_dist.concentration + self.dimension, self.concentration = ( + base_dist.dimension, + base_dist.concentration, + ) self.sample_method = sample_method - super(LKJ, self).__init__(base_dist, CorrMatrixCholeskyTransform().inv, - validate_args=validate_args) + super(LKJ, self).__init__( + base_dist, CorrMatrixCholeskyTransform().inv, validate_args=validate_args + ) @property def mean(self): - return jnp.broadcast_to(jnp.identity(self.dimension), self.batch_shape + (self.dimension, self.dimension)) + return jnp.broadcast_to( + jnp.identity(self.dimension), + self.batch_shape + (self.dimension, self.dimension), + ) def tree_flatten(self): return (self.concentration,), (self.dimension, self.sample_method) @@ -518,11 +604,13 @@ class LKJCholesky(Distribution): [1] `Generating random correlation matrices based on vines and extended onion method`, Daniel Lewandowski, Dorota Kurowicka, Harry Joe """ - arg_constraints = {'concentration': constraints.positive} - reparametrized_params = ['concentration'] + arg_constraints = {"concentration": constraints.positive} + reparametrized_params = ["concentration"] support = constraints.corr_cholesky - def __init__(self, dimension, concentration=1., sample_method='onion', validate_args=None): + def __init__( + self, dimension, concentration=1.0, sample_method="onion", validate_args=None + ): if dimension < 2: raise ValueError("Dimension must be greater than or equal to 2.") self.dimension = dimension @@ -540,25 +628,31 @@ def __init__(self, dimension, concentration=1., sample_method='onion', validate_ Dm1 = self.dimension - 1 marginal_concentration = concentration + 0.5 * (self.dimension - 2) offset = 0.5 * jnp.arange(Dm1) - if sample_method == 'onion': + if sample_method == "onion": # The following construction follows from the algorithm in Section 3.2 of [1]: # NB: in [1], the method for case k > 1 can also work for the case k = 1. - beta_concentration0 = jnp.expand_dims(marginal_concentration, axis=-1) - offset + beta_concentration0 = ( + jnp.expand_dims(marginal_concentration, axis=-1) - offset + ) beta_concentration1 = offset + 0.5 self._beta = Beta(beta_concentration1, beta_concentration0) - elif sample_method == 'cvine': + elif sample_method == "cvine": # The following construction follows from the algorithm in Section 2.4 of [1]: # offset_tril is [0, 1, 1, 2, 2, 2,...] / 2 offset_tril = matrix_to_tril_vec(jnp.broadcast_to(offset, (Dm1, Dm1))) - beta_concentration = jnp.expand_dims(marginal_concentration, axis=-1) - offset_tril + beta_concentration = ( + jnp.expand_dims(marginal_concentration, axis=-1) - offset_tril + ) self._beta = Beta(beta_concentration, beta_concentration) else: raise ValueError("`method` should be one of 'cvine' or 'onion'.") self.sample_method = sample_method - super(LKJCholesky, self).__init__(batch_shape=batch_shape, - event_shape=event_shape, - validate_args=validate_args) + super(LKJCholesky, self).__init__( + batch_shape=batch_shape, + event_shape=event_shape, + validate_args=validate_args, + ) def _cvine(self, key, size): # C-vine method first uses beta_dist to generate partial correlations, @@ -589,19 +683,28 @@ def _onion(self, key, size): # a hypershere (ref: http://mathworld.wolfram.com/HyperspherePointPicking.html) normal_sample = random.normal( key_normal, - shape=size + self.batch_shape + (self.dimension * (self.dimension - 1) // 2,) + shape=size + + self.batch_shape + + (self.dimension * (self.dimension - 1) // 2,), ) normal_sample = vec_to_tril_matrix(normal_sample, diagonal=0) - u_hypershere = normal_sample / jnp.linalg.norm(normal_sample, axis=-1, keepdims=True) + u_hypershere = normal_sample / jnp.linalg.norm( + normal_sample, axis=-1, keepdims=True + ) w = jnp.expand_dims(jnp.sqrt(beta_sample), axis=-1) * u_hypershere # put w into the off-diagonal triangular part - cholesky = ops.index_add(jnp.zeros(size + self.batch_shape + self.event_shape), - ops.index[..., 1:, :-1], w) + cholesky = ops.index_add( + jnp.zeros(size + self.batch_shape + self.event_shape), + ops.index[..., 1:, :-1], + w, + ) # correct the diagonal # NB: we clip due to numerical precision - diag = jnp.sqrt(jnp.clip(1 - jnp.sum(cholesky ** 2, axis=-1), a_min=0.)) - cholesky = cholesky + jnp.expand_dims(diag, axis=-1) * jnp.identity(self.dimension) + diag = jnp.sqrt(jnp.clip(1 - jnp.sum(cholesky ** 2, axis=-1), a_min=0.0)) + cholesky = cholesky + jnp.expand_dims(diag, axis=-1) * jnp.identity( + self.dimension + ) return cholesky def sample(self, key, sample_shape=()): @@ -666,14 +769,16 @@ def tree_unflatten(cls, aux_data, params): class LogNormal(TransformedDistribution): - arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} support = constraints.positive - reparametrized_params = ['loc', 'scale'] + reparametrized_params = ["loc", "scale"] - def __init__(self, loc=0., scale=1., validate_args=None): + def __init__(self, loc=0.0, scale=1.0, validate_args=None): base_dist = Normal(loc, scale) self.loc, self.scale = base_dist.loc, base_dist.scale - super(LogNormal, self).__init__(base_dist, ExpTransform(), validate_args=validate_args) + super(LogNormal, self).__init__( + base_dist, ExpTransform(), validate_args=validate_args + ) @property def mean(self): @@ -688,18 +793,20 @@ def tree_flatten(self): class Logistic(Distribution): - arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} support = constraints.real - reparametrized_params = ['loc', 'scale'] + reparametrized_params = ["loc", "scale"] - def __init__(self, loc=0., scale=1., validate_args=None): + def __init__(self, loc=0.0, scale=1.0, validate_args=None): self.loc, self.scale = promote_shapes(loc, scale) batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) super(Logistic, self).__init__(batch_shape, validate_args=validate_args) def sample(self, key, sample_shape=()): assert is_prng_key(key) - z = random.logistic(key, shape=sample_shape + self.batch_shape + self.event_shape) + z = random.logistic( + key, shape=sample_shape + self.batch_shape + self.event_shape + ) return self.loc + z * self.scale @validate_sample @@ -745,10 +852,12 @@ def _batch_mahalanobis(bL, bx): bx_new_shape += (-1,) bx = jnp.reshape(bx, bx_new_shape) # Permute bx to make it have shape (..., 1, j, i, 1, n) - permute_dims = (tuple(range(sample_ndim)) - + tuple(range(sample_ndim, bx.ndim - 1, 2)) - + tuple(range(sample_ndim + 1, bx.ndim - 1, 2)) - + (bx.ndim - 1,)) + permute_dims = ( + tuple(range(sample_ndim)) + + tuple(range(sample_ndim, bx.ndim - 1, 2)) + + tuple(range(sample_ndim + 1, bx.ndim - 1, 2)) + + (bx.ndim - 1,) + ) bx = jnp.transpose(bx, permute_dims) # reshape to (-1, i, 1, n) @@ -770,17 +879,30 @@ def _batch_mahalanobis(bL, bx): class MultivariateNormal(Distribution): - arg_constraints = {'loc': constraints.real_vector, - 'covariance_matrix': constraints.positive_definite, - 'precision_matrix': constraints.positive_definite, - 'scale_tril': constraints.lower_cholesky} + arg_constraints = { + "loc": constraints.real_vector, + "covariance_matrix": constraints.positive_definite, + "precision_matrix": constraints.positive_definite, + "scale_tril": constraints.lower_cholesky, + } support = constraints.real_vector - reparametrized_params = ['loc', 'covariance_matrix', 'precision_matrix', 'scale_tril'] - - def __init__(self, loc=0., covariance_matrix=None, precision_matrix=None, scale_tril=None, - validate_args=None): + reparametrized_params = [ + "loc", + "covariance_matrix", + "precision_matrix", + "scale_tril", + ] + + def __init__( + self, + loc=0.0, + covariance_matrix=None, + precision_matrix=None, + scale_tril=None, + validate_args=None, + ): if jnp.ndim(loc) == 0: - loc, = promote_shapes(loc, shape=(1,)) + (loc,) = promote_shapes(loc, shape=(1,)) # temporary append a new axis to loc loc = loc[..., jnp.newaxis] if covariance_matrix is not None: @@ -792,26 +914,40 @@ def __init__(self, loc=0., covariance_matrix=None, precision_matrix=None, scale_ elif scale_tril is not None: loc, self.scale_tril = promote_shapes(loc, scale_tril) else: - raise ValueError('One of `covariance_matrix`, `precision_matrix`, `scale_tril`' - ' must be specified.') - batch_shape = lax.broadcast_shapes(jnp.shape(loc)[:-2], jnp.shape(self.scale_tril)[:-2]) + raise ValueError( + "One of `covariance_matrix`, `precision_matrix`, `scale_tril`" + " must be specified." + ) + batch_shape = lax.broadcast_shapes( + jnp.shape(loc)[:-2], jnp.shape(self.scale_tril)[:-2] + ) event_shape = jnp.shape(self.scale_tril)[-1:] self.loc = loc[..., 0] - super(MultivariateNormal, self).__init__(batch_shape=batch_shape, - event_shape=event_shape, - validate_args=validate_args) + super(MultivariateNormal, self).__init__( + batch_shape=batch_shape, + event_shape=event_shape, + validate_args=validate_args, + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - eps = random.normal(key, shape=sample_shape + self.batch_shape + self.event_shape) - return self.loc + jnp.squeeze(jnp.matmul(self.scale_tril, eps[..., jnp.newaxis]), axis=-1) + eps = random.normal( + key, shape=sample_shape + self.batch_shape + self.event_shape + ) + return self.loc + jnp.squeeze( + jnp.matmul(self.scale_tril, eps[..., jnp.newaxis]), axis=-1 + ) @validate_sample def log_prob(self, value): M = _batch_mahalanobis(self.scale_tril, value - self.loc) - half_log_det = jnp.log(jnp.diagonal(self.scale_tril, axis1=-2, axis2=-1)).sum(-1) - normalize_term = half_log_det + 0.5 * self.scale_tril.shape[-1] * jnp.log(2 * jnp.pi) - return - 0.5 * M - normalize_term + half_log_det = jnp.log(jnp.diagonal(self.scale_tril, axis1=-2, axis2=-1)).sum( + -1 + ) + normalize_term = half_log_det + 0.5 * self.scale_tril.shape[-1] * jnp.log( + 2 * jnp.pi + ) + return -0.5 * M - normalize_term @lazy_property def covariance_matrix(self): @@ -819,7 +955,9 @@ def covariance_matrix(self): @lazy_property def precision_matrix(self): - identity = jnp.broadcast_to(jnp.eye(self.scale_tril.shape[-1]), self.scale_tril.shape) + identity = jnp.broadcast_to( + jnp.eye(self.scale_tril.shape[-1]), self.scale_tril.shape + ) return cho_solve((self.scale_tril, True), identity) @property @@ -828,8 +966,9 @@ def mean(self): @property def variance(self): - return jnp.broadcast_to(jnp.sum(self.scale_tril ** 2, axis=-1), - self.batch_shape + self.event_shape) + return jnp.broadcast_to( + jnp.sum(self.scale_tril ** 2, axis=-1), self.batch_shape + self.event_shape + ) def tree_flatten(self): return (self.loc, self.scale_tril), None @@ -840,7 +979,9 @@ def tree_unflatten(cls, aux_data, params): return cls(loc, scale_tril=scale_tril) @staticmethod - def infer_shapes(loc=(), covariance_matrix=None, precision_matrix=None, scale_tril=None): + def infer_shapes( + loc=(), covariance_matrix=None, precision_matrix=None, scale_tril=None + ): batch_shape, event_shape = loc[:-1], loc[-1:] for matrix in [covariance_matrix, precision_matrix, scale_tril]: if matrix is not None: @@ -879,7 +1020,9 @@ def _batch_lowrank_logdet(W, D, capacitance_tril): where :math:`C` is the capacitance matrix :math:`I + W.T @ inv(D) @ W`, to compute the log determinant. """ - return 2 * jnp.sum(jnp.log(jnp.diagonal(capacitance_tril, axis1=-2, axis2=-1)), axis=-1) + jnp.log(D).sum(-1) + return 2 * jnp.sum( + jnp.log(jnp.diagonal(capacitance_tril, axis1=-2, axis2=-1)), axis=-1 + ) + jnp.log(D).sum(-1) def _batch_lowrank_mahalanobis(W, D, x, capacitance_tril): @@ -900,34 +1043,49 @@ class LowRankMultivariateNormal(Distribution): arg_constraints = { "loc": constraints.real_vector, "cov_factor": constraints.independent(constraints.real, 2), - "cov_diag": constraints.independent(constraints.positive, 1) + "cov_diag": constraints.independent(constraints.positive, 1), } support = constraints.real_vector - reparametrized_params = ['loc', 'cov_factor', 'cov_diag'] + reparametrized_params = ["loc", "cov_factor", "cov_diag"] def __init__(self, loc, cov_factor, cov_diag, validate_args=None): if jnp.ndim(loc) < 1: raise ValueError("`loc` must be at least one-dimensional.") event_shape = jnp.shape(loc)[-1:] if jnp.ndim(cov_factor) < 2: - raise ValueError("`cov_factor` must be at least two-dimensional, " - "with optional leading batch dimensions") + raise ValueError( + "`cov_factor` must be at least two-dimensional, " + "with optional leading batch dimensions" + ) if jnp.shape(cov_factor)[-2:-1] != event_shape: - raise ValueError("`cov_factor` must be a batch of matrices with shape {} x m" - .format(event_shape[0])) + raise ValueError( + "`cov_factor` must be a batch of matrices with shape {} x m".format( + event_shape[0] + ) + ) if jnp.shape(cov_diag)[-1:] != event_shape: - raise ValueError("`cov_diag` must be a batch of vectors with shape {}".format(self.event_shape)) + raise ValueError( + "`cov_diag` must be a batch of vectors with shape {}".format( + self.event_shape + ) + ) - loc, cov_factor, cov_diag = promote_shapes(loc[..., jnp.newaxis], cov_factor, cov_diag[..., jnp.newaxis]) - batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(cov_factor), jnp.shape(cov_diag))[:-2] + loc, cov_factor, cov_diag = promote_shapes( + loc[..., jnp.newaxis], cov_factor, cov_diag[..., jnp.newaxis] + ) + batch_shape = lax.broadcast_shapes( + jnp.shape(loc), jnp.shape(cov_factor), jnp.shape(cov_diag) + )[:-2] self.loc = loc[..., 0] self.cov_factor = cov_factor cov_diag = cov_diag[..., 0] self.cov_diag = cov_diag self._capacitance_tril = _batch_capacitance_tril(cov_factor, cov_diag) super(LowRankMultivariateNormal, self).__init__( - batch_shape=batch_shape, event_shape=event_shape, validate_args=validate_args - ) + batch_shape=batch_shape, + event_shape=event_shape, + validate_args=validate_args, + ) @property def mean(self): @@ -958,7 +1116,7 @@ def covariance_matrix(self): new_diag = self.cov_diag[..., jnp.newaxis] * jnp.identity(self.loc.shape[-1]) covariance_matrix = new_diag + jnp.matmul( self.cov_factor, jnp.swapaxes(self.cov_factor, -1, -2) - ) + ) return covariance_matrix @lazy_property @@ -966,12 +1124,15 @@ def precision_matrix(self): # We use "Woodbury matrix identity" to take advantage of low rank form:: # inv(W @ W.T + D) = inv(D) - inv(D) @ W @ inv(C) @ W.T @ inv(D) # where :math:`C` is the capacitance matrix. - Wt_Dinv = (jnp.swapaxes(self.cov_factor, -1, -2) - / jnp.expand_dims(self.cov_diag, axis=-2)) + Wt_Dinv = jnp.swapaxes(self.cov_factor, -1, -2) / jnp.expand_dims( + self.cov_diag, axis=-2 + ) A = solve_triangular(Wt_Dinv, self._capacitance_tril, lower=True) # TODO: find a better solution to create a diagonal matrix inverse_cov_diag = jnp.reciprocal(self.cov_diag) - diag_embed = inverse_cov_diag[..., jnp.newaxis] * jnp.identity(self.loc.shape[-1]) + diag_embed = inverse_cov_diag[..., jnp.newaxis] * jnp.identity( + self.loc.shape[-1] + ) return diag_embed - jnp.matmul(jnp.swapaxes(A, -1, -2), A) def sample(self, key, sample_shape=()): @@ -982,25 +1143,27 @@ def sample(self, key, sample_shape=()): D_shape = batch_shape + self.cov_diag.shape[-1:] eps_W = random.normal(key_W, W_shape) eps_D = random.normal(key_D, D_shape) - return (self.loc + _batch_mv(self.cov_factor, eps_W) - + jnp.sqrt(self.cov_diag) * eps_D) + return ( + self.loc + + _batch_mv(self.cov_factor, eps_W) + + jnp.sqrt(self.cov_diag) * eps_D + ) @validate_sample def log_prob(self, value): diff = value - self.loc - M = _batch_lowrank_mahalanobis(self.cov_factor, - self.cov_diag, - diff, - self._capacitance_tril) - log_det = _batch_lowrank_logdet(self.cov_factor, - self.cov_diag, - self._capacitance_tril) + M = _batch_lowrank_mahalanobis( + self.cov_factor, self.cov_diag, diff, self._capacitance_tril + ) + log_det = _batch_lowrank_logdet( + self.cov_factor, self.cov_diag, self._capacitance_tril + ) return -0.5 * (self.loc.shape[-1] * jnp.log(2 * jnp.pi) + log_det + M) def entropy(self): - log_det = _batch_lowrank_logdet(self.cov_factor, - self.cov_diag, - self._capacitance_tril) + log_det = _batch_lowrank_logdet( + self.cov_factor, self.cov_diag, self._capacitance_tril + ) H = 0.5 * (self.loc.shape[-1] * (1.0 + jnp.log(2 * jnp.pi)) + log_det) return jnp.broadcast_to(H, self.batch_shape) @@ -1012,18 +1175,22 @@ def infer_shapes(loc, cov_factor, cov_diag): class Normal(Distribution): - arg_constraints = {'loc': constraints.real, 'scale': constraints.positive} + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} support = constraints.real - reparametrized_params = ['loc', 'scale'] + reparametrized_params = ["loc", "scale"] - def __init__(self, loc=0., scale=1., validate_args=None): + def __init__(self, loc=0.0, scale=1.0, validate_args=None): self.loc, self.scale = promote_shapes(loc, scale) batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) - super(Normal, self).__init__(batch_shape=batch_shape, validate_args=validate_args) + super(Normal, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - eps = random.normal(key, shape=sample_shape + self.batch_shape + self.event_shape) + eps = random.normal( + key, shape=sample_shape + self.batch_shape + self.event_shape + ) return self.loc + eps * self.scale @validate_sample @@ -1049,13 +1216,15 @@ def variance(self): class Pareto(TransformedDistribution): - arg_constraints = {'scale': constraints.positive, 'alpha': constraints.positive} + arg_constraints = {"scale": constraints.positive, "alpha": constraints.positive} reparametrized_params = ["scale", "alpha"] def __init__(self, scale, alpha, validate_args=None): self.scale, self.alpha = promote_shapes(scale, alpha) batch_shape = lax.broadcast_shapes(jnp.shape(scale), jnp.shape(alpha)) - scale, alpha = jnp.broadcast_to(scale, batch_shape), jnp.broadcast_to(alpha, batch_shape) + scale, alpha = jnp.broadcast_to(scale, batch_shape), jnp.broadcast_to( + alpha, batch_shape + ) base_dist = Exponential(alpha) transforms = [ExpTransform(), AffineTransform(loc=0, scale=scale)] super(Pareto, self).__init__(base_dist, transforms, validate_args=validate_args) @@ -1069,7 +1238,9 @@ def mean(self): @property def variance(self): # var is inf for alpha <= 2 - a = jnp.divide((self.scale ** 2) * self.alpha, (self.alpha - 1) ** 2 * (self.alpha - 2)) + a = jnp.divide( + (self.scale ** 2) * self.alpha, (self.alpha - 1) ** 2 * (self.alpha - 2) + ) return jnp.where(self.alpha <= 2, jnp.inf, a) # override the default behaviour to save computations @@ -1082,13 +1253,21 @@ def tree_flatten(self): class StudentT(Distribution): - arg_constraints = {'df': constraints.positive, 'loc': constraints.real, 'scale': constraints.positive} + arg_constraints = { + "df": constraints.positive, + "loc": constraints.real, + "scale": constraints.positive, + } support = constraints.real - reparametrized_params = ['df', 'loc', 'scale'] + reparametrized_params = ["df", "loc", "scale"] - def __init__(self, df, loc=0., scale=1., validate_args=None): - batch_shape = lax.broadcast_shapes(jnp.shape(df), jnp.shape(loc), jnp.shape(scale)) - self.df, self.loc, self.scale = promote_shapes(df, loc, scale, shape=batch_shape) + def __init__(self, df, loc=0.0, scale=1.0, validate_args=None): + batch_shape = lax.broadcast_shapes( + jnp.shape(df), jnp.shape(loc), jnp.shape(scale) + ) + self.df, self.loc, self.scale = promote_shapes( + df, loc, scale, shape=batch_shape + ) df = jnp.broadcast_to(df, batch_shape) self._chi2 = Chi2(df) super(StudentT, self).__init__(batch_shape, validate_args=validate_args) @@ -1104,18 +1283,27 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): y = (value - self.loc) / self.scale - z = (jnp.log(self.scale) + 0.5 * jnp.log(self.df) + 0.5 * jnp.log(jnp.pi) + - gammaln(0.5 * self.df) - gammaln(0.5 * (self.df + 1.))) - return -0.5 * (self.df + 1.) * jnp.log1p(y ** 2. / self.df) - z + z = ( + jnp.log(self.scale) + + 0.5 * jnp.log(self.df) + + 0.5 * jnp.log(jnp.pi) + + gammaln(0.5 * self.df) + - gammaln(0.5 * (self.df + 1.0)) + ) + return -0.5 * (self.df + 1.0) * jnp.log1p(y ** 2.0 / self.df) - z @property def mean(self): # for df <= 1. should be jnp.nan (keeping jnp.inf for consistency with scipy) - return jnp.broadcast_to(jnp.where(self.df <= 1, jnp.inf, self.loc), self.batch_shape) + return jnp.broadcast_to( + jnp.where(self.df <= 1, jnp.inf, self.loc), self.batch_shape + ) @property def variance(self): - var = jnp.where(self.df > 2, jnp.divide(self.scale ** 2 * self.df, self.df - 2.0), jnp.inf) + var = jnp.where( + self.df > 2, jnp.divide(self.scale ** 2 * self.df, self.df - 2.0), jnp.inf + ) var = jnp.where(self.df <= 1, jnp.nan, var) return jnp.broadcast_to(var, self.batch_shape) @@ -1128,7 +1316,11 @@ def cdf(self, value): # when scaled < 0, returns 0.5 * Beta(df/2, 0.5).cdf(beta_value) # when scaled > 0, returns 1 - 0.5 * Beta(df/2, 0.5).cdf(beta_value) scaled_sign_half = 0.5 * jnp.sign(scaled) - return 0.5 + scaled_sign_half - 0.5 * jnp.sign(scaled) * betainc(0.5 * self.df, 0.5, beta_value) + return ( + 0.5 + + scaled_sign_half + - 0.5 * jnp.sign(scaled) * betainc(0.5 * self.df, 0.5, beta_value) + ) def icdf(self, q): # scipy.special.betaincinv is not avaiable yet in JAX @@ -1141,13 +1333,16 @@ class LeftTruncatedDistribution(Distribution): reparametrized_params = ["low"] supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) - def __init__(self, base_dist, low=0., validate_args=None): + def __init__(self, base_dist, low=0.0, validate_args=None): assert isinstance(base_dist, self.supported_types) - assert base_dist.support is constraints.real, \ - "The base distribution should be univariate and have real support." + assert ( + base_dist.support is constraints.real + ), "The base distribution should be univariate and have real support." batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(low)) - self.base_dist = tree_map(lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist) - self.low, = promote_shapes(low, shape=batch_shape) + self.base_dist = tree_map( + lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist + ) + (self.low,) = promote_shapes(low, shape=batch_shape) self._support = constraints.greater_than(low) super().__init__(batch_shape, validate_args=validate_args) @@ -1159,32 +1354,38 @@ def support(self): def _tail_prob_at_low(self): # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1., -1.) + sign = jnp.where(loc >= self.low, 1.0, -1.0) return self.base_dist.cdf(loc - sign * (loc - self.low)) @lazy_property def _tail_prob_at_high(self): # if low < loc, returns cdf(high) = 1; otherwise returns 1 - cdf(high) = 0 - return jnp.where(self.low <= self.base_dist.loc, 1., 0.) + return jnp.where(self.low <= self.base_dist.loc, 1.0, 0.0) def sample(self, key, sample_shape=()): assert is_prng_key(key) u = random.uniform(key, sample_shape + self.batch_shape) loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1., -1.) + sign = jnp.where(loc >= self.low, 1.0, -1.0) return (1 - sign) * loc + sign * self.base_dist.icdf( - (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high) + (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high + ) @validate_sample def log_prob(self, value): - sign = jnp.where(self.base_dist.loc >= self.low, 1., -1.) - return self.base_dist.log_prob(value) - \ - jnp.log(sign * (self._tail_prob_at_high - self._tail_prob_at_low)) + sign = jnp.where(self.base_dist.loc >= self.low, 1.0, -1.0) + return self.base_dist.log_prob(value) - jnp.log( + sign * (self._tail_prob_at_high - self._tail_prob_at_low) + ) def tree_flatten(self): base_flatten, base_aux = self.base_dist.tree_flatten() if isinstance(self._support.lower_bound, (int, float)): - return base_flatten, (type(self.base_dist), base_aux, self._support.lower_bound) + return base_flatten, ( + type(self.base_dist), + base_aux, + self._support.lower_bound, + ) else: return (base_flatten, self.low), (type(self.base_dist), base_aux) @@ -1205,13 +1406,16 @@ class RightTruncatedDistribution(Distribution): reparametrized_params = ["high"] supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) - def __init__(self, base_dist, high=0., validate_args=None): + def __init__(self, base_dist, high=0.0, validate_args=None): assert isinstance(base_dist, self.supported_types) - assert base_dist.support is constraints.real, \ - "The base distribution should be univariate and have real support." + assert ( + base_dist.support is constraints.real + ), "The base distribution should be univariate and have real support." batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(high)) - self.base_dist = tree_map(lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist) - self.high, = promote_shapes(high, shape=batch_shape) + self.base_dist = tree_map( + lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist + ) + (self.high,) = promote_shapes(high, shape=batch_shape) self._support = constraints.less_than(high) super().__init__(batch_shape, validate_args=validate_args) @@ -1235,7 +1439,11 @@ def log_prob(self, value): def tree_flatten(self): base_flatten, base_aux = self.base_dist.tree_flatten() if isinstance(self._support.upper_bound, (int, float)): - return base_flatten, (type(self.base_dist), base_aux, self._support.upper_bound) + return base_flatten, ( + type(self.base_dist), + base_aux, + self._support.upper_bound, + ) else: return (base_flatten, self.high), (type(self.base_dist), base_aux) @@ -1256,14 +1464,19 @@ class TwoSidedTruncatedDistribution(Distribution): reparametrized_params = ["low", "high"] supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) - def __init__(self, base_dist, low=0., high=1., validate_args=None): + def __init__(self, base_dist, low=0.0, high=1.0, validate_args=None): assert isinstance(base_dist, self.supported_types) - assert base_dist.support is constraints.real, \ - "The base distribution should be univariate and have real support." - batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(low), jnp.shape(high)) - self.base_dist = tree_map(lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist) - self.low, = promote_shapes(low, shape=batch_shape) - self.high, = promote_shapes(high, shape=batch_shape) + assert ( + base_dist.support is constraints.real + ), "The base distribution should be univariate and have real support." + batch_shape = lax.broadcast_shapes( + base_dist.batch_shape, jnp.shape(low), jnp.shape(high) + ) + self.base_dist = tree_map( + lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist + ) + (self.low,) = promote_shapes(low, shape=batch_shape) + (self.high,) = promote_shapes(high, shape=batch_shape) self._support = constraints.interval(low, high) super().__init__(batch_shape, validate_args=validate_args) @@ -1275,14 +1488,14 @@ def support(self): def _tail_prob_at_low(self): # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1., -1.) + sign = jnp.where(loc >= self.low, 1.0, -1.0) return self.base_dist.cdf(loc - sign * (loc - self.low)) @lazy_property def _tail_prob_at_high(self): # if low < loc, returns cdf(high); otherwise returns 1 - cdf(high) loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1., -1.) + sign = jnp.where(loc >= self.low, 1.0, -1.0) return self.base_dist.cdf(loc - sign * (loc - self.high)) def sample(self, key, sample_shape=()): @@ -1297,9 +1510,10 @@ def sample(self, key, sample_shape=()): # Else # A = 2 * loc - icdf[(1 - u) * cdf(2*loc-low)) + u * cdf(2*loc - high)] loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1., -1.) + sign = jnp.where(loc >= self.low, 1.0, -1.0) return (1 - sign) * loc + sign * self.base_dist.icdf( - (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high) + (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high + ) @validate_sample def log_prob(self, value): @@ -1308,16 +1522,22 @@ def log_prob(self, value): # cdf(high) - cdf(low) = as-is # if low > loc # cdf(high) - cdf(low) = cdf(2 * loc - low) - cdf(2 * loc - high) - sign = jnp.where(self.base_dist.loc >= self.low, 1., -1.) - return self.base_dist.log_prob(value) - \ - jnp.log(sign * (self._tail_prob_at_high - self._tail_prob_at_low)) + sign = jnp.where(self.base_dist.loc >= self.low, 1.0, -1.0) + return self.base_dist.log_prob(value) - jnp.log( + sign * (self._tail_prob_at_high - self._tail_prob_at_low) + ) def tree_flatten(self): base_flatten, base_aux = self.base_dist.tree_flatten() - if isinstance(self._support.lower_bound, (int, float)) and \ - isinstance(self._support.upper_bound, (int, float)): - return base_flatten, (type(self.base_dist), base_aux, - self._support.lower_bound, self._support.upper_bound) + if isinstance(self._support.lower_bound, (int, float)) and isinstance( + self._support.upper_bound, (int, float) + ): + return base_flatten, ( + type(self.base_dist), + base_aux, + self._support.lower_bound, + self._support.upper_bound, + ) else: return (base_flatten, self.low, self.high), (type(self.base_dist), base_aux) @@ -1349,21 +1569,32 @@ def TruncatedDistribution(base_dist, low=None, high=None, validate_args=None): if low is None: return base_dist else: - return LeftTruncatedDistribution(base_dist, low=low, validate_args=validate_args) + return LeftTruncatedDistribution( + base_dist, low=low, validate_args=validate_args + ) elif low is None: - return RightTruncatedDistribution(base_dist, high=high, validate_args=validate_args) + return RightTruncatedDistribution( + base_dist, high=high, validate_args=validate_args + ) else: - return TwoSidedTruncatedDistribution(base_dist, low=low, high=high, validate_args=validate_args) + return TwoSidedTruncatedDistribution( + base_dist, low=low, high=high, validate_args=validate_args + ) class TruncatedCauchy(LeftTruncatedDistribution): - arg_constraints = {'low': constraints.real, 'loc': constraints.real, - 'scale': constraints.positive} + arg_constraints = { + "low": constraints.real, + "loc": constraints.real, + "scale": constraints.positive, + } reparametrized_params = ["low", "loc", "scale"] - def __init__(self, low=0., loc=0., scale=1., validate_args=None): + def __init__(self, low=0.0, loc=0.0, scale=1.0, validate_args=None): self.low, self.loc, self.scale = promote_shapes(low, loc, scale) - super().__init__(Cauchy(self.loc, self.scale), low=self.low, validate_args=validate_args) + super().__init__( + Cauchy(self.loc, self.scale), low=self.low, validate_args=validate_args + ) @property def mean(self): @@ -1389,13 +1620,18 @@ def tree_unflatten(cls, aux_data, params): class TruncatedNormal(LeftTruncatedDistribution): - arg_constraints = {'low': constraints.real, 'loc': constraints.real, - 'scale': constraints.positive} + arg_constraints = { + "low": constraints.real, + "loc": constraints.real, + "scale": constraints.positive, + } reparametrized_params = ["low", "loc", "scale"] - def __init__(self, low=0., loc=0., scale=1., validate_args=None): + def __init__(self, low=0.0, loc=0.0, scale=1.0, validate_args=None): self.low, self.loc, self.scale = promote_shapes(low, loc, scale) - super().__init__(Normal(self.loc, self.scale), low=self.low, validate_args=validate_args) + super().__init__( + Normal(self.loc, self.scale), low=self.low, validate_args=validate_args + ) @property def mean(self): @@ -1405,7 +1641,9 @@ def mean(self): @property def variance(self): low_prob = jnp.exp(self.log_prob(self.low)) - return (self.scale ** 2) * (1 + (self.low - self.loc) * low_prob - (low_prob * self.scale) ** 2) + return (self.scale ** 2) * ( + 1 + (self.low - self.loc) * low_prob - (low_prob * self.scale) ** 2 + ) def tree_flatten(self): if isinstance(self._support.lower_bound, (int, float)): @@ -1423,10 +1661,10 @@ def tree_unflatten(cls, aux_data, params): class Uniform(Distribution): - arg_constraints = {'low': constraints.dependent, 'high': constraints.dependent} - reparametrized_params = ['low', 'high'] + arg_constraints = {"low": constraints.dependent, "high": constraints.dependent} + reparametrized_params = ["low", "high"] - def __init__(self, low=0., high=1., validate_args=None): + def __init__(self, low=0.0, high=1.0, validate_args=None): self.low, self.high = promote_shapes(low, high) batch_shape = lax.broadcast_shapes(jnp.shape(low), jnp.shape(high)) self._support = constraints.interval(low, high) @@ -1443,19 +1681,20 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): shape = lax.broadcast_shapes(jnp.shape(value), self.batch_shape) - return - jnp.broadcast_to(jnp.log(self.high - self.low), shape) + return -jnp.broadcast_to(jnp.log(self.high - self.low), shape) @property def mean(self): - return self.low + (self.high - self.low) / 2. + return self.low + (self.high - self.low) / 2.0 @property def variance(self): - return (self.high - self.low) ** 2 / 12. + return (self.high - self.low) ** 2 / 12.0 def tree_flatten(self): - if isinstance(self._support.lower_bound, (int, float)) and \ - isinstance(self._support.upper_bound, (int, float)): + if isinstance(self._support.lower_bound, (int, float)) and isinstance( + self._support.upper_bound, (int, float) + ): aux_data = (self._support.lower_bound, self._support.upper_bound) else: aux_data = None @@ -1485,12 +1724,16 @@ class TruncatedPolyaGamma(Distribution): support = constraints.interval(0.0, truncation_point) def __init__(self, batch_shape=(), validate_args=None): - super(TruncatedPolyaGamma, self).__init__(batch_shape, validate_args=validate_args) + super(TruncatedPolyaGamma, self).__init__( + batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) denom = jnp.square(jnp.arange(0.5, self.num_gamma_variates)) - x = random.gamma(key, jnp.ones(self.batch_shape + sample_shape + (self.num_gamma_variates,))) + x = random.gamma( + key, jnp.ones(self.batch_shape + sample_shape + (self.num_gamma_variates,)) + ) x = jnp.sum(x / denom, axis=-1) return jnp.clip(x * (0.5 / jnp.pi ** 2), a_max=self.truncation_point) @@ -1499,7 +1742,11 @@ def log_prob(self, value): value = value[..., None] all_indices = jnp.arange(0, self.num_log_prob_terms) two_n_plus_one = 2.0 * all_indices + 1.0 - log_terms = jnp.log(two_n_plus_one) - 1.5 * jnp.log(value) - 0.125 * jnp.square(two_n_plus_one) / value + log_terms = ( + jnp.log(two_n_plus_one) + - 1.5 * jnp.log(value) + - 0.125 * jnp.square(two_n_plus_one) / value + ) even_terms = jnp.take(log_terms, all_indices[::2], axis=-1) odd_terms = jnp.take(log_terms, all_indices[1::2], axis=-1) sum_even = jnp.exp(logsumexp(even_terms, axis=-1)) diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index aeccc9c95..eca7f8de2 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -10,16 +10,22 @@ from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution -from numpyro.distributions.util import is_prng_key, promote_shapes, safe_normalize, validate_sample, von_mises_centered +from numpyro.distributions.util import ( + is_prng_key, + promote_shapes, + safe_normalize, + validate_sample, + von_mises_centered, +) class VonMises(Distribution): - arg_constraints = {'loc': constraints.real, 'concentration': constraints.positive} - reparametrized_params = ['loc'] + arg_constraints = {"loc": constraints.real, "concentration": constraints.positive} + reparametrized_params = ["loc"] support = constraints.interval(-math.pi, math.pi) def __init__(self, loc, concentration, validate_args=None): - """ von Mises distribution for sampling directions. + """von Mises distribution for sampling directions. :param loc: center of distribution :param concentration: concentration of distribution @@ -28,38 +34,45 @@ def __init__(self, loc, concentration, validate_args=None): batch_shape = lax.broadcast_shapes(jnp.shape(concentration), jnp.shape(loc)) - super(VonMises, self).__init__(batch_shape=batch_shape, - validate_args=validate_args) + super(VonMises, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): - """ Generate sample from von Mises distribution + """Generate sample from von Mises distribution :param key: random number generator key :param sample_shape: shape of samples :return: samples from von Mises """ assert is_prng_key(key) - samples = von_mises_centered(key, self.concentration, sample_shape + self.shape()) + samples = von_mises_centered( + key, self.concentration, sample_shape + self.shape() + ) samples = samples + self.loc # VM(0, concentration) -> VM(loc,concentration) - samples = (samples + jnp.pi) % (2. * jnp.pi) - jnp.pi + samples = (samples + jnp.pi) % (2.0 * jnp.pi) - jnp.pi return samples @validate_sample def log_prob(self, value): - return -(jnp.log(2 * jnp.pi) + jnp.log(i0e(self.concentration))) + \ - self.concentration * (jnp.cos((value - self.loc) % (2 * jnp.pi)) - 1) + return -( + jnp.log(2 * jnp.pi) + jnp.log(i0e(self.concentration)) + ) + self.concentration * (jnp.cos((value - self.loc) % (2 * jnp.pi)) - 1) @property def mean(self): """ Computes circular mean of distribution. NOTE: same as location when mapped to support [-pi, pi] """ - return jnp.broadcast_to((self.loc + jnp.pi) % (2. * jnp.pi) - jnp.pi, self.batch_shape) + return jnp.broadcast_to( + (self.loc + jnp.pi) % (2.0 * jnp.pi) - jnp.pi, self.batch_shape + ) @property def variance(self): """ Computes circular variance of distribution """ - return jnp.broadcast_to(1. - i1e(self.concentration) / i0e(self.concentration), - self.batch_shape) + return jnp.broadcast_to( + 1.0 - i1e(self.concentration) / i0e(self.concentration), self.batch_shape + ) class ProjectedNormal(Distribution): @@ -87,6 +100,7 @@ def model(): Modeling and Bayesian Inference" https://projecteuclid.org/euclid.ba/1453211962 """ + arg_constraints = {"concentration": constraints.real_vector} reparametrized_params = ["concentration"] support = constraints.sphere @@ -119,8 +133,10 @@ def log_prob(self, value): if self._validate_args: event_shape = value.shape[-1:] if event_shape != self.event_shape: - raise ValueError(f"Expected event shape {self.event_shape}, " - f"but got {event_shape}") + raise ValueError( + f"Expected event shape {self.event_shape}, " + f"but got {event_shape}" + ) self._validate_sample(value) dim = int(self.concentration.shape[-1]) if dim == 2: @@ -154,8 +170,10 @@ def _dot(x, y): # This is the log of a definite integral, computed by mathematica: # Integrate[x/(E^((x-t)^2/2) Sqrt[2 Pi]), {x, 0, Infinity}] # = (t + Sqrt[2/Pi]/E^(t^2/2) + t Erf[t/Sqrt[2]])/2 - para_part = jnp.log((jnp.exp((-0.5) * t2) * ((2 / math.pi) ** 0.5) - + t * (1 + erf(t * 0.5 ** 0.5))) / 2) + para_part = jnp.log( + (jnp.exp((-0.5) * t2) * ((2 / math.pi) ** 0.5) + t * (1 + erf(t * 0.5 ** 0.5))) + / 2 + ) return para_part + perp_part @@ -175,7 +193,9 @@ def _dot(x, y): # This is the log of a definite integral, computed by mathematica: # Integrate[x^2/(E^((x-t)^2/2) Sqrt[2 Pi]), {x, 0, Infinity}] # = t/(E^(t^2/2) Sqrt[2 Pi]) + ((1 + t^2) (1 + Erf[t/Sqrt[2]]))/2 - para_part = jnp.log(t * jnp.exp((-0.5) * t2) / (2 * math.pi) ** 0.5 - + (1 + t2) * (1 + erf(t * 0.5 ** 0.5)) / 2) + para_part = jnp.log( + t * jnp.exp((-0.5) * t2) / (2 * math.pi) ** 0.5 + + (1 + t2) * (1 + erf(t * 0.5 ** 0.5)) / 2 + ) return para_part + perp_part diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 0724fba3f..a41702a29 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -46,7 +46,7 @@ lazy_property, multinomial, promote_shapes, - validate_sample + validate_sample, ) from numpyro.util import not_jax_tracer @@ -70,18 +70,22 @@ def _to_logits_multinom(probs): class BernoulliProbs(Distribution): - arg_constraints = {'probs': constraints.unit_interval} + arg_constraints = {"probs": constraints.unit_interval} support = constraints.boolean has_enumerate_support = True is_discrete = True def __init__(self, probs, validate_args=None): self.probs = probs - super(BernoulliProbs, self).__init__(batch_shape=jnp.shape(self.probs), validate_args=validate_args) + super(BernoulliProbs, self).__init__( + batch_shape=jnp.shape(self.probs), validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - samples = random.bernoulli(key, self.probs, shape=sample_shape + self.batch_shape) + samples = random.bernoulli( + key, self.probs, shape=sample_shape + self.batch_shape + ) return samples.astype(jnp.result_type(samples, int)) @validate_sample @@ -108,18 +112,22 @@ def enumerate_support(self, expand=True): class BernoulliLogits(Distribution): - arg_constraints = {'logits': constraints.real} + arg_constraints = {"logits": constraints.real} support = constraints.boolean has_enumerate_support = True is_discrete = True def __init__(self, logits=None, validate_args=None): self.logits = logits - super(BernoulliLogits, self).__init__(batch_shape=jnp.shape(self.logits), validate_args=validate_args) + super(BernoulliLogits, self).__init__( + batch_shape=jnp.shape(self.logits), validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - samples = random.bernoulli(key, self.probs, shape=sample_shape + self.batch_shape) + samples = random.bernoulli( + key, self.probs, shape=sample_shape + self.batch_shape + ) return samples.astype(jnp.result_type(samples, int)) @validate_sample @@ -151,31 +159,42 @@ def Bernoulli(probs=None, logits=None, validate_args=None): elif logits is not None: return BernoulliLogits(logits, validate_args=validate_args) else: - raise ValueError('One of `probs` or `logits` must be specified.') + raise ValueError("One of `probs` or `logits` must be specified.") class BinomialProbs(Distribution): - arg_constraints = {'probs': constraints.unit_interval, - 'total_count': constraints.nonnegative_integer} + arg_constraints = { + "probs": constraints.unit_interval, + "total_count": constraints.nonnegative_integer, + } has_enumerate_support = True is_discrete = True def __init__(self, probs, total_count=1, validate_args=None): self.probs, self.total_count = promote_shapes(probs, total_count) batch_shape = lax.broadcast_shapes(jnp.shape(probs), jnp.shape(total_count)) - super(BinomialProbs, self).__init__(batch_shape=batch_shape, validate_args=validate_args) + super(BinomialProbs, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - return binomial(key, self.probs, n=self.total_count, shape=sample_shape + self.batch_shape) + return binomial( + key, self.probs, n=self.total_count, shape=sample_shape + self.batch_shape + ) @validate_sample def log_prob(self, value): log_factorial_n = gammaln(self.total_count + 1) log_factorial_k = gammaln(value + 1) log_factorial_nmk = gammaln(self.total_count - value + 1) - return (log_factorial_n - log_factorial_k - log_factorial_nmk + - xlogy(value, self.probs) + xlog1py(self.total_count - value, -self.probs)) + return ( + log_factorial_n + - log_factorial_k + - log_factorial_nmk + + xlogy(value, self.probs) + + xlog1py(self.total_count - value, -self.probs) + ) @lazy_property def logits(self): @@ -187,7 +206,9 @@ def mean(self): @property def variance(self): - return jnp.broadcast_to(self.total_count * self.probs * (1 - self.probs), self.batch_shape) + return jnp.broadcast_to( + self.total_count * self.probs * (1 - self.probs), self.batch_shape + ) @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): @@ -198,19 +219,24 @@ def enumerate_support(self, expand=True): total_count = np.amax(self.total_count) # NB: the error can't be raised if inhomogeneous issue happens when tracing if np.amin(self.total_count) != total_count: - raise NotImplementedError("Inhomogeneous total count not supported" - " by `enumerate_support`.") + raise NotImplementedError( + "Inhomogeneous total count not supported" " by `enumerate_support`." + ) else: total_count = jnp.amax(self.total_count) - values = jnp.arange(total_count + 1).reshape((-1,) + (1,) * len(self.batch_shape)) + values = jnp.arange(total_count + 1).reshape( + (-1,) + (1,) * len(self.batch_shape) + ) if expand: values = jnp.broadcast_to(values, values.shape[:1] + self.batch_shape) return values class BinomialLogits(Distribution): - arg_constraints = {'logits': constraints.real, - 'total_count': constraints.nonnegative_integer} + arg_constraints = { + "logits": constraints.real, + "total_count": constraints.nonnegative_integer, + } has_enumerate_support = True is_discrete = True enumerate_support = BinomialProbs.enumerate_support @@ -218,21 +244,29 @@ class BinomialLogits(Distribution): def __init__(self, logits, total_count=1, validate_args=None): self.logits, self.total_count = promote_shapes(logits, total_count) batch_shape = lax.broadcast_shapes(jnp.shape(logits), jnp.shape(total_count)) - super(BinomialLogits, self).__init__(batch_shape=batch_shape, validate_args=validate_args) + super(BinomialLogits, self).__init__( + batch_shape=batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - return binomial(key, self.probs, n=self.total_count, shape=sample_shape + self.batch_shape) + return binomial( + key, self.probs, n=self.total_count, shape=sample_shape + self.batch_shape + ) @validate_sample def log_prob(self, value): log_factorial_n = gammaln(self.total_count + 1) log_factorial_k = gammaln(value + 1) log_factorial_nmk = gammaln(self.total_count - value + 1) - normalize_term = (self.total_count * jnp.clip(self.logits, 0) + - xlog1py(self.total_count, jnp.exp(-jnp.abs(self.logits))) - - log_factorial_n) - return value * self.logits - log_factorial_k - log_factorial_nmk - normalize_term + normalize_term = ( + self.total_count * jnp.clip(self.logits, 0) + + xlog1py(self.total_count, jnp.exp(-jnp.abs(self.logits))) + - log_factorial_n + ) + return ( + value * self.logits - log_factorial_k - log_factorial_nmk - normalize_term + ) @lazy_property def probs(self): @@ -244,7 +278,9 @@ def mean(self): @property def variance(self): - return jnp.broadcast_to(self.total_count * self.probs * (1 - self.probs), self.batch_shape) + return jnp.broadcast_to( + self.total_count * self.probs * (1 - self.probs), self.batch_shape + ) @constraints.dependent_property(is_discrete=True, event_dim=0) def support(self): @@ -257,11 +293,11 @@ def Binomial(total_count=1, probs=None, logits=None, validate_args=None): elif logits is not None: return BinomialLogits(logits, total_count, validate_args=validate_args) else: - raise ValueError('One of `probs` or `logits` must be specified.') + raise ValueError("One of `probs` or `logits` must be specified.") class CategoricalProbs(Distribution): - arg_constraints = {'probs': constraints.simplex} + arg_constraints = {"probs": constraints.simplex} has_enumerate_support = True is_discrete = True @@ -269,8 +305,9 @@ def __init__(self, probs, validate_args=None): if jnp.ndim(probs) < 1: raise ValueError("`probs` parameter must be at least one-dimensional.") self.probs = probs - super(CategoricalProbs, self).__init__(batch_shape=jnp.shape(self.probs)[:-1], - validate_args=validate_args) + super(CategoricalProbs, self).__init__( + batch_shape=jnp.shape(self.probs)[:-1], validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -302,14 +339,16 @@ def support(self): return constraints.integer_interval(0, jnp.shape(self.probs)[-1] - 1) def enumerate_support(self, expand=True): - values = jnp.arange(self.probs.shape[-1]).reshape((-1,) + (1,) * len(self.batch_shape)) + values = jnp.arange(self.probs.shape[-1]).reshape( + (-1,) + (1,) * len(self.batch_shape) + ) if expand: values = jnp.broadcast_to(values, values.shape[:1] + self.batch_shape) return values class CategoricalLogits(Distribution): - arg_constraints = {'logits': constraints.real_vector} + arg_constraints = {"logits": constraints.real_vector} has_enumerate_support = True is_discrete = True @@ -317,12 +356,15 @@ def __init__(self, logits, validate_args=None): if jnp.ndim(logits) < 1: raise ValueError("`logits` parameter must be at least one-dimensional.") self.logits = logits - super(CategoricalLogits, self).__init__(batch_shape=jnp.shape(logits)[:-1], - validate_args=validate_args) + super(CategoricalLogits, self).__init__( + batch_shape=jnp.shape(logits)[:-1], validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - return random.categorical(key, self.logits, shape=sample_shape + self.batch_shape) + return random.categorical( + key, self.logits, shape=sample_shape + self.batch_shape + ) @validate_sample def log_prob(self, value): @@ -350,7 +392,9 @@ def support(self): return constraints.integer_interval(0, jnp.shape(self.logits)[-1] - 1) def enumerate_support(self, expand=True): - values = jnp.arange(self.logits.shape[-1]).reshape((-1,) + (1,) * len(self.batch_shape)) + values = jnp.arange(self.logits.shape[-1]).reshape( + (-1,) + (1,) * len(self.batch_shape) + ) if expand: values = jnp.broadcast_to(values, values.shape[:1] + self.batch_shape) return values @@ -362,7 +406,7 @@ def Categorical(probs=None, logits=None, validate_args=None): elif logits is not None: return CategoricalLogits(logits, validate_args=validate_args) else: - raise ValueError('One of `probs` or `logits` must be specified.') + raise ValueError("One of `probs` or `logits` must be specified.") class OrderedLogistic(CategoricalProbs): @@ -378,12 +422,15 @@ class OrderedLogistic(CategoricalProbs): of a linear model. :param numpy.ndarray cutpoints: positions in real domain to separate categories. """ - arg_constraints = {'predictor': constraints.real, - 'cutpoints': constraints.ordered_vector} + + arg_constraints = { + "predictor": constraints.real, + "cutpoints": constraints.ordered_vector, + } def __init__(self, predictor, cutpoints, validate_args=None): if jnp.ndim(predictor) == 0: - predictor, = promote_shapes(predictor, shape=(1,)) + (predictor,) = promote_shapes(predictor, shape=(1,)) else: predictor = predictor[..., None] predictor, self.cutpoints = promote_shapes(predictor, cutpoints) @@ -408,44 +455,58 @@ class PRNGIdentity(Distribution): draw a batch of :func:`~jax.random.PRNGKey` using the :class:`~numpyro.handlers.seed` handler. Only `sample` method is supported. """ + is_discrete = True def __init__(self): - warnings.warn("PRNGIdentity distribution is deprecated. To get a random " - "PRNG key, you can use `numpyro.prng_key()` instead.", - FutureWarning) + warnings.warn( + "PRNGIdentity distribution is deprecated. To get a random " + "PRNG key, you can use `numpyro.prng_key()` instead.", + FutureWarning, + ) super(PRNGIdentity, self).__init__(event_shape=(2,)) def sample(self, key, sample_shape=()): - return jnp.reshape(random.split(key, np.prod(sample_shape).astype(np.int32)), - sample_shape + self.event_shape) + return jnp.reshape( + random.split(key, np.prod(sample_shape).astype(np.int32)), + sample_shape + self.event_shape, + ) class MultinomialProbs(Distribution): - arg_constraints = {'probs': constraints.simplex, - 'total_count': constraints.nonnegative_integer} + arg_constraints = { + "probs": constraints.simplex, + "total_count": constraints.nonnegative_integer, + } is_discrete = True def __init__(self, probs, total_count=1, validate_args=None): if jnp.ndim(probs) < 1: raise ValueError("`probs` parameter must be at least one-dimensional.") - batch_shape, event_shape = self.infer_shapes(jnp.shape(probs), jnp.shape(total_count)) + batch_shape, event_shape = self.infer_shapes( + jnp.shape(probs), jnp.shape(total_count) + ) self.probs = promote_shapes(probs, shape=batch_shape + jnp.shape(probs)[-1:])[0] self.total_count = promote_shapes(total_count, shape=batch_shape)[0] - super(MultinomialProbs, self).__init__(batch_shape=batch_shape, - event_shape=event_shape, - validate_args=validate_args) + super(MultinomialProbs, self).__init__( + batch_shape=batch_shape, + event_shape=event_shape, + validate_args=validate_args, + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - return multinomial(key, self.probs, self.total_count, shape=sample_shape + self.batch_shape) + return multinomial( + key, self.probs, self.total_count, shape=sample_shape + self.batch_shape + ) @validate_sample def log_prob(self, value): if self._validate_args: self._validate_sample(value) - return gammaln(self.total_count + 1) \ - + jnp.sum(xlogy(value, self.probs) - gammaln(value + 1), axis=-1) + return gammaln(self.total_count + 1) + jnp.sum( + xlogy(value, self.probs) - gammaln(value + 1), axis=-1 + ) @lazy_property def logits(self): @@ -471,31 +532,44 @@ def infer_shapes(probs, total_count): class MultinomialLogits(Distribution): - arg_constraints = {'logits': constraints.real_vector, - 'total_count': constraints.nonnegative_integer} + arg_constraints = { + "logits": constraints.real_vector, + "total_count": constraints.nonnegative_integer, + } is_discrete = True def __init__(self, logits, total_count=1, validate_args=None): if jnp.ndim(logits) < 1: raise ValueError("`logits` parameter must be at least one-dimensional.") - batch_shape, event_shape = self.infer_shapes(jnp.shape(logits), jnp.shape(total_count)) - self.logits = promote_shapes(logits, shape=batch_shape + jnp.shape(logits)[-1:])[0] + batch_shape, event_shape = self.infer_shapes( + jnp.shape(logits), jnp.shape(total_count) + ) + self.logits = promote_shapes( + logits, shape=batch_shape + jnp.shape(logits)[-1:] + )[0] self.total_count = promote_shapes(total_count, shape=batch_shape)[0] - super(MultinomialLogits, self).__init__(batch_shape=batch_shape, - event_shape=event_shape, - validate_args=validate_args) + super(MultinomialLogits, self).__init__( + batch_shape=batch_shape, + event_shape=event_shape, + validate_args=validate_args, + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - return multinomial(key, self.probs, self.total_count, shape=sample_shape + self.batch_shape) + return multinomial( + key, self.probs, self.total_count, shape=sample_shape + self.batch_shape + ) @validate_sample def log_prob(self, value): if self._validate_args: self._validate_sample(value) - normalize_term = self.total_count * logsumexp(self.logits, axis=-1) \ - - gammaln(self.total_count + 1) - return jnp.sum(value * self.logits - gammaln(value + 1), axis=-1) - normalize_term + normalize_term = self.total_count * logsumexp(self.logits, axis=-1) - gammaln( + self.total_count + 1 + ) + return ( + jnp.sum(value * self.logits - gammaln(value + 1), axis=-1) - normalize_term + ) @lazy_property def probs(self): @@ -526,11 +600,11 @@ def Multinomial(total_count=1, probs=None, logits=None, validate_args=None): elif logits is not None: return MultinomialLogits(logits, total_count, validate_args=validate_args) else: - raise ValueError('One of `probs` or `logits` must be specified.') + raise ValueError("One of `probs` or `logits` must be specified.") class Poisson(Distribution): - arg_constraints = {'rate': constraints.positive} + arg_constraints = {"rate": constraints.positive} support = constraints.nonnegative_integer is_discrete = True @@ -564,14 +638,17 @@ class ZeroInflatedPoisson(Distribution): :param numpy.ndarray gate: probability of extra zeros. :param numpy.ndarray rate: rate of Poisson distribution. """ - arg_constraints = {'gate': constraints.unit_interval, 'rate': constraints.positive} + + arg_constraints = {"gate": constraints.unit_interval, "rate": constraints.positive} support = constraints.nonnegative_integer is_discrete = True - def __init__(self, gate, rate=1., validate_args=None): + def __init__(self, gate, rate=1.0, validate_args=None): batch_shape = lax.broadcast_shapes(jnp.shape(gate), jnp.shape(rate)) self.gate, self.rate = promote_shapes(gate, rate) - super(ZeroInflatedPoisson, self).__init__(batch_shape, validate_args=validate_args) + super(ZeroInflatedPoisson, self).__init__( + batch_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -583,8 +660,14 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): - log_prob = jnp.log(self.rate) * value - gammaln(value + 1) + (jnp.log1p(-self.gate) - self.rate) - return jnp.where(value == 0, jnp.logaddexp(jnp.log(self.gate), log_prob), log_prob) + log_prob = ( + jnp.log(self.rate) * value + - gammaln(value + 1) + + (jnp.log1p(-self.gate) - self.rate) + ) + return jnp.where( + value == 0, jnp.logaddexp(jnp.log(self.gate), log_prob), log_prob + ) @lazy_property def mean(self): @@ -596,14 +679,15 @@ def variance(self): class GeometricProbs(Distribution): - arg_constraints = {'probs': constraints.unit_interval} + arg_constraints = {"probs": constraints.unit_interval} support = constraints.nonnegative_integer is_discrete = True def __init__(self, probs, validate_args=None): self.probs = probs - super(GeometricProbs, self).__init__(batch_shape=jnp.shape(self.probs), - validate_args=validate_args) + super(GeometricProbs, self).__init__( + batch_shape=jnp.shape(self.probs), validate_args=validate_args + ) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -624,22 +708,23 @@ def logits(self): @property def mean(self): - return 1. / self.probs - 1. + return 1.0 / self.probs - 1.0 @property def variance(self): - return (1. / self.probs - 1.) / self.probs + return (1.0 / self.probs - 1.0) / self.probs class GeometricLogits(Distribution): - arg_constraints = {'logits': constraints.real} + arg_constraints = {"logits": constraints.real} support = constraints.nonnegative_integer is_discrete = True def __init__(self, logits, validate_args=None): self.logits = logits - super(GeometricLogits, self).__init__(batch_shape=jnp.shape(self.logits), - validate_args=validate_args) + super(GeometricLogits, self).__init__( + batch_shape=jnp.shape(self.logits), validate_args=validate_args + ) @lazy_property def probs(self): @@ -659,11 +744,11 @@ def log_prob(self, value): @property def mean(self): - return 1. / self.probs - 1. + return 1.0 / self.probs - 1.0 @property def variance(self): - return (1. / self.probs - 1.) / self.probs + return (1.0 / self.probs - 1.0) / self.probs def Geometric(probs=None, logits=None, validate_args=None): @@ -672,4 +757,4 @@ def Geometric(probs=None, logits=None, validate_args=None): elif logits is not None: return GeometricLogits(logits, validate_args=validate_args) else: - raise ValueError('One of `probs` or `logits` must be specified.') + raise ValueError("One of `probs` or `logits` must be specified.") diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index eaf24b12f..31ea62ed6 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -37,7 +37,12 @@ import jax.numpy as jnp from numpyro.distributions.transforms import ComposeTransform, Transform -from numpyro.distributions.util import lazy_property, promote_shapes, sum_rightmost, validate_sample +from numpyro.distributions.util import ( + lazy_property, + promote_shapes, + sum_rightmost, + validate_sample, +) from numpyro.util import not_jax_tracer from . import constraints @@ -120,6 +125,7 @@ class Distribution(metaclass=DistributionMeta): >>> d.event_shape (4,) """ + arg_constraints = {} support = None has_enumerate_support = False @@ -131,12 +137,15 @@ class Distribution(metaclass=DistributionMeta): # ref: https://github.com/google/jax/issues/2916 def __init_subclass__(cls, **kwargs): super().__init_subclass__(**kwargs) - tree_util.register_pytree_node(cls, - cls.tree_flatten, - cls.tree_unflatten) + tree_util.register_pytree_node(cls, cls.tree_flatten, cls.tree_unflatten) def tree_flatten(self): - return tuple(getattr(self, param) for param in sorted(self.arg_constraints.keys())), None + return ( + tuple( + getattr(self, param) for param in sorted(self.arg_constraints.keys()) + ), + None, + ) @classmethod def tree_unflatten(cls, aux_data, params): @@ -155,15 +164,20 @@ def __init__(self, batch_shape=(), event_shape=(), validate_args=None): self._validate_args = validate_args if self._validate_args: for param, constraint in self.arg_constraints.items(): - if param not in self.__dict__ and isinstance(getattr(type(self), param), lazy_property): + if param not in self.__dict__ and isinstance( + getattr(type(self), param), lazy_property + ): continue if constraints.is_dependent(constraint): continue # skip constraints that cannot be checked is_valid = constraint(getattr(self, param)) if not_jax_tracer(is_valid): if not np.all(is_valid): - raise ValueError("{} distribution got invalid {} parameter.".format( - self.__class__.__name__, param)) + raise ValueError( + "{} distribution got invalid {} parameter.".format( + self.__class__.__name__, param + ) + ) super(Distribution, self).__init__() @property @@ -275,13 +289,15 @@ def _validate_sample(self, value): mask = self.support(value) if not_jax_tracer(mask): if not np.all(mask): - warnings.warn('Out-of-support values provided to log prob method. ' - 'The value argument should be within the support.') + warnings.warn( + "Out-of-support values provided to log prob method. " + "The value argument should be within the support." + ) return mask def __call__(self, *args, **kwargs): - key = kwargs.pop('rng_key') - sample_intermediates = kwargs.pop('sample_intermediates', False) + key = kwargs.pop("rng_key") + sample_intermediates = kwargs.pop("sample_intermediates", False) if sample_intermediates: return self.sample_with_intermediates(key, *args, **kwargs) return self.sample(key, *args, **kwargs) @@ -422,7 +438,7 @@ def infer_shapes(cls, *args, **kwargs): batch_shapes = [] for name, shape in kwargs.items(): event_dim = cls.arg_constraints.get(name, constraints.real).event_dim - batch_shapes.append(shape[:len(shape) - event_dim]) + batch_shapes.append(shape[: len(shape) - event_dim]) batch_shape = lax.broadcast_shapes(*batch_shapes) if batch_shapes else () event_shape = () return batch_shape, event_shape @@ -451,7 +467,9 @@ class ExpandedDistribution(Distribution): def __init__(self, base_dist, batch_shape=()): if isinstance(base_dist, ExpandedDistribution): - batch_shape, _, _ = self._broadcast_shape(base_dist.batch_shape, batch_shape) + batch_shape, _, _ = self._broadcast_shape( + base_dist.batch_shape, batch_shape + ) base_dist = base_dist.base_dist self.base_dist = base_dist @@ -459,8 +477,9 @@ def __init__(self, base_dist, batch_shape=()): # Do basic validation. e.g. we should not "unexpand" distributions even if that is possible. new_shape, _, _ = self._broadcast_shape(base_dist.batch_shape, batch_shape) # Record interstitial and expanded dims/sizes w.r.t. the base distribution - new_shape, expanded_sizes, interstitial_sizes = self._broadcast_shape(base_dist.batch_shape, - new_shape) + new_shape, expanded_sizes, interstitial_sizes = self._broadcast_shape( + base_dist.batch_shape, new_shape + ) self._expanded_sizes = expanded_sizes self._interstitial_sizes = interstitial_sizes super().__init__(new_shape, base_dist.event_shape) @@ -468,8 +487,11 @@ def __init__(self, base_dist, batch_shape=()): @staticmethod def _broadcast_shape(existing_shape, new_shape): if len(new_shape) < len(existing_shape): - raise ValueError("Cannot broadcast distribution of shape {} to shape {}" - .format(existing_shape, new_shape)) + raise ValueError( + "Cannot broadcast distribution of shape {} to shape {}".format( + existing_shape, new_shape + ) + ) reversed_shape = list(reversed(existing_shape)) expanded_sizes, interstitial_sizes = [], [] for i, size in enumerate(reversed(new_shape)): @@ -481,9 +503,16 @@ def _broadcast_shape(existing_shape, new_shape): reversed_shape[i] = size interstitial_sizes.append((-i - 1, size)) elif reversed_shape[i] != size: - raise ValueError("Cannot broadcast distribution of shape {} to shape {}" - .format(existing_shape, new_shape)) - return tuple(reversed(reversed_shape)), OrderedDict(expanded_sizes), OrderedDict(interstitial_sizes) + raise ValueError( + "Cannot broadcast distribution of shape {} to shape {}".format( + existing_shape, new_shape + ) + ) + return ( + tuple(reversed(reversed_shape)), + OrderedDict(expanded_sizes), + OrderedDict(interstitial_sizes), + ) @property def has_enumerate_support(self): @@ -509,7 +538,9 @@ def _sample(self, sample_fn, key, sample_shape=()): batch_ndims = jnp.ndim(samples) - event_dim interstitial_dims = tuple(batch_ndims + i for i in interstitial_dims) interstitial_idx = len(sample_shape) + len(expanded_sizes) - interstitial_sample_dims = range(interstitial_idx, interstitial_idx + len(interstitial_dims)) + interstitial_sample_dims = range( + interstitial_idx, interstitial_idx + len(interstitial_dims) + ) permutation = list(range(batch_ndims)) for dim1, dim2 in zip(interstitial_dims, interstitial_sample_dims): permutation[dim1], permutation[dim2] = permutation[dim2], permutation[dim1] @@ -532,7 +563,8 @@ def reshape_sample(x): def rsample(self, key, sample_shape=()): return self._sample( lambda *args, **kwargs: (self.base_dist.rsample(*args, **kwargs), []), - key, sample_shape + key, + sample_shape, ) @property @@ -546,8 +578,10 @@ def sample(self, key, sample_shape=()): return self.sample_with_intermediates(key, sample_shape)[0] def log_prob(self, value): - shape = lax.broadcast_shapes(self.batch_shape, - jnp.shape(value)[:max(jnp.ndim(value) - self.event_dim, 0)]) + shape = lax.broadcast_shapes( + self.batch_shape, + jnp.shape(value)[: max(jnp.ndim(value) - self.event_dim, 0)], + ) log_prob = self.base_dist.log_prob(value) return jnp.broadcast_to(log_prob, shape) @@ -561,17 +595,22 @@ def enumerate_support(self, expand=True): @property def mean(self): - return jnp.broadcast_to(self.base_dist.mean, self.batch_shape + self.event_shape) + return jnp.broadcast_to( + self.base_dist.mean, self.batch_shape + self.event_shape + ) @property def variance(self): - return jnp.broadcast_to(self.base_dist.variance, self.batch_shape + self.event_shape) + return jnp.broadcast_to( + self.base_dist.variance, self.batch_shape + self.event_shape + ) def tree_flatten(self): prepend_ndim = len(self.batch_shape) - len(self.base_dist.batch_shape) base_dist = tree_util.tree_map( lambda x: promote_shapes(x, shape=(1,) * prepend_ndim + jnp.shape(x))[0], - self.base_dist) + self.base_dist, + ) base_flatten, base_aux = base_dist.tree_flatten() return base_flatten, (type(self.base_dist), base_aux, self.batch_shape) @@ -579,7 +618,9 @@ def tree_flatten(self): def tree_unflatten(cls, aux_data, params): base_cls, base_aux, batch_shape = aux_data base_dist = base_cls.tree_unflatten(base_aux, params) - prepend_shape = base_dist.batch_shape[:len(base_dist.batch_shape) - len(batch_shape)] + prepend_shape = base_dist.batch_shape[ + : len(base_dist.batch_shape) - len(batch_shape) + ] return cls(base_dist, batch_shape=prepend_shape + batch_shape) @@ -633,16 +674,19 @@ class ImproperUniform(Distribution): set `batch_shape=()`. :param tuple event_shape: event shape of this distribution. """ + arg_constraints = {} support = constraints.dependent def __init__(self, support, batch_shape, event_shape, validate_args=None): - self.support = constraints.independent(support, len(event_shape) - support.event_dim) + self.support = constraints.independent( + support, len(event_shape) - support.event_dim + ) super().__init__(batch_shape, event_shape, validate_args=validate_args) @validate_sample def log_prob(self, value): - batch_shape = jnp.shape(value)[:jnp.ndim(value) - len(self.event_shape)] + batch_shape = jnp.shape(value)[: jnp.ndim(value) - len(self.event_shape)] batch_shape = lax.broadcast_shapes(batch_shape, self.batch_shape) return jnp.zeros(batch_shape) @@ -659,7 +703,8 @@ def tree_flatten(self): "Please raising a feature request for your specific `support`. " "Alternatively, you can use '.mask(False)' pattern. " "For example, to define an improper prior over positive domain, " - "we can use the distribution `dist.LogNormal(0, 1).mask(False)`.") + "we can use the distribution `dist.LogNormal(0, 1).mask(False)`." + ) class Independent(Distribution): @@ -684,24 +729,32 @@ class Independent(Distribution): :param numpyro.distribution.Distribution base_distribution: a distribution instance. :param int reinterpreted_batch_ndims: the number of batch dims to reinterpret as event dims. """ + arg_constraints = {} def __init__(self, base_dist, reinterpreted_batch_ndims, validate_args=None): if reinterpreted_batch_ndims > len(base_dist.batch_shape): - raise ValueError("Expected reinterpreted_batch_ndims <= len(base_distribution.batch_shape), " - "actual {} vs {}".format(reinterpreted_batch_ndims, - len(base_dist.batch_shape))) + raise ValueError( + "Expected reinterpreted_batch_ndims <= len(base_distribution.batch_shape), " + "actual {} vs {}".format( + reinterpreted_batch_ndims, len(base_dist.batch_shape) + ) + ) shape = base_dist.batch_shape + base_dist.event_shape event_dim = reinterpreted_batch_ndims + len(base_dist.event_shape) - batch_shape = shape[:len(shape) - event_dim] - event_shape = shape[len(shape) - event_dim:] + batch_shape = shape[: len(shape) - event_dim] + event_shape = shape[len(shape) - event_dim :] self.base_dist = base_dist self.reinterpreted_batch_ndims = reinterpreted_batch_ndims - super(Independent, self).__init__(batch_shape, event_shape, validate_args=validate_args) + super(Independent, self).__init__( + batch_shape, event_shape, validate_args=validate_args + ) @property def support(self): - return constraints.independent(self.base_dist.support, self.reinterpreted_batch_ndims) + return constraints.independent( + self.base_dist.support, self.reinterpreted_batch_ndims + ) @property def has_enumerate_support(self): @@ -738,12 +791,20 @@ def log_prob(self, value): return sum_rightmost(log_prob, self.reinterpreted_batch_ndims) def expand(self, batch_shape): - base_batch_shape = batch_shape + self.event_shape[:self.reinterpreted_batch_ndims] - return self.base_dist.expand(base_batch_shape).to_event(self.reinterpreted_batch_ndims) + base_batch_shape = ( + batch_shape + self.event_shape[: self.reinterpreted_batch_ndims] + ) + return self.base_dist.expand(base_batch_shape).to_event( + self.reinterpreted_batch_ndims + ) def tree_flatten(self): base_flatten, base_aux = self.base_dist.tree_flatten() - return base_flatten, (type(self.base_dist), base_aux, self.reinterpreted_batch_ndims) + return base_flatten, ( + type(self.base_dist), + base_aux, + self.reinterpreted_batch_ndims, + ) @classmethod def tree_unflatten(cls, aux_data, params): @@ -762,18 +823,21 @@ class MaskedDistribution(Distribution): :param mask: A boolean or boolean-valued array. :type mask: jnp.ndarray or bool """ + arg_constraints = {} def __init__(self, base_dist, mask): if isinstance(mask, bool): self._mask = mask else: - batch_shape = lax.broadcast_shapes(jnp.shape(mask), tuple(base_dist.batch_shape)) + batch_shape = lax.broadcast_shapes( + jnp.shape(mask), tuple(base_dist.batch_shape) + ) if mask.shape != batch_shape: mask = jnp.broadcast_to(mask, batch_shape) if base_dist.batch_shape != batch_shape: base_dist = base_dist.expand(batch_shape) - self._mask = mask.astype('bool') + self._mask = mask.astype("bool") self.base_dist = base_dist super().__init__(base_dist.batch_shape, base_dist.event_shape) @@ -801,8 +865,10 @@ def sample(self, key, sample_shape=()): def log_prob(self, value): if self._mask is False: - shape = lax.broadcast_shapes(tuple(self.base_dist.batch_shape), - jnp.shape(value)[:max(jnp.ndim(value) - len(self.event_shape), 0)]) + shape = lax.broadcast_shapes( + tuple(self.base_dist.batch_shape), + jnp.shape(value)[: max(jnp.ndim(value) - len(self.event_shape), 0)], + ) return jnp.zeros(shape) if self._mask is True: return self.base_dist.log_prob(value) @@ -811,9 +877,11 @@ def log_prob(self, value): except NotImplementedError: pass else: - mask = jnp.reshape(self._mask, jnp.shape(self._mask) + (1,) * self.event_dim) + mask = jnp.reshape( + self._mask, jnp.shape(self._mask) + (1,) * self.event_dim + ) value = jnp.where(mask, value, default_value) - return jnp.where(self._mask, self.base_dist.log_prob(value), 0.) + return jnp.where(self._mask, self.base_dist.log_prob(value), 0.0) def enumerate_support(self, expand=True): return self.base_dist.enumerate_support(expand=expand) @@ -857,16 +925,21 @@ class TransformedDistribution(Distribution): :param validate_args: Whether to enable validation of distribution parameters and arguments to `.log_prob` method. """ + arg_constraints = {} def __init__(self, base_distribution, transforms, validate_args=None): if isinstance(transforms, Transform): - transforms = [transforms, ] + transforms = [transforms] elif isinstance(transforms, list): if not all(isinstance(t, Transform) for t in transforms): - raise ValueError("transforms must be a Transform or a list of Transforms") + raise ValueError( + "transforms must be a Transform or a list of Transforms" + ) else: - raise ValueError("transforms must be a Transform or list, but was {}".format(transforms)) + raise ValueError( + "transforms must be a Transform or list, but was {}".format(transforms) + ) if isinstance(base_distribution, TransformedDistribution): base_dist = base_distribution.base_dist self.transforms = base_distribution.transforms + transforms @@ -878,12 +951,17 @@ def __init__(self, base_distribution, transforms, validate_args=None): transform = ComposeTransform(self.transforms) domain_event_dim = transform.domain.event_dim if len(base_shape) < domain_event_dim: - raise ValueError("Base distribution needs to have shape with size at least {}, but got {}." - .format(domain_event_dim, base_shape)) + raise ValueError( + "Base distribution needs to have shape with size at least {}, but got {}.".format( + domain_event_dim, base_shape + ) + ) shape = transform.forward_shape(base_shape) expanded_base_shape = transform.inverse_shape(shape) if base_shape != expanded_base_shape: - base_batch_shape = expanded_base_shape[:len(expanded_base_shape) - base_event_dim] + base_batch_shape = expanded_base_shape[ + : len(expanded_base_shape) - base_event_dim + ] base_dist = base_dist.expand(base_batch_shape) reinterpreted_batch_ndims = domain_event_dim - base_event_dim if reinterpreted_batch_ndims > 0: @@ -891,12 +969,16 @@ def __init__(self, base_distribution, transforms, validate_args=None): self.base_dist = base_dist # Compute shapes. - event_dim = transform.codomain.event_dim + max(base_event_dim - domain_event_dim, 0) + event_dim = transform.codomain.event_dim + max( + base_event_dim - domain_event_dim, 0 + ) assert len(shape) >= event_dim cut = len(shape) - event_dim batch_shape = shape[:cut] event_shape = shape[cut:] - super(TransformedDistribution, self).__init__(batch_shape, event_shape, validate_args=validate_args) + super(TransformedDistribution, self).__init__( + batch_shape, event_shape, validate_args=validate_args + ) @property def has_rsample(self): @@ -916,7 +998,9 @@ def support(self): if self.event_dim == codomain_event_dim: return codomain else: - return constraints.independent(codomain, self.event_dim - codomain_event_dim) + return constraints.independent( + codomain, self.event_dim - codomain_event_dim + ) def sample(self, key, sample_shape=()): x = self.base_dist(rng_key=key, sample_shape=sample_shape) @@ -937,8 +1021,11 @@ def sample_with_intermediates(self, key, sample_shape=()): def log_prob(self, value, intermediates=None): if intermediates is not None: if len(intermediates) != len(self.transforms): - raise ValueError('Intermediates array has length = {}. Expected = {}.' - .format(len(intermediates), len(self.transforms))) + raise ValueError( + "Intermediates array has length = {}. Expected = {}.".format( + len(intermediates), len(self.transforms) + ) + ) event_dim = len(self.event_shape) log_prob = 0.0 y = value @@ -951,8 +1038,9 @@ def log_prob(self, value, intermediates=None): event_dim = transform.domain.event_dim + batch_ndim y = x - log_prob = log_prob + sum_rightmost(self.base_dist.log_prob(y), - event_dim - len(self.base_dist.event_shape)) + log_prob = log_prob + sum_rightmost( + self.base_dist.log_prob(y), event_dim - len(self.base_dist.event_shape) + ) return log_prob @property @@ -968,26 +1056,34 @@ def tree_flatten(self): "Flatenning TransformedDistribution is only supported for some specific cases." " Consider using `TransformReparam` to convert this distribution to the base_dist," " which is supported in most situtations. In addition, please reach out to us with" - " your usage cases.") + " your usage cases." + ) class Delta(Distribution): - arg_constraints = {'v': constraints.dependent(is_discrete=False), - 'log_density': constraints.real} - reparameterized_params = ['v', 'log_density'] + arg_constraints = { + "v": constraints.dependent(is_discrete=False), + "log_density": constraints.real, + } + reparameterized_params = ["v", "log_density"] is_discrete = True - def __init__(self, v=0., log_density=0., event_dim=0, validate_args=None): + def __init__(self, v=0.0, log_density=0.0, event_dim=0, validate_args=None): if event_dim > jnp.ndim(v): - raise ValueError('Expected event_dim <= v.dim(), actual {} vs {}' - .format(event_dim, jnp.ndim(v))) + raise ValueError( + "Expected event_dim <= v.dim(), actual {} vs {}".format( + event_dim, jnp.ndim(v) + ) + ) batch_dim = jnp.ndim(v) - event_dim batch_shape = jnp.shape(v)[:batch_dim] event_shape = jnp.shape(v)[batch_dim:] self.v = v # NB: following Pyro implementation, log_density should be broadcasted to batch_shape self.log_density = promote_shapes(log_density, shape=batch_shape)[0] - super(Delta, self).__init__(batch_shape, event_shape, validate_args=validate_args) + super(Delta, self).__init__( + batch_shape, event_shape, validate_args=validate_args + ) @constraints.dependent_property(is_discrete=True) def support(self): @@ -1027,14 +1123,17 @@ class Unit(Distribution): This is used for :func:`numpyro.factor` statements. """ - arg_constraints = {'log_factor': constraints.real} + + arg_constraints = {"log_factor": constraints.real} support = constraints.real def __init__(self, log_factor, validate_args=None): batch_shape = jnp.shape(log_factor) event_shape = (0,) # This satisfies .size == 0. self.log_factor = log_factor - super(Unit, self).__init__(batch_shape, event_shape, validate_args=validate_args) + super(Unit, self).__init__( + batch_shape, event_shape, validate_args=validate_args + ) def sample(self, key, sample_shape=()): return jnp.empty(sample_shape + self.batch_shape + self.event_shape) diff --git a/numpyro/distributions/flows.py b/numpyro/distributions/flows.py index 68ee26574..9a9b5401e 100644 --- a/numpyro/distributions/flows.py +++ b/numpyro/distributions/flows.py @@ -28,10 +28,13 @@ class InverseAutoregressiveTransform(Transform): 1. *Improving Variational Inference with Inverse Autoregressive Flow* [arXiv:1606.04934], Diederik P. Kingma, Tim Salimans, Rafal Jozefowicz, Xi Chen, Ilya Sutskever, Max Welling """ + domain = real_vector codomain = real_vector - def __init__(self, autoregressive_nn, log_scale_min_clip=-5., log_scale_max_clip=3.): + def __init__( + self, autoregressive_nn, log_scale_min_clip=-5.0, log_scale_max_clip=3.0 + ): """ :param autoregressive_nn: an autoregressive neural network whose forward call returns a real-valued mean and log scale as a tuple @@ -48,7 +51,9 @@ def __call__(self, x): def call_with_intermediates(self, x): mean, log_scale = self.arn(x) - log_scale = _clamp_preserve_gradients(log_scale, self.log_scale_min_clip, self.log_scale_max_clip) + log_scale = _clamp_preserve_gradients( + log_scale, self.log_scale_min_clip, self.log_scale_max_clip + ) scale = jnp.exp(log_scale) return scale * x + mean, log_scale @@ -59,8 +64,11 @@ def _inverse(self, y): # NOTE: Inversion is an expensive operation that scales in the dimension of the input def _update_x(i, x): mean, log_scale = self.arn(x) - inverse_scale = jnp.exp(-_clamp_preserve_gradients( - log_scale, min=self.log_scale_min_clip, max=self.log_scale_max_clip)) + inverse_scale = jnp.exp( + -_clamp_preserve_gradients( + log_scale, min=self.log_scale_min_clip, max=self.log_scale_max_clip + ) + ) x = (y - mean) * inverse_scale return x @@ -76,7 +84,9 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): """ if intermediates is None: log_scale = self.arn(x)[1] - log_scale = _clamp_preserve_gradients(log_scale, self.log_scale_min_clip, self.log_scale_max_clip) + log_scale = _clamp_preserve_gradients( + log_scale, self.log_scale_min_clip, self.log_scale_max_clip + ) return log_scale.sum(-1) else: log_scale = intermediates @@ -92,6 +102,7 @@ class BlockNeuralAutoregressiveTransform(Transform): 1. *Block Neural Autoregressive Flow*, Nicola De Cao, Ivan Titov, Wilker Aziz """ + domain = real_vector codomain = real_vector @@ -109,8 +120,10 @@ def call_with_intermediates(self, x): return y, logdet def _inverse(self, y): - raise NotImplementedError("Block neural autoregressive transform does not have an analytic" - " inverse implemented.") + raise NotImplementedError( + "Block neural autoregressive transform does not have an analytic" + " inverse implemented." + ) def log_abs_det_jacobian(self, x, y, intermediates=None): """ diff --git a/numpyro/distributions/gof.py b/numpyro/distributions/gof.py index 0439e2482..b6d93bb73 100644 --- a/numpyro/distributions/gof.py +++ b/numpyro/distributions/gof.py @@ -72,19 +72,13 @@ class InvalidTest(ValueError): def print_histogram(probs, counts): max_count = max(counts) - print('{: >8} {: >8}'.format('Prob', 'Count')) + print("{: >8} {: >8}".format("Prob", "Count")) for prob, count in sorted(zip(probs, counts), reverse=True): width = int(round(HISTOGRAM_WIDTH * count / max_count)) - print('{: >8.3f} {: >8d} {}'.format(prob, count, '-' * width)) + print("{: >8.3f} {: >8d} {}".format(prob, count, "-" * width)) -def multinomial_goodness_of_fit( - probs, - counts, - *, - total_count=None, - plot=False, -): +def multinomial_goodness_of_fit(probs, counts, *, total_count=None, plot=False): """ Pearson's chi^2 test, on possibly truncated data. https://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test @@ -114,16 +108,16 @@ def multinomial_goodness_of_fit( for p, c in zip(probs.tolist(), counts.tolist()): if abs(p - 1) < 1e-8: return 1 if c == total_count else 0 - assert p < 1, f'bad probability: {p:g}' + assert p < 1, f"bad probability: {p:g}" if p > 0: mean = total_count * p variance = total_count * p * (1 - p) if not (variance > 1): - raise InvalidTest('Goodness of fit is inaccurate; use more samples') + raise InvalidTest("Goodness of fit is inaccurate; use more samples") chi_squared += (c - mean) ** 2 / variance dof += 1 else: - warnings.warn('Zero probability in goodness-of-fit test') + warnings.warn("Zero probability in goodness-of-fit test") if c > 0: return math.inf @@ -149,7 +143,7 @@ def unif01_goodness_of_fit(samples, *, plot=False): assert samples.max() <= 1 bin_count = int(round(len(samples) ** 0.333)) if bin_count < 7: - raise InvalidTest('imprecise test, use more samples') + raise InvalidTest("imprecise test, use more samples") probs = np.ones(bin_count) / bin_count binned = (samples * bin_count).astype(np.int) binned = np.clip(binned, 0, bin_count - 1) @@ -190,9 +184,9 @@ def density_goodness_of_fit(samples, probs, plot=False): probs = jax.lax.stop_gradient(probs) assert samples.shape == probs.shape if len(samples) <= 100: - raise InvalidTest('imprecision; use more samples') + raise InvalidTest("imprecision; use more samples") - index = np.argsort(samples, 0, kind='quicksort') + index = np.argsort(samples, 0, kind="quicksort") samples = samples[index] probs = probs[index] gaps = samples[1:] - samples[:-1] @@ -213,6 +207,7 @@ def get_nearest_neighbor_distances(samples): try: # This version scales as O(N log(N)). from scipy.spatial import cKDTree + distances, indices = cKDTree(samples).query(samples, k=2) return distances[:, 1] except ImportError: @@ -259,7 +254,7 @@ def vector_density_goodness_of_fit(samples, probs, *, dim=None, plot=False): dim = samples.shape[-1] assert dim if len(samples) <= 1000 * dim: - raise InvalidTest('imprecision; use more samples') + raise InvalidTest("imprecision; use more samples") radii = get_nearest_neighbor_distances(samples) density = len(samples) * probs volume = volume_of_sphere(dim, radii) diff --git a/numpyro/distributions/kl.py b/numpyro/distributions/kl.py index 5e5fe2445..c97bbeb63 100644 --- a/numpyro/distributions/kl.py +++ b/numpyro/distributions/kl.py @@ -37,19 +37,27 @@ Distribution, ExpandedDistribution, Independent, - MaskedDistribution + MaskedDistribution, ) from numpyro.distributions.util import scale_and_mask, sum_rightmost -_KL_REGISTRY = {} # Source of truth mapping a few general (type, type) pairs to functions. -_KL_MEMOIZE = {} # Memoized version mapping many specific (type, type) pairs to functions. +_KL_REGISTRY = ( + {} +) # Source of truth mapping a few general (type, type) pairs to functions. +_KL_MEMOIZE = ( + {} +) # Memoized version mapping many specific (type, type) pairs to functions. def register_kl(type_p, type_q): if not isinstance(type_p, type) and issubclass(type_p, Distribution): - raise TypeError('Expected type_p to be a Distribution subclass but got {}'.format(type_p)) + raise TypeError( + "Expected type_p to be a Distribution subclass but got {}".format(type_p) + ) if not isinstance(type_q, type) and issubclass(type_q, Distribution): - raise TypeError('Expected type_q to be a Distribution subclass but got {}'.format(type_q)) + raise TypeError( + "Expected type_q to be a Distribution subclass but got {}".format(type_q) + ) def decorator(fun): _KL_REGISTRY[type_p, type_q] = fun @@ -61,7 +69,7 @@ def decorator(fun): @total_ordering class _Match(object): - __slots__ = ['types'] + __slots__ = ["types"] def __init__(self, *types): self.types = types @@ -82,8 +90,11 @@ def _dispatch_kl(type_p, type_q): """ Find the most specific approximate match, assuming single inheritance. """ - matches = [(super_p, super_q) for super_p, super_q in _KL_REGISTRY - if issubclass(type_p, super_p) and issubclass(type_q, super_q)] + matches = [ + (super_p, super_q) + for super_p, super_q in _KL_REGISTRY + if issubclass(type_p, super_p) and issubclass(type_q, super_q) + ] if not matches: return NotImplemented # Check that the left- and right- lexicographic orders agree. @@ -92,9 +103,12 @@ def _dispatch_kl(type_p, type_q): left_fun = _KL_REGISTRY[left_p, left_q] right_fun = _KL_REGISTRY[right_p, right_q] if left_fun is not right_fun: - warnings.warn('Ambiguous kl_divergence({}, {}). Please register_kl({}, {})'.format( - type_p.__name__, type_q.__name__, left_p.__name__, right_q.__name__), - RuntimeWarning) + warnings.warn( + "Ambiguous kl_divergence({}, {}). Please register_kl({}, {})".format( + type_p.__name__, type_q.__name__, left_p.__name__, right_q.__name__ + ), + RuntimeWarning, + ) return left_fun @@ -170,7 +184,7 @@ def _kl_masked_masked(p, q): mask = p._mask & q._mask if mask is False: - return 0. + return 0.0 if mask is True: return kl_divergence(p.base_dist, q.base_dist) kl = kl_divergence(p.base_dist, q.base_dist) diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 7747cd83b..636e15b2d 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -16,37 +16,42 @@ from jax.tree_util import tree_flatten, tree_map from numpyro.distributions import constraints -from numpyro.distributions.util import matrix_to_tril_vec, signed_stick_breaking_tril, sum_rightmost, vec_to_tril_matrix +from numpyro.distributions.util import ( + matrix_to_tril_vec, + signed_stick_breaking_tril, + sum_rightmost, + vec_to_tril_matrix, +) from numpyro.util import not_jax_tracer __all__ = [ - 'biject_to', - 'AbsTransform', - 'AffineTransform', - 'CholeskyTransform', - 'ComposeTransform', - 'CorrCholeskyTransform', - 'CorrMatrixCholeskyTransform', - 'ExpTransform', - 'SoftplusTransform', - 'IdentityTransform', - 'InvCholeskyTransform', - 'LowerCholeskyTransform', - 'LowerCholeskyAffine', - 'PermuteTransform', - 'PowerTransform', - 'SigmoidTransform', - 'SoftplusTransform', - 'SoftplusLowerCholeskyTransform', - 'StickBreakingTransform', - 'Transform', - 'UnpackTransform', + "biject_to", + "AbsTransform", + "AffineTransform", + "CholeskyTransform", + "ComposeTransform", + "CorrCholeskyTransform", + "CorrMatrixCholeskyTransform", + "ExpTransform", + "SoftplusTransform", + "IdentityTransform", + "InvCholeskyTransform", + "LowerCholeskyTransform", + "LowerCholeskyAffine", + "PermuteTransform", + "PowerTransform", + "SigmoidTransform", + "SoftplusTransform", + "SoftplusLowerCholeskyTransform", + "StickBreakingTransform", + "Transform", + "UnpackTransform", ] def _clipped_expit(x): finfo = jnp.finfo(jnp.result_type(x)) - return jnp.clip(expit(x), a_min=finfo.tiny, a_max=1. - finfo.eps) + return jnp.clip(expit(x), a_min=finfo.tiny, a_max=1.0 - finfo.eps) class Transform(object): @@ -56,9 +61,11 @@ class Transform(object): @property def event_dim(self): - warnings.warn("transform.event_dim is deprecated. Please use Transform.domain.event_dim to " - "get input event dim or Transform.codomain.event_dim to get output event dim.", - FutureWarning) + warnings.warn( + "transform.event_dim is deprecated. Please use Transform.domain.event_dim to " + "get input event dim or Transform.codomain.event_dim to get output event dim.", + FutureWarning, + ) return self.domain.event_dim @property @@ -148,6 +155,7 @@ class AffineTransform(Transform): .. note:: When `scale` is a JAX tracer, we always assume that `scale > 0` when calculating `codomain`. """ + def __init__(self, loc, scale, domain=constraints.real): self.loc = loc self.scale = scale @@ -171,11 +179,13 @@ def codomain(self): return constraints.less_than(self(self.domain.upper_bound)) elif isinstance(self.domain, constraints.interval): if not_jax_tracer(self.scale) and np.all(np.less(self.scale, 0)): - return constraints.interval(self(self.domain.upper_bound), - self(self.domain.lower_bound)) + return constraints.interval( + self(self.domain.upper_bound), self(self.domain.lower_bound) + ) else: - return constraints.interval(self(self.domain.lower_bound), - self(self.domain.upper_bound)) + return constraints.interval( + self(self.domain.lower_bound), self(self.domain.upper_bound) + ) else: raise NotImplementedError @@ -189,27 +199,31 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): return jnp.broadcast_to(jnp.log(jnp.abs(self.scale)), jnp.shape(x)) def forward_shape(self, shape): - return lax.broadcast_shapes(shape, - getattr(self.loc, "shape", ()), - getattr(self.scale, "shape", ())) + return lax.broadcast_shapes( + shape, getattr(self.loc, "shape", ()), getattr(self.scale, "shape", ()) + ) def inverse_shape(self, shape): - return lax.broadcast_shapes(shape, - getattr(self.loc, "shape", ()), - getattr(self.scale, "shape", ())) + return lax.broadcast_shapes( + shape, getattr(self.loc, "shape", ()), getattr(self.scale, "shape", ()) + ) def _get_compose_transform_input_event_dim(parts): input_event_dim = parts[-1].domain.event_dim - for part in parts[len(parts) - 1::-1]: - input_event_dim = part.domain.event_dim + max(input_event_dim - part.codomain.event_dim, 0) + for part in parts[len(parts) - 1 :: -1]: + input_event_dim = part.domain.event_dim + max( + input_event_dim - part.codomain.event_dim, 0 + ) return input_event_dim def _get_compose_transform_output_event_dim(parts): output_event_dim = parts[0].codomain.event_dim for part in parts[1:]: - output_event_dim = part.codomain.event_dim + max(output_event_dim - part.domain.event_dim, 0) + output_event_dim = part.codomain.event_dim + max( + output_event_dim - part.domain.event_dim, 0 + ) return output_event_dim @@ -225,7 +239,9 @@ def domain(self): if input_event_dim == first_input_event_dim: return self.parts[0].domain else: - return constraints.independent(self.parts[0].domain, input_event_dim - first_input_event_dim) + return constraints.independent( + self.parts[0].domain, input_event_dim - first_input_event_dim + ) @property def codomain(self): @@ -235,7 +251,9 @@ def codomain(self): if output_event_dim == last_output_event_dim: return self.parts[-1].codomain else: - return constraints.independent(self.parts[-1].codomain, output_event_dim - last_output_event_dim) + return constraints.independent( + self.parts[-1].codomain, output_event_dim - last_output_event_dim + ) def __call__(self, x): for part in self.parts: @@ -250,10 +268,13 @@ def _inverse(self, y): def log_abs_det_jacobian(self, x, y, intermediates=None): if intermediates is not None: if len(intermediates) != len(self.parts): - raise ValueError('Intermediates array has length = {}. Expected = {}.' - .format(len(intermediates), len(self.parts))) + raise ValueError( + "Intermediates array has length = {}. Expected = {}.".format( + len(intermediates), len(self.parts) + ) + ) - result = 0. + result = 0.0 input_event_dim = self.domain.event_dim for i, part in enumerate(self.parts[:-1]): y_tmp = part(x) if intermediates is None else intermediates[i][0] @@ -332,7 +353,9 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): # Ref: http://web.mit.edu/18.325/www/handouts/handout2.pdf page 13 n = jnp.shape(x)[-1] order = -jnp.arange(n, 0, -1) - return -n * jnp.log(2) + jnp.sum(order * jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1)), axis=-1) + return -n * jnp.log(2) + jnp.sum( + order * jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1)), axis=-1 + ) class CorrCholeskyTransform(Transform): @@ -374,10 +397,12 @@ def _inverse(self, y): z1m_cumprod = 1 - jnp.cumsum(y * y, axis=-1) pad_width = [(0, 0)] * y.ndim pad_width[-1] = (1, 0) - z1m_cumprod_shifted = jnp.pad(z1m_cumprod[..., :-1], pad_width, - mode="constant", constant_values=1.) + z1m_cumprod_shifted = jnp.pad( + z1m_cumprod[..., :-1], pad_width, mode="constant", constant_values=1.0 + ) t = matrix_to_tril_vec(y, diagonal=-1) / jnp.sqrt( - matrix_to_tril_vec(z1m_cumprod_shifted, diagonal=-1)) + matrix_to_tril_vec(z1m_cumprod_shifted, diagonal=-1) + ) # inverse of tanh x = jnp.log((1 + t) / (1 - t)) / 2 return x @@ -394,7 +419,7 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): z1m_cumprod_tril = matrix_to_tril_vec(z1m_cumprod, diagonal=-2) stick_breaking_logdet = 0.5 * jnp.sum(jnp.log(z1m_cumprod_tril), axis=-1) - tanh_logdet = -2 * jnp.sum(x + softplus(-2 * x) - jnp.log(2.), axis=-1) + tanh_logdet = -2 * jnp.sum(x + softplus(-2 * x) - jnp.log(2.0), axis=-1) return stick_breaking_logdet + tanh_logdet def forward_shape(self, shape): @@ -432,8 +457,10 @@ def codomain(self): elif isinstance(self.domain, constraints.greater_than): return constraints.greater_than(self.__call__(self.domain.lower_bound)) elif isinstance(self.domain, constraints.interval): - return constraints.interval(self.__call__(self.domain.lower_bound), - self.__call__(self.domain.upper_bound)) + return constraints.interval( + self.__call__(self.domain.lower_bound), + self.__call__(self.domain.upper_bound), + ) else: raise NotImplementedError @@ -449,7 +476,6 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): class IdentityTransform(Transform): - def __call__(self, x): return x @@ -466,6 +492,7 @@ class IndependentTransform(Transform): dims in :meth:`check`, so that an event is valid only if all its independent entries are valid. """ + def __init__(self, base_transform, reinterpreted_batch_ndims): assert isinstance(base_transform, Transform) assert isinstance(reinterpreted_batch_ndims, int) @@ -476,11 +503,15 @@ def __init__(self, base_transform, reinterpreted_batch_ndims): @property def domain(self): - return constraints.independent(self.base_transform.domain, self.reinterpreted_batch_ndims) + return constraints.independent( + self.base_transform.domain, self.reinterpreted_batch_ndims + ) @property def codomain(self): - return constraints.independent(self.base_transform.codomain, self.reinterpreted_batch_ndims) + return constraints.independent( + self.base_transform.codomain, self.reinterpreted_batch_ndims + ) def __call__(self, x): return self.base_transform(x) @@ -489,7 +520,9 @@ def _inverse(self, y): return self.base_transform._inverse(y) def log_abs_det_jacobian(self, x, y, intermediates=None): - result = self.base_transform.log_abs_det_jacobian(x, y, intermediates=intermediates) + result = self.base_transform.log_abs_det_jacobian( + x, y, intermediates=intermediates + ) if jnp.ndim(result) < self.reinterpreted_batch_ndims: expected = self.domain.event_dim raise ValueError(f"Expected x.dim() >= {expected} but got {jnp.ndim(x)}") @@ -512,8 +545,11 @@ class InvCholeskyTransform(Transform): """ def __init__(self, domain=constraints.lower_cholesky): - warnings.warn("InvCholeskyTransform is deprecated. Please use CholeskyTransform" - " or CorrMatrixCholeskyTransform instead.", FutureWarning) + warnings.warn( + "InvCholeskyTransform is deprecated. Please use CholeskyTransform" + " or CorrMatrixCholeskyTransform instead.", + FutureWarning, + ) assert domain in [constraints.lower_cholesky, constraints.corr_cholesky] self.domain = domain @@ -535,12 +571,16 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): # Ref: http://web.mit.edu/18.325/www/handouts/handout2.pdf page 13 n = jnp.shape(x)[-1] order = jnp.arange(n, 0, -1) - return n * jnp.log(2) + jnp.sum(order * jnp.log(jnp.diagonal(x, axis1=-2, axis2=-1)), axis=-1) + return n * jnp.log(2) + jnp.sum( + order * jnp.log(jnp.diagonal(x, axis1=-2, axis2=-1)), axis=-1 + ) else: # NB: see derivation in LKJCholesky implementation n = jnp.shape(x)[-1] order = jnp.arange(n - 1, -1, -1) - return jnp.sum(order * jnp.log(jnp.diagonal(x, axis1=-2, axis2=-1)), axis=-1) + return jnp.sum( + order * jnp.log(jnp.diagonal(x, axis1=-2, axis2=-1)), axis=-1 + ) class LowerCholeskyAffine(Transform): @@ -555,14 +595,18 @@ class LowerCholeskyAffine(Transform): def __init__(self, loc, scale_tril): if jnp.ndim(scale_tril) != 2: - raise ValueError("Only support 2-dimensional scale_tril matrix. " - "Please make a feature request if you need to " - "use this transform with batched scale_tril.") + raise ValueError( + "Only support 2-dimensional scale_tril matrix. " + "Please make a feature request if you need to " + "use this transform with batched scale_tril." + ) self.loc = loc self.scale_tril = scale_tril def __call__(self, x): - return self.loc + jnp.squeeze(jnp.matmul(self.scale_tril, x[..., jnp.newaxis]), axis=-1) + return self.loc + jnp.squeeze( + jnp.matmul(self.scale_tril, x[..., jnp.newaxis]), axis=-1 + ) def _inverse(self, y): y = y - self.loc @@ -572,8 +616,10 @@ def _inverse(self, y): return jnp.reshape(xt.T, original_shape) def log_abs_det_jacobian(self, x, y, intermediates=None): - return jnp.broadcast_to(jnp.log(jnp.diagonal(self.scale_tril, axis1=-2, axis2=-1)).sum(-1), - jnp.shape(x)[:-1]) + return jnp.broadcast_to( + jnp.log(jnp.diagonal(self.scale_tril, axis1=-2, axis2=-1)).sum(-1), + jnp.shape(x)[:-1], + ) def forward_shape(self, shape): if len(shape) < 1: @@ -598,7 +644,9 @@ def __call__(self, x): def _inverse(self, y): z = matrix_to_tril_vec(y, diagonal=-1) - return jnp.concatenate([z, jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1))], axis=-1) + return jnp.concatenate( + [z, jnp.log(jnp.diagonal(y, axis1=-2, axis2=-1))], axis=-1 + ) def log_abs_det_jacobian(self, x, y, intermediates=None): # the jacobian is diagonal, so logdet is the sum of diagonal `exp` transform @@ -621,6 +669,7 @@ class OrderedTransform(Transform): 1. *Stan Reference Manual v2.20, section 10.6*, Stan Development Team """ + domain = constraints.real_vector codomain = constraints.ordered_vector @@ -648,13 +697,15 @@ def __call__(self, x): def _inverse(self, y): size = self.permutation.size - permutation_inv = ops.index_update(jnp.zeros(size, dtype=jnp.result_type(int)), - self.permutation, - jnp.arange(size)) + permutation_inv = ops.index_update( + jnp.zeros(size, dtype=jnp.result_type(int)), + self.permutation, + jnp.arange(size), + ) return y[..., permutation_inv] def log_abs_det_jacobian(self, x, y, intermediates=None): - return jnp.full(jnp.shape(x)[:-1], 0.) + return jnp.full(jnp.shape(x)[:-1], 0.0) class PowerTransform(Transform): @@ -722,6 +773,7 @@ class SoftplusLowerCholeskyTransform(Transform): nonnegative diagonal entries. This is useful for parameterizing positive definite matrices in terms of their Cholesky factorization. """ + domain = constraints.real_vector codomain = constraints.softplus_lower_cholesky @@ -760,15 +812,19 @@ def __call__(self, x): z1m_cumprod = jnp.cumprod(1 - z, axis=-1) pad_width = [(0, 0)] * x.ndim pad_width[-1] = (0, 1) - z_padded = jnp.pad(z, pad_width, mode="constant", constant_values=1.) + z_padded = jnp.pad(z, pad_width, mode="constant", constant_values=1.0) pad_width = [(0, 0)] * x.ndim pad_width[-1] = (1, 0) - z1m_cumprod_shifted = jnp.pad(z1m_cumprod, pad_width, mode="constant", constant_values=1.) + z1m_cumprod_shifted = jnp.pad( + z1m_cumprod, pad_width, mode="constant", constant_values=1.0 + ) return z_padded * z1m_cumprod_shifted def _inverse(self, y): y_crop = y[..., :-1] - z1m_cumprod = jnp.clip(1 - jnp.cumsum(y_crop, axis=-1), a_min=jnp.finfo(y.dtype).tiny) + z1m_cumprod = jnp.clip( + 1 - jnp.cumsum(y_crop, axis=-1), a_min=jnp.finfo(y.dtype).tiny + ) # hence x = logit(z) = log(z / (1 - z)) = y[::-1] / z1m_cumprod x = jnp.log(y_crop / z1m_cumprod) return x + jnp.log(x.shape[-1] - jnp.arange(x.shape[-1])) @@ -799,6 +855,7 @@ class UnpackTransform(Transform): :param unpack_fn: callable used to unpack a contiguous array. """ + domain = constraints.real_vector codomain = constraints.dependent @@ -809,18 +866,23 @@ def __call__(self, x): batch_shape = x.shape[:-1] if batch_shape: unpacked = vmap(self.unpack_fn)(x.reshape((-1,) + x.shape[-1:])) - return tree_map(lambda z: jnp.reshape(z, batch_shape + z.shape[1:]), unpacked) + return tree_map( + lambda z: jnp.reshape(z, batch_shape + z.shape[1:]), unpacked + ) else: return self.unpack_fn(x) def _inverse(self, y): - leading_dims = [v.shape[0] if jnp.ndim(v) > 0 else 0 - for v in tree_flatten(y)[0]] + leading_dims = [ + v.shape[0] if jnp.ndim(v) > 0 else 0 for v in tree_flatten(y)[0] + ] d0 = leading_dims[0] not_scalar = d0 > 0 or len(leading_dims) > 1 if not_scalar and all(d == d0 for d in leading_dims[1:]): - warnings.warn("UnpackTransform.inv might lead to an unexpected behavior because it" - " cannot transform a batch of unpacked arrays.") + warnings.warn( + "UnpackTransform.inv might lead to an unexpected behavior because it" + " cannot transform a batch of unpacked arrays." + ) return ravel_pytree(y)[0] def log_abs_det_jacobian(self, x, y, intermediates=None): @@ -837,6 +899,7 @@ def inverse_shape(self, shape): # CONSTRAINT_REGISTRY ########################################################## + class ConstraintRegistry(object): def __init__(self): self._registry = {} @@ -869,30 +932,38 @@ def _transform_to_corr_cholesky(constraint): @biject_to.register(constraints.corr_matrix) def _transform_to_corr_matrix(constraint): - return ComposeTransform([CorrCholeskyTransform(), - CorrMatrixCholeskyTransform().inv]) + return ComposeTransform( + [CorrCholeskyTransform(), CorrMatrixCholeskyTransform().inv] + ) @biject_to.register(constraints.greater_than) def _transform_to_greater_than(constraint): if constraint is constraints.positive: return ExpTransform() - return ComposeTransform([ExpTransform(), - AffineTransform(constraint.lower_bound, 1, - domain=constraints.positive)]) + return ComposeTransform( + [ + ExpTransform(), + AffineTransform(constraint.lower_bound, 1, domain=constraints.positive), + ] + ) @biject_to.register(constraints.less_than) def _transform_to_less_than(constraint): - return ComposeTransform([ExpTransform(), - AffineTransform(constraint.upper_bound, -1, - domain=constraints.positive)]) + return ComposeTransform( + [ + ExpTransform(), + AffineTransform(constraint.upper_bound, -1, domain=constraints.positive), + ] + ) @biject_to.register(constraints.independent) def _biject_to_independent(constraint): - return IndependentTransform(biject_to(constraint.base_constraint), - constraint.reinterpreted_batch_ndims) + return IndependentTransform( + biject_to(constraint.base_constraint), constraint.reinterpreted_batch_ndims + ) @biject_to.register(constraints.interval) @@ -900,9 +971,14 @@ def _transform_to_interval(constraint): if constraint is constraints.unit_interval: return SigmoidTransform() scale = constraint.upper_bound - constraint.lower_bound - return ComposeTransform([SigmoidTransform(), - AffineTransform(constraint.lower_bound, scale, - domain=constraints.unit_interval)]) + return ComposeTransform( + [ + SigmoidTransform(), + AffineTransform( + constraint.lower_bound, scale, domain=constraints.unit_interval + ), + ] + ) @biject_to.register(constraints.lower_cholesky) diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index bc7e82188..991b3f327 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -13,7 +13,9 @@ from jax.scipy.linalg import solve_triangular # Parameters for Transformed Rejection with Squeeze (TRS) algorithm - page 3. -_tr_params = namedtuple('tr_params', ['c', 'b', 'a', 'alpha', 'u_r', 'v_r', 'm', 'log_p', 'log1_p', 'log_h']) +_tr_params = namedtuple( + "tr_params", ["c", "b", "a", "alpha", "u_r", "v_r", "m", "log_p", "log1_p", "log_h"] +) def _get_tr_params(n, p): @@ -30,29 +32,34 @@ def _get_tr_params(n, p): m = jnp.floor((n + 1) * p).astype(n.dtype) log_p = jnp.log(p) log1_p = jnp.log1p(-p) - log_h = (m + 0.5) * (jnp.log((m + 1.) / (n - m + 1.)) + log1_p - log_p) + \ - (stirling_approx_tail(m) + stirling_approx_tail(n - m)) + log_h = (m + 0.5) * (jnp.log((m + 1.0) / (n - m + 1.0)) + log1_p - log_p) + ( + stirling_approx_tail(m) + stirling_approx_tail(n - m) + ) return _tr_params(c, b, a, alpha, u_r, v_r, m, log_p, log1_p, log_h) def stirling_approx_tail(k): - precomputed = jnp.array([ - 0.08106146679532726, - 0.04134069595540929, - 0.02767792568499834, - 0.02079067210376509, - 0.01664469118982119, - 0.01387612882307075, - 0.01189670994589177, - 0.01041126526197209, - 0.009255462182712733, - 0.008330563433362871, - ]) + precomputed = jnp.array( + [ + 0.08106146679532726, + 0.04134069595540929, + 0.02767792568499834, + 0.02079067210376509, + 0.01664469118982119, + 0.01387612882307075, + 0.01189670994589177, + 0.01041126526197209, + 0.009255462182712733, + 0.008330563433362871, + ] + ) kp1 = k + 1 kp1sq = (k + 1) ** 2 - return jnp.where(k < 10, - precomputed[k], - (1. / 12 - (1. / 360 - (1. / 1260) / kp1sq) / kp1sq) / kp1) + return jnp.where( + k < 10, + precomputed[k], + (1.0 / 12 - (1.0 / 360 - (1.0 / 1260) / kp1sq) / kp1sq) / kp1, + ) def _binomial_btrs(key, p, n): @@ -70,7 +77,9 @@ def _btrs_body_fn(val): u = random.uniform(key_u) v = random.uniform(key_v) u = u - 0.5 - k = jnp.floor((2 * tr_params.a / (0.5 - jnp.abs(u)) + tr_params.b) * u + tr_params.c).astype(n.dtype) + k = jnp.floor( + (2 * tr_params.a / (0.5 - jnp.abs(u)) + tr_params.b) * u + tr_params.c + ).astype(n.dtype) return k, key, u, v def _btrs_cond_fn(val): @@ -82,24 +91,30 @@ def accept_fn(k, u, v): log_p = tr_params.log_p log1_p = tr_params.log1_p # See: formula for log(f(k)) at bottom of Page 5. - log_f = (n + 1.) * jnp.log((n - m + 1.) / (n - k + 1.)) + \ - (k + 0.5) * (jnp.log((n - k + 1.) / (k + 1.)) + log_p - log1_p) + \ - (stirling_approx_tail(k) - stirling_approx_tail(n - k)) + tr_params.log_h + log_f = ( + (n + 1.0) * jnp.log((n - m + 1.0) / (n - k + 1.0)) + + (k + 0.5) * (jnp.log((n - k + 1.0) / (k + 1.0)) + log_p - log1_p) + + (stirling_approx_tail(k) - stirling_approx_tail(n - k)) + + tr_params.log_h + ) g = (tr_params.a / (0.5 - jnp.abs(u)) ** 2) + tr_params.b return jnp.log((v * tr_params.alpha) / g) <= log_f k, key, u, v = val early_accept = (jnp.abs(u) <= tr_params.u_r) & (v <= tr_params.v_r) early_reject = (k < 0) | (k > n) - return lax.cond(early_accept | early_reject, - (), - lambda _: ~early_accept, - (k, u, v), - lambda x: ~accept_fn(*x)) + return lax.cond( + early_accept | early_reject, + (), + lambda _: ~early_accept, + (k, u, v), + lambda x: ~accept_fn(*x), + ) tr_params = _get_tr_params(n, p) - ret = lax.while_loop(_btrs_cond_fn, _btrs_body_fn, - (-1, key, 1., 1.)) # use k=-1 initially so that cond_fn returns True + ret = lax.while_loop( + _btrs_cond_fn, _btrs_body_fn, (-1, key, 1.0, 1.0) + ) # use k=-1 initially so that cond_fn returns True return ret[0] @@ -117,8 +132,7 @@ def _binom_inv_cond_fn(val): return geom_acc <= n log1_p = jnp.log1p(-p) - ret = lax.while_loop(_binom_inv_cond_fn, _binom_inv_body_fn, - (-1, key, 0.)) + ret = lax.while_loop(_binom_inv_cond_fn, _binom_inv_body_fn, (-1, key, 0.0)) return ret[0] @@ -127,20 +141,24 @@ def dispatch(key, p, n): is_le_mid = p <= 0.5 pq = jnp.where(is_le_mid, p, 1 - p) mu = n * pq - k = lax.cond(mu < 10, - (key, pq, n), - lambda x: _binomial_inversion(*x), - (key, pq, n), - lambda x: _binomial_btrs(*x)) + k = lax.cond( + mu < 10, + (key, pq, n), + lambda x: _binomial_inversion(*x), + (key, pq, n), + lambda x: _binomial_btrs(*x), + ) return jnp.where(is_le_mid, k, n - k) # Return 0 for nan `p` or negative `n`, since nan values are not allowed for integer types cond0 = jnp.isfinite(p) & (n > 0) & (p > 0) - return lax.cond(cond0 & (p < 1), - (key, p, n), - lambda x: dispatch(*x), - (), - lambda _: jnp.where(cond0, n, 0)) + return lax.cond( + cond0 & (p < 1), + (key, p, n), + lambda x: dispatch(*x), + (), + lambda _: jnp.where(cond0, n, 0), + ) @partial(jit, static_argnums=(3,)) @@ -150,9 +168,8 @@ def _binomial(key, p, n, shape): p = jnp.reshape(jnp.broadcast_to(p, shape), -1) n = jnp.reshape(jnp.broadcast_to(n, shape), -1) key = random.split(key, jnp.size(p)) - if jax.default_backend() == 'cpu': - ret = lax.map(lambda x: _binomial_dispatch(*x), - (key, p, n)) + if jax.default_backend() == "cpu": + ret = lax.map(lambda x: _binomial_dispatch(*x), (key, p, n)) else: ret = vmap(lambda *x: _binomial_dispatch(*x))(key, p, n) return jnp.reshape(ret, shape) @@ -179,10 +196,16 @@ def categorical(key, p, shape=()): def _scatter_add_one(operand, indices, updates): - return lax.scatter_add(operand, indices, updates, - lax.ScatterDimensionNumbers(update_window_dims=(), - inserted_window_dims=(0,), - scatter_dims_to_operand_dims=(0,))) + return lax.scatter_add( + operand, + indices, + updates, + lax.ScatterDimensionNumbers( + update_window_dims=(), + inserted_window_dims=(0,), + scatter_dims_to_operand_dims=(0,), + ), + ) @partial(jit, static_argnums=(3, 4)) @@ -196,18 +219,27 @@ def _multinomial(key, p, n, n_max, shape=()): indices = categorical(key, p, (n_max,) + shape) # mask out values when counts is heterogeneous if jnp.ndim(n) > 0: - mask = promote_shapes(jnp.arange(n_max) < jnp.expand_dims(n, -1), shape=shape + (n_max,))[0] + mask = promote_shapes( + jnp.arange(n_max) < jnp.expand_dims(n, -1), shape=shape + (n_max,) + )[0] mask = jnp.moveaxis(mask, -1, 0).astype(indices.dtype) - excess = jnp.concatenate([jnp.expand_dims(n_max - n, -1), jnp.zeros(jnp.shape(n) + (p.shape[-1] - 1,))], -1) + excess = jnp.concatenate( + [ + jnp.expand_dims(n_max - n, -1), + jnp.zeros(jnp.shape(n) + (p.shape[-1] - 1,)), + ], + -1, + ) else: mask = 1 excess = 0 # NB: we transpose to move batch shape to the front - indices_2D = (jnp.reshape(indices * mask, (n_max, -1,))).T - samples_2D = vmap(_scatter_add_one, (0, 0, 0))(jnp.zeros((indices_2D.shape[0], p.shape[-1]), - dtype=indices.dtype), - jnp.expand_dims(indices_2D, axis=-1), - jnp.ones(indices_2D.shape, dtype=indices.dtype)) + indices_2D = (jnp.reshape(indices * mask, (n_max, -1))).T + samples_2D = vmap(_scatter_add_one, (0, 0, 0))( + jnp.zeros((indices_2D.shape[0], p.shape[-1]), dtype=indices.dtype), + jnp.expand_dims(indices_2D, axis=-1), + jnp.ones(indices_2D.shape, dtype=indices.dtype), + ) return jnp.reshape(samples_2D, shape + p.shape[-1:]) - excess @@ -221,7 +253,9 @@ def cholesky_of_inverse(matrix): # which is more numerically stable. # Refer to: # https://nbviewer.jupyter.org/gist/fehiepsi/5ef8e09e61604f10607380467eb82006#Precision-to-scale_tril - tril_inv = jnp.swapaxes(jnp.linalg.cholesky(matrix[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1) + tril_inv = jnp.swapaxes( + jnp.linalg.cholesky(matrix[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1 + ) identity = jnp.broadcast_to(jnp.identity(matrix.shape[-1]), tril_inv.shape) return solve_triangular(tril_inv, identity, lower=True) @@ -247,8 +281,10 @@ def promote_shapes(*args, shape=()): else: shapes = [jnp.shape(arg) for arg in args] num_dims = len(lax.broadcast_shapes(shape, *shapes)) - return [_reshape(arg, (1,) * (num_dims - len(s)) + s) - if len(s) < num_dims else arg for arg, s in zip(args, shapes)] + return [ + _reshape(arg, (1,) * (num_dims - len(s)) + s) if len(s) < num_dims else arg + for arg, s in zip(args, shapes) + ] def sum_rightmost(x, dim): @@ -270,10 +306,16 @@ def vec_to_tril_matrix(t, diagonal=0): n = round((math.sqrt(1 + 8 * t.shape[-1]) - 1) / 2) - diagonal n2 = n * n idx = jnp.reshape(jnp.arange(n2), (n, n))[jnp.tril_indices(n, diagonal)] - x = lax.scatter_add(jnp.zeros(t.shape[:-1] + (n2,)), jnp.expand_dims(idx, axis=-1), t, - lax.ScatterDimensionNumbers(update_window_dims=range(t.ndim - 1), - inserted_window_dims=(t.ndim - 1,), - scatter_dims_to_operand_dims=(t.ndim - 1,))) + x = lax.scatter_add( + jnp.zeros(t.shape[:-1] + (n2,)), + jnp.expand_dims(idx, axis=-1), + t, + lax.ScatterDimensionNumbers( + update_window_dims=range(t.ndim - 1), + inserted_window_dims=(t.ndim - 1,), + scatter_dims_to_operand_dims=(t.ndim - 1,), + ), + ) return jnp.reshape(x, x.shape[:-1] + (n, n)) @@ -308,7 +350,9 @@ def scan_fn(carry, val): return (b, w), (Dj_new, L_j) D, L = jnp.moveaxis(D, -1, 0), jnp.moveaxis(L, -1, 0) # move scan dim to front - _, (D, L) = lax.scan(scan_fn, (jnp.ones(batch_shape), x), (jnp.arange(D.shape[0]), D, L)) + _, (D, L) = lax.scan( + scan_fn, (jnp.ones(batch_shape), x), (jnp.arange(D.shape[0]), D, L) + ) D, L = jnp.moveaxis(D, 0, -1), jnp.moveaxis(L, 0, -1) # move scan dim back return L * jnp.sqrt(D)[..., None, :] @@ -328,8 +372,9 @@ def signed_stick_breaking_tril(t): pad_width = [(0, 0)] * z.ndim pad_width[-1] = (1, 0) - z1m_cumprod_sqrt_shifted = jnp.pad(z1m_cumprod_sqrt[..., :-1], pad_width, - mode="constant", constant_values=1.) + z1m_cumprod_sqrt_shifted = jnp.pad( + z1m_cumprod_sqrt[..., :-1], pad_width, mode="constant", constant_values=1.0 + ) y = (r + jnp.identity(r.shape[-1])) * z1m_cumprod_sqrt_shifted return y @@ -346,7 +391,7 @@ def logmatmulexp(x, y): def clamp_probs(probs): finfo = jnp.finfo(jnp.result_type(probs)) - return jnp.clip(probs, a_min=finfo.tiny, a_max=1. - finfo.eps) + return jnp.clip(probs, a_min=finfo.tiny, a_max=1.0 - finfo.eps) def is_identically_zero(x): @@ -372,18 +417,18 @@ def is_identically_one(x): def von_mises_centered(key, concentration, shape=(), dtype=jnp.float64): - """ Compute centered von Mises samples using rejection sampling from [1] with wrapped Cauchy proposal. + """Compute centered von Mises samples using rejection sampling from [1] with wrapped Cauchy proposal. - *** References *** - [1] Luc Devroye "Non-Uniform Random Variate Generation", Springer-Verlag, 1986; - Chapter 9, p. 473-476. http://www.nrbook.com/devroye/Devroye_files/chapter_nine.pdf + *** References *** + [1] Luc Devroye "Non-Uniform Random Variate Generation", Springer-Verlag, 1986; + Chapter 9, p. 473-476. http://www.nrbook.com/devroye/Devroye_files/chapter_nine.pdf - :param key: random number generator key - :param concentration: concentration of distribution - :param shape: shape of samples - :param dtype: float precesions for choosing correct s cutfoff - :return: centered samples from von Mises + :param key: random number generator key + :param concentration: concentration of distribution + :param shape: shape of samples + :param dtype: float precesions for choosing correct s cutfoff + :return: centered samples from von Mises """ shape = shape or jnp.shape(concentration) dtype = jnp.result_type(dtype) @@ -396,16 +441,18 @@ def von_mises_centered(key, concentration, shape=(), dtype=jnp.float64): def _von_mises_centered(key, concentration, shape, dtype): # Cutoff from TensorFlow probability # (https://github.com/tensorflow/probability/blob/f051e03dd3cc847d31061803c2b31c564562a993/tensorflow_probability/python/distributions/von_mises.py#L567-L570) - s_cutoff_map = {jnp.dtype(jnp.float16): 1.8e-1, - jnp.dtype(jnp.float32): 2e-2, - jnp.dtype(jnp.float64): 1.2e-4} + s_cutoff_map = { + jnp.dtype(jnp.float16): 1.8e-1, + jnp.dtype(jnp.float32): 2e-2, + jnp.dtype(jnp.float64): 1.2e-4, + } s_cutoff = s_cutoff_map.get(dtype) - r = 1. + jnp.sqrt(1. + 4. * concentration ** 2) - rho = (r - jnp.sqrt(2. * r)) / (2. * concentration) - s_exact = (1. + rho ** 2) / (2. * rho) + r = 1.0 + jnp.sqrt(1.0 + 4.0 * concentration ** 2) + rho = (r - jnp.sqrt(2.0 * r)) / (2.0 * concentration) + s_exact = (1.0 + rho ** 2) / (2.0 * rho) - s_approximate = 1. / concentration + s_approximate = 1.0 / concentration s = jnp.where(concentration > s_cutoff, s_exact, s_approximate) @@ -418,16 +465,22 @@ def body_fn(*args): i, key, done, _, w = args[0] uni_ukey, uni_vkey, key = random.split(key, 3) - u = random.uniform(key=uni_ukey, shape=shape, dtype=concentration.dtype, minval=-1., maxval=1.) + u = random.uniform( + key=uni_ukey, + shape=shape, + dtype=concentration.dtype, + minval=-1.0, + maxval=1.0, + ) z = jnp.cos(jnp.pi * u) - w = jnp.where(done, w, (1. + s * z) / (s + z)) # Update where not done + w = jnp.where(done, w, (1.0 + s * z) / (s + z)) # Update where not done y = concentration * (s - w) v = random.uniform(key=uni_vkey, shape=shape, dtype=concentration.dtype) - accept = (y * (2. - y) >= v) | (jnp.log(y / v) + 1. >= y) + accept = (y * (2.0 - y) >= v) | (jnp.log(y / v) + 1.0 >= y) - return i+1, key, accept | done, u, w + return i + 1, key, accept | done, u, w init_done = jnp.zeros(shape, dtype=bool) init_u = jnp.zeros(shape) @@ -436,7 +489,7 @@ def body_fn(*args): _, _, done, u, w = lax.while_loop( cond_fun=cond_fn, body_fun=body_fn, - init_val=(jnp.array(0), key, init_done, init_u, init_w) + init_val=(jnp.array(0), key, init_done, init_u, init_w), ) return jnp.sign(u) * jnp.arccos(w) @@ -453,7 +506,7 @@ def scale_and_mask(x, scale=None, mask=None): if mask is None: return x else: - return jnp.where(mask, x, 0.) + return jnp.where(mask, x, 0.0) # TODO: use funsor implementation @@ -490,7 +543,7 @@ def safe_normalize(x, *, p=2): x = x / jnp.clip(norm, a_min=jnp.finfo(x).tiny) # Avoid the singularity. mask = jnp.all(x == 0, axis=-1, keepdims=True) - x = jnp.where(mask, x.shape[-1] ** (-1/p), x) + x = jnp.where(mask, x.shape[-1] ** (-1 / p), x) return x @@ -553,7 +606,7 @@ def validate_sample(log_prob_fn): def wrapper(self, *args, **kwargs): log_prob = log_prob_fn(self, *args, *kwargs) if self._validate_args: - value = kwargs['value'] if 'value' in kwargs else args[0] + value = kwargs["value"] if "value" in kwargs else args[0] mask = self._validate_sample(value) log_prob = jnp.where(mask, log_prob, -jnp.inf) return log_prob diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index f25dab872..cf444c5db 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -17,53 +17,56 @@ from jax import lax -if 'CI' in os.environ: - DATA_DIR = os.path.expanduser('~/.data') +if "CI" in os.environ: + DATA_DIR = os.path.expanduser("~/.data") else: - DATA_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), - '.data')) + DATA_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), ".data")) os.makedirs(DATA_DIR, exist_ok=True) -dset = namedtuple('dset', ['name', 'urls']) +dset = namedtuple("dset", ["name", "urls"]) -BASEBALL = dset('baseball', [ - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/EfronMorrisBB.txt', -]) +BASEBALL = dset( + "baseball", ["https://d2hg8soec8ck9v.cloudfront.net/datasets/EfronMorrisBB.txt"] +) -COVTYPE = dset('covtype', [ - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/covtype.zip', -]) +COVTYPE = dset( + "covtype", ["https://d2hg8soec8ck9v.cloudfront.net/datasets/covtype.zip"] +) -DIPPER_VOLE = dset('dipper_vole', [ - 'https://github.com/pyro-ppl/datasets/blob/master/dipper_vole.zip?raw=true', -]) +DIPPER_VOLE = dset( + "dipper_vole", + ["https://github.com/pyro-ppl/datasets/blob/master/dipper_vole.zip?raw=true"], +) -MNIST = dset('mnist', [ - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-images-idx3-ubyte.gz', - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-labels-idx1-ubyte.gz', - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/t10k-images-idx3-ubyte.gz', - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/t10k-labels-idx1-ubyte.gz', -]) +MNIST = dset( + "mnist", + [ + "https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-images-idx3-ubyte.gz", + "https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/train-labels-idx1-ubyte.gz", + "https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/t10k-images-idx3-ubyte.gz", + "https://d2hg8soec8ck9v.cloudfront.net/datasets/mnist/t10k-labels-idx1-ubyte.gz", + ], +) -SP500 = dset('SP500', [ - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/SP500.csv', -]) +SP500 = dset("SP500", ["https://d2hg8soec8ck9v.cloudfront.net/datasets/SP500.csv"]) -UCBADMIT = dset('ucbadmit', [ - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/UCBadmit.csv', -]) +UCBADMIT = dset( + "ucbadmit", ["https://d2hg8soec8ck9v.cloudfront.net/datasets/UCBadmit.csv"] +) -LYNXHARE = dset('lynxhare', [ - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/LynxHare.txt', -]) +LYNXHARE = dset( + "lynxhare", ["https://d2hg8soec8ck9v.cloudfront.net/datasets/LynxHare.txt"] +) -JSB_CHORALES = dset('jsb_chorales', [ - 'https://d2hg8soec8ck9v.cloudfront.net/datasets/polyphonic/jsb_chorales.pickle', -]) +JSB_CHORALES = dset( + "jsb_chorales", + ["https://d2hg8soec8ck9v.cloudfront.net/datasets/polyphonic/jsb_chorales.pickle"], +) -HIGGS = dset("higgs", [ - "https://archive.ics.uci.edu/ml/machine-learning-databases/00280/HIGGS.csv.gz", -]) +HIGGS = dset( + "higgs", + ["https://archive.ics.uci.edu/ml/machine-learning-databases/00280/HIGGS.csv.gz"], +) def _download(dset): @@ -71,9 +74,9 @@ def _download(dset): file = os.path.basename(urlparse(url).path) out_path = os.path.join(DATA_DIR, file) if not os.path.exists(out_path): - print('Downloading - {}.'.format(url)) + print("Downloading - {}.".format(url)) urlretrieve(url, out_path) - print('Download complete.') + print("Download complete.") def _load_baseball(): @@ -81,44 +84,49 @@ def _load_baseball(): def train_test_split(file): train, test, player_names = [], [], [] - with open(file, 'r') as f: - csv_reader = csv.DictReader(f, delimiter='\t', quoting=csv.QUOTE_NONE) + with open(file, "r") as f: + csv_reader = csv.DictReader(f, delimiter="\t", quoting=csv.QUOTE_NONE) for row in csv_reader: - player_names.append(row['FirstName'] + ' ' + row['LastName']) - at_bats, hits = row['At-Bats'], row['Hits'] + player_names.append(row["FirstName"] + " " + row["LastName"]) + at_bats, hits = row["At-Bats"], row["Hits"] train.append(np.array([int(at_bats), int(hits)])) - season_at_bats, season_hits = row['SeasonAt-Bats'], row['SeasonHits'] + season_at_bats, season_hits = row["SeasonAt-Bats"], row["SeasonHits"] test.append(np.array([int(season_at_bats), int(season_hits)])) return np.stack(train), np.stack(test), player_names - train, test, player_names = train_test_split(os.path.join(DATA_DIR, 'EfronMorrisBB.txt')) - return {'train': (train, player_names), - 'test': (test, player_names)} + train, test, player_names = train_test_split( + os.path.join(DATA_DIR, "EfronMorrisBB.txt") + ) + return {"train": (train, player_names), "test": (test, player_names)} def _load_covtype(): _download(COVTYPE) - file_path = os.path.join(DATA_DIR, 'covtype.zip') + file_path = os.path.join(DATA_DIR, "covtype.zip") data = np.load(file_path) - return { - 'train': (data['data'], data['target']) - } + return {"train": (data["data"], data["target"])} def _load_dipper_vole(): _download(DIPPER_VOLE) - file_path = os.path.join(DATA_DIR, 'dipper_vole.zip') + file_path = os.path.join(DATA_DIR, "dipper_vole.zip") data = {} with zipfile.ZipFile(file_path) as zipper: - data['dipper'] = ( - np.genfromtxt(zipper.open('dipper_capture_history.csv'), delimiter=',')[:, 1:].astype(int), - np.genfromtxt(zipper.open('dipper_sex.csv'), delimiter=',')[:, 1].astype(int) + data["dipper"] = ( + np.genfromtxt(zipper.open("dipper_capture_history.csv"), delimiter=",")[ + :, 1: + ].astype(int), + np.genfromtxt(zipper.open("dipper_sex.csv"), delimiter=",")[:, 1].astype( + int + ), ) - data['vole'] = ( - np.genfromtxt(zipper.open('meadow_voles_capture_history.csv'), delimiter=',')[:, 1:], + data["vole"] = ( + np.genfromtxt( + zipper.open("meadow_voles_capture_history.csv"), delimiter="," + )[:, 1:], ) return data @@ -128,66 +136,75 @@ def _load_mnist(): _download(MNIST) def read_label(file): - with gzip.open(file, 'rb') as f: + with gzip.open(file, "rb") as f: f.read(8) - data = np.frombuffer(f.read(), dtype=np.int8) / np.float32(255.) + data = np.frombuffer(f.read(), dtype=np.int8) / np.float32(255.0) return data def read_img(file): - with gzip.open(file, 'rb') as f: + with gzip.open(file, "rb") as f: _, _, nrows, ncols = struct.unpack(">IIII", f.read(16)) - data = np.frombuffer(f.read(), dtype=np.uint8) / np.float32(255.) + data = np.frombuffer(f.read(), dtype=np.uint8) / np.float32(255.0) return data.reshape(-1, nrows, ncols) - files = [os.path.join(DATA_DIR, os.path.basename(urlparse(url).path)) - for url in MNIST.urls] - return {'train': (read_img(files[0]), read_label(files[1])), - 'test': (read_img(files[2]), read_label(files[3]))} + files = [ + os.path.join(DATA_DIR, os.path.basename(urlparse(url).path)) + for url in MNIST.urls + ] + return { + "train": (read_img(files[0]), read_label(files[1])), + "test": (read_img(files[2]), read_label(files[3])), + } def _load_sp500(): _download(SP500) date, value = [], [] - with open(os.path.join(DATA_DIR, 'SP500.csv'), 'r') as f: + with open(os.path.join(DATA_DIR, "SP500.csv"), "r") as f: csv_reader = csv.DictReader(f, quoting=csv.QUOTE_NONE) for row in csv_reader: - date.append(row['DATE']) - value.append(float(row['VALUE'])) + date.append(row["DATE"]) + value.append(float(row["VALUE"])) value = np.stack(value) - return {'train': (date, value)} + return {"train": (date, value)} def _load_ucbadmit(): _download(UCBADMIT) dept, male, applications, admit = [], [], [], [] - with open(os.path.join(DATA_DIR, 'UCBadmit.csv')) as f: + with open(os.path.join(DATA_DIR, "UCBadmit.csv")) as f: csv_reader = csv.DictReader( f, - delimiter=';', - fieldnames=['index', 'dept', 'gender', 'admit', 'reject', 'applications'] + delimiter=";", + fieldnames=["index", "dept", "gender", "admit", "reject", "applications"], ) next(csv_reader) # skip the first row for row in csv_reader: - dept.append(ord(row['dept']) - ord('A')) - male.append(row['gender'] == 'male') - applications.append(int(row['applications'])) - admit.append(int(row['admit'])) + dept.append(ord(row["dept"]) - ord("A")) + male.append(row["gender"] == "male") + applications.append(int(row["applications"])) + admit.append(int(row["admit"])) - return {'train': (np.stack(dept), np.stack(male), np.stack(applications), np.stack(admit))} + return { + "train": ( + np.stack(dept), + np.stack(male), + np.stack(applications), + np.stack(admit), + ) + } def _load_lynxhare(): _download(LYNXHARE) - file_path = os.path.join(DATA_DIR, 'LynxHare.txt') + file_path = os.path.join(DATA_DIR, "LynxHare.txt") data = np.loadtxt(file_path) - return { - 'train': (data[:, 0].astype(int), data[:, 1:]) - } + return {"train": (data[:, 0].astype(int), data[:, 1:])} def _pad_sequence(sequences): @@ -204,8 +221,8 @@ def _pad_sequence(sequences): def _load_jsb_chorales(): _download(JSB_CHORALES) - file_path = os.path.join(DATA_DIR, 'jsb_chorales.pickle') - with open(file_path, 'rb') as f: + file_path = os.path.join(DATA_DIR, "jsb_chorales.pickle") + with open(file_path, "rb") as f: data = pickle.load(f) # XXX: we might expose those in `load_dataset` keywords @@ -215,18 +232,18 @@ def _load_jsb_chorales(): for split, data_split in data.items(): processed_dataset[split] = {} n_seqs = len(data_split) - processed_dataset[split]['sequence_lengths'] = np.zeros(n_seqs, dtype=np.long) - processed_dataset[split]['sequences'] = [] + processed_dataset[split]["sequence_lengths"] = np.zeros(n_seqs, dtype=np.long) + processed_dataset[split]["sequences"] = [] for seq in range(n_seqs): seq_length = len(data_split[seq]) - processed_dataset[split]['sequence_lengths'][seq] = seq_length + processed_dataset[split]["sequence_lengths"][seq] = seq_length processed_sequence = np.zeros((seq_length, note_range)) for t in range(seq_length): note_slice = np.array(list(data_split[seq][t])) - min_note slice_length = len(note_slice) if slice_length > 0: processed_sequence[t, note_slice] = np.ones(slice_length) - processed_dataset[split]['sequences'].append(processed_sequence) + processed_dataset[split]["sequences"].append(processed_sequence) for k, v in processed_dataset.items(): lengths = v["sequence_lengths"] @@ -239,9 +256,9 @@ def _load_higgs(num_datapoints): warnings.warn("Higgs is a 2.6 GB dataset") _download(HIGGS) - file_path = os.path.join(DATA_DIR, 'HIGGS.csv.gz') - with io.TextIOWrapper(gzip.open(file_path, 'rb')) as f: - csv_reader = csv.reader(f, delimiter=',', quoting=csv.QUOTE_NONE) + file_path = os.path.join(DATA_DIR, "HIGGS.csv.gz") + with io.TextIOWrapper(gzip.open(file_path, "rb")) as f: + csv_reader = csv.reader(f, delimiter=",", quoting=csv.QUOTE_NONE) obs = [] data = [] for i, row in enumerate(csv_reader): @@ -251,10 +268,12 @@ def _load_higgs(num_datapoints): break obs = np.stack(obs) data = np.stack(data) - n, = obs.shape + (n,) = obs.shape - return {'train': (data[:-(n//20)], obs[:-(n//20)]), - 'test': (data[-(n//20):], obs[-(n//20):])} # standard split -500_000: as test + return { + "train": (data[: -(n // 20)], obs[: -(n // 20)]), + "test": (data[-(n // 20) :], obs[-(n // 20) :]), + } # standard split -500_000: as test def _load(dset, num_datapoints=-1): @@ -276,10 +295,10 @@ def _load(dset, num_datapoints=-1): return _load_jsb_chorales() elif dset == HIGGS: return _load_higgs(num_datapoints) - raise ValueError('Dataset - {} not found.'.format(dset.name)) + raise ValueError("Dataset - {} not found.".format(dset.name)) -def iter_dataset(dset, batch_size=None, split='train', shuffle=True): +def iter_dataset(dset, batch_size=None, split="train", shuffle=True): arrays = _load(dset)[split] num_records = len(arrays[0]) idxs = np.arange(num_records) @@ -293,7 +312,9 @@ def iter_dataset(dset, batch_size=None, split='train', shuffle=True): yield tuple(a[idxs[start_idx:end_idx]] for a in arrays) -def load_dataset(dset, batch_size=None, split='train', shuffle=True, num_datapoints=None): +def load_dataset( + dset, batch_size=None, split="train", shuffle=True, num_datapoints=None +): arrays = _load(dset, num_datapoints)[split] num_records = len(arrays[0]) idxs = np.arange(num_records) @@ -301,11 +322,18 @@ def load_dataset(dset, batch_size=None, split='train', shuffle=True, num_datapoi batch_size = num_records def init(): - return num_records // batch_size, np.random.permutation(idxs) if shuffle else idxs + return ( + num_records // batch_size, + np.random.permutation(idxs) if shuffle else idxs, + ) def get_batch(i=0, idxs=idxs): ret_idx = lax.dynamic_slice_in_dim(idxs, i * batch_size, batch_size) - return tuple(np.take(a, ret_idx, axis=0) if isinstance(a, list) - else lax.index_take(a, (ret_idx,), axes=(0,)) for a in arrays) + return tuple( + np.take(a, ret_idx, axis=0) + if isinstance(a, list) + else lax.index_take(a, (ret_idx,), axes=(0,)) + for a in arrays + ) return init, get_batch diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 8814143e8..cb1ead7ae 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -90,20 +90,20 @@ from numpyro.util import not_jax_tracer __all__ = [ - 'block', - 'collapse', - 'condition', - 'infer_config', - 'lift', - 'mask', - 'reparam', - 'replay', - 'scale', - 'scope', - 'seed', - 'substitute', - 'trace', - 'do' + "block", + "collapse", + "condition", + "infer_config", + "lift", + "mask", + "reparam", + "replay", + "scale", + "scope", + "seed", + "substitute", + "trace", + "do", ] @@ -143,13 +143,16 @@ def __enter__(self): return self.trace def postprocess_message(self, msg): - if 'name' not in msg: + if "name" not in msg: # skip recording helper messages e.g. `control_flow`, `to_data`, `to_funsor` # which has no name return - assert not (msg['type'] == 'sample' and msg['name'] in self.trace), \ - 'all sites must have unique names but got `{}` duplicated'.format(msg['name']) - self.trace[msg['name']] = msg.copy() + assert not ( + msg["type"] == "sample" and msg["name"] in self.trace + ), "all sites must have unique names but got `{}` duplicated".format( + msg["name"] + ) + self.trace[msg["name"]] = msg.copy() def get_trace(self, *args, **kwargs): """ @@ -199,8 +202,8 @@ def __init__(self, fn=None, guide_trace=None): super(replay, self).__init__(fn) def process_message(self, msg): - if msg['type'] in ('sample', 'plate') and msg['name'] in self.guide_trace: - msg['value'] = self.guide_trace[msg['name']]['value'] + if msg["type"] in ("sample", "plate") and msg["name"] in self.guide_trace: + msg["value"] = self.guide_trace[msg["name"]]["value"] class block(Messenger): @@ -241,14 +244,14 @@ def __init__(self, fn=None, hide_fn=None, hide=None): if hide_fn is not None: self.hide_fn = hide_fn elif hide is not None: - self.hide_fn = lambda msg: msg.get('name') in hide + self.hide_fn = lambda msg: msg.get("name") in hide else: self.hide_fn = lambda msg: True super(block, self).__init__(fn) def process_message(self, msg): if self.hide_fn(msg): - msg['stop'] = True + msg["stop"] = True class collapse(trace): @@ -258,12 +261,14 @@ class collapse(trace): fail. Code using the results of sample sites must be written to accept Funsors rather than Tensors. This requires ``funsor`` to be installed. """ + _coerce = None def __init__(self, *args, **kwargs): if collapse._coerce is None: import funsor from funsor.distribution import CoerceDistributionToFunsor + funsor.set_backend("jax") collapse._coerce = CoerceDistributionToFunsor("jax") super().__init__(*args, **kwargs) @@ -279,8 +284,9 @@ def process_message(self, msg): msg["stop"] = True def __enter__(self): - self.preserved_plates = frozenset(h.name for h in _PYRO_STACK - if isinstance(h, plate)) + self.preserved_plates = frozenset( + h.name for h in _PYRO_STACK if isinstance(h, plate) + ) COERCIONS.append(self._coerce) return super().__enter__() @@ -358,27 +364,30 @@ def __init__(self, fn=None, data=None, condition_fn=None): self.condition_fn = condition_fn self.data = data if sum((x is not None for x in (data, condition_fn))) != 1: - raise ValueError('Only one of `data` or `condition_fn` ' - 'should be provided.') + raise ValueError( + "Only one of `data` or `condition_fn` " "should be provided." + ) super(condition, self).__init__(fn) def process_message(self, msg): - if (msg['type'] != 'sample') or msg.get('_control_flow_done', False): - if msg['type'] == 'control_flow': + if (msg["type"] != "sample") or msg.get("_control_flow_done", False): + if msg["type"] == "control_flow": if self.data is not None: - msg['kwargs']['substitute_stack'].append(('condition', self.data)) + msg["kwargs"]["substitute_stack"].append(("condition", self.data)) if self.condition_fn is not None: - msg['kwargs']['substitute_stack'].append(('condition', self.condition_fn)) + msg["kwargs"]["substitute_stack"].append( + ("condition", self.condition_fn) + ) return if self.data is not None: - value = self.data.get(msg['name']) + value = self.data.get(msg["name"]) else: value = self.condition_fn(msg) if value is not None: - msg['value'] = value - msg['is_observed'] = True + msg["value"] = value + msg["is_observed"] = True class infer_config(Messenger): @@ -449,8 +458,10 @@ def process_message(self, msg): msg["type"] = "sample" msg["fn"] = fn msg["args"] = () - msg["kwargs"] = {"rng_key": msg["kwargs"].get("rng_key", None), - "sample_shape": msg["kwargs"].get("sample_shape", ())} + msg["kwargs"] = { + "rng_key": msg["kwargs"].get("rng_key", None), + "sample_shape": msg["kwargs"].get("sample_shape", ()), + } msg["intermediates"] = [] msg["infer"] = msg.get("infer", {}) else: @@ -477,18 +488,20 @@ class mask(Messenger): """ def __init__(self, fn=None, mask=True): - if jnp.result_type(mask) != 'bool': + if jnp.result_type(mask) != "bool": raise ValueError("`mask` should be a bool array.") self.mask = mask super().__init__(fn) def process_message(self, msg): - if msg['type'] != 'sample': + if msg["type"] != "sample": if msg["type"] == "inspect": - msg["mask"] = self.mask if msg["mask"] is None else (self.mask & msg["mask"]) + msg["mask"] = ( + self.mask if msg["mask"] is None else (self.mask & msg["mask"]) + ) return - msg['fn'] = msg['fn'].mask(self.mask) + msg["fn"] = msg["fn"].mask(self.mask) class reparam(Messenger): @@ -535,10 +548,10 @@ def process_message(self, msg): if value is not None: if new_fn is None: - msg['type'] = 'deterministic' - msg['value'] = value + msg["type"] = "deterministic" + msg["value"] = value for key in list(msg.keys()): - if key not in ('type', 'name', 'value'): + if key not in ("type", "name", "value"): del msg[key] return @@ -560,7 +573,7 @@ class scale(Messenger): :type scale: float or numpy.ndarray """ - def __init__(self, fn=None, scale=1.): + def __init__(self, fn=None, scale=1.0): if not_jax_tracer(scale): if np.any(np.less_equal(scale, 0)): raise ValueError("'scale' argument should be positive.") @@ -568,10 +581,12 @@ def __init__(self, fn=None, scale=1.): super().__init__(fn) def process_message(self, msg): - if msg['type'] not in ('param', 'sample', 'plate'): + if msg["type"] not in ("param", "sample", "plate"): return - msg["scale"] = self.scale if msg.get('scale') is None else self.scale * msg['scale'] + msg["scale"] = ( + self.scale if msg.get("scale") is None else self.scale * msg["scale"] + ) class scope(Messenger): @@ -598,14 +613,14 @@ class scope(Messenger): :param str divider: a string to join the prefix and sample name; default to `'/'` """ - def __init__(self, fn=None, prefix='', divider='/'): + def __init__(self, fn=None, prefix="", divider="/"): self.prefix = prefix self.divider = divider super().__init__(fn) def process_message(self, msg): - if msg.get('name'): - msg['name'] = f"{self.prefix}{self.divider}{msg['name']}" + if msg.get("name"): + msg["name"] = f"{self.prefix}{self.divider}{msg['name']}" class seed(Messenger): @@ -651,21 +666,30 @@ class seed(Messenger): """ def __init__(self, fn=None, rng_seed=None): - if isinstance(rng_seed, int) or (isinstance(rng_seed, jnp.ndarray) and not jnp.shape(rng_seed)): + if isinstance(rng_seed, int) or ( + isinstance(rng_seed, jnp.ndarray) and not jnp.shape(rng_seed) + ): rng_seed = random.PRNGKey(rng_seed) - if not (isinstance(rng_seed, jnp.ndarray) and rng_seed.dtype == jnp.uint32 and rng_seed.shape == (2,)): - raise TypeError('Incorrect type for rng_seed: {}'.format(type(rng_seed))) + if not ( + isinstance(rng_seed, jnp.ndarray) + and rng_seed.dtype == jnp.uint32 + and rng_seed.shape == (2,) + ): + raise TypeError("Incorrect type for rng_seed: {}".format(type(rng_seed))) self.rng_key = rng_seed super(seed, self).__init__(fn) def process_message(self, msg): - if (msg['type'] == 'sample' and not msg['is_observed'] and msg['kwargs']['rng_key'] is None) \ - or msg['type'] in ['prng_key', 'plate', 'control_flow']: - if msg['value'] is not None: + if ( + msg["type"] == "sample" + and not msg["is_observed"] + and msg["kwargs"]["rng_key"] is None + ) or msg["type"] in ["prng_key", "plate", "control_flow"]: + if msg["value"] is not None: # no need to create a new key when value is available return self.rng_key, rng_key_sample = random.split(self.rng_key) - msg['kwargs']['rng_key'] = rng_key_sample + msg["kwargs"]["rng_key"] = rng_key_sample class substitute(Messenger): @@ -708,26 +732,31 @@ def __init__(self, fn=None, data=None, substitute_fn=None): self.substitute_fn = substitute_fn self.data = data if sum((x is not None for x in (data, substitute_fn))) != 1: - raise ValueError('Only one of `data` or `substitute_fn` ' - 'should be provided.') + raise ValueError( + "Only one of `data` or `substitute_fn` " "should be provided." + ) super(substitute, self).__init__(fn) def process_message(self, msg): - if (msg['type'] not in ('sample', 'param', 'plate')) or msg.get('_control_flow_done', False): - if msg['type'] == 'control_flow': + if (msg["type"] not in ("sample", "param", "plate")) or msg.get( + "_control_flow_done", False + ): + if msg["type"] == "control_flow": if self.data is not None: - msg['kwargs']['substitute_stack'].append(('substitute', self.data)) + msg["kwargs"]["substitute_stack"].append(("substitute", self.data)) if self.substitute_fn is not None: - msg['kwargs']['substitute_stack'].append(('substitute', self.substitute_fn)) + msg["kwargs"]["substitute_stack"].append( + ("substitute", self.substitute_fn) + ) return if self.data is not None: - value = self.data.get(msg['name']) + value = self.data.get(msg["name"]) else: value = self.substitute_fn(msg) if value is not None: - msg['value'] = value + msg["value"] = value class do(Messenger): @@ -780,23 +809,26 @@ def __init__(self, fn=None, data=None): super(do, self).__init__(fn) def process_message(self, msg): - if msg['type'] != 'sample': + if msg["type"] != "sample": return - if msg.get('_intervener_id', None) != self._intervener_id and \ - self.data.get(msg['name']) is not None: - if msg.get('_intervener_id', None) is not None: + if ( + msg.get("_intervener_id", None) != self._intervener_id + and self.data.get(msg["name"]) is not None + ): + if msg.get("_intervener_id", None) is not None: warnings.warn( "Attempting to intervene on variable {} multiple times," - "this is almost certainly incorrect behavior".format(msg['name']), - RuntimeWarning) - msg['_intervener_id'] = self._intervener_id + "this is almost certainly incorrect behavior".format(msg["name"]), + RuntimeWarning, + ) + msg["_intervener_id"] = self._intervener_id # split node, avoid reapplying self recursively to new node new_msg = msg.copy() apply_stack(new_msg) - intervention = self.data.get(msg['name']) - msg['name'] = msg['name'] + "__CF" # mangle old name - msg['value'] = intervention - msg['is_observed'] = True - msg['stop'] = True + intervention = self.data.get(msg["name"]) + msg["name"] = msg["name"] + "__CF" # mangle old name + msg["value"] = intervention + msg["is_observed"] = True + msg["stop"] = True diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 66857a33a..11fa0a553 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -10,7 +10,7 @@ init_to_median, init_to_sample, init_to_uniform, - init_to_value + init_to_value, ) from numpyro.infer.mcmc import MCMC from numpyro.infer.mixed_hmc import MixedHMC @@ -21,27 +21,27 @@ from . import autoguide, reparam __all__ = [ - 'autoguide', - 'init_to_feasible', - 'init_to_median', - 'init_to_sample', - 'init_to_uniform', - 'init_to_value', - 'log_likelihood', - 'reparam', - 'BarkerMH', - 'DiscreteHMCGibbs', - 'ELBO', - 'HMC', - 'HMCECS', - 'HMCGibbs', - 'MCMC', - 'MixedHMC', - 'NUTS', - 'Predictive', - 'RenyiELBO', - 'SA', - 'SVI', - 'Trace_ELBO', - 'TraceMeanField_ELBO', + "autoguide", + "init_to_feasible", + "init_to_median", + "init_to_sample", + "init_to_uniform", + "init_to_value", + "log_likelihood", + "reparam", + "BarkerMH", + "DiscreteHMCGibbs", + "ELBO", + "HMC", + "HMCECS", + "HMCGibbs", + "MCMC", + "MixedHMC", + "NUTS", + "Predictive", + "RenyiELBO", + "SA", + "SVI", + "Trace_ELBO", + "TraceMeanField_ELBO", ] diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 4ff2885a6..246dd9642 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -17,7 +17,10 @@ from numpyro import handlers import numpyro.distributions as dist from numpyro.distributions import constraints -from numpyro.distributions.flows import BlockNeuralAutoregressiveTransform, InverseAutoregressiveTransform +from numpyro.distributions.flows import ( + BlockNeuralAutoregressiveTransform, + InverseAutoregressiveTransform, +) from numpyro.distributions.transforms import ( AffineTransform, ComposeTransform, @@ -25,9 +28,13 @@ LowerCholeskyAffine, PermuteTransform, UnpackTransform, - biject_to + biject_to, +) +from numpyro.distributions.util import ( + cholesky_of_inverse, + periodic_repeat, + sum_rightmost, ) -from numpyro.distributions.util import cholesky_of_inverse, periodic_repeat, sum_rightmost from numpyro.infer.elbo import Trace_ELBO from numpyro.infer.initialization import init_to_median from numpyro.infer.util import init_to_uniform, initialize_model @@ -36,16 +43,16 @@ from numpyro.util import not_jax_tracer __all__ = [ - 'AutoContinuous', - 'AutoGuide', - 'AutoDiagonalNormal', - 'AutoLaplaceApproximation', - 'AutoLowRankMultivariateNormal', - 'AutoNormal', - 'AutoMultivariateNormal', - 'AutoBNAFNormal', - 'AutoIAFNormal', - 'AutoDelta', + "AutoContinuous", + "AutoGuide", + "AutoDiagonalNormal", + "AutoLaplaceApproximation", + "AutoLowRankMultivariateNormal", + "AutoNormal", + "AutoMultivariateNormal", + "AutoBNAFNormal", + "AutoIAFNormal", + "AutoDelta", ] @@ -65,7 +72,9 @@ class AutoGuide(ABC): automatically as usual. This is useful for data subsampling. """ - def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, create_plates=None): + def __init__( + self, model, *, prefix="auto", init_loc_fn=init_to_uniform, create_plates=None + ): self.model = model self.prefix = prefix self.init_loc_fn = init_loc_fn @@ -81,14 +90,16 @@ def _create_plates(self, *args, **kwargs): plates = self.create_plates(*args, **kwargs) if isinstance(plates, numpyro.plate): plates = [plates] - assert all(isinstance(p, numpyro.plate) for p in plates), \ - "create_plates() returned a non-plate" + assert all( + isinstance(p, numpyro.plate) for p in plates + ), "create_plates() returned a non-plate" self.plates = {p.name: p for p in plates} for name, frame in sorted(self._prototype_frames.items()): if name not in self.plates: full_size = self._prototype_frame_full_sizes[name] - self.plates[name] = numpyro.plate(name, full_size, dim=frame.dim, - subsample_size=frame.size) + self.plates[name] = numpyro.plate( + name, full_size, dim=frame.dim, subsample_size=frame.size + ) return self.plates @abstractmethod @@ -117,12 +128,19 @@ def sample_posterior(self, rng_key, params, *args, **kwargs): def _setup_prototype(self, *args, **kwargs): rng_key = numpyro.prng_key() with handlers.block(): - init_params, _, self._postprocess_fn, self.prototype_trace = initialize_model( - rng_key, self.model, + ( + init_params, + _, + self._postprocess_fn, + self.prototype_trace, + ) = initialize_model( + rng_key, + self.model, init_strategy=self.init_loc_fn, dynamic_args=False, model_args=args, - model_kwargs=kwargs) + model_kwargs=kwargs, + ) self._init_locs = init_params[0] self._prototype_frames = {} @@ -160,15 +178,25 @@ class AutoNormal(AutoGuide): or iterable of plates. Plates not returned will be created automatically as usual. This is useful for data subsampling. """ + # TODO consider switching to constraints.softplus_positive # See https://github.com/pyro-ppl/numpyro/issues/855 scale_constraint = constraints.positive - def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, - create_plates=None): + def __init__( + self, + model, + *, + prefix="auto", + init_loc_fn=init_to_uniform, + init_scale=0.1, + create_plates=None, + ): self._init_scale = init_scale self._event_dims = {} - super().__init__(model, prefix=prefix, init_loc_fn=init_loc_fn, create_plates=create_plates) + super().__init__( + model, prefix=prefix, init_loc_fn=init_loc_fn, create_plates=create_plates + ) def _setup_prototype(self, *args, **kwargs): super()._setup_prototype(*args, **kwargs) @@ -177,7 +205,11 @@ def _setup_prototype(self, *args, **kwargs): if site["type"] != "sample" or site["is_observed"]: continue - event_dim = site["fn"].event_dim + jnp.ndim(self._init_locs[name]) - jnp.ndim(site["value"]) + event_dim = ( + site["fn"].event_dim + + jnp.ndim(self._init_locs[name]) + - jnp.ndim(site["value"]) + ) self._event_dims[name] = event_dim # If subsampling, repeat init_value to full size. @@ -185,7 +217,9 @@ def _setup_prototype(self, *args, **kwargs): full_size = self._prototype_frame_full_sizes[frame.name] if full_size != frame.size: dim = frame.dim - event_dim - self._init_locs[name] = periodic_repeat(self._init_locs[name], full_size, dim) + self._init_locs[name] = periodic_repeat( + self._init_locs[name], full_size, dim + ) def __call__(self, *args, **kwargs): """ @@ -210,20 +244,24 @@ def __call__(self, *args, **kwargs): for frame in site["cond_indep_stack"]: stack.enter_context(plates[frame.name]) - site_loc = numpyro.param("{}_{}_loc".format(name, self.prefix), init_loc, - event_dim=event_dim) - site_scale = numpyro.param("{}_{}_scale".format(name, self.prefix), - jnp.full(jnp.shape(init_loc), self._init_scale), - constraint=self.scale_constraint, - event_dim=event_dim) + site_loc = numpyro.param( + "{}_{}_loc".format(name, self.prefix), init_loc, event_dim=event_dim + ) + site_scale = numpyro.param( + "{}_{}_scale".format(name, self.prefix), + jnp.full(jnp.shape(init_loc), self._init_scale), + constraint=self.scale_constraint, + event_dim=event_dim, + ) site_fn = dist.Normal(site_loc, site_scale).to_event(event_dim) - if site["fn"].support is constraints.real \ - or (isinstance(site["fn"].support, constraints.independent) and - site["fn"].support is constraints.real): + if site["fn"].support is constraints.real or ( + isinstance(site["fn"].support, constraints.independent) + and site["fn"].support is constraints.real + ): result[name] = numpyro.sample(name, site_fn) else: - transform = biject_to(site['fn'].support) + transform = biject_to(site["fn"].support) guide_dist = dist.TransformedDistribution(site_fn, transform) result[name] = numpyro.sample(name, guide_dist) @@ -232,13 +270,18 @@ def __call__(self, *args, **kwargs): def _constrain(self, latent_samples): name = list(latent_samples)[0] sample_shape = jnp.shape(latent_samples[name])[ - :jnp.ndim(latent_samples[name]) - jnp.ndim(self._init_locs[name])] + : jnp.ndim(latent_samples[name]) - jnp.ndim(self._init_locs[name]) + ] if sample_shape: - flatten_samples = tree_map(lambda x: jnp.reshape(x, (-1,) + jnp.shape(x)[len(sample_shape):]), - latent_samples) + flatten_samples = tree_map( + lambda x: jnp.reshape(x, (-1,) + jnp.shape(x)[len(sample_shape) :]), + latent_samples, + ) contrained_samples = lax.map(self._postprocess_fn, flatten_samples) - return tree_map(lambda x: jnp.reshape(x, sample_shape + jnp.shape(x)[1:]), - contrained_samples) + return tree_map( + lambda x: jnp.reshape(x, sample_shape + jnp.shape(x)[1:]), + contrained_samples, + ) else: return self._postprocess_fn(latent_samples) @@ -248,11 +291,16 @@ def sample_posterior(self, rng_key, params, sample_shape=()): with handlers.seed(rng_seed=rng_key): latent_samples = {} for k in locs: - latent_samples[k] = numpyro.sample(k, dist.Normal(locs[k], scales[k]).expand_by(sample_shape)) + latent_samples[k] = numpyro.sample( + k, dist.Normal(locs[k], scales[k]).expand_by(sample_shape) + ) return self._constrain(latent_samples) def median(self, params): - locs = {k: params["{}_{}_loc".format(k, self.prefix)] for k, v in self._init_locs.items()} + locs = { + k: params["{}_{}_loc".format(k, self.prefix)] + for k, v in self._init_locs.items() + } return self._constrain(locs) def quantiles(self, params, quantiles): @@ -285,16 +333,22 @@ class AutoDelta(AutoGuide): or iterable of plates. Plates not returned will be created automatically as usual. This is useful for data subsampling. """ - def __init__(self, model, *, prefix='auto', init_loc_fn=init_to_median, - create_plates=None): + + def __init__( + self, model, *, prefix="auto", init_loc_fn=init_to_median, create_plates=None + ): self._event_dims = {} - super().__init__(model, prefix=prefix, init_loc_fn=init_loc_fn, create_plates=create_plates) + super().__init__( + model, prefix=prefix, init_loc_fn=init_loc_fn, create_plates=create_plates + ) def _setup_prototype(self, *args, **kwargs): super()._setup_prototype(*args, **kwargs) with numpyro.handlers.block(): self._init_locs = { - k: v for k, v in self._postprocess_fn(self._init_locs).items() if k in self._init_locs + k: v + for k, v in self._postprocess_fn(self._init_locs).items() + if k in self._init_locs } for name, site in self.prototype_trace.items(): if site["type"] != "sample" or site["is_observed"]: @@ -308,7 +362,9 @@ def _setup_prototype(self, *args, **kwargs): full_size = self._prototype_frame_full_sizes[frame.name] if full_size != frame.size: dim = frame.dim - event_dim - self._init_locs[name] = periodic_repeat(self._init_locs[name], full_size, dim) + self._init_locs[name] = periodic_repeat( + self._init_locs[name], full_size, dim + ) def __call__(self, *args, **kwargs): if self.prototype_trace is None: @@ -327,9 +383,12 @@ def __call__(self, *args, **kwargs): for frame in site["cond_indep_stack"]: stack.enter_context(plates[frame.name]) - site_loc = numpyro.param("{}_{}_loc".format(name, self.prefix), init_loc, - constraint=site['fn'].support, - event_dim=event_dim) + site_loc = numpyro.param( + "{}_{}_loc".format(name, self.prefix), + init_loc, + constraint=site["fn"].support, + event_dim=event_dim, + ) site_fn = dist.Delta(site_loc).to_event(event_dim) result[name] = numpyro.sample(name, site_fn) @@ -375,6 +434,7 @@ class AutoContinuous(AutoGuide): :param callable init_loc_fn: A per-site initialization function. See :ref:`init_strategy` section for available functions. """ + def _setup_prototype(self, *args, **kwargs): super()._setup_prototype(*args, **kwargs) self._init_latent, unpack_latent = ravel_pytree(self._init_locs) @@ -383,18 +443,24 @@ def _setup_prototype(self, *args, **kwargs): self._unpack_latent = UnpackTransform(unpack_latent) self.latent_dim = jnp.size(self._init_latent) if self.latent_dim == 0: - raise RuntimeError('{} found no latent variables; Use an empty guide instead' - .format(type(self).__name__)) + raise RuntimeError( + "{} found no latent variables; Use an empty guide instead".format( + type(self).__name__ + ) + ) @abstractmethod def _get_posterior(self): raise NotImplementedError def _sample_latent(self, *args, **kwargs): - sample_shape = kwargs.pop('sample_shape', ()) + sample_shape = kwargs.pop("sample_shape", ()) posterior = self._get_posterior() - return numpyro.sample("_{}_latent".format(self.prefix), posterior.expand_by(sample_shape), - infer={"is_auxiliary": True}) + return numpyro.sample( + "_{}_latent".format(self.prefix), + posterior.expand_by(sample_shape), + infer={"is_auxiliary": True}, + ) def __call__(self, *args, **kwargs): """ @@ -414,16 +480,21 @@ def __call__(self, *args, **kwargs): for name, unconstrained_value in self._unpack_latent(latent).items(): site = self.prototype_trace[name] - transform = biject_to(site['fn'].support) + transform = biject_to(site["fn"].support) value = transform(unconstrained_value) if numpyro.get_mask() is False: - log_density = 0. + log_density = 0.0 else: - log_density = - transform.log_abs_det_jacobian(unconstrained_value, value) - event_ndim = site['fn'].event_dim - log_density = sum_rightmost(log_density, - jnp.ndim(log_density) - jnp.ndim(value) + event_ndim) - delta_dist = dist.Delta(value, log_density=log_density, event_dim=event_ndim) + log_density = -transform.log_abs_det_jacobian( + unconstrained_value, value + ) + event_ndim = site["fn"].event_dim + log_density = sum_rightmost( + log_density, jnp.ndim(log_density) - jnp.ndim(value) + event_ndim + ) + delta_dist = dist.Delta( + value, log_density=log_density, event_dim=event_ndim + ) result[name] = numpyro.sample(name, delta_dist) return result @@ -432,19 +503,33 @@ def _unpack_and_constrain(self, latent_sample, params): def unpack_single_latent(latent): unpacked_samples = self._unpack_latent(latent) # XXX: we need to add param here to be able to replay model - unpacked_samples.update({k: v for k, v in params.items() if k in self.prototype_trace - and self.prototype_trace[k]['type'] == 'param'}) + unpacked_samples.update( + { + k: v + for k, v in params.items() + if k in self.prototype_trace + and self.prototype_trace[k]["type"] == "param" + } + ) samples = self._postprocess_fn(unpacked_samples) # filter out param sites - return {k: v for k, v in samples.items() if k in self.prototype_trace - and self.prototype_trace[k]['type'] != 'param'} + return { + k: v + for k, v in samples.items() + if k in self.prototype_trace + and self.prototype_trace[k]["type"] != "param" + } sample_shape = jnp.shape(latent_sample)[:-1] if sample_shape: - latent_sample = jnp.reshape(latent_sample, (-1, jnp.shape(latent_sample)[-1])) + latent_sample = jnp.reshape( + latent_sample, (-1, jnp.shape(latent_sample)[-1]) + ) unpacked_samples = lax.map(unpack_single_latent, latent_sample) - return tree_map(lambda x: jnp.reshape(x, sample_shape + jnp.shape(x)[1:]), - unpacked_samples) + return tree_map( + lambda x: jnp.reshape(x, sample_shape + jnp.shape(x)[1:]), + unpacked_samples, + ) else: return unpack_single_latent(latent_sample) @@ -468,8 +553,9 @@ def get_transform(self, params): :rtype: :class:`~numpyro.distributions.transforms.Transform` """ posterior = handlers.substitute(self._get_posterior, params)() - assert isinstance(posterior, dist.TransformedDistribution), \ - "posterior is not a transformed distribution" + assert isinstance( + posterior, dist.TransformedDistribution + ), "posterior is not a transformed distribution" if len(posterior.transforms) > 0: return ComposeTransform(posterior.transforms) else: @@ -500,7 +586,8 @@ def sample_posterior(self, rng_key, params, sample_shape=()): :rtype: dict """ latent_sample = handlers.substitute( - handlers.seed(self._sample_latent, rng_key), params)(sample_shape=sample_shape) + handlers.seed(self._sample_latent, rng_key), params + )(sample_shape=sample_shape) return self._unpack_and_constrain(latent_sample, params) def median(self, params): @@ -542,34 +629,47 @@ class AutoDiagonalNormal(AutoContinuous): guide = AutoDiagonalNormal(model, ...) svi = SVI(model, guide, ...) """ + # TODO consider switching to constraints.softplus_positive # See https://github.com/pyro-ppl/numpyro/issues/855 scale_constraint = constraints.positive - def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, - init_strategy=None): + def __init__( + self, + model, + *, + prefix="auto", + init_loc_fn=init_to_uniform, + init_scale=0.1, + init_strategy=None, + ): if init_strategy is not None: init_loc_fn = init_strategy - warnings.warn("`init_strategy` argument has been deprecated in favor of `init_loc_fn`" - " argument.", FutureWarning) + warnings.warn( + "`init_strategy` argument has been deprecated in favor of `init_loc_fn`" + " argument.", + FutureWarning, + ) if init_scale <= 0: raise ValueError("Expected init_scale > 0. but got {}".format(init_scale)) self._init_scale = init_scale super().__init__(model, prefix=prefix, init_loc_fn=init_loc_fn) def _get_posterior(self): - loc = numpyro.param('{}_loc'.format(self.prefix), self._init_latent) - scale = numpyro.param('{}_scale'.format(self.prefix), - jnp.full(self.latent_dim, self._init_scale), - constraint=self.scale_constraint) + loc = numpyro.param("{}_loc".format(self.prefix), self._init_latent) + scale = numpyro.param( + "{}_scale".format(self.prefix), + jnp.full(self.latent_dim, self._init_scale), + constraint=self.scale_constraint, + ) return dist.Normal(loc, scale) def get_base_dist(self): return dist.Normal(jnp.zeros(self.latent_dim), 1).to_event(1) def get_transform(self, params): - loc = params['{}_loc'.format(self.prefix)] - scale = params['{}_scale'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] + scale = params["{}_scale".format(self.prefix)] return IndependentTransform(AffineTransform(loc, scale), 1) def get_posterior(self, params): @@ -580,7 +680,7 @@ def get_posterior(self, params): return dist.Normal(transform.loc, transform.scale) def median(self, params): - loc = params['{}_loc'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] return self._unpack_and_constrain(loc, params) def quantiles(self, params, quantiles): @@ -600,34 +700,47 @@ class AutoMultivariateNormal(AutoContinuous): guide = AutoMultivariateNormal(model, ...) svi = SVI(model, guide, ...) """ + # TODO consider switching to constraints.softplus_lower_cholesky # See https://github.com/pyro-ppl/numpyro/issues/855 scale_tril_constraint = constraints.lower_cholesky - def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, - init_strategy=None): + def __init__( + self, + model, + *, + prefix="auto", + init_loc_fn=init_to_uniform, + init_scale=0.1, + init_strategy=None, + ): if init_strategy is not None: init_loc_fn = init_strategy - warnings.warn("`init_strategy` argument has been deprecated in favor of `init_loc_fn`" - " argument.", FutureWarning) + warnings.warn( + "`init_strategy` argument has been deprecated in favor of `init_loc_fn`" + " argument.", + FutureWarning, + ) if init_scale <= 0: raise ValueError("Expected init_scale > 0. but got {}".format(init_scale)) self._init_scale = init_scale super().__init__(model, prefix=prefix, init_loc_fn=init_loc_fn) def _get_posterior(self): - loc = numpyro.param('{}_loc'.format(self.prefix), self._init_latent) - scale_tril = numpyro.param('{}_scale_tril'.format(self.prefix), - jnp.identity(self.latent_dim) * self._init_scale, - constraint=self.scale_tril_constraint) + loc = numpyro.param("{}_loc".format(self.prefix), self._init_latent) + scale_tril = numpyro.param( + "{}_scale_tril".format(self.prefix), + jnp.identity(self.latent_dim) * self._init_scale, + constraint=self.scale_tril_constraint, + ) return dist.MultivariateNormal(loc, scale_tril=scale_tril) def get_base_dist(self): return dist.Normal(jnp.zeros(self.latent_dim), 1).to_event(1) def get_transform(self, params): - loc = params['{}_loc'.format(self.prefix)] - scale_tril = params['{}_scale_tril'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] + scale_tril = params["{}_scale_tril".format(self.prefix)] return LowerCholeskyAffine(loc, scale_tril) def get_posterior(self, params): @@ -638,13 +751,15 @@ def get_posterior(self, params): return dist.MultivariateNormal(transform.loc, transform.scale_tril) def median(self, params): - loc = params['{}_loc'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] return self._unpack_and_constrain(loc, params) def quantiles(self, params, quantiles): transform = self.get_transform(params) quantiles = jnp.array(quantiles)[..., None] - latent = dist.Normal(transform.loc, jnp.diagonal(transform.scale_tril)).icdf(quantiles) + latent = dist.Normal(transform.loc, jnp.diagonal(transform.scale_tril)).icdf( + quantiles + ) return self._unpack_and_constrain(latent, params) @@ -659,30 +774,47 @@ class AutoLowRankMultivariateNormal(AutoContinuous): guide = AutoLowRankMultivariateNormal(model, rank=2, ...) svi = SVI(model, guide, ...) """ + # TODO consider switching to constraints.softplus_positive # See https://github.com/pyro-ppl/numpyro/issues/855 scale_constraint = constraints.positive - def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, init_scale=0.1, - rank=None, init_strategy=None): + def __init__( + self, + model, + *, + prefix="auto", + init_loc_fn=init_to_uniform, + init_scale=0.1, + rank=None, + init_strategy=None, + ): if init_strategy is not None: init_loc_fn = init_strategy - warnings.warn("`init_strategy` argument has been deprecated in favor of `init_loc_fn`" - " argument.", FutureWarning) + warnings.warn( + "`init_strategy` argument has been deprecated in favor of `init_loc_fn`" + " argument.", + FutureWarning, + ) if init_scale <= 0: raise ValueError("Expected init_scale > 0. but got {}".format(init_scale)) self._init_scale = init_scale self.rank = rank super(AutoLowRankMultivariateNormal, self).__init__( - model, prefix=prefix, init_loc_fn=init_loc_fn) + model, prefix=prefix, init_loc_fn=init_loc_fn + ) def _get_posterior(self, *args, **kwargs): rank = int(round(self.latent_dim ** 0.5)) if self.rank is None else self.rank - loc = numpyro.param('{}_loc'.format(self.prefix), self._init_latent) - cov_factor = numpyro.param('{}_cov_factor'.format(self.prefix), jnp.zeros((self.latent_dim, rank))) - scale = numpyro.param('{}_scale'.format(self.prefix), - jnp.full(self.latent_dim, self._init_scale), - constraint=self.scale_constraint) + loc = numpyro.param("{}_loc".format(self.prefix), self._init_latent) + cov_factor = numpyro.param( + "{}_cov_factor".format(self.prefix), jnp.zeros((self.latent_dim, rank)) + ) + scale = numpyro.param( + "{}_scale".format(self.prefix), + jnp.full(self.latent_dim, self._init_scale), + constraint=self.scale_constraint, + ) cov_diag = scale * scale cov_factor = cov_factor * scale[..., None] return dist.LowRankMultivariateNormal(loc, cov_factor, cov_diag) @@ -698,21 +830,21 @@ def get_posterior(self, params): """ Returns a lowrank multivariate Normal posterior distribution. """ - loc = params['{}_loc'.format(self.prefix)] - cov_factor = params['{}_cov_factor'.format(self.prefix)] - scale = params['{}_scale'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] + cov_factor = params["{}_cov_factor".format(self.prefix)] + scale = params["{}_scale".format(self.prefix)] cov_diag = scale * scale cov_factor = cov_factor * scale[..., None] return dist.LowRankMultivariateNormal(loc, cov_factor, cov_diag) def median(self, params): - loc = params['{}_loc'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] return self._unpack_and_constrain(loc, params) def quantiles(self, params, quantiles): - loc = params[f'{self.prefix}_loc'] - cov_factor = params[f'{self.prefix}_cov_factor'] - scale = params[f'{self.prefix}_scale'] + loc = params[f"{self.prefix}_loc"] + cov_factor = params[f"{self.prefix}_cov_factor"] + scale = params[f"{self.prefix}_scale"] scale = scale * jnp.sqrt(jnp.square(cov_factor).sum(-1) + 1) quantiles = jnp.array(quantiles)[..., None] latent = dist.Normal(loc, scale).icdf(quantiles) @@ -733,18 +865,21 @@ class AutoLaplaceApproximation(AutoContinuous): guide = AutoLaplaceApproximation(model, ...) svi = SVI(model, guide, ...) """ + def _setup_prototype(self, *args, **kwargs): super(AutoLaplaceApproximation, self)._setup_prototype(*args, **kwargs) def loss_fn(params): # we are doing maximum likelihood, so only require `num_particles=1` and an arbitrary rng_key. - return Trace_ELBO().loss(random.PRNGKey(0), params, self.model, self, *args, **kwargs) + return Trace_ELBO().loss( + random.PRNGKey(0), params, self.model, self, *args, **kwargs + ) self._loss_fn = loss_fn def _get_posterior(self, *args, **kwargs): # sample from Delta guide - loc = numpyro.param('{}_loc'.format(self.prefix), self._init_latent) + loc = numpyro.param("{}_loc".format(self.prefix), self._init_latent) return dist.Delta(loc, event_dim=1) def get_base_dist(self): @@ -753,18 +888,20 @@ def get_base_dist(self): def get_transform(self, params): def loss_fn(z): params1 = params.copy() - params1['{}_loc'.format(self.prefix)] = z + params1["{}_loc".format(self.prefix)] = z return self._loss_fn(params1) - loc = params['{}_loc'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] precision = hessian(loss_fn)(loc) scale_tril = cholesky_of_inverse(precision) if not_jax_tracer(scale_tril): if np.any(np.isnan(scale_tril)): - warnings.warn("Hessian of log posterior at the MAP point is singular. Posterior" - " samples from AutoLaplaceApproxmiation will be constant (equal to" - " the MAP point).") - scale_tril = jnp.where(jnp.isnan(scale_tril), 0., scale_tril) + warnings.warn( + "Hessian of log posterior at the MAP point is singular. Posterior" + " samples from AutoLaplaceApproxmiation will be constant (equal to" + " the MAP point)." + ) + scale_tril = jnp.where(jnp.isnan(scale_tril), 0.0, scale_tril) return LowerCholeskyAffine(loc, scale_tril) def get_posterior(self, params): @@ -779,13 +916,15 @@ def sample_posterior(self, rng_key, params, sample_shape=()): return self._unpack_and_constrain(latent_sample, params) def median(self, params): - loc = params['{}_loc'.format(self.prefix)] + loc = params["{}_loc".format(self.prefix)] return self._unpack_and_constrain(loc, params) def quantiles(self, params, quantiles): transform = self.get_transform(params) quantiles = jnp.array(quantiles)[..., None] - latent = dist.Normal(transform.loc, jnp.diagonal(transform.scale_tril)).icdf(quantiles) + latent = dist.Normal(transform.loc, jnp.diagonal(transform.scale_tril)).icdf( + quantiles + ) return self._unpack_and_constrain(latent, params) @@ -813,13 +952,26 @@ class AutoIAFNormal(AutoContinuous): :param callable nonlinearity: the nonlinearity to use in the feedforward network. Defaults to :func:`jax.experimental.stax.Elu`. """ - def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, - num_flows=3, hidden_dims=None, skip_connections=False, nonlinearity=stax.Elu, - init_strategy=None): + + def __init__( + self, + model, + *, + prefix="auto", + init_loc_fn=init_to_uniform, + num_flows=3, + hidden_dims=None, + skip_connections=False, + nonlinearity=stax.Elu, + init_strategy=None, + ): if init_strategy is not None: init_loc_fn = init_strategy - warnings.warn("`init_strategy` argument has been deprecated in favor of `init_loc_fn`" - " argument.", FutureWarning) + warnings.warn( + "`init_strategy` argument has been deprecated in favor of `init_loc_fn`" + " argument.", + FutureWarning, + ) self.num_flows = num_flows # 2-layer, stax.Elu, skip_connections=False by default following the experiments in # IAF paper (https://arxiv.org/abs/1606.04934) @@ -827,21 +979,34 @@ def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, self._hidden_dims = hidden_dims self._skip_connections = skip_connections self._nonlinearity = nonlinearity - super(AutoIAFNormal, self).__init__(model, prefix=prefix, init_loc_fn=init_loc_fn) + super(AutoIAFNormal, self).__init__( + model, prefix=prefix, init_loc_fn=init_loc_fn + ) def _get_posterior(self): if self.latent_dim == 1: - raise ValueError('latent dim = 1. Consider using AutoDiagonalNormal instead') - hidden_dims = [self.latent_dim, self.latent_dim] if self._hidden_dims is None else self._hidden_dims + raise ValueError( + "latent dim = 1. Consider using AutoDiagonalNormal instead" + ) + hidden_dims = ( + [self.latent_dim, self.latent_dim] + if self._hidden_dims is None + else self._hidden_dims + ) flows = [] for i in range(self.num_flows): if i > 0: flows.append(PermuteTransform(jnp.arange(self.latent_dim)[::-1])) - arn = AutoregressiveNN(self.latent_dim, hidden_dims, - permutation=jnp.arange(self.latent_dim), - skip_connections=self._skip_connections, - nonlinearity=self._nonlinearity) - arnn = numpyro.module('{}_arn__{}'.format(self.prefix, i), arn, (self.latent_dim,)) + arn = AutoregressiveNN( + self.latent_dim, + hidden_dims, + permutation=jnp.arange(self.latent_dim), + skip_connections=self._skip_connections, + nonlinearity=self._nonlinearity, + ) + arnn = numpyro.module( + "{}_arn__{}".format(self.prefix, i), arn, (self.latent_dim,) + ) flows.append(InverseAutoregressiveTransform(arnn)) return dist.TransformedDistribution(self.get_base_dist(), flows) @@ -875,26 +1040,46 @@ class AutoBNAFNormal(AutoContinuous): input dimension. This corresponds to both :math:`a` and :math:`b` in reference [1]. The elements of hidden_factors must be integers. """ - def __init__(self, model, *, prefix="auto", init_loc_fn=init_to_uniform, num_flows=1, - hidden_factors=[8, 8], init_strategy=None): + + def __init__( + self, + model, + *, + prefix="auto", + init_loc_fn=init_to_uniform, + num_flows=1, + hidden_factors=[8, 8], + init_strategy=None, + ): if init_strategy is not None: init_loc_fn = init_strategy - warnings.warn("`init_strategy` argument has been deprecated in favor of `init_loc_fn`" - " argument.", FutureWarning) + warnings.warn( + "`init_strategy` argument has been deprecated in favor of `init_loc_fn`" + " argument.", + FutureWarning, + ) self.num_flows = num_flows self._hidden_factors = hidden_factors - super(AutoBNAFNormal, self).__init__(model, prefix=prefix, init_loc_fn=init_loc_fn) + super(AutoBNAFNormal, self).__init__( + model, prefix=prefix, init_loc_fn=init_loc_fn + ) def _get_posterior(self): if self.latent_dim == 1: - raise ValueError('latent dim = 1. Consider using AutoDiagonalNormal instead') + raise ValueError( + "latent dim = 1. Consider using AutoDiagonalNormal instead" + ) flows = [] for i in range(self.num_flows): if i > 0: flows.append(PermuteTransform(jnp.arange(self.latent_dim)[::-1])) residual = "gated" if i < (self.num_flows - 1) else None - arn = BlockNeuralAutoregressiveNN(self.latent_dim, self._hidden_factors, residual) - arnn = numpyro.module('{}_arn__{}'.format(self.prefix, i), arn, (self.latent_dim,)) + arn = BlockNeuralAutoregressiveNN( + self.latent_dim, self._hidden_factors, residual + ) + arnn = numpyro.module( + "{}_arn__{}".format(self.prefix, i), arn, (self.latent_dim,) + ) flows.append(BlockNeuralAutoregressiveTransform(arnn)) return dist.TransformedDistribution(self.get_base_dist(), flows) diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py index 4e4691fd4..2649184a3 100644 --- a/numpyro/infer/barker.py +++ b/numpyro/infer/barker.py @@ -16,8 +16,19 @@ from numpyro.infer.util import initialize_model from numpyro.util import identity -BarkerMHState = namedtuple("BarkerMHState", [ - "i", "z", "potential_energy", "z_grad", "accept_prob", "mean_accept_prob", "adapt_state", "rng_key"]) +BarkerMHState = namedtuple( + "BarkerMHState", + [ + "i", + "z", + "potential_energy", + "z_grad", + "accept_prob", + "mean_accept_prob", + "adapt_state", + "rng_key", + ], +) """ A :func:`~collections.namedtuple` consisting of the following fields: @@ -99,11 +110,20 @@ class BarkerMH(MCMCKernel): >>> mcmc.run(jax.random.PRNGKey(0)) >>> mcmc.print_summary() # doctest: +SKIP """ - def __init__(self, model=None, potential_fn=None, step_size=1.0, - adapt_step_size=True, adapt_mass_matrix=True, dense_mass=False, - target_accept_prob=0.4, init_strategy=init_to_uniform): + + def __init__( + self, + model=None, + potential_fn=None, + step_size=1.0, + adapt_step_size=True, + adapt_mass_matrix=True, + dense_mass=False, + target_accept_prob=0.4, + init_strategy=init_to_uniform, + ): if not (model is None) ^ (potential_fn is None): - raise ValueError('Only one of `model` or `potential_fn` must be specified.') + raise ValueError("Only one of `model` or `potential_fn` must be specified.") self._model = model self._potential_fn = potential_fn self._step_size = step_size @@ -119,21 +139,28 @@ def model(self): @property def sample_field(self): - return 'z' + return "z" def get_diagnostics_str(self, state): - return 'step size {:.2e}. acc. prob={:.2f}'.format(state.adapt_state.step_size, - state.mean_accept_prob) + return "step size {:.2e}. acc. prob={:.2f}".format( + state.adapt_state.step_size, state.mean_accept_prob + ) def _init_state(self, rng_key, model_args, model_kwargs, init_params): if self._model is not None: - params_info, potential_fn_gen, self._postprocess_fn, model_trace = initialize_model( + ( + params_info, + potential_fn_gen, + self._postprocess_fn, + model_trace, + ) = initialize_model( rng_key, self._model, dynamic_args=True, init_strategy=self._init_strategy, model_args=model_args, - model_kwargs=model_kwargs) + model_kwargs=model_kwargs, + ) init_params = params_info[0] model_kwargs = {} if model_kwargs is None else model_kwargs self._potential_fn = potential_fn_gen(*model_args, **model_kwargs) @@ -142,14 +169,19 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): self._num_warmup = num_warmup # TODO (low-priority): support chain_method="vectorized", i.e. rng_key is a batch of keys - assert rng_key.shape == (2,), ("BarkerMH only supports chain_method='parallel' or chain_method='sequential'." - " Please put in a feature request if you think it would be useful to be able " - "to use BarkerMH in vectorized mode.") + assert rng_key.shape == (2,), ( + "BarkerMH only supports chain_method='parallel' or chain_method='sequential'." + " Please put in a feature request if you think it would be useful to be able " + "to use BarkerMH in vectorized mode." + ) rng_key, rng_key_init_model, rng_key_wa = random.split(rng_key, 3) - init_params = self._init_state(rng_key_init_model, model_args, model_kwargs, init_params) + init_params = self._init_state( + rng_key_init_model, model_args, model_kwargs, init_params + ) if self._potential_fn and init_params is None: - raise ValueError('Valid value of `init_params` must be provided with' - ' `potential_fn`.') + raise ValueError( + "Valid value of `init_params` must be provided with" " `potential_fn`." + ) pe, grad = jax.value_and_grad(self._potential_fn)(init_params) @@ -158,12 +190,23 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): adapt_step_size=self._adapt_step_size, adapt_mass_matrix=self._adapt_mass_matrix, dense_mass=self._dense_mass, - target_accept_prob=self._target_accept_prob) + target_accept_prob=self._target_accept_prob, + ) size = len(ravel_pytree(init_params)[0]) - wa_state = wa_init((init_params,), rng_key_wa, self._step_size, mass_matrix_size=size) + wa_state = wa_init( + (init_params,), rng_key_wa, self._step_size, mass_matrix_size=size + ) wa_state = wa_state._replace(rng_key=None) - init_state = BarkerMHState(jnp.array(0), init_params, pe, grad, jnp.zeros(()), - jnp.zeros(()), wa_state, rng_key) + init_state = BarkerMHState( + jnp.array(0), + init_params, + pe, + grad, + jnp.zeros(()), + jnp.zeros(()), + wa_state, + rng_key, + ) return jax.device_put(init_state) def postprocess_fn(self, args, kwargs): @@ -180,41 +223,65 @@ def sample(self, state, model_args, model_kwargs): mass_sqrt_inv = adapt_state.mass_matrix_sqrt_inv - x_grad_flat_scaled = mass_sqrt_inv @ x_grad_flat if self._dense_mass else mass_sqrt_inv * x_grad_flat + x_grad_flat_scaled = ( + mass_sqrt_inv @ x_grad_flat + if self._dense_mass + else mass_sqrt_inv * x_grad_flat + ) # Generate proposal y. z = adapt_state.step_size * random.normal(key_normal, shape) p = expit(-z * x_grad_flat_scaled) - b = jnp.where(random.uniform(key_bernoulli, shape) < p, 1., -1.) + b = jnp.where(random.uniform(key_bernoulli, shape) < p, 1.0, -1.0) dx_flat = b * z - dx_flat_scaled = mass_sqrt_inv.T @ dx_flat if self._dense_mass else mass_sqrt_inv * dx_flat + dx_flat_scaled = ( + mass_sqrt_inv.T @ dx_flat if self._dense_mass else mass_sqrt_inv * dx_flat + ) y_flat = x_flat + dx_flat_scaled y = unravel_fn(y_flat) y_pe, y_grad = jax.value_and_grad(self._potential_fn)(y) y_grad_flat, _ = ravel_pytree(y_grad) - y_grad_flat_scaled = mass_sqrt_inv @ y_grad_flat if self._dense_mass else mass_sqrt_inv * y_grad_flat - - log_accept_ratio = x_pe - y_pe + jnp.sum(softplus(dx_flat * x_grad_flat_scaled) - - softplus(-dx_flat * y_grad_flat_scaled)) - accept_prob = jnp.clip(jnp.exp(log_accept_ratio), a_max=1.) - - x, x_flat, pe, x_grad = jax.lax.cond(random.bernoulli(key_accept, accept_prob), - (y, y_flat, y_pe, y_grad), identity, - (x, x_flat, x_pe, x_grad), identity) + y_grad_flat_scaled = ( + mass_sqrt_inv @ y_grad_flat + if self._dense_mass + else mass_sqrt_inv * y_grad_flat + ) + + log_accept_ratio = ( + x_pe + - y_pe + + jnp.sum( + softplus(dx_flat * x_grad_flat_scaled) + - softplus(-dx_flat * y_grad_flat_scaled) + ) + ) + accept_prob = jnp.clip(jnp.exp(log_accept_ratio), a_max=1.0) + + x, x_flat, pe, x_grad = jax.lax.cond( + random.bernoulli(key_accept, accept_prob), + (y, y_flat, y_pe, y_grad), + identity, + (x, x_flat, x_pe, x_grad), + identity, + ) # do not update adapt_state after warmup phase - adapt_state = jax.lax.cond(i < self._num_warmup, - (i, accept_prob, (x,), adapt_state), - lambda args: self._wa_update(*args), - adapt_state, - identity) + adapt_state = jax.lax.cond( + i < self._num_warmup, + (i, accept_prob, (x,), adapt_state), + lambda args: self._wa_update(*args), + adapt_state, + identity, + ) itr = i + 1 n = jnp.where(i < self._num_warmup, itr, itr - self._num_warmup) mean_accept_prob = mean_accept_prob + (accept_prob - mean_accept_prob) / n - return BarkerMHState(itr, x, pe, x_grad, accept_prob, mean_accept_prob, adapt_state, rng_key) + return BarkerMHState( + itr, x, pe, x_grad, accept_prob, mean_accept_prob, adapt_state, rng_key + ) diff --git a/numpyro/infer/elbo.py b/numpyro/infer/elbo.py index 2c0e1579c..e251f0320 100644 --- a/numpyro/infer/elbo.py +++ b/numpyro/infer/elbo.py @@ -38,6 +38,7 @@ class Trace_ELBO: :param num_particles: The number of particles/samples used to form the ELBO (gradient) estimators. """ + def __init__(self, num_particles=1): self.num_particles = num_particles @@ -56,11 +57,14 @@ def loss(self, rng_key, param_map, model, guide, *args, **kwargs): during the course of fitting). :return: negative of the Evidence Lower Bound (ELBO) to be minimized. """ + def single_particle_elbo(rng_key): model_seed, guide_seed = random.split(rng_key) seeded_model = seed(model, model_seed) seeded_guide = seed(guide, guide_seed) - guide_log_density, guide_trace = log_density(seeded_guide, args, kwargs, param_map) + guide_log_density, guide_trace = log_density( + seeded_guide, args, kwargs, param_map + ) seeded_model = replay(seeded_model, guide_trace) model_log_density, _ = log_density(seeded_model, args, kwargs, param_map) @@ -71,25 +75,27 @@ def single_particle_elbo(rng_key): # Return (-elbo) since by convention we do gradient descent on a loss and # the ELBO is a lower bound that needs to be maximized. if self.num_particles == 1: - return - single_particle_elbo(rng_key) + return -single_particle_elbo(rng_key) else: rng_keys = random.split(rng_key, self.num_particles) - return - jnp.mean(vmap(single_particle_elbo)(rng_keys)) + return -jnp.mean(vmap(single_particle_elbo)(rng_keys)) class ELBO(Trace_ELBO): def __init__(self, num_particles=1): - warnings.warn("Using ELBO directly in SVI is deprecated. Please use Trace_ELBO class instead.", - FutureWarning) + warnings.warn( + "Using ELBO directly in SVI is deprecated. Please use Trace_ELBO class instead.", + FutureWarning, + ) super().__init__(num_particles=num_particles) def _get_log_prob_sum(site): - if site['intermediates']: - log_prob = site['fn'].log_prob(site['value'], site['intermediates']) + if site["intermediates"]: + log_prob = site["fn"].log_prob(site["value"], site["intermediates"]) else: - log_prob = site['fn'].log_prob(site['value']) - log_prob = scale_and_mask(log_prob, site['scale']) + log_prob = site["fn"].log_prob(site["value"]) + log_prob = scale_and_mask(log_prob, site["scale"]) return jnp.sum(log_prob) @@ -98,17 +104,27 @@ def _check_mean_field_requirement(model_trace, guide_trace): Checks that the guide and model sample sites are ordered identically. This is sufficient but not necessary for correctness. """ - model_sites = [name for name, site in model_trace.items() - if site["type"] == "sample" and name in guide_trace] - guide_sites = [name for name, site in guide_trace.items() - if site["type"] == "sample" and name in model_trace] + model_sites = [ + name + for name, site in model_trace.items() + if site["type"] == "sample" and name in guide_trace + ] + guide_sites = [ + name + for name, site in guide_trace.items() + if site["type"] == "sample" and name in model_trace + ] assert set(model_sites) == set(guide_sites) if model_sites != guide_sites: - warnings.warn("Failed to verify mean field restriction on the guide. " - "To eliminate this warning, ensure model and guide sites " - "occur in the same order.\n" + - "Model sites:\n " + "\n ".join(model_sites) + - "Guide sites:\n " + "\n ".join(guide_sites)) + warnings.warn( + "Failed to verify mean field restriction on the guide. " + "To eliminate this warning, ensure model and guide sites " + "occur in the same order.\n" + + "Model sites:\n " + + "\n ".join(model_sites) + + "Guide sites:\n " + + "\n ".join(guide_sites) + ) class TraceMeanField_ELBO(Trace_ELBO): @@ -128,6 +144,7 @@ class TraceMeanField_ELBO(Trace_ELBO): condition is always satisfied if the model and guide have identical dependency structures. """ + def loss(self, rng_key, param_map, model, guide, *args, **kwargs): """ Evaluates the ELBO with an estimator that uses num_particles many samples/particles. @@ -143,6 +160,7 @@ def loss(self, rng_key, param_map, model, guide, *args, **kwargs): during the course of fitting). :return: negative of the Evidence Lower Bound (ELBO) to be minimized. """ + def single_particle_elbo(rng_key): model_seed, guide_seed = random.split(rng_key) seeded_model = seed(model, model_seed) @@ -165,8 +183,11 @@ def single_particle_elbo(rng_key): kl_qp = scale_and_mask(kl_qp, scale=guide_site["scale"]) elbo_particle = elbo_particle - jnp.sum(kl_qp) except NotImplementedError: - elbo_particle = elbo_particle + _get_log_prob_sum(model_site) \ + elbo_particle = ( + elbo_particle + + _get_log_prob_sum(model_site) - _get_log_prob_sum(guide_site) + ) # handle auxiliary sites in the guide for name, site in guide_trace.items(): @@ -177,10 +198,10 @@ def single_particle_elbo(rng_key): return elbo_particle if self.num_particles == 1: - return - single_particle_elbo(rng_key) + return -single_particle_elbo(rng_key) else: rng_keys = random.split(rng_key, self.num_particles) - return - jnp.mean(vmap(single_particle_elbo)(rng_keys)) + return -jnp.mean(vmap(single_particle_elbo)(rng_keys)) class RenyiELBO(Trace_ELBO): @@ -205,10 +226,13 @@ class RenyiELBO(Trace_ELBO): 1. *Renyi Divergence Variational Inference*, Yingzhen Li, Richard E. Turner 2. *Importance Weighted Autoencoders*, Yuri Burda, Roger Grosse, Ruslan Salakhutdinov """ + def __init__(self, alpha=0, num_particles=2): if alpha == 1: - raise ValueError("The order alpha should not be equal to 1. Please use ELBO class" - "for the case alpha = 1.") + raise ValueError( + "The order alpha should not be equal to 1. Please use ELBO class" + "for the case alpha = 1." + ) self.alpha = alpha super(RenyiELBO, self).__init__(num_particles=num_particles) @@ -227,15 +251,22 @@ def loss(self, rng_key, param_map, model, guide, *args, **kwargs): during the course of fitting). :returns: negative of the Renyi Evidence Lower Bound (ELBO) to be minimized. """ + def single_particle_elbo(rng_key): model_seed, guide_seed = random.split(rng_key) seeded_model = seed(model, model_seed) seeded_guide = seed(guide, guide_seed) - guide_log_density, guide_trace = log_density(seeded_guide, args, kwargs, param_map) + guide_log_density, guide_trace = log_density( + seeded_guide, args, kwargs, param_map + ) # NB: we only want to substitute params not available in guide_trace - model_param_map = {k: v for k, v in param_map.items() if k not in guide_trace} + model_param_map = { + k: v for k, v in param_map.items() if k not in guide_trace + } seeded_model = replay(seeded_model, guide_trace) - model_log_density, _ = log_density(seeded_model, args, kwargs, model_param_map) + model_log_density, _ = log_density( + seeded_model, args, kwargs, model_param_map + ) # log p(z) - log q(z) elbo = model_log_density - guide_log_density @@ -243,9 +274,9 @@ def single_particle_elbo(rng_key): rng_keys = random.split(rng_key, self.num_particles) elbos = vmap(single_particle_elbo)(rng_keys) - scaled_elbos = (1. - self.alpha) * elbos + scaled_elbos = (1.0 - self.alpha) * elbos avg_log_exp = logsumexp(scaled_elbos) - jnp.log(self.num_particles) weights = jnp.exp(scaled_elbos - avg_log_exp) - renyi_elbo = avg_log_exp / (1. - self.alpha) + renyi_elbo = avg_log_exp / (1.0 - self.alpha) weighted_elbo = jnp.dot(stop_gradient(weights), elbos) / self.num_particles - return - (stop_gradient(renyi_elbo - weighted_elbo) + weighted_elbo) + return -(stop_gradient(renyi_elbo - weighted_elbo) + weighted_elbo) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index f1cc6c1b2..4f5ae2f65 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -15,15 +15,30 @@ euclidean_kinetic_energy, find_reasonable_step_size, velocity_verlet, - warmup_adapter + warmup_adapter, ) from numpyro.infer.mcmc import MCMCKernel from numpyro.infer.util import ParamInfo, init_to_uniform, initialize_model from numpyro.util import cond, fori_loop, identity -HMCState = namedtuple('HMCState', ['i', 'z', 'z_grad', 'potential_energy', 'energy', - 'r', 'trajectory_length', 'num_steps', 'accept_prob', - 'mean_accept_prob', 'diverging', 'adapt_state', 'rng_key']) +HMCState = namedtuple( + "HMCState", + [ + "i", + "z", + "z_grad", + "potential_energy", + "energy", + "r", + "trajectory_length", + "num_steps", + "accept_prob", + "mean_accept_prob", + "diverging", + "adapt_state", + "rng_key", + ], +) """ A :func:`~collections.namedtuple` consisting of the following fields: @@ -87,7 +102,7 @@ def momentum_generator(prototype_r, mass_matrix_sqrt, rng_key): raise ValueError("Mass matrix has incorrect number of dims.") -def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo='NUTS'): +def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo="NUTS"): r""" Hamiltonian Monte Carlo inference, using either fixed number of steps or the No U-Turn Sampler (NUTS) with adaptive path length. @@ -162,25 +177,27 @@ def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo='NUTS'): wa_update = None wa_steps = None forward_mode_ad = False - max_delta_energy = 1000. - if algo not in {'HMC', 'NUTS'}: - raise ValueError('`algo` must be one of `HMC` or `NUTS`.') - - def init_kernel(init_params, - num_warmup, - step_size=1.0, - inverse_mass_matrix=None, - adapt_step_size=True, - adapt_mass_matrix=True, - dense_mass=False, - target_accept_prob=0.8, - trajectory_length=2*math.pi, - max_tree_depth=10, - find_heuristic_step_size=False, - forward_mode_differentiation=False, - model_args=(), - model_kwargs=None, - rng_key=random.PRNGKey(0)): + max_delta_energy = 1000.0 + if algo not in {"HMC", "NUTS"}: + raise ValueError("`algo` must be one of `HMC` or `NUTS`.") + + def init_kernel( + init_params, + num_warmup, + step_size=1.0, + inverse_mass_matrix=None, + adapt_step_size=True, + adapt_mass_matrix=True, + dense_mass=False, + target_accept_prob=0.8, + trajectory_length=2 * math.pi, + max_tree_depth=10, + find_heuristic_step_size=False, + forward_mode_differentiation=False, + model_args=(), + model_kwargs=None, + rng_key=random.PRNGKey(0), + ): """ Initializes the HMC sampler. @@ -240,7 +257,9 @@ def init_kernel(init_params, """ step_size = lax.convert_element_type(step_size, jnp.result_type(float)) - trajectory_length = lax.convert_element_type(trajectory_length, jnp.result_type(float)) + trajectory_length = lax.convert_element_type( + trajectory_length, jnp.result_type(float) + ) nonlocal wa_update, max_treedepth, vv_update, wa_steps, forward_mode_ad forward_mode_ad = forward_mode_differentiation wa_steps = num_warmup @@ -252,41 +271,66 @@ def init_kernel(init_params, pe_fn = potential_fn if potential_fn_gen: if pe_fn is not None: - raise ValueError('Only one of `potential_fn` or `potential_fn_gen` must be provided.') + raise ValueError( + "Only one of `potential_fn` or `potential_fn_gen` must be provided." + ) else: kwargs = {} if model_kwargs is None else model_kwargs pe_fn = potential_fn_gen(*model_args, **kwargs) find_reasonable_ss = None if find_heuristic_step_size: - find_reasonable_ss = partial(find_reasonable_step_size, - pe_fn, - kinetic_fn, - momentum_generator) - - wa_init, wa_update = warmup_adapter(num_warmup, - adapt_step_size=adapt_step_size, - adapt_mass_matrix=adapt_mass_matrix, - dense_mass=dense_mass, - target_accept_prob=target_accept_prob, - find_reasonable_step_size=find_reasonable_ss) + find_reasonable_ss = partial( + find_reasonable_step_size, pe_fn, kinetic_fn, momentum_generator + ) + + wa_init, wa_update = warmup_adapter( + num_warmup, + adapt_step_size=adapt_step_size, + adapt_mass_matrix=adapt_mass_matrix, + dense_mass=dense_mass, + target_accept_prob=target_accept_prob, + find_reasonable_step_size=find_reasonable_ss, + ) rng_key_hmc, rng_key_wa, rng_key_momentum = random.split(rng_key, 3) z_info = IntegratorState(z=z, potential_energy=pe, z_grad=z_grad) - wa_state = wa_init(z_info, rng_key_wa, step_size, - inverse_mass_matrix=inverse_mass_matrix) + wa_state = wa_init( + z_info, rng_key_wa, step_size, inverse_mass_matrix=inverse_mass_matrix + ) r = momentum_generator(z, wa_state.mass_matrix_sqrt, rng_key_momentum) vv_init, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) vv_state = vv_init(z, r, potential_energy=pe, z_grad=z_grad) - energy = vv_state.potential_energy + kinetic_fn(wa_state.inverse_mass_matrix, vv_state.r) + energy = vv_state.potential_energy + kinetic_fn( + wa_state.inverse_mass_matrix, vv_state.r + ) zero_int = jnp.array(0, dtype=jnp.result_type(int)) - hmc_state = HMCState(zero_int, vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, - None, trajectory_length, - zero_int, jnp.zeros(()), jnp.zeros(()), jnp.array(False), wa_state, rng_key_hmc) + hmc_state = HMCState( + zero_int, + vv_state.z, + vv_state.z_grad, + vv_state.potential_energy, + energy, + None, + trajectory_length, + zero_int, + jnp.zeros(()), + jnp.zeros(()), + jnp.array(False), + wa_state, + rng_key_hmc, + ) return device_put(hmc_state) - def _hmc_next(step_size, inverse_mass_matrix, vv_state, - model_args, model_kwargs, rng_key, trajectory_length): + def _hmc_next( + step_size, + inverse_mass_matrix, + vv_state, + model_args, + model_kwargs, + rng_key, + trajectory_length, + ): if potential_fn_gen: nonlocal vv_update, forward_mode_ad pe_fn = potential_fn_gen(*model_args, **model_kwargs) @@ -299,41 +343,73 @@ def _hmc_next(step_size, inverse_mass_matrix, vv_state, num_steps = _get_num_steps(step_size, trajectory_length) # makes sure trajectory length is constant, rather than step_size * num_steps step_size = trajectory_length / num_steps - vv_state_new = fori_loop(0, num_steps, - lambda i, val: vv_update(step_size, inverse_mass_matrix, val), - vv_state) - energy_old = vv_state.potential_energy + kinetic_fn(inverse_mass_matrix, vv_state.r) - energy_new = vv_state_new.potential_energy + kinetic_fn(inverse_mass_matrix, vv_state_new.r) + vv_state_new = fori_loop( + 0, + num_steps, + lambda i, val: vv_update(step_size, inverse_mass_matrix, val), + vv_state, + ) + energy_old = vv_state.potential_energy + kinetic_fn( + inverse_mass_matrix, vv_state.r + ) + energy_new = vv_state_new.potential_energy + kinetic_fn( + inverse_mass_matrix, vv_state_new.r + ) delta_energy = energy_new - energy_old delta_energy = jnp.where(jnp.isnan(delta_energy), jnp.inf, delta_energy) accept_prob = jnp.clip(jnp.exp(-delta_energy), a_max=1.0) diverging = delta_energy > max_delta_energy transition = random.bernoulli(rng_key, accept_prob) - vv_state, energy = cond(transition, - (vv_state_new, energy_new), identity, - (vv_state, energy_old), identity) + vv_state, energy = cond( + transition, + (vv_state_new, energy_new), + identity, + (vv_state, energy_old), + identity, + ) return vv_state, energy, num_steps, accept_prob, diverging - def _nuts_next(step_size, inverse_mass_matrix, vv_state, - model_args, model_kwargs, rng_key, trajectory_length): + def _nuts_next( + step_size, + inverse_mass_matrix, + vv_state, + model_args, + model_kwargs, + rng_key, + trajectory_length, + ): if potential_fn_gen: nonlocal vv_update, forward_mode_ad pe_fn = potential_fn_gen(*model_args, **model_kwargs) _, vv_update = velocity_verlet(pe_fn, kinetic_fn, forward_mode_ad) - binary_tree = build_tree(vv_update, kinetic_fn, vv_state, - inverse_mass_matrix, step_size, rng_key, - max_delta_energy=max_delta_energy, - max_tree_depth=max_treedepth) + binary_tree = build_tree( + vv_update, + kinetic_fn, + vv_state, + inverse_mass_matrix, + step_size, + rng_key, + max_delta_energy=max_delta_energy, + max_tree_depth=max_treedepth, + ) accept_prob = binary_tree.sum_accept_probs / binary_tree.num_proposals num_steps = binary_tree.num_proposals - vv_state = IntegratorState(z=binary_tree.z_proposal, - r=vv_state.r, - potential_energy=binary_tree.z_proposal_pe, - z_grad=binary_tree.z_proposal_grad) - return vv_state, binary_tree.z_proposal_energy, num_steps, accept_prob, binary_tree.diverging + vv_state = IntegratorState( + z=binary_tree.z_proposal, + r=vv_state.r, + potential_energy=binary_tree.z_proposal_pe, + z_grad=binary_tree.z_proposal_grad, + ) + return ( + vv_state, + binary_tree.z_proposal_energy, + num_steps, + accept_prob, + binary_tree.diverging, + ) - _next = _nuts_next if algo == 'NUTS' else _hmc_next + _next = _nuts_next if algo == "NUTS" else _hmc_next def sample_kernel(hmc_state, model_args=(), model_kwargs=None): """ @@ -348,36 +424,63 @@ def sample_kernel(hmc_state, model_args=(), model_kwargs=None): """ model_kwargs = {} if model_kwargs is None else model_kwargs - rng_key, rng_key_momentum, rng_key_transition = random.split(hmc_state.rng_key, 3) - r = momentum_generator(hmc_state.z, hmc_state.adapt_state.mass_matrix_sqrt, rng_key_momentum) \ - if hmc_state.r is None else hmc_state.r - vv_state = IntegratorState(hmc_state.z, r, hmc_state.potential_energy, hmc_state.z_grad) - vv_state, energy, num_steps, accept_prob, diverging = _next(hmc_state.adapt_state.step_size, - hmc_state.adapt_state.inverse_mass_matrix, - vv_state, - model_args, - model_kwargs, - rng_key_transition, - hmc_state.trajectory_length) + rng_key, rng_key_momentum, rng_key_transition = random.split( + hmc_state.rng_key, 3 + ) + r = ( + momentum_generator( + hmc_state.z, hmc_state.adapt_state.mass_matrix_sqrt, rng_key_momentum + ) + if hmc_state.r is None + else hmc_state.r + ) + vv_state = IntegratorState( + hmc_state.z, r, hmc_state.potential_energy, hmc_state.z_grad + ) + vv_state, energy, num_steps, accept_prob, diverging = _next( + hmc_state.adapt_state.step_size, + hmc_state.adapt_state.inverse_mass_matrix, + vv_state, + model_args, + model_kwargs, + rng_key_transition, + hmc_state.trajectory_length, + ) # not update adapt_state after warmup phase - adapt_state = cond(hmc_state.i < wa_steps, - (hmc_state.i, accept_prob, vv_state, hmc_state.adapt_state), - lambda args: wa_update(*args), - hmc_state.adapt_state, - identity) + adapt_state = cond( + hmc_state.i < wa_steps, + (hmc_state.i, accept_prob, vv_state, hmc_state.adapt_state), + lambda args: wa_update(*args), + hmc_state.adapt_state, + identity, + ) itr = hmc_state.i + 1 n = jnp.where(hmc_state.i < wa_steps, itr, itr - wa_steps) - mean_accept_prob = hmc_state.mean_accept_prob + (accept_prob - hmc_state.mean_accept_prob) / n + mean_accept_prob = ( + hmc_state.mean_accept_prob + (accept_prob - hmc_state.mean_accept_prob) / n + ) r = vv_state.r if hmc_state.r is not None else None - return HMCState(itr, vv_state.z, vv_state.z_grad, vv_state.potential_energy, energy, - r, hmc_state.trajectory_length, num_steps, - accept_prob, mean_accept_prob, diverging, adapt_state, rng_key) + return HMCState( + itr, + vv_state.z, + vv_state.z_grad, + vv_state.potential_energy, + energy, + r, + hmc_state.trajectory_length, + num_steps, + accept_prob, + mean_accept_prob, + diverging, + adapt_state, + rng_key, + ) # Make `init_kernel` and `sample_kernel` visible from the global scope once # `hmc` is called for sphinx doc generation. - if 'SPHINX_BUILD' in os.environ: + if "SPHINX_BUILD" in os.environ: hmc.init_kernel = init_kernel hmc.sample_kernel = sample_kernel @@ -456,34 +559,42 @@ class HMC(MCMCKernel): `JAX's The Autodiff Cookbook `_ for more information. """ - def __init__(self, - model=None, - potential_fn=None, - kinetic_fn=None, - step_size=1.0, - inverse_mass_matrix=None, - adapt_step_size=True, - adapt_mass_matrix=True, - dense_mass=False, - target_accept_prob=0.8, - trajectory_length=2 * math.pi, - init_strategy=init_to_uniform, - find_heuristic_step_size=False, - forward_mode_differentiation=False): + + def __init__( + self, + model=None, + potential_fn=None, + kinetic_fn=None, + step_size=1.0, + inverse_mass_matrix=None, + adapt_step_size=True, + adapt_mass_matrix=True, + dense_mass=False, + target_accept_prob=0.8, + trajectory_length=2 * math.pi, + init_strategy=init_to_uniform, + find_heuristic_step_size=False, + forward_mode_differentiation=False, + ): if not (model is None) ^ (potential_fn is None): - raise ValueError('Only one of `model` or `potential_fn` must be specified.') + raise ValueError("Only one of `model` or `potential_fn` must be specified.") self._model = model self._potential_fn = potential_fn - self._kinetic_fn = kinetic_fn if kinetic_fn is not None else euclidean_kinetic_energy + self._kinetic_fn = ( + kinetic_fn if kinetic_fn is not None else euclidean_kinetic_energy + ) self._step_size = float(step_size) if isinstance(step_size, int) else step_size self._inverse_mass_matrix = inverse_mass_matrix self._adapt_step_size = adapt_step_size self._adapt_mass_matrix = adapt_mass_matrix self._dense_mass = dense_mass self._target_accept_prob = target_accept_prob - self._trajectory_length = float(trajectory_length) \ - if isinstance(trajectory_length, int) else trajectory_length - self._algo = 'HMC' + self._trajectory_length = ( + float(trajectory_length) + if isinstance(trajectory_length, int) + else trajectory_length + ) + self._algo = "HMC" self._max_tree_depth = 10 self._init_strategy = init_strategy self._find_heuristic_step_size = find_heuristic_step_size @@ -503,17 +614,22 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): init_strategy=self._init_strategy, model_args=model_args, model_kwargs=model_kwargs, - forward_mode_differentiation=self._forward_mode_differentiation) + forward_mode_differentiation=self._forward_mode_differentiation, + ) if self._init_fn is None: - self._init_fn, self._sample_fn = hmc(potential_fn_gen=potential_fn, - kinetic_fn=self._kinetic_fn, - algo=self._algo) + self._init_fn, self._sample_fn = hmc( + potential_fn_gen=potential_fn, + kinetic_fn=self._kinetic_fn, + algo=self._algo, + ) self._potential_fn_gen = potential_fn self._postprocess_fn = postprocess_fn elif self._init_fn is None: - self._init_fn, self._sample_fn = hmc(potential_fn=self._potential_fn, - kinetic_fn=self._kinetic_fn, - algo=self._algo) + self._init_fn, self._sample_fn = hmc( + potential_fn=self._potential_fn, + kinetic_fn=self._kinetic_fn, + algo=self._algo, + ) return init_params @@ -523,28 +639,35 @@ def model(self): @property def sample_field(self): - return 'z' + return "z" @property def default_fields(self): - return ('z', 'diverging') + return ("z", "diverging") def get_diagnostics_str(self, state): - return '{} steps of size {:.2e}. acc. prob={:.2f}'.format(state.num_steps, - state.adapt_state.step_size, - state.mean_accept_prob) + return "{} steps of size {:.2e}. acc. prob={:.2f}".format( + state.num_steps, state.adapt_state.step_size, state.mean_accept_prob + ) - def init(self, rng_key, num_warmup, init_params=None, model_args=(), model_kwargs={}): + def init( + self, rng_key, num_warmup, init_params=None, model_args=(), model_kwargs={} + ): # non-vectorized if rng_key.ndim == 1: rng_key, rng_key_init_model = random.split(rng_key) # vectorized else: - rng_key, rng_key_init_model = jnp.swapaxes(vmap(random.split)(rng_key), 0, 1) - init_params = self._init_state(rng_key_init_model, model_args, model_kwargs, init_params) + rng_key, rng_key_init_model = jnp.swapaxes( + vmap(random.split)(rng_key), 0, 1 + ) + init_params = self._init_state( + rng_key_init_model, model_args, model_kwargs, init_params + ) if self._potential_fn and init_params is None: - raise ValueError('Valid value of `init_params` must be provided with' - ' `potential_fn`.') + raise ValueError( + "Valid value of `init_params` must be provided with" " `potential_fn`." + ) # change dense_mass to a structural form dense_mass = self._dense_mass @@ -690,29 +813,38 @@ class NUTS(HMC): `JAX's The Autodiff Cookbook `_ for more information. """ - def __init__(self, - model=None, - potential_fn=None, - kinetic_fn=None, - step_size=1.0, - inverse_mass_matrix=None, - adapt_step_size=True, - adapt_mass_matrix=True, - dense_mass=False, - target_accept_prob=0.8, - trajectory_length=None, - max_tree_depth=10, - init_strategy=init_to_uniform, - find_heuristic_step_size=False, - forward_mode_differentiation=False): - super(NUTS, self).__init__(potential_fn=potential_fn, model=model, kinetic_fn=kinetic_fn, - step_size=step_size, inverse_mass_matrix=inverse_mass_matrix, - adapt_step_size=adapt_step_size, - adapt_mass_matrix=adapt_mass_matrix, dense_mass=dense_mass, - target_accept_prob=target_accept_prob, - trajectory_length=trajectory_length, - init_strategy=init_strategy, - find_heuristic_step_size=find_heuristic_step_size, - forward_mode_differentiation=forward_mode_differentiation) + + def __init__( + self, + model=None, + potential_fn=None, + kinetic_fn=None, + step_size=1.0, + inverse_mass_matrix=None, + adapt_step_size=True, + adapt_mass_matrix=True, + dense_mass=False, + target_accept_prob=0.8, + trajectory_length=None, + max_tree_depth=10, + init_strategy=init_to_uniform, + find_heuristic_step_size=False, + forward_mode_differentiation=False, + ): + super(NUTS, self).__init__( + potential_fn=potential_fn, + model=model, + kinetic_fn=kinetic_fn, + step_size=step_size, + inverse_mass_matrix=inverse_mass_matrix, + adapt_step_size=adapt_step_size, + adapt_mass_matrix=adapt_mass_matrix, + dense_mass=dense_mass, + target_accept_prob=target_accept_prob, + trajectory_length=trajectory_length, + init_strategy=init_strategy, + find_heuristic_step_size=find_heuristic_step_size, + forward_mode_differentiation=forward_mode_differentiation, + ) self._max_tree_depth = max_tree_depth - self._algo = 'NUTS' + self._algo = "NUTS" diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 587ba1c46..1c03edc23 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -8,7 +8,17 @@ import numpy as np -from jax import device_put, grad, hessian, jacfwd, jacobian, lax, ops, random, value_and_grad +from jax import ( + device_put, + grad, + hessian, + jacfwd, + jacobian, + lax, + ops, + random, + value_and_grad, +) import jax.numpy as jnp from jax.scipy.special import expit @@ -88,7 +98,9 @@ def __init__(self, inner_kernel, gibbs_fn, gibbs_sites): raise ValueError("inner_kernel must be a HMC or NUTS sampler.") if not callable(gibbs_fn): raise ValueError("gibbs_fn must be a callable") - assert inner_kernel.model is not None, "HMCGibbs does not support models specified via a potential function." + assert ( + inner_kernel.model is not None + ), "HMCGibbs does not support models specified via a potential function." self.inner_kernel = copy.copy(inner_kernel) self.inner_kernel._model = partial(_wrap_model, inner_kernel.model) @@ -102,9 +114,9 @@ def model(self): def get_diagnostics_str(self, state): state = state.hmc_state - return '{} steps of size {:.2e}. acc. prob={:.2f}'.format(state.num_steps, - state.adapt_state.step_size, - state.mean_accept_prob) + return "{} steps of size {:.2e}. acc. prob={:.2f}".format( + state.num_steps, state.adapt_state.step_size, state.mean_accept_prob + ) def postprocess_fn(self, args, kwargs): def fn(z): @@ -121,12 +133,20 @@ def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() if self._prototype_trace is None: rng_key, key_u = random.split(rng_key) - self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) + self._prototype_trace = trace(seed(self.model, key_u)).get_trace( + *model_args, **model_kwargs + ) rng_key, key_z = random.split(rng_key) - gibbs_sites = {name: site["value"] for name, site in self._prototype_trace.items() if name in self._gibbs_sites} + gibbs_sites = { + name: site["value"] + for name, site in self._prototype_trace.items() + if name in self._gibbs_sites + } model_kwargs["_gibbs_sites"] = gibbs_sites - hmc_state = self.inner_kernel.init(key_z, num_warmup, init_params, model_args, model_kwargs) + hmc_state = self.inner_kernel.init( + key_z, num_warmup, init_params, model_args, model_kwargs + ) z = {**gibbs_sites, **hmc_state.z} @@ -138,7 +158,8 @@ def sample(self, state, model_args, model_kwargs): def potential_fn(z_gibbs, z_hmc): return self.inner_kernel._potential_fn_gen( - *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + *model_args, _gibbs_sites=z_gibbs, **model_kwargs + )(z_hmc) z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} @@ -146,13 +167,17 @@ def potential_fn(z_gibbs, z_hmc): model_kwargs_["_gibbs_sites"] = z_gibbs z_hmc = self.inner_kernel.postprocess_fn(model_args, model_kwargs_)(z_hmc) - z_gibbs = self._gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc) + z_gibbs = self._gibbs_fn( + rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc + ) if self.inner_kernel._forward_mode_differentiation: pe = potential_fn(z_gibbs, state.hmc_state.z) z_grad = jacfwd(partial(potential_fn, z_gibbs))(state.hmc_state.z) else: - pe, z_grad = value_and_grad(partial(potential_fn, z_gibbs))(state.hmc_state.z) + pe, z_grad = value_and_grad(partial(potential_fn, z_gibbs))( + state.hmc_state.z + ) hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) model_kwargs_["_gibbs_sites"] = z_gibbs @@ -163,7 +188,9 @@ def potential_fn(z_gibbs, z_hmc): return HMCGibbsState(z, hmc_state, rng_key) -def _discrete_gibbs_proposal_body_fn(z_init_flat, unravel_fn, pe_init, potential_fn, idx, i, val): +def _discrete_gibbs_proposal_body_fn( + z_init_flat, unravel_fn, pe_init, potential_fn, idx, i, val +): rng_key, z, pe, log_weight_sum = val rng_key, rng_transition = random.split(rng_key) proposal = jnp.where(i >= z_init_flat[idx], i + 1, i) @@ -175,9 +202,13 @@ def _discrete_gibbs_proposal_body_fn(z_init_flat, unravel_fn, pe_init, potential log_weight_new = jnp.where(jnp.isfinite(log_weight_new), log_weight_new, -jnp.inf) # transition_prob = e^weight_new / (e^weight_logsumexp + e^weight_new) transition_prob = expit(log_weight_new - log_weight_sum) - z, pe = cond(random.bernoulli(rng_transition, transition_prob), - (z_new, pe_new), identity, - (z, pe), identity) + z, pe = cond( + random.bernoulli(rng_transition, transition_prob), + (z_new, pe_new), + identity, + (z, pe), + identity, + ) log_weight_sum = jnp.logaddexp(log_weight_new, log_weight_sum) return rng_key, z, pe, log_weight_sum @@ -193,31 +224,52 @@ def _discrete_gibbs_proposal(rng_key, z_discrete, pe, potential_fn, idx, support # might change across different discrete variables; # so here we will loop over all proposals and use an online scheme to sample from # the conditional categorical distribution - body_fn = partial(_discrete_gibbs_proposal_body_fn, - z_discrete_flat, unravel_fn, pe, potential_fn, idx) - init_val = (rng_key, z_discrete, pe, jnp.array(0.)) + body_fn = partial( + _discrete_gibbs_proposal_body_fn, + z_discrete_flat, + unravel_fn, + pe, + potential_fn, + idx, + ) + init_val = (rng_key, z_discrete, pe, jnp.array(0.0)) rng_key, z_new, pe_new, _ = fori_loop(0, support_size - 1, body_fn, init_val) - log_accept_ratio = jnp.array(0.) + log_accept_ratio = jnp.array(0.0) return rng_key, z_new, pe_new, log_accept_ratio -def _discrete_modified_gibbs_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_size, - stay_prob=0.): - assert isinstance(stay_prob, float) and stay_prob >= 0. and stay_prob < 1 +def _discrete_modified_gibbs_proposal( + rng_key, z_discrete, pe, potential_fn, idx, support_size, stay_prob=0.0 +): + assert isinstance(stay_prob, float) and stay_prob >= 0.0 and stay_prob < 1 z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) - body_fn = partial(_discrete_gibbs_proposal_body_fn, - z_discrete_flat, unravel_fn, pe, potential_fn, idx) + body_fn = partial( + _discrete_gibbs_proposal_body_fn, + z_discrete_flat, + unravel_fn, + pe, + potential_fn, + idx, + ) # like gibbs_step but here, weight of the current value is 0 init_val = (rng_key, z_discrete, pe, jnp.array(-jnp.inf)) - rng_key, z_new, pe_new, log_weight_sum = fori_loop(0, support_size - 1, body_fn, init_val) + rng_key, z_new, pe_new, log_weight_sum = fori_loop( + 0, support_size - 1, body_fn, init_val + ) rng_key, rng_stay = random.split(rng_key) - z_new, pe_new = cond(random.bernoulli(rng_stay, stay_prob), - (z_discrete, pe), identity, - (z_new, pe_new), identity) + z_new, pe_new = cond( + random.bernoulli(rng_stay, stay_prob), + (z_discrete, pe), + identity, + (z_new, pe_new), + identity, + ) # here we calculate the MH correction: (1 - P(z)) / (1 - P(z_new)) # where 1 - P(z) ~ weight_sum # and 1 - P(z_new) ~ 1 + weight_sum - z_new_weight - log_accept_ratio = log_weight_sum - jnp.log(jnp.exp(log_weight_sum) - jnp.expm1(pe - pe_new)) + log_accept_ratio = log_weight_sum - jnp.log( + jnp.exp(log_weight_sum) - jnp.expm1(pe - pe_new) + ) return rng_key, z_new, pe_new, log_accept_ratio @@ -233,9 +285,10 @@ def _discrete_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_si return rng_key, z_new, pe_new, log_accept_ratio -def _discrete_modified_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_size, - stay_prob=0.): - assert isinstance(stay_prob, float) and stay_prob >= 0. and stay_prob < 1 +def _discrete_modified_rw_proposal( + rng_key, z_discrete, pe, potential_fn, idx, support_size, stay_prob=0.0 +): + assert isinstance(stay_prob, float) and stay_prob >= 0.0 and stay_prob < 1 rng_key, rng_proposal, rng_stay = random.split(rng_key, 3) z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) @@ -263,14 +316,23 @@ def body_fn(i, val): support_size = support_sizes_flat[idx] rng_key, z, pe = val rng_key, z_new, pe_new, log_accept_ratio = proposal_fn( - rng_key, z, pe, potential_fn=partial(potential_fn, z_hmc=hmc_sites), - idx=idx, support_size=support_size) + rng_key, + z, + pe, + potential_fn=partial(potential_fn, z_hmc=hmc_sites), + idx=idx, + support_size=support_size, + ) rng_key, rng_accept = random.split(rng_key) # u ~ Uniform(0, 1), u < accept_ratio => -log(u) > -log_accept_ratio # and -log(u) ~ exponential(1) - z, pe = cond(random.exponential(rng_accept) > -log_accept_ratio, - (z_new, pe_new), identity, - (z, pe), identity) + z, pe = cond( + random.exponential(rng_accept) > -log_accept_ratio, + (z_new, pe_new), + identity, + (z, pe), + identity, + ) return rng_key, z, pe init_val = (rng_key, gibbs_sites, pe) @@ -338,31 +400,46 @@ def __init__(self, inner_kernel, *, random_walk=False, modified=False): self._modified = modified if random_walk: if modified: - self._discrete_proposal_fn = partial(_discrete_modified_rw_proposal, stay_prob=0.) + self._discrete_proposal_fn = partial( + _discrete_modified_rw_proposal, stay_prob=0.0 + ) else: self._discrete_proposal_fn = _discrete_rw_proposal else: if modified: - self._discrete_proposal_fn = partial(_discrete_modified_gibbs_proposal, stay_prob=0.) + self._discrete_proposal_fn = partial( + _discrete_modified_gibbs_proposal, stay_prob=0.0 + ) else: self._discrete_proposal_fn = _discrete_gibbs_proposal def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() rng_key, key_u = random.split(rng_key) - self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) + self._prototype_trace = trace(seed(self.model, key_u)).get_trace( + *model_args, **model_kwargs + ) self._support_sizes = { - name: np.broadcast_to(site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"])) + name: np.broadcast_to( + site["fn"].enumerate_support(False).shape[0], jnp.shape(site["value"]) + ) for name, site in self._prototype_trace.items() - if site["type"] == "sample" and site["fn"].has_enumerate_support and not site["is_observed"] + if site["type"] == "sample" + and site["fn"].has_enumerate_support + and not site["is_observed"] } - self._gibbs_sites = [name for name, site in self._prototype_trace.items() - if site["type"] == "sample" - and site["fn"].has_enumerate_support - and not site["is_observed"] - and site["infer"].get("enumerate", "") != "parallel"] - assert self._gibbs_sites, "Cannot detect any discrete latent variables in the model." + self._gibbs_sites = [ + name + for name, site in self._prototype_trace.items() + if site["type"] == "sample" + and site["fn"].has_enumerate_support + and not site["is_observed"] + and site["infer"].get("enumerate", "") != "parallel" + ] + assert ( + self._gibbs_sites + ), "Cannot detect any discrete latent variables in the model." return super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) def sample(self, state, model_args, model_kwargs): @@ -371,7 +448,8 @@ def sample(self, state, model_args, model_kwargs): def potential_fn(z_gibbs, z_hmc): return self.inner_kernel._potential_fn_gen( - *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + *model_args, _gibbs_sites=z_gibbs, **model_kwargs + )(z_hmc) z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} z_hmc = {k: v for k, v in state.z.items() if k in state.hmc_state.z} @@ -380,9 +458,15 @@ def potential_fn(z_gibbs, z_hmc): # different from the implementation in HMCGibbs.sample, we feed the current potential energy # and get new potential energy from gibbs_fn - gibbs_fn = _discrete_gibbs_fn(potential_fn, self._support_sizes, self._discrete_proposal_fn) - z_gibbs, pe = gibbs_fn(rng_key=rng_gibbs, gibbs_sites=z_gibbs, hmc_sites=z_hmc, - pe=state.hmc_state.potential_energy) + gibbs_fn = _discrete_gibbs_fn( + potential_fn, self._support_sizes, self._discrete_proposal_fn + ) + z_gibbs, pe = gibbs_fn( + rng_key=rng_gibbs, + gibbs_sites=z_gibbs, + hmc_sites=z_hmc, + pe=state.hmc_state.potential_energy, + ) if self.inner_kernel._forward_mode_differentiation: z_grad = jacfwd(partial(potential_fn, z_gibbs))(state.hmc_state.z) @@ -409,14 +493,17 @@ def _update_block(rng_key, num_blocks, subsample_idx, plate_size): subsample_idx_padded = jnp.pad(subsample_idx, (0, pad)) start = chosen_block * block_size subsample_idx_padded = lax.dynamic_update_slice_in_dim( - subsample_idx_padded, new_idx, start, 0) + subsample_idx_padded, new_idx, start, 0 + ) return rng_key, subsample_idx_padded[:subsample_size], pad, new_idx, start def _block_update(plate_sizes, num_blocks, rng_key, gibbs_sites, gibbs_state): u_new = {} for name, subsample_idx in gibbs_sites.items(): - rng_key, u_new[name], *_ = _update_block(rng_key, num_blocks, subsample_idx, plate_sizes[name]) + rng_key, u_new[name], *_ = _update_block( + rng_key, num_blocks, subsample_idx, plate_sizes[name] + ) return u_new, gibbs_state @@ -426,14 +513,20 @@ def _block_update_proxy(num_blocks, rng_key, gibbs_sites, plate_sizes): new_idxs = {} starts = {} for name, subsample_idx in gibbs_sites.items(): - rng_key, u_new[name], pads[name], new_idxs[name], starts[name] = _update_block(rng_key, num_blocks, - subsample_idx, plate_sizes[name]) + rng_key, u_new[name], pads[name], new_idxs[name], starts[name] = _update_block( + rng_key, num_blocks, subsample_idx, plate_sizes[name] + ) return u_new, pads, new_idxs, starts -HMCECSState = namedtuple("HMCECSState", "z, hmc_state, rng_key, gibbs_state, accept_prob") -TaylorProxyState = namedtuple("TaylorProxyState", "ref_subsample_log_liks, " - "ref_subsample_log_lik_grads, ref_subsample_log_lik_hessians") +HMCECSState = namedtuple( + "HMCECSState", "z, hmc_state, rng_key, gibbs_state, accept_prob" +) +TaylorProxyState = namedtuple( + "TaylorProxyState", + "ref_subsample_log_liks, " + "ref_subsample_log_lik_grads, ref_subsample_log_lik_hessians", +) def _wrap_gibbs_state(model, *args, **kwargs): @@ -521,34 +614,48 @@ def fn(z): def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() rng_key, key_u = random.split(rng_key) - self._prototype_trace = trace(seed(self.model, key_u)).get_trace(*model_args, **model_kwargs) + self._prototype_trace = trace(seed(self.model, key_u)).get_trace( + *model_args, **model_kwargs + ) self._subsample_plate_sizes = { name: site["args"] for name, site in self._prototype_trace.items() - if site["type"] == "plate" and site["args"][0] > site["args"][1] # i.e. size > subsample_size - } + if site["type"] == "plate" and site["args"][0] > site["args"][1] + } # i.e. size > subsample_size self._gibbs_sites = list(self._subsample_plate_sizes.keys()) assert self._gibbs_sites, "Cannot detect any subsample statements in the model." if self._proxy is not None: - proxy_fn, gibbs_init, self._gibbs_update = self._proxy(self._prototype_trace, - self._subsample_plate_sizes, - self.model, - model_args, - model_kwargs.copy(), - num_blocks=self._num_blocks) + proxy_fn, gibbs_init, self._gibbs_update = self._proxy( + self._prototype_trace, + self._subsample_plate_sizes, + self.model, + model_args, + model_kwargs.copy(), + num_blocks=self._num_blocks, + ) method = perturbed_method(self._subsample_plate_sizes, proxy_fn) - self.inner_kernel._model = estimate_likelihood(self.inner_kernel._model, method) - - z_gibbs = {name: site["value"] for name, site in self._prototype_trace.items() if name in self._gibbs_sites} + self.inner_kernel._model = estimate_likelihood( + self.inner_kernel._model, method + ) + + z_gibbs = { + name: site["value"] + for name, site in self._prototype_trace.items() + if name in self._gibbs_sites + } rng_key, rng_state = random.split(rng_key) gibbs_state = gibbs_init(rng_state, z_gibbs) else: - self._gibbs_update = partial(_block_update, self._subsample_plate_sizes, self._num_blocks) + self._gibbs_update = partial( + _block_update, self._subsample_plate_sizes, self._num_blocks + ) gibbs_state = () model_kwargs["_gibbs_state"] = gibbs_state state = super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) - return HMCECSState(state.z, state.hmc_state, state.rng_key, gibbs_state, jnp.zeros(())) + return HMCECSState( + state.z, state.hmc_state, state.rng_key, gibbs_state, jnp.zeros(()) + ) def sample(self, state, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs.copy() @@ -556,10 +663,16 @@ def sample(self, state, model_args, model_kwargs): def potential_fn(z_gibbs, gibbs_state, z_hmc): return self.inner_kernel._potential_fn_gen( - *model_args, _gibbs_sites=z_gibbs, _gibbs_state=gibbs_state, **model_kwargs)(z_hmc) + *model_args, + _gibbs_sites=z_gibbs, + _gibbs_state=gibbs_state, + **model_kwargs, + )(z_hmc) z_gibbs = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} - z_gibbs_new, gibbs_state_new = self._gibbs_update(rng_key, z_gibbs, state.gibbs_state) + z_gibbs_new, gibbs_state_new = self._gibbs_update( + rng_key, z_gibbs, state.gibbs_state + ) # given a fixed hmc_sites, pe_new - pe_curr = loglik_new - loglik_curr pe = state.hmc_state.potential_energy @@ -567,12 +680,14 @@ def potential_fn(z_gibbs, gibbs_state, z_hmc): accept_prob = jnp.clip(jnp.exp(pe - pe_new), a_max=1.0) transition = random.bernoulli(rng_key, accept_prob) grad_ = jacfwd if self.inner_kernel._forward_mode_differentiation else grad - z_gibbs, gibbs_state, pe, z_grad = cond(transition, - (z_gibbs_new, gibbs_state_new, pe_new), - lambda vals: vals + (grad_(partial(potential_fn, - vals[0], - vals[1]))(state.hmc_state.z),), - (z_gibbs, state.gibbs_state, pe, state.hmc_state.z_grad), identity) + z_gibbs, gibbs_state, pe, z_grad = cond( + transition, + (z_gibbs_new, gibbs_state_new, pe_new), + lambda vals: vals + + (grad_(partial(potential_fn, vals[0], vals[1]))(state.hmc_state.z),), + (z_gibbs, state.gibbs_state, pe, state.hmc_state.z_grad), + identity, + ) hmc_state = state.hmc_state._replace(z_grad=z_grad, potential_energy=pe) @@ -592,13 +707,20 @@ def perturbed_method(subsample_plate_sizes, proxy_fn): def estimator(likelihoods, params, gibbs_state): subsample_log_liks = defaultdict(float) for (fn, value, name, subsample_dim) in likelihoods.values(): - subsample_log_liks[name] += _sum_all_except_at_dim(fn.log_prob(value), subsample_dim) + subsample_log_liks[name] += _sum_all_except_at_dim( + fn.log_prob(value), subsample_dim + ) - log_lik_sum = 0. + log_lik_sum = 0.0 - proxy_value_all, proxy_value_subsample = proxy_fn(params, subsample_log_liks.keys(), gibbs_state) + proxy_value_all, proxy_value_subsample = proxy_fn( + params, subsample_log_liks.keys(), gibbs_state + ) - for name, subsample_log_lik in subsample_log_liks.items(): # loop over all subsample sites + for ( + name, + subsample_log_lik, + ) in subsample_log_liks.items(): # loop over all subsample sites n, m = subsample_plate_sizes[name] diff = subsample_log_lik - proxy_value_subsample[name] @@ -612,7 +734,7 @@ def estimator(likelihoods, params, gibbs_state): def taylor_proxy(reference_params): - """ Control variate for unbiased log likelihood estimation using a Taylor expansion around a reference + """Control variate for unbiased log likelihood estimation using a Taylor expansion around a reference parameter. Suggest for subsampling in [1]. :param dict reference_params: Model parameterization at MLE or MAP-estimate. @@ -623,20 +745,36 @@ def taylor_proxy(reference_params): Bardenet., R., Doucet, A., Holmes, C. (2014) """ - def construct_proxy_fn(prototype_trace, subsample_plate_sizes, model, model_args, model_kwargs, num_blocks=1): - ref_params = {name: biject_to(prototype_trace[name]["fn"].support).inv(value) - for name, value in reference_params.items()} + def construct_proxy_fn( + prototype_trace, + subsample_plate_sizes, + model, + model_args, + model_kwargs, + num_blocks=1, + ): + ref_params = { + name: biject_to(prototype_trace[name]["fn"].support).inv(value) + for name, value in reference_params.items() + } ref_params_flat, unravel_fn = ravel_pytree(ref_params) def log_likelihood(params_flat, subsample_indices=None): if subsample_indices is None: - subsample_indices = {k: jnp.arange(v[0]) for k, v in subsample_plate_sizes.items()} + subsample_indices = { + k: jnp.arange(v[0]) for k, v in subsample_plate_sizes.items() + } params = unravel_fn(params_flat) with warnings.catch_warnings(): warnings.simplefilter("ignore") - params = {name: biject_to(prototype_trace[name]["fn"].support)(value) for name, value in params.items()} - with block(), trace() as tr, substitute(data=subsample_indices), substitute(data=params): + params = { + name: biject_to(prototype_trace[name]["fn"].support)(value) + for name, value in params.items() + } + with block(), trace() as tr, substitute( + data=subsample_indices + ), substitute(data=params): model(*model_args, **model_kwargs) log_lik = {} @@ -645,14 +783,19 @@ def log_likelihood(params_flat, subsample_indices=None): for frame in site["cond_indep_stack"]: if frame.name in log_lik: log_lik[frame.name] += _sum_all_except_at_dim( - site["fn"].log_prob(site["value"]), frame.dim) + site["fn"].log_prob(site["value"]), frame.dim + ) else: log_lik[frame.name] = _sum_all_except_at_dim( - site["fn"].log_prob(site["value"]), frame.dim) + site["fn"].log_prob(site["value"]), frame.dim + ) return log_lik def log_likelihood_sum(params_flat, subsample_indices=None): - return {k: v.sum() for k, v in log_likelihood(params_flat, subsample_indices).items()} + return { + k: v.sum() + for k, v in log_likelihood(params_flat, subsample_indices).items() + } # those stats are dict keyed by subsample names ref_log_likelihoods_sum = log_likelihood_sum(ref_params_flat) @@ -661,33 +804,58 @@ def log_likelihood_sum(params_flat, subsample_indices=None): def gibbs_init(rng_key, gibbs_sites): ref_subsample_log_liks = log_likelihood(ref_params_flat, gibbs_sites) - ref_subsample_log_lik_grads = jacfwd(log_likelihood)(ref_params_flat, gibbs_sites) - ref_subsample_log_lik_hessians = jacfwd(jacfwd(log_likelihood))(ref_params_flat, gibbs_sites) - return TaylorProxyState(ref_subsample_log_liks, ref_subsample_log_lik_grads, ref_subsample_log_lik_hessians) + ref_subsample_log_lik_grads = jacfwd(log_likelihood)( + ref_params_flat, gibbs_sites + ) + ref_subsample_log_lik_hessians = jacfwd(jacfwd(log_likelihood))( + ref_params_flat, gibbs_sites + ) + return TaylorProxyState( + ref_subsample_log_liks, + ref_subsample_log_lik_grads, + ref_subsample_log_lik_hessians, + ) def gibbs_update(rng_key, gibbs_sites, gibbs_state): - u_new, pads, new_idxs, starts = _block_update_proxy(num_blocks, rng_key, gibbs_sites, subsample_plate_sizes) + u_new, pads, new_idxs, starts = _block_update_proxy( + num_blocks, rng_key, gibbs_sites, subsample_plate_sizes + ) new_states = defaultdict(dict) ref_subsample_log_liks = log_likelihood(ref_params_flat, new_idxs) - ref_subsample_log_lik_grads = jacfwd(log_likelihood)(ref_params_flat, new_idxs) - ref_subsample_log_lik_hessians = jacfwd(jacfwd(log_likelihood))(ref_params_flat, new_idxs) + ref_subsample_log_lik_grads = jacfwd(log_likelihood)( + ref_params_flat, new_idxs + ) + ref_subsample_log_lik_hessians = jacfwd(jacfwd(log_likelihood))( + ref_params_flat, new_idxs + ) for stat, new_block_values, last_values in zip( - ["log_liks", "grads", "hessians"], - [ref_subsample_log_liks, - ref_subsample_log_lik_grads, - ref_subsample_log_lik_hessians], - [gibbs_state.ref_subsample_log_liks, - gibbs_state.ref_subsample_log_lik_grads, - gibbs_state.ref_subsample_log_lik_hessians]): + ["log_liks", "grads", "hessians"], + [ + ref_subsample_log_liks, + ref_subsample_log_lik_grads, + ref_subsample_log_lik_hessians, + ], + [ + gibbs_state.ref_subsample_log_liks, + gibbs_state.ref_subsample_log_lik_grads, + gibbs_state.ref_subsample_log_lik_hessians, + ], + ): for name, subsample_idx in gibbs_sites.items(): size, subsample_size = subsample_plate_sizes[name] pad, start = pads[name], starts[name] - new_value = jnp.pad(last_values[name], [(0, pad)] + [(0, 0)] * (jnp.ndim(last_values[name]) - 1)) + new_value = jnp.pad( + last_values[name], + [(0, pad)] + [(0, 0)] * (jnp.ndim(last_values[name]) - 1), + ) new_value = lax.dynamic_update_slice_in_dim( - new_value, new_block_values[name], start, 0) + new_value, new_block_values[name], start, 0 + ) new_states[stat][name] = new_value[:subsample_size] - gibbs_state = TaylorProxyState(new_states["log_liks"], new_states["grads"], new_states["hessians"]) + gibbs_state = TaylorProxyState( + new_states["log_liks"], new_states["grads"], new_states["hessians"] + ) return u_new, gibbs_state def proxy_fn(params, subsample_lik_sites, gibbs_state): @@ -701,15 +869,25 @@ def proxy_fn(params, subsample_lik_sites, gibbs_state): proxy_sum = defaultdict(float) proxy_subsample = defaultdict(float) for name in subsample_lik_sites: - proxy_subsample[name] = (ref_subsample_log_liks[name] + - jnp.dot(ref_subsample_log_lik_grads[name], params_diff) + - 0.5 * jnp.dot(jnp.dot(ref_subsample_log_lik_hessians[name], params_diff), - params_diff)) - - proxy_sum[name] = (ref_log_likelihoods_sum[name] + - jnp.dot(ref_log_likelihood_grads_sum[name], params_diff) + - 0.5 * jnp.dot(jnp.dot(ref_log_likelihood_hessians_sum[name], params_diff), - params_diff)) + proxy_subsample[name] = ( + ref_subsample_log_liks[name] + + jnp.dot(ref_subsample_log_lik_grads[name], params_diff) + + 0.5 + * jnp.dot( + jnp.dot(ref_subsample_log_lik_hessians[name], params_diff), + params_diff, + ) + ) + + proxy_sum[name] = ( + ref_log_likelihoods_sum[name] + + jnp.dot(ref_log_likelihood_grads_sum[name], params_diff) + + 0.5 + * jnp.dot( + jnp.dot(ref_log_likelihood_hessians_sum[name], params_diff), + params_diff, + ) + ) return proxy_sum, proxy_subsample return proxy_fn, gibbs_init, gibbs_update @@ -739,8 +917,11 @@ def __enter__(self): for handler in numpyro.primitives._PYRO_STACK[::-1]: # the potential_fn in HMC makes the PYRO_STACK nested like trace(...); so we can extract the # unconstrained_params from the _unconstrain_reparam substitute_fn - if isinstance(handler, substitute) and isinstance(handler.substitute_fn, partial) \ - and handler.substitute_fn.func is _unconstrain_reparam: + if ( + isinstance(handler, substitute) + and isinstance(handler.substitute_fn, partial) + and handler.substitute_fn.func is _unconstrain_reparam + ): self.params = handler.substitute_fn.args[0] break return super().__enter__() @@ -755,8 +936,10 @@ def __exit__(self, exc_type, exc_value, traceback): return if numpyro.get_mask() is not False: - numpyro.factor("_biased_corrected_log_likelihood", - self.method(self.likelihoods, self.params, self.gibbs_state)) + numpyro.factor( + "_biased_corrected_log_likelihood", + self.method(self.likelihoods, self.params, self.gibbs_state), + ) # clean up self.params = None @@ -778,9 +961,16 @@ def process_message(self, msg): for frame in msg["cond_indep_stack"]: if frame.name in self.subsample_plates: if msg["name"] in self.likelihoods: - raise RuntimeError(f"Multiple subsample plates at site {msg['name']} " - "are not allowed. Please reshape your data.") - self.likelihoods[msg["name"]] = (msg["fn"], msg["value"], frame.name, frame.dim) + raise RuntimeError( + f"Multiple subsample plates at site {msg['name']} " + "are not allowed. Please reshape your data." + ) + self.likelihoods[msg["name"]] = ( + msg["fn"], + msg["value"], + frame.name, + frame.dim, + ) # mask the current likelihood msg["fn"] = msg["fn"].mask(False) elif msg["type"] == "plate" and msg["args"][0] > msg["args"][1]: diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 765423cdd..86f9f9764 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -14,19 +14,48 @@ import numpyro.distributions as dist from numpyro.util import cond, identity, while_loop -AdaptWindow = namedtuple('AdaptWindow', ['start', 'end']) +AdaptWindow = namedtuple("AdaptWindow", ["start", "end"]) # XXX: we need to store rng_key here in case we use find_reasonable_step_size functionality -HMCAdaptState = namedtuple('HMCAdaptState', ['step_size', 'inverse_mass_matrix', 'mass_matrix_sqrt', - 'mass_matrix_sqrt_inv', - 'ss_state', 'mm_state', 'window_idx', 'rng_key']) -IntegratorState = namedtuple('IntegratorState', ['z', 'r', 'potential_energy', 'z_grad']) +HMCAdaptState = namedtuple( + "HMCAdaptState", + [ + "step_size", + "inverse_mass_matrix", + "mass_matrix_sqrt", + "mass_matrix_sqrt_inv", + "ss_state", + "mm_state", + "window_idx", + "rng_key", + ], +) +IntegratorState = namedtuple( + "IntegratorState", ["z", "r", "potential_energy", "z_grad"] +) IntegratorState.__new__.__defaults__ = (None,) * len(IntegratorState._fields) -TreeInfo = namedtuple('TreeInfo', ['z_left', 'r_left', 'z_left_grad', - 'z_right', 'r_right', 'z_right_grad', - 'z_proposal', 'z_proposal_pe', 'z_proposal_grad', 'z_proposal_energy', - 'depth', 'weight', 'r_sum', 'turning', 'diverging', - 'sum_accept_probs', 'num_proposals']) +TreeInfo = namedtuple( + "TreeInfo", + [ + "z_left", + "r_left", + "z_left_grad", + "z_right", + "r_right", + "z_right_grad", + "z_proposal", + "z_proposal_pe", + "z_proposal_grad", + "z_proposal_energy", + "depth", + "weight", + "r_sum", + "turning", + "diverging", + "sum_accept_probs", + "num_proposals", + ], +) def dual_averaging(t0=10, kappa=0.75, gamma=0.05): @@ -65,7 +94,8 @@ def dual_averaging(t0=10, kappa=0.75, gamma=0.05): controls the speed of the convergence of the scheme. Defaults to 0.05. :return: a (`init_fn`, `update_fn`) pair. """ - def init_fn(prox_center=0.): + + def init_fn(prox_center=0.0): """ :param float prox_center: A parameter introduced in reference [1] which pulls the primal sequence towards it. Defaults to 0. @@ -116,6 +146,7 @@ def welford_covariance(diagonal=True): Otherwise, we estimate the covariance of the samples. Defaults to True. :return: a (`init_fn`, `update_fn`, `final_fn`) triple. """ + def init_fn(size): """ :param int size: size of each sample. For a structured mass matrix, @@ -176,7 +207,8 @@ def final_fn(state, regularize=False): cov, cov_inv_sqrt, tril_inv = {}, {}, {} for site_names, state_block in state.items(): cov_block, cov_inv_sqrt_block, tril_inv_block = final_fn( - state_block, regularize=regularize) + state_block, regularize=regularize + ) cov[site_names] = cov_block cov_inv_sqrt[site_names] = cov_inv_sqrt_block tril_inv[site_names] = tril_inv_block @@ -195,7 +227,9 @@ def final_fn(state, regularize=False): cov = scaled_cov + shrinkage * jnp.identity(mean.shape[0]) if jnp.ndim(cov) == 2: # copy the implementation of distributions.util.cholesky_of_inverse here - tril_inv = jnp.swapaxes(jnp.linalg.cholesky(cov[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1) + tril_inv = jnp.swapaxes( + jnp.linalg.cholesky(cov[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1 + ) identity = jnp.identity(cov.shape[-1]) cov_inv_sqrt = solve_triangular(tril_inv, identity, lower=True) else: @@ -232,6 +266,7 @@ def velocity_verlet(potential_fn, kinetic_fn, forward_mode_differentiation=False inverse mass matrix and momentum. :return: a pair of (`init_fn`, `update_fn`). """ + def init_fn(z, r, potential_energy=None, z_grad=None): """ :param z: Position of the particle. @@ -241,7 +276,9 @@ def init_fn(z, r, potential_energy=None, z_grad=None): :return: initial state for the integrator. """ if potential_energy is None or z_grad is None: - potential_energy, z_grad = _value_and_grad(potential_fn, z, forward_mode_differentiation) + potential_energy, z_grad = _value_and_grad( + potential_fn, z, forward_mode_differentiation + ) return IntegratorState(z, r, potential_energy, z_grad) def update_fn(step_size, inverse_mass_matrix, state): @@ -253,18 +290,31 @@ def update_fn(step_size, inverse_mass_matrix, state): :return: new state for the integrator. """ z, r, _, z_grad = state - r = tree_multimap(lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad) # r(n+1/2) + r = tree_multimap( + lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad + ) # r(n+1/2) r_grad = _kinetic_grad(kinetic_fn, inverse_mass_matrix, r) z = tree_multimap(lambda z, r_grad: z + step_size * r_grad, z, r_grad) # z(n+1) - potential_energy, z_grad = _value_and_grad(potential_fn, z, forward_mode_differentiation) - r = tree_multimap(lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad) # r(n+1) + potential_energy, z_grad = _value_and_grad( + potential_fn, z, forward_mode_differentiation + ) + r = tree_multimap( + lambda r, z_grad: r - 0.5 * step_size * z_grad, r, z_grad + ) # r(n+1) return IntegratorState(z, r, potential_energy, z_grad) return init_fn, update_fn -def find_reasonable_step_size(potential_fn, kinetic_fn, momentum_generator, - init_step_size, inverse_mass_matrix, z_info, rng_key): +def find_reasonable_step_size( + potential_fn, + kinetic_fn, + momentum_generator, + init_step_size, + inverse_mass_matrix, + z_info, + rng_key, +): """ Finds a reasonable step size by tuning `init_step_size`. This function is used to avoid working with a too large or too small step size in HMC. @@ -305,9 +355,9 @@ def _body_fn(state): # of a value simulated using a large step size for a constrained sample site). step_size = (2.0 ** direction) * step_size r = momentum_generator(z, inverse_mass_matrix, rng_key_momentum) - _, r_new, potential_energy_new, _ = vv_update(step_size, - inverse_mass_matrix, - (z, r, potential_energy, z_grad)) + _, r_new, potential_energy_new, _ = vv_update( + step_size, inverse_mass_matrix, (z, r, potential_energy, z_grad) + ) energy_current = kinetic_fn(inverse_mass_matrix, r) + potential_energy energy_new = kinetic_fn(inverse_mass_matrix, r_new) + potential_energy_new delta_energy = energy_new - energy_current @@ -321,7 +371,9 @@ def _cond_fn(state): # condition to run only if step_size is not too large or we are not increasing step_size not_large_step_size_cond = (step_size < finfo.max) | (direction <= 0) not_extreme_cond = not_small_step_size_cond & not_large_step_size_cond - return not_extreme_cond & ((last_direction == 0) | (direction == last_direction)) + return not_extreme_cond & ( + (last_direction == 0) | (direction == last_direction) + ) step_size, _, _, _ = while_loop(_cond_fn, _body_fn, (init_step_size, 0, 0, rng_key)) return step_size @@ -391,7 +443,9 @@ def _initialize_mass_matrix(z, inverse_mass_matrix, dense_mass): for site_names in dense_mass: inverse_mm = inverse_mass_matrix.get(site_names) z_block = tuple(z[k] for k in site_names) - inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix(z_block, inverse_mm, True) + inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix( + z_block, inverse_mm, True + ) inverse_mass_matrix[site_names] = inverse_mm mass_matrix_sqrt[site_names] = mm_sqrt mass_matrix_sqrt_inv[site_names] = mm_sqrt_inv @@ -401,22 +455,29 @@ def _initialize_mass_matrix(z, inverse_mass_matrix, dense_mass): if site_names in dense_mass: continue z_block = tuple(z[k] for k in site_names) - inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix(z_block, inverse_mm, False) + inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix( + z_block, inverse_mm, False + ) inverse_mass_matrix[site_names] = inverse_mm mass_matrix_sqrt[site_names] = mm_sqrt mass_matrix_sqrt_inv[site_names] = mm_sqrt_inv remaining_sites = tuple(sorted(set(z) - set().union(*inverse_mass_matrix))) if len(remaining_sites) > 0: z_block = tuple(z[k] for k in remaining_sites) - inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix(z_block, None, False) + inverse_mm, mm_sqrt, mm_sqrt_inv = _initialize_mass_matrix( + z_block, None, False + ) inverse_mass_matrix[remaining_sites] = inverse_mm mass_matrix_sqrt[remaining_sites] = mm_sqrt mass_matrix_sqrt_inv[remaining_sites] = mm_sqrt_inv expected_site_names = sorted(z) - actual_site_names = sorted([k for site_names in inverse_mass_matrix for k in site_names]) - assert actual_site_names == expected_site_names, \ - ("There seems to be a conflict of sites names specified in the initial" - " `inverse_mass_matrix` and in `dense_mass` argument.") + actual_site_names = sorted( + [k for site_names in inverse_mass_matrix for k in site_names] + ) + assert actual_site_names == expected_site_names, ( + "There seems to be a conflict of sites names specified in the initial" + " `inverse_mass_matrix` and in `dense_mass` argument." + ) return inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv mass_matrix_size = jnp.size(ravel_pytree(z)[0]) @@ -430,10 +491,17 @@ def _initialize_mass_matrix(z, inverse_mass_matrix, dense_mass): if dense_mass: if jnp.ndim(inverse_mass_matrix) == 1: inverse_mass_matrix = jnp.diag(inverse_mass_matrix) - mass_matrix_sqrt_inv = jnp.swapaxes(jnp.linalg.cholesky( - inverse_mass_matrix[..., ::-1, ::-1])[..., ::-1, ::-1], -2, -1) + mass_matrix_sqrt_inv = jnp.swapaxes( + jnp.linalg.cholesky(inverse_mass_matrix[..., ::-1, ::-1])[ + ..., ::-1, ::-1 + ], + -2, + -1, + ) identity = jnp.identity(inverse_mass_matrix.shape[-1]) - mass_matrix_sqrt = solve_triangular(mass_matrix_sqrt_inv, identity, lower=True) + mass_matrix_sqrt = solve_triangular( + mass_matrix_sqrt_inv, identity, lower=True + ) else: if jnp.ndim(inverse_mass_matrix) == 2: inverse_mass_matrix = jnp.diag(inverse_mass_matrix) @@ -442,9 +510,14 @@ def _initialize_mass_matrix(z, inverse_mass_matrix, dense_mass): return inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv -def warmup_adapter(num_adapt_steps, find_reasonable_step_size=None, - adapt_step_size=True, adapt_mass_matrix=True, - dense_mass=False, target_accept_prob=0.8): +def warmup_adapter( + num_adapt_steps, + find_reasonable_step_size=None, + adapt_step_size=True, + adapt_mass_matrix=True, + dense_mass=False, + target_accept_prob=0.8, +): """ A scheme to adapt tunable parameters, namely step size and mass matrix, during the warmup phase of HMC. @@ -470,7 +543,9 @@ def warmup_adapter(num_adapt_steps, find_reasonable_step_size=None, adaptation_schedule = jnp.array(build_adaptation_schedule(num_adapt_steps)) num_windows = len(adaptation_schedule) - def init_fn(z_info, rng_key, step_size=1.0, inverse_mass_matrix=None, mass_matrix_size=None): + def init_fn( + z_info, rng_key, step_size=1.0, inverse_mass_matrix=None, mass_matrix_size=None + ): """ :param IntegratorState z_info: The initial integrator state. :param jax.random.PRNGKey rng_key: Random key to be used as the source of randomness. @@ -482,12 +557,16 @@ def init_fn(z_info, rng_key, step_size=1.0, inverse_mass_matrix=None, mass_matri :return: initial state of the adapt scheme. """ rng_key, rng_key_ss = random.split(rng_key) - inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv = _initialize_mass_matrix( - z_info[0], inverse_mass_matrix, dense_mass - ) + ( + inverse_mass_matrix, + mass_matrix_sqrt, + mass_matrix_sqrt_inv, + ) = _initialize_mass_matrix(z_info[0], inverse_mass_matrix, dense_mass) if adapt_step_size: - step_size = find_reasonable_step_size(step_size, inverse_mass_matrix, z_info, rng_key_ss) + step_size = find_reasonable_step_size( + step_size, inverse_mass_matrix, z_info, rng_key_ss + ) ss_state = ss_init(jnp.log(10 * step_size)) if isinstance(inverse_mass_matrix, dict): @@ -497,15 +576,33 @@ def init_fn(z_info, rng_key, step_size=1.0, inverse_mass_matrix=None, mass_matri mm_state = mm_init(size) window_idx = jnp.array(0, dtype=jnp.result_type(int)) - return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, - ss_state, mm_state, window_idx, rng_key) + return HMCAdaptState( + step_size, + inverse_mass_matrix, + mass_matrix_sqrt, + mass_matrix_sqrt_inv, + ss_state, + mm_state, + window_idx, + rng_key, + ) def _update_at_window_end(z_info, rng_key_ss, state): - step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, \ - ss_state, mm_state, window_idx, rng_key = state + ( + step_size, + inverse_mass_matrix, + mass_matrix_sqrt, + mass_matrix_sqrt_inv, + ss_state, + mm_state, + window_idx, + rng_key, + ) = state if adapt_mass_matrix: - inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv = mm_final(mm_state, regularize=True) + inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv = mm_final( + mm_state, regularize=True + ) if isinstance(inverse_mass_matrix, dict): size = {k: v.shape for k, v in inverse_mass_matrix.items()} else: @@ -513,13 +610,23 @@ def _update_at_window_end(z_info, rng_key_ss, state): mm_state = mm_init(size) if adapt_step_size: - step_size = find_reasonable_step_size(step_size, inverse_mass_matrix, z_info, rng_key_ss) + step_size = find_reasonable_step_size( + step_size, inverse_mass_matrix, z_info, rng_key_ss + ) # NB: when step_size is large, say 1e38, jnp.log(10 * step_size) will be inf # and jnp.log(10) + jnp.log(step_size) will be finite ss_state = ss_init(jnp.log(10) + jnp.log(step_size)) - return HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, - ss_state, mm_state, window_idx, rng_key) + return HMCAdaptState( + step_size, + inverse_mass_matrix, + mass_matrix_sqrt, + mass_matrix_sqrt_inv, + ss_state, + mm_state, + window_idx, + rng_key, + ) def update_fn(t, accept_prob, z_info, state): """ @@ -529,8 +636,16 @@ def update_fn(t, accept_prob, z_info, state): :param state: Current state of the adapt scheme. :return: new state of the adapt scheme. """ - step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, \ - ss_state, mm_state, window_idx, rng_key = state + ( + step_size, + inverse_mass_matrix, + mass_matrix_sqrt, + mass_matrix_sqrt_inv, + ss_state, + mm_state, + window_idx, + rng_key, + ) = state if rng_key is not None: rng_key, rng_key_ss = random.split(rng_key) else: @@ -541,9 +656,11 @@ def update_fn(t, accept_prob, z_info, state): ss_state = ss_update(target_accept_prob - accept_prob, ss_state) # note: at the end of warmup phase, use average of log step_size log_step_size, log_step_size_avg, *_ = ss_state - step_size = jnp.where(t == (num_adapt_steps - 1), - jnp.exp(log_step_size_avg), - jnp.exp(log_step_size)) + step_size = jnp.where( + t == (num_adapt_steps - 1), + jnp.exp(log_step_size_avg), + jnp.exp(log_step_size), + ) # account the the case log_step_size is an extreme number finfo = jnp.finfo(jnp.result_type(step_size)) step_size = jnp.clip(step_size, a_min=finfo.tiny, a_max=finfo.max) @@ -552,17 +669,33 @@ def update_fn(t, accept_prob, z_info, state): is_middle_window = (0 < window_idx) & (window_idx < (num_windows - 1)) if adapt_mass_matrix: z = z_info[0] - mm_state = cond(is_middle_window, - (z, mm_state), lambda args: mm_update(*args), - mm_state, identity) + mm_state = cond( + is_middle_window, + (z, mm_state), + lambda args: mm_update(*args), + mm_state, + identity, + ) t_at_window_end = t == adaptation_schedule[window_idx, 1] window_idx = jnp.where(t_at_window_end, window_idx + 1, window_idx) - state = HMCAdaptState(step_size, inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv, - ss_state, mm_state, window_idx, rng_key) - state = cond(t_at_window_end & is_middle_window, - (z_info, rng_key_ss, state), lambda args: _update_at_window_end(*args), - state, identity) + state = HMCAdaptState( + step_size, + inverse_mass_matrix, + mass_matrix_sqrt, + mass_matrix_sqrt_inv, + ss_state, + mm_state, + window_idx, + rng_key, + ) + state = cond( + t_at_window_end & is_middle_window, + (z_info, rng_key_ss, state), + lambda args: _update_at_window_end(*args), + state, + identity, + ) return state return init_fn, update_fn @@ -599,7 +732,9 @@ def _momentum_angle(inverse_mass_matrix, r_left, r_right, r_sum): def _is_turning(inverse_mass_matrix, r_left, r_right, r_sum): - left_angle, right_angle = _momentum_angle(inverse_mass_matrix, r_left, r_right, r_sum) + left_angle, right_angle = _momentum_angle( + inverse_mass_matrix, r_left, r_right, r_sum + ) turning_at_left = left_angle <= 0 turning_at_right = right_angle <= 0 return turning_at_left | turning_at_right @@ -617,30 +752,45 @@ def _biased_transition_kernel(current_tree, new_tree): transition_prob = jnp.exp(new_tree.weight - current_tree.weight) # If new tree is turning or diverging, we won't move the proposal # to the new tree. - transition_prob = jnp.where(new_tree.turning | new_tree.diverging, - 0.0, jnp.clip(transition_prob, a_max=1.0)) + transition_prob = jnp.where( + new_tree.turning | new_tree.diverging, 0.0, jnp.clip(transition_prob, a_max=1.0) + ) return transition_prob -def _combine_tree(current_tree, new_tree, inverse_mass_matrix, going_right, rng_key, biased_transition): +def _combine_tree( + current_tree, new_tree, inverse_mass_matrix, going_right, rng_key, biased_transition +): # Now we combine the current tree and the new tree. Note that outside # leaves of the combined tree are determined by the direction. z_left, r_left, z_left_grad, z_right, r_right, r_right_grad = cond( going_right, (current_tree, new_tree), - lambda trees: (trees[0].z_left, trees[0].r_left, - trees[0].z_left_grad, trees[1].z_right, - trees[1].r_right, trees[1].z_right_grad), + lambda trees: ( + trees[0].z_left, + trees[0].r_left, + trees[0].z_left_grad, + trees[1].z_right, + trees[1].r_right, + trees[1].z_right_grad, + ), (new_tree, current_tree), - lambda trees: (trees[0].z_left, trees[0].r_left, - trees[0].z_left_grad, trees[1].z_right, - trees[1].r_right, trees[1].z_right_grad) + lambda trees: ( + trees[0].z_left, + trees[0].r_left, + trees[0].z_left_grad, + trees[1].z_right, + trees[1].r_right, + trees[1].z_right_grad, + ), ) r_sum = tree_multimap(jnp.add, current_tree.r_sum, new_tree.r_sum) if biased_transition: transition_prob = _biased_transition_kernel(current_tree, new_tree) - turning = new_tree.turning | _is_turning(inverse_mass_matrix, r_left, r_right, r_sum) + turning = new_tree.turning | _is_turning( + inverse_mass_matrix, r_left, r_right, r_sum + ) else: transition_prob = _uniform_transition_kernel(current_tree, new_tree) turning = current_tree.turning @@ -648,8 +798,20 @@ def _combine_tree(current_tree, new_tree, inverse_mass_matrix, going_right, rng_ transition = random.bernoulli(rng_key, transition_prob) z_proposal, z_proposal_pe, z_proposal_grad, z_proposal_energy = cond( transition, - new_tree, lambda tree: (tree.z_proposal, tree.z_proposal_pe, tree.z_proposal_grad, tree.z_proposal_energy), - current_tree, lambda tree: (tree.z_proposal, tree.z_proposal_pe, tree.z_proposal_grad, tree.z_proposal_energy) + new_tree, + lambda tree: ( + tree.z_proposal, + tree.z_proposal_pe, + tree.z_proposal_grad, + tree.z_proposal_energy, + ), + current_tree, + lambda tree: ( + tree.z_proposal, + tree.z_proposal_pe, + tree.z_proposal_grad, + tree.z_proposal_energy, + ), ) tree_depth = current_tree.depth + 1 @@ -659,19 +821,42 @@ def _combine_tree(current_tree, new_tree, inverse_mass_matrix, going_right, rng_ sum_accept_probs = current_tree.sum_accept_probs + new_tree.sum_accept_probs num_proposals = current_tree.num_proposals + new_tree.num_proposals - return TreeInfo(z_left, r_left, z_left_grad, z_right, r_right, r_right_grad, - z_proposal, z_proposal_pe, z_proposal_grad, z_proposal_energy, - tree_depth, tree_weight, r_sum, turning, diverging, - sum_accept_probs, num_proposals) + return TreeInfo( + z_left, + r_left, + z_left_grad, + z_right, + r_right, + r_right_grad, + z_proposal, + z_proposal_pe, + z_proposal_grad, + z_proposal_energy, + tree_depth, + tree_weight, + r_sum, + turning, + diverging, + sum_accept_probs, + num_proposals, + ) -def _build_basetree(vv_update, kinetic_fn, z, r, z_grad, inverse_mass_matrix, step_size, going_right, - energy_current, max_delta_energy): +def _build_basetree( + vv_update, + kinetic_fn, + z, + r, + z_grad, + inverse_mass_matrix, + step_size, + going_right, + energy_current, + max_delta_energy, +): step_size = jnp.where(going_right, step_size, -step_size) z_new, r_new, potential_energy_new, z_new_grad = vv_update( - step_size, - inverse_mass_matrix, - (z, r, energy_current, z_grad), + step_size, inverse_mass_matrix, (z, r, energy_current, z_grad) ) energy_new = potential_energy_new + kinetic_fn(inverse_mass_matrix, r_new) @@ -682,44 +867,82 @@ def _build_basetree(vv_update, kinetic_fn, z, r, z_grad, inverse_mass_matrix, st diverging = delta_energy > max_delta_energy accept_prob = jnp.clip(jnp.exp(-delta_energy), a_max=1.0) - return TreeInfo(z_new, r_new, z_new_grad, z_new, r_new, z_new_grad, - z_new, potential_energy_new, z_new_grad, energy_new, - depth=0, weight=tree_weight, r_sum=r_new, turning=False, - diverging=diverging, sum_accept_probs=accept_prob, num_proposals=1) + return TreeInfo( + z_new, + r_new, + z_new_grad, + z_new, + r_new, + z_new_grad, + z_new, + potential_energy_new, + z_new_grad, + energy_new, + depth=0, + weight=tree_weight, + r_sum=r_new, + turning=False, + diverging=diverging, + sum_accept_probs=accept_prob, + num_proposals=1, + ) def _get_leaf(tree, going_right): - return cond(going_right, - tree, - lambda tree: (tree.z_right, tree.r_right, tree.z_right_grad), - tree, - lambda tree: (tree.z_left, tree.r_left, tree.z_left_grad)) + return cond( + going_right, + tree, + lambda tree: (tree.z_right, tree.r_right, tree.z_right_grad), + tree, + lambda tree: (tree.z_left, tree.r_left, tree.z_left_grad), + ) -def _double_tree(current_tree, vv_update, kinetic_fn, inverse_mass_matrix, step_size, - going_right, rng_key, energy_current, max_delta_energy, r_ckpts, r_sum_ckpts): +def _double_tree( + current_tree, + vv_update, + kinetic_fn, + inverse_mass_matrix, + step_size, + going_right, + rng_key, + energy_current, + max_delta_energy, + r_ckpts, + r_sum_ckpts, +): key, transition_key = random.split(rng_key) - new_tree = _iterative_build_subtree(current_tree, vv_update, kinetic_fn, - inverse_mass_matrix, step_size, - going_right, key, energy_current, max_delta_energy, - r_ckpts, r_sum_ckpts) + new_tree = _iterative_build_subtree( + current_tree, + vv_update, + kinetic_fn, + inverse_mass_matrix, + step_size, + going_right, + key, + energy_current, + max_delta_energy, + r_ckpts, + r_sum_ckpts, + ) - return _combine_tree(current_tree, new_tree, inverse_mass_matrix, going_right, transition_key, - True) + return _combine_tree( + current_tree, new_tree, inverse_mass_matrix, going_right, transition_key, True + ) def _leaf_idx_to_ckpt_idxs(n): # computes the number of non-zero bits except the last bit # e.g. 6 -> 2, 7 -> 2, 13 -> 2 - _, idx_max = while_loop(lambda nc: nc[0] > 0, - lambda nc: (nc[0] >> 1, nc[1] + (nc[0] & 1)), - (n >> 1, 0)) + _, idx_max = while_loop( + lambda nc: nc[0] > 0, lambda nc: (nc[0] >> 1, nc[1] + (nc[0] & 1)), (n >> 1, 0) + ) # computes the number of contiguous last non-zero bits # e.g. 6 -> 0, 7 -> 3, 13 -> 1 - _, num_subtrees = while_loop(lambda nc: (nc[0] & 1) != 0, - lambda nc: (nc[0] >> 1, nc[1] + 1), - (n, 0)) + _, num_subtrees = while_loop( + lambda nc: (nc[0] & 1) != 0, lambda nc: (nc[0] >> 1, nc[1] + 1), (n, 0) + ) # TODO: explore the potential of setting idx_min=0 to allow more turning checks # It will be useful in case: e.g. assume a tree 0 -> 7 is a circle, # subtrees 0 -> 3, 4 -> 7 are half-circles, which two leaves might not @@ -733,8 +956,16 @@ def _leaf_idx_to_ckpt_idxs(n): return idx_min, idx_max -def _is_iterative_turning(inverse_mass_matrix, r, r_sum, r_ckpts, r_sum_ckpts, idx_min, idx_max, - unravel_fn=identity): +def _is_iterative_turning( + inverse_mass_matrix, + r, + r_sum, + r_ckpts, + r_sum_ckpts, + idx_min, + idx_max, + unravel_fn=identity, +): def _body_fn(state): i, _ = state subtree_r_sum = r_sum - r_sum_ckpts[i] + r_ckpts[i] @@ -742,15 +973,25 @@ def _body_fn(state): r_left = unravel_fn(r_ckpts[i]) return i - 1, _is_turning(inverse_mass_matrix, r_left, r, subtree_r_sum) - _, turning = while_loop(lambda it: (it[0] >= idx_min) & ~it[1], - _body_fn, - (idx_max, False)) + _, turning = while_loop( + lambda it: (it[0] >= idx_min) & ~it[1], _body_fn, (idx_max, False) + ) return turning -def _iterative_build_subtree(prototype_tree, vv_update, kinetic_fn, - inverse_mass_matrix, step_size, going_right, rng_key, - energy_current, max_delta_energy, r_ckpts, r_sum_ckpts): +def _iterative_build_subtree( + prototype_tree, + vv_update, + kinetic_fn, + inverse_mass_matrix, + step_size, + going_right, + rng_key, + energy_current, + max_delta_energy, + r_ckpts, + r_sum_ckpts, +): max_num_proposals = 2 ** prototype_tree.depth def _cond_fn(state): @@ -762,13 +1003,31 @@ def _body_fn(state): rng_key, transition_rng_key = random.split(rng_key) # If we are going to the right, start from the right leaf of the current tree. z, r, z_grad = _get_leaf(current_tree, going_right) - new_leaf = _build_basetree(vv_update, kinetic_fn, z, r, z_grad, inverse_mass_matrix, step_size, - going_right, energy_current, max_delta_energy) - new_tree = cond(current_tree.num_proposals == 0, - new_leaf, - identity, - (current_tree, new_leaf, inverse_mass_matrix, going_right, transition_rng_key), - lambda x: _combine_tree(*x, False)) + new_leaf = _build_basetree( + vv_update, + kinetic_fn, + z, + r, + z_grad, + inverse_mass_matrix, + step_size, + going_right, + energy_current, + max_delta_energy, + ) + new_tree = cond( + current_tree.num_proposals == 0, + new_leaf, + identity, + ( + current_tree, + new_leaf, + inverse_mass_matrix, + going_right, + transition_rng_key, + ), + lambda x: _combine_tree(*x, False), + ) leaf_idx = current_tree.num_proposals # NB: in the special case leaf_idx=0, ckpt_idx_min=1 and ckpt_idx_max=0, @@ -777,35 +1036,66 @@ def _body_fn(state): r, unravel_fn = ravel_pytree(new_leaf.r_right) r_sum, _ = ravel_pytree(new_tree.r_sum) # we update checkpoints when leaf_idx is even - r_ckpts, r_sum_ckpts = cond(leaf_idx % 2 == 0, - (r_ckpts, r_sum_ckpts), - lambda x: (index_update(x[0], ckpt_idx_max, r), - index_update(x[1], ckpt_idx_max, r_sum)), - (r_ckpts, r_sum_ckpts), - identity) - - turning = _is_iterative_turning(inverse_mass_matrix, new_leaf.r_right, r_sum, - r_ckpts, r_sum_ckpts, - ckpt_idx_min, ckpt_idx_max, unravel_fn) + r_ckpts, r_sum_ckpts = cond( + leaf_idx % 2 == 0, + (r_ckpts, r_sum_ckpts), + lambda x: ( + index_update(x[0], ckpt_idx_max, r), + index_update(x[1], ckpt_idx_max, r_sum), + ), + (r_ckpts, r_sum_ckpts), + identity, + ) + + turning = _is_iterative_turning( + inverse_mass_matrix, + new_leaf.r_right, + r_sum, + r_ckpts, + r_sum_ckpts, + ckpt_idx_min, + ckpt_idx_max, + unravel_fn, + ) return new_tree, turning, r_ckpts, r_sum_ckpts, rng_key basetree = prototype_tree._replace(num_proposals=0) tree, turning, _, _, _ = while_loop( - _cond_fn, - _body_fn, - (basetree, False, r_ckpts, r_sum_ckpts, rng_key) + _cond_fn, _body_fn, (basetree, False, r_ckpts, r_sum_ckpts, rng_key) ) # update depth and turning condition - return TreeInfo(tree.z_left, tree.r_left, tree.z_left_grad, - tree.z_right, tree.r_right, tree.z_right_grad, - tree.z_proposal, tree.z_proposal_pe, tree.z_proposal_grad, tree.z_proposal_energy, - prototype_tree.depth, tree.weight, tree.r_sum, turning, tree.diverging, - tree.sum_accept_probs, tree.num_proposals) + return TreeInfo( + tree.z_left, + tree.r_left, + tree.z_left_grad, + tree.z_right, + tree.r_right, + tree.z_right_grad, + tree.z_proposal, + tree.z_proposal_pe, + tree.z_proposal_grad, + tree.z_proposal_energy, + prototype_tree.depth, + tree.weight, + tree.r_sum, + turning, + tree.diverging, + tree.sum_accept_probs, + tree.num_proposals, + ) -def build_tree(verlet_update, kinetic_fn, verlet_state, inverse_mass_matrix, step_size, rng_key, - max_delta_energy=1000., max_tree_depth=10): +def build_tree( + verlet_update, + kinetic_fn, + verlet_state, + inverse_mass_matrix, + step_size, + rng_key, + max_delta_energy=1000.0, + max_tree_depth=10, +): """ Builds a binary tree from the `verlet_state`. This is used in NUTS sampler. @@ -835,11 +1125,25 @@ def build_tree(verlet_update, kinetic_fn, verlet_state, inverse_mass_matrix, ste r_ckpts = jnp.zeros((max_tree_depth, latent_size)) r_sum_ckpts = jnp.zeros((max_tree_depth, latent_size)) - tree = TreeInfo(z, r, z_grad, z, r, z_grad, z, potential_energy, z_grad, energy_current, - depth=0, weight=jnp.zeros(()), r_sum=r, turning=jnp.array(False), - diverging=jnp.array(False), - sum_accept_probs=jnp.zeros(()), - num_proposals=jnp.array(0, dtype=jnp.result_type(int))) + tree = TreeInfo( + z, + r, + z_grad, + z, + r, + z_grad, + z, + potential_energy, + z_grad, + energy_current, + depth=0, + weight=jnp.zeros(()), + r_sum=r, + turning=jnp.array(False), + diverging=jnp.array(False), + sum_accept_probs=jnp.zeros(()), + num_proposals=jnp.array(0, dtype=jnp.result_type(int)), + ) def _cond_fn(state): tree, _ = state @@ -849,9 +1153,19 @@ def _body_fn(state): tree, key = state key, direction_key, doubling_key = random.split(key, 3) going_right = random.bernoulli(direction_key) - tree = _double_tree(tree, verlet_update, kinetic_fn, inverse_mass_matrix, step_size, - going_right, doubling_key, energy_current, max_delta_energy, - r_ckpts, r_sum_ckpts) + tree = _double_tree( + tree, + verlet_update, + kinetic_fn, + inverse_mass_matrix, + step_size, + going_right, + doubling_key, + energy_current, + max_delta_energy, + r_ckpts, + r_sum_ckpts, + ) return tree, key state = (tree, rng_key) @@ -923,7 +1237,9 @@ def consensus(subposteriors, num_draws=None, diagonal=False, rng_key=None): # stack subposteriors joined_subposteriors = tree_multimap(lambda *args: jnp.stack(args), *subposteriors) # shape of joined_subposteriors: n_subs x n_samples x sample_shape - joined_subposteriors = vmap(vmap(lambda sample: ravel_pytree(sample)[0]))(joined_subposteriors) + joined_subposteriors = vmap(vmap(lambda sample: ravel_pytree(sample)[0]))( + joined_subposteriors + ) if num_draws is not None: rng_key = random.PRNGKey(0) if rng_key is None else rng_key @@ -931,19 +1247,29 @@ def consensus(subposteriors, num_draws=None, diagonal=False, rng_key=None): n_subs = len(subposteriors) n_samples = tree_flatten(subposteriors[0])[0][0].shape[0] # shape of draw_idxs: n_subs x num_draws x sample_shape - draw_idxs = random.randint(rng_key, shape=(n_subs, num_draws), minval=0, maxval=n_samples) - joined_subposteriors = vmap(lambda x, idx: x[idx])(joined_subposteriors, draw_idxs) + draw_idxs = random.randint( + rng_key, shape=(n_subs, num_draws), minval=0, maxval=n_samples + ) + joined_subposteriors = vmap(lambda x, idx: x[idx])( + joined_subposteriors, draw_idxs + ) if diagonal: # compute weights for each subposterior (ref: Section 3.1 of [1]) weights = vmap(lambda x: 1 / jnp.var(x, ddof=1, axis=0))(joined_subposteriors) normalized_weights = weights / jnp.sum(weights, axis=0) # get weighted samples - samples_flat = jnp.einsum('ij,ikj->kj', normalized_weights, joined_subposteriors) + samples_flat = jnp.einsum( + "ij,ikj->kj", normalized_weights, joined_subposteriors + ) else: weights = vmap(lambda x: jnp.linalg.inv(jnp.cov(x.T)))(joined_subposteriors) - normalized_weights = jnp.matmul(jnp.linalg.inv(jnp.sum(weights, axis=0)), weights) - samples_flat = jnp.einsum('ijk,ilk->lj', normalized_weights, joined_subposteriors) + normalized_weights = jnp.matmul( + jnp.linalg.inv(jnp.sum(weights, axis=0)), weights + ) + samples_flat = jnp.einsum( + "ijk,ilk->lj", normalized_weights, joined_subposteriors + ) # unravel_fn acts on 1 sample of a subposterior _, unravel_fn = ravel_pytree(tree_map(lambda x: x[0], subposteriors[0])) @@ -965,7 +1291,9 @@ def parametric(subposteriors, diagonal=False): :return: the estimated mean and variance/covariance parameters of the joined posterior """ joined_subposteriors = tree_multimap(lambda *args: jnp.stack(args), *subposteriors) - joined_subposteriors = vmap(vmap(lambda sample: ravel_pytree(sample)[0]))(joined_subposteriors) + joined_subposteriors = vmap(vmap(lambda sample: ravel_pytree(sample)[0]))( + joined_subposteriors + ) submeans = jnp.mean(joined_subposteriors, axis=1) if diagonal: @@ -974,7 +1302,7 @@ def parametric(subposteriors, diagonal=False): normalized_weights = var * weights # comparing to consensus implementation, we compute weighted mean here - mean = jnp.einsum('ij,ij->j', normalized_weights, submeans) + mean = jnp.einsum("ij,ij->j", normalized_weights, submeans) return mean, var else: weights = vmap(lambda x: jnp.linalg.inv(jnp.cov(x.T)))(joined_subposteriors) @@ -982,7 +1310,7 @@ def parametric(subposteriors, diagonal=False): normalized_weights = jnp.matmul(cov, weights) # comparing to consensus implementation, we compute weighted mean here - mean = jnp.einsum('ijk,ik->j', normalized_weights, submeans) + mean = jnp.einsum("ijk,ik->j", normalized_weights, submeans) return mean, cov diff --git a/numpyro/infer/initialization.py b/numpyro/infer/initialization.py index 48271ef69..d1a2d1912 100644 --- a/numpyro/infer/initialization.py +++ b/numpyro/infer/initialization.py @@ -20,11 +20,17 @@ def init_to_median(site=None, num_samples=15): if site is None: return partial(init_to_median, num_samples=num_samples) - if site['type'] == 'sample' and not site['is_observed'] and not site['fn'].is_discrete: - rng_key = site['kwargs'].get('rng_key') - sample_shape = site['kwargs'].get('sample_shape') + if ( + site["type"] == "sample" + and not site["is_observed"] + and not site["fn"].is_discrete + ): + rng_key = site["kwargs"].get("rng_key") + sample_shape = site["kwargs"].get("sample_shape") try: - samples = site['fn'](sample_shape=(num_samples,) + sample_shape, rng_key=rng_key) + samples = site["fn"]( + sample_shape=(num_samples,) + sample_shape, rng_key=rng_key + ) return jnp.median(samples, axis=0) except NotImplementedError: return init_to_uniform(site) @@ -47,15 +53,20 @@ def init_to_uniform(site=None, radius=2): if site is None: return partial(init_to_uniform, radius=radius) - if site['type'] == 'sample' and not site['is_observed'] and not site['fn'].is_discrete: - rng_key = site['kwargs'].get('rng_key') - sample_shape = site['kwargs'].get('sample_shape') + if ( + site["type"] == "sample" + and not site["is_observed"] + and not site["fn"].is_discrete + ): + rng_key = site["kwargs"].get("rng_key") + sample_shape = site["kwargs"].get("sample_shape") rng_key, subkey = random.split(rng_key) - transform = biject_to(site['fn'].support) + transform = biject_to(site["fn"].support) unconstrained_shape = transform.inverse_shape(site["fn"].shape()) unconstrained_samples = dist.Uniform(-radius, radius)( - rng_key=rng_key, sample_shape=sample_shape + unconstrained_shape) + rng_key=rng_key, sample_shape=sample_shape + unconstrained_shape + ) return transform(unconstrained_samples) @@ -77,8 +88,8 @@ def init_to_value(site=None, values={}): if site is None: return partial(init_to_value, values=values) - if site['type'] == 'sample' and not site['is_observed']: - if site['name'] in values: - return values[site['name']] + if site["type"] == "sample" and not site["is_observed"]: + if site["name"] in values: + return values[site["name"]] else: # defer to default strategy return init_to_uniform(site) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index fe0f9c347..3af9da5a6 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -17,8 +17,8 @@ from numpyro.util import cached_by, fori_collect, identity __all__ = [ - 'MCMCKernel', - 'MCMC', + "MCMCKernel", + "MCMC", ] @@ -67,6 +67,7 @@ class MCMCKernel(ABC): >>> samples = mcmc.get_samples() >>> mcmc.print_summary() # doctest: +SKIP """ + def postprocess_fn(self, model_args, model_kwargs): """ Get a function that transforms unconstrained values at sample sites to values @@ -137,13 +138,13 @@ def get_diagnostics_str(self, state): Given the current `state`, returns the diagnostics string to be added to progress bar for diagnostics purpose. """ - return '' + return "" def _get_progbar_desc_str(num_warmup, phase, i): if phase is not None: return phase - return 'warmup' if i < num_warmup else 'sample' + return "warmup" if i < num_warmup else "sample" def _get_value_from_index(xs, i): @@ -168,7 +169,7 @@ def _sample_fn_jit_args(state, sampler): def _sample_fn_nojit_args(state, sampler, args, kwargs): # state is a tuple of size 1 - containing HMCState - return sampler.sample(state[0], args, kwargs), + return (sampler.sample(state[0], args, kwargs),) def _collect_fn(collect_fields): @@ -229,16 +230,19 @@ class MCMC(object): computation as a function of model arguments. As such, calling `MCMC.run` again on a same sized but different dataset will not result in additional compilation cost. """ - def __init__(self, - sampler, - num_warmup, - num_samples, - num_chains=1, - thinning=1, - postprocess_fn=None, - chain_method='parallel', - progress_bar=True, - jit_model_args=False): + + def __init__( + self, + sampler, + num_warmup, + num_samples, + num_chains=1, + thinning=1, + postprocess_fn=None, + chain_method="parallel", + progress_bar=True, + jit_model_args=False, + ): self.sampler = sampler self._sample_field = sampler.sample_field self._default_fields = sampler.default_fields @@ -246,20 +250,25 @@ def __init__(self, self.num_samples = num_samples self.num_chains = num_chains if not isinstance(thinning, int) or thinning < 1: - raise ValueError('thinning must be a positive integer') + raise ValueError("thinning must be a positive integer") self.thinning = thinning self.postprocess_fn = postprocess_fn - if chain_method not in ['parallel', 'vectorized', 'sequential']: - raise ValueError('Only supporting the following methods to draw chains:' - ' "sequential", "parallel", or "vectorized"') - if chain_method == 'parallel' and local_device_count() < self.num_chains: - chain_method = 'sequential' - warnings.warn('There are not enough devices to run parallel chains: expected {} but got {}.' - ' Chains will be drawn sequentially. If you are running MCMC in CPU,' - ' consider using `numpyro.set_host_device_count({})` at the beginning' - ' of your program. You can double-check how many devices are available in' - ' your system using `jax.local_device_count()`.' - .format(self.num_chains, local_device_count(), self.num_chains)) + if chain_method not in ["parallel", "vectorized", "sequential"]: + raise ValueError( + "Only supporting the following methods to draw chains:" + ' "sequential", "parallel", or "vectorized"' + ) + if chain_method == "parallel" and local_device_count() < self.num_chains: + chain_method = "sequential" + warnings.warn( + "There are not enough devices to run parallel chains: expected {} but got {}." + " Chains will be drawn sequentially. If you are running MCMC in CPU," + " consider using `numpyro.set_host_device_count({})` at the beginning" + " of your program. You can double-check how many devices are available in" + " your system using `jax.local_device_count()`.".format( + self.num_chains, local_device_count(), self.num_chains + ) + ) self.chain_method = chain_method self.progress_bar = progress_bar if "CI" in os.environ or "PYTEST_XDIST_WORKER" in os.environ: @@ -282,7 +291,9 @@ def _get_cached_fns(self): args, kwargs = (None,), (None,) else: args = tree_map(lambda x: _hashable(x), self._args) - kwargs = tree_map(lambda x: _hashable(x), tuple(sorted(self._kwargs.items()))) + kwargs = tree_map( + lambda x: _hashable(x), tuple(sorted(self._kwargs.items())) + ) key = args + kwargs try: fns = self._cache.get(key, None) @@ -306,10 +317,15 @@ def laxmap_postprocess_fn(states, args, kwargs): sample_fn = partial(_sample_fn_jit_args, sampler=self.sampler) postprocess_fn = jit(laxmap_postprocess_fn) else: - sample_fn = partial(_sample_fn_nojit_args, sampler=self.sampler, - args=self._args, kwargs=self._kwargs) - postprocess_fn = jit(partial(laxmap_postprocess_fn, - args=self._args, kwargs=self._kwargs)) + sample_fn = partial( + _sample_fn_nojit_args, + sampler=self.sampler, + args=self._args, + kwargs=self._kwargs, + ) + postprocess_fn = jit( + partial(laxmap_postprocess_fn, args=self._args, kwargs=self._kwargs) + ) fns = sample_fn, postprocess_fn if key is not None: @@ -330,28 +346,43 @@ def _get_cached_init_state(self, rng_key, args, kwargs): def _single_chain_mcmc(self, init, args, kwargs, collect_fields): rng_key, init_state, init_params = init if init_state is None: - init_state = self.sampler.init(rng_key, self.num_warmup, init_params, - model_args=args, model_kwargs=kwargs) + init_state = self.sampler.init( + rng_key, + self.num_warmup, + init_params, + model_args=args, + model_kwargs=kwargs, + ) sample_fn, postprocess_fn = self._get_cached_fns() - diagnostics = lambda x: self.sampler.get_diagnostics_str(x[0]) if rng_key.ndim == 1 else '' # noqa: E731 + diagnostics = ( + lambda x: self.sampler.get_diagnostics_str(x[0]) + if rng_key.ndim == 1 + else "" + ) # noqa: E731 init_val = (init_state, args, kwargs) if self._jit_model_args else (init_state,) lower_idx = self._collection_params["lower"] upper_idx = self._collection_params["upper"] phase = self._collection_params["phase"] collection_size = self._collection_params["collection_size"] - collection_size = collection_size if collection_size is None else collection_size // self.thinning - collect_vals = fori_collect(lower_idx, - upper_idx, - sample_fn, - init_val, - transform=_collect_fn(collect_fields), - progbar=self.progress_bar, - return_last_val=True, - thinning=self.thinning, - collection_size=collection_size, - progbar_desc=partial(_get_progbar_desc_str, lower_idx, phase), - diagnostics_fn=diagnostics, - num_chains=self.num_chains if self.chain_method == 'parallel' else 1) + collection_size = ( + collection_size + if collection_size is None + else collection_size // self.thinning + ) + collect_vals = fori_collect( + lower_idx, + upper_idx, + sample_fn, + init_val, + transform=_collect_fn(collect_fields), + progbar=self.progress_bar, + return_last_val=True, + thinning=self.thinning, + collection_size=collection_size, + progbar_desc=partial(_get_progbar_desc_str, lower_idx, phase), + diagnostics_fn=diagnostics, + num_chains=self.num_chains if self.chain_method == "parallel" else 1, + ) states, last_val = collect_vals # Get first argument of type `HMCState` last_state = last_val[0] @@ -365,20 +396,28 @@ def _single_chain_mcmc(self, init, args, kwargs, collect_fields): # (which happens when lower_idx==upper_idx) if len(site_values) > 0 and jnp.shape(site_values[0])[0] > 0: if self._jit_model_args: - states[self._sample_field] = postprocess_fn(states[self._sample_field], args, kwargs) + states[self._sample_field] = postprocess_fn( + states[self._sample_field], args, kwargs + ) else: states[self._sample_field] = postprocess_fn(states[self._sample_field]) return states, last_state - def _set_collection_params(self, lower=None, upper=None, collection_size=None, phase=None): + def _set_collection_params( + self, lower=None, upper=None, collection_size=None, phase=None + ): self._collection_params["lower"] = self.num_warmup if lower is None else lower - self._collection_params["upper"] = self.num_warmup + self.num_samples if upper is None else upper + self._collection_params["upper"] = ( + self.num_warmup + self.num_samples if upper is None else upper + ) self._collection_params["collection_size"] = collection_size self._collection_params["phase"] = phase def _compile(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): self._set_collection_params(0, 0, self.num_samples) - self.run(rng_key, *args, extra_fields=extra_fields, init_params=init_params, **kwargs) + self.run( + rng_key, *args, extra_fields=extra_fields, init_params=init_params, **kwargs + ) rng_key = (_hashable(rng_key),) args = tree_map(lambda x: _hashable(x), args) kwargs = tree_map(lambda x: _hashable(x), tuple(sorted(kwargs.items()))) @@ -420,7 +459,15 @@ def last_state(self): """ return self._last_state - def warmup(self, rng_key, *args, extra_fields=(), collect_warmup=False, init_params=None, **kwargs): + def warmup( + self, + rng_key, + *args, + extra_fields=(), + collect_warmup=False, + init_params=None, + **kwargs + ): """ Run the MCMC warmup adaptation phase. After this call, `self.warmup_state` will be set and the :meth:`run` method will skip the warmup adaptation phase. To run `warmup` again @@ -444,8 +491,12 @@ def warmup(self, rng_key, *args, extra_fields=(), collect_warmup=False, init_par if collect_warmup: self._set_collection_params(0, self.num_warmup, self.num_warmup, "warmup") else: - self._set_collection_params(self.num_warmup, self.num_warmup, self.num_samples, "warmup") - self.run(rng_key, *args, extra_fields=extra_fields, init_params=init_params, **kwargs) + self._set_collection_params( + self.num_warmup, self.num_warmup, self.num_samples, "warmup" + ) + self.run( + rng_key, *args, extra_fields=extra_fields, init_params=init_params, **kwargs + ) self._warmup_state = self._last_state def run(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): @@ -470,7 +521,9 @@ def run(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): See https://jax.readthedocs.io/en/latest/async_dispatch.html and https://jax.readthedocs.io/en/latest/profiling.html for pointers on profiling jax programs. """ - init_params = tree_map(lambda x: lax.convert_element_type(x, jnp.result_type(x)), init_params) + init_params = tree_map( + lambda x: lax.convert_element_type(x, jnp.result_type(x)), init_params + ) self._args = args self._kwargs = kwargs init_state = self._get_cached_init_state(rng_key, args, kwargs) @@ -484,30 +537,41 @@ def run(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): if init_params is not None and self.num_chains > 1: prototype_init_val = tree_flatten(init_params)[0][0] if jnp.shape(prototype_init_val)[0] != self.num_chains: - raise ValueError('`init_params` must have the same leading dimension' - ' as `num_chains`.') + raise ValueError( + "`init_params` must have the same leading dimension" + " as `num_chains`." + ) assert isinstance(extra_fields, (tuple, list)) - collect_fields = tuple(set((self._sample_field,) + tuple(self._default_fields) + - tuple(extra_fields))) - partial_map_fn = partial(self._single_chain_mcmc, - args=args, - kwargs=kwargs, - collect_fields=collect_fields) + collect_fields = tuple( + set( + (self._sample_field,) + + tuple(self._default_fields) + + tuple(extra_fields) + ) + ) + partial_map_fn = partial( + self._single_chain_mcmc, + args=args, + kwargs=kwargs, + collect_fields=collect_fields, + ) map_args = (rng_key, init_state, init_params) if self.num_chains == 1: states_flat, last_state = partial_map_fn(map_args) states = tree_map(lambda x: x[jnp.newaxis, ...], states_flat) else: - if self.chain_method == 'sequential': + if self.chain_method == "sequential": states, last_state = _laxmap(partial_map_fn, map_args) - elif self.chain_method == 'parallel': + elif self.chain_method == "parallel": states, last_state = pmap(partial_map_fn)(map_args) else: - assert self.chain_method == 'vectorized' + assert self.chain_method == "vectorized" states, last_state = partial_map_fn(map_args) # swap num_samples x num_chains to num_chains x num_samples states = tree_map(lambda x: jnp.swapaxes(x, 0, 1), states) - states_flat = tree_map(lambda x: jnp.reshape(x, (-1,) + x.shape[2:]), states) + states_flat = tree_map( + lambda x: jnp.reshape(x, (-1,) + x.shape[2:]), states + ) self._last_state = last_state self._states = states self._states_flat = states_flat @@ -524,8 +588,11 @@ def get_samples(self, group_by_chain=False): but can be any :func:`jaxlib.pytree`, more generally (e.g. when defining a `potential_fn` for HMC that takes `list` args). """ - return self._states[self._sample_field] if group_by_chain \ + return ( + self._states[self._sample_field] + if group_by_chain else self._states_flat[self._sample_field] + ) def get_extra_fields(self, group_by_chain=False): """ @@ -557,12 +624,17 @@ def print_summary(self, prob=0.9, exclude_deterministic=True): # they can have different key names, not necessary due to deterministic # behavior. We might revise this logic if needed in the future. if isinstance(state_sample_field, dict): - sites = {k: v for k, v in self._states[self._sample_field].items() - if k in state_sample_field} + sites = { + k: v + for k, v in self._states[self._sample_field].items() + if k in state_sample_field + } print_summary(sites, prob=prob) extra_fields = self.get_extra_fields() - if 'diverging' in extra_fields: - print("Number of divergences: {}".format(jnp.sum(extra_fields['diverging']))) + if "diverging" in extra_fields: + print( + "Number of divergences: {}".format(jnp.sum(extra_fields["diverging"])) + ) def __getstate__(self): state = self.__dict__.copy() diff --git a/numpyro/infer/mixed_hmc.py b/numpyro/infer/mixed_hmc.py index 73a285e6b..f0df47e47 100644 --- a/numpyro/infer/mixed_hmc.py +++ b/numpyro/infer/mixed_hmc.py @@ -67,33 +67,50 @@ class MixedHMC(DiscreteHMCGibbs): >>> assert abs(jnp.var(samples["x"]) - 4.36) < 0.5 """ - def __init__(self, inner_kernel, *, num_discrete_updates=None, random_walk=False, modified=False): + def __init__( + self, + inner_kernel, + *, + num_discrete_updates=None, + random_walk=False, + modified=False + ): super().__init__(inner_kernel, random_walk=random_walk, modified=modified) if inner_kernel._algo == "NUTS": - raise ValueError("The algorithm only works with HMC and and does not support NUTS.") + raise ValueError( + "The algorithm only works with HMC and and does not support NUTS." + ) self._num_discrete_updates = num_discrete_updates def init(self, rng_key, num_warmup, init_params, model_args, model_kwargs): rng_key, rng_r = random.split(rng_key) state = super().init(rng_key, num_warmup, init_params, model_args, model_kwargs) - self._support_sizes_flat, _ = ravel_pytree({k: self._support_sizes[k] for k in self._gibbs_sites}) + self._support_sizes_flat, _ = ravel_pytree( + {k: self._support_sizes[k] for k in self._gibbs_sites} + ) if self._num_discrete_updates is None: self._num_discrete_updates = self._support_sizes_flat.shape[0] self._num_warmup = num_warmup # NB: the warmup adaptation can not be performed in sub-trajectories (i.e. the hmc trajectory # between two discrete updates), so we will do it here, at the end of each MixedHMC step. - _, self._wa_update = warmup_adapter(num_warmup, - adapt_step_size=self.inner_kernel._adapt_step_size, - adapt_mass_matrix=self.inner_kernel._adapt_mass_matrix, - dense_mass=self.inner_kernel._dense_mass, - target_accept_prob=self.inner_kernel._target_accept_prob, - find_reasonable_step_size=None) + _, self._wa_update = warmup_adapter( + num_warmup, + adapt_step_size=self.inner_kernel._adapt_step_size, + adapt_mass_matrix=self.inner_kernel._adapt_mass_matrix, + dense_mass=self.inner_kernel._dense_mass, + target_accept_prob=self.inner_kernel._target_accept_prob, + find_reasonable_step_size=None, + ) # In HMC, when `hmc_state.r` is not None, we will skip drawing a random momemtum at the # beginning of an HMC step. The reason is we need to maintain `r` between each sub-trajectories. - r = momentum_generator(state.hmc_state.z, state.hmc_state.adapt_state.mass_matrix_sqrt, rng_r) - return MixedHMCState(state.z, state.hmc_state._replace(r=r), state.rng_key, jnp.zeros(())) + r = momentum_generator( + state.hmc_state.z, state.hmc_state.adapt_state.mass_matrix_sqrt, rng_r + ) + return MixedHMCState( + state.z, state.hmc_state._replace(r=r), state.rng_key, jnp.zeros(()) + ) def sample(self, state, model_args, model_kwargs): model_kwargs = {} if model_kwargs is None else model_kwargs @@ -101,13 +118,26 @@ def sample(self, state, model_args, model_kwargs): def potential_fn(z_gibbs, z_hmc): return self.inner_kernel._potential_fn_gen( - *model_args, _gibbs_sites=z_gibbs, **model_kwargs)(z_hmc) + *model_args, _gibbs_sites=z_gibbs, **model_kwargs + )(z_hmc) - def update_discrete(idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum): + def update_discrete( + idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum + ): # Algo 1, line 19: get a new discrete proposal - rng_key, z_discrete_new, pe_new, log_accept_ratio = self._discrete_proposal_fn( - rng_key, z_discrete, hmc_state.potential_energy, - partial(potential_fn, z_hmc=hmc_state.z), idx, self._support_sizes_flat[idx]) + ( + rng_key, + z_discrete_new, + pe_new, + log_accept_ratio, + ) = self._discrete_proposal_fn( + rng_key, + z_discrete, + hmc_state.potential_energy, + partial(potential_fn, z_hmc=hmc_state.z), + idx, + self._support_sizes_flat[idx], + ) # Algo 1, line 20: depending on reject or refract, we will update # the discrete variable and its corresponding kinetic energy. In case of # refract, we will need to update the potential energy and its grad w.r.t. hmc_state.z @@ -116,9 +146,16 @@ def update_discrete(idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_s z_discrete, pe, ke_discrete_i, z_grad = lax.cond( ke_discrete_i_new > 0, (z_discrete_new, pe_new, ke_discrete_i_new), - lambda vals: vals + (grad_(partial(potential_fn, vals[0]))(hmc_state.z),), - (z_discrete, hmc_state.potential_energy, ke_discrete[idx], hmc_state.z_grad), - identity) + lambda vals: vals + + (grad_(partial(potential_fn, vals[0]))(hmc_state.z),), + ( + z_discrete, + hmc_state.potential_energy, + ke_discrete[idx], + hmc_state.z_grad, + ), + identity, + ) delta_pe_sum = delta_pe_sum + pe - hmc_state.potential_energy ke_discrete = ops.index_update(ke_discrete, idx, ke_discrete_i) @@ -128,34 +165,55 @@ def update_discrete(idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_s def update_continuous(hmc_state, z_discrete): model_kwargs_ = model_kwargs.copy() model_kwargs_["_gibbs_sites"] = z_discrete - hmc_state_new = self.inner_kernel.sample(hmc_state, model_args, model_kwargs_) + hmc_state_new = self.inner_kernel.sample( + hmc_state, model_args, model_kwargs_ + ) # each time a sub-trajectory is performed, we need to reset i and adapt_state # (we will only update them at the end of HMCGibbs step) # For `num_steps`, we will record its cumulative sum for diagnostics - hmc_state = hmc_state_new._replace(i=hmc_state.i, - adapt_state=hmc_state.adapt_state, - num_steps=hmc_state.num_steps + hmc_state_new.num_steps) + hmc_state = hmc_state_new._replace( + i=hmc_state.i, + adapt_state=hmc_state.adapt_state, + num_steps=hmc_state.num_steps + hmc_state_new.num_steps, + ) return hmc_state def body_fn(i, vals): - rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum, arrival_times = vals + ( + rng_key, + hmc_state, + z_discrete, + ke_discrete, + delta_pe_sum, + arrival_times, + ) = vals idx = jnp.argmin(arrival_times) # NB: length of each sub-trajectory is scaled from the current min(arrival_times) # (see the note at total_time below) trajectory_length = arrival_times[idx] * time_unit arrival_times = arrival_times - arrival_times[idx] - arrival_times = ops.index_update(arrival_times, idx, 1.) + arrival_times = ops.index_update(arrival_times, idx, 1.0) # this is a trick, so that in a sub-trajectory of HMC, we always accept the new proposal pe = jnp.inf - hmc_state = hmc_state._replace(trajectory_length=trajectory_length, potential_energy=pe) + hmc_state = hmc_state._replace( + trajectory_length=trajectory_length, potential_energy=pe + ) # Algo 1, line 7: perform a sub-trajectory hmc_state = update_continuous(hmc_state, z_discrete) # Algo 1, line 8: perform a discrete update rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum = update_discrete( - idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum) - return rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum, arrival_times + idx, rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum + ) + return ( + rng_key, + hmc_state, + z_discrete, + ke_discrete, + delta_pe_sum, + arrival_times, + ) z_discrete = {k: v for k, v in state.z.items() if k not in state.hmc_state.z} rng_key, rng_ke, rng_time, rng_r, rng_accept = random.split(state.rng_key, 5) @@ -166,27 +224,40 @@ def body_fn(i, vals): # the same job: the sub-trajectory length eta_t * M_t is the lag between two arrival time. arrival_times = random.uniform(rng_time, (num_discretes,)) # compute the amount of time to make `num_discrete_updates` discrete updates - total_time = (self._num_discrete_updates - 1) // num_discretes \ - + jnp.sort(arrival_times)[(self._num_discrete_updates - 1) % num_discretes] + total_time = (self._num_discrete_updates - 1) // num_discretes + jnp.sort( + arrival_times + )[(self._num_discrete_updates - 1) % num_discretes] # NB: total_time can be different from the HMC trajectory length, so we need to scale # the time unit so that total_time * time_unit = hmc_trajectory_length time_unit = state.hmc_state.trajectory_length / total_time # Algo 1, line 2: sample hmc momentum - r = momentum_generator(state.hmc_state.r, state.hmc_state.adapt_state.mass_matrix_sqrt, rng_r) + r = momentum_generator( + state.hmc_state.r, state.hmc_state.adapt_state.mass_matrix_sqrt, rng_r + ) hmc_state = state.hmc_state._replace(r=r, num_steps=0) hmc_ke = euclidean_kinetic_energy(hmc_state.adapt_state.inverse_mass_matrix, r) # Algo 1, line 10: compute the initial energy energy_old = hmc_ke + hmc_state.potential_energy # Algo 1, line 3: set initial values - delta_pe_sum = 0. - init_val = (rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum, arrival_times) + delta_pe_sum = 0.0 + init_val = ( + rng_key, + hmc_state, + z_discrete, + ke_discrete, + delta_pe_sum, + arrival_times, + ) # Algo 1, line 6-9: perform the update loop rng_key, hmc_state_new, z_discrete_new, _, delta_pe_sum, _ = fori_loop( - 0, self._num_discrete_updates, body_fn, init_val) + 0, self._num_discrete_updates, body_fn, init_val + ) # Algo 1, line 10: compute the proposal energy - hmc_ke = euclidean_kinetic_energy(hmc_state.adapt_state.inverse_mass_matrix, hmc_state_new.r) + hmc_ke = euclidean_kinetic_energy( + hmc_state.adapt_state.inverse_mass_matrix, hmc_state_new.r + ) energy_new = hmc_ke + hmc_state_new.potential_energy # Algo 1, line 11: perform MH correction delta_energy = energy_new - energy_old - delta_pe_sum @@ -196,26 +267,38 @@ def body_fn(i, vals): # record the correct new num_steps hmc_state = hmc_state._replace(num_steps=hmc_state_new.num_steps) # reset the trajectory length - hmc_state_new = hmc_state_new._replace(trajectory_length=hmc_state.trajectory_length) - hmc_state, z_discrete = cond(random.bernoulli(rng_key, accept_prob), - (hmc_state_new, z_discrete_new), identity, - (hmc_state, z_discrete), identity) + hmc_state_new = hmc_state_new._replace( + trajectory_length=hmc_state.trajectory_length + ) + hmc_state, z_discrete = cond( + random.bernoulli(rng_key, accept_prob), + (hmc_state_new, z_discrete_new), + identity, + (hmc_state, z_discrete), + identity, + ) # perform hmc adapting (similar to the implementation in hmc) - adapt_state = cond(hmc_state.i < self._num_warmup, - (hmc_state.i, accept_prob, (hmc_state.z,), hmc_state.adapt_state), - lambda args: self._wa_update(*args), - hmc_state.adapt_state, - identity) + adapt_state = cond( + hmc_state.i < self._num_warmup, + (hmc_state.i, accept_prob, (hmc_state.z,), hmc_state.adapt_state), + lambda args: self._wa_update(*args), + hmc_state.adapt_state, + identity, + ) itr = hmc_state.i + 1 n = jnp.where(hmc_state.i < self._num_warmup, itr, itr - self._num_warmup) mean_accept_prob_prev = state.hmc_state.mean_accept_prob - mean_accept_prob = mean_accept_prob_prev + (accept_prob - mean_accept_prob_prev) / n - hmc_state = hmc_state._replace(i=itr, - accept_prob=accept_prob, - mean_accept_prob=mean_accept_prob, - adapt_state=adapt_state) + mean_accept_prob = ( + mean_accept_prob_prev + (accept_prob - mean_accept_prob_prev) / n + ) + hmc_state = hmc_state._replace( + i=itr, + accept_prob=accept_prob, + mean_accept_prob=mean_accept_prob, + adapt_state=adapt_state, + ) z = {**z_discrete, **hmc_state.z} return MixedHMCState(z, hmc_state, rng_key, accept_prob) diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index 46dff3e9e..e7363a3c4 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -16,6 +16,7 @@ class Reparam(ABC): """ Base class for reparameterizers. """ + @abstractmethod def __call__(self, name, fn, obs): """ @@ -36,7 +37,7 @@ def _unwrap(self, fn): event_dim = fn.event_dim while isinstance(fn, (dist.Independent, dist.ExpandedDistribution)): fn = fn.base_dist - expand_shape = shape[:len(shape) - fn.event_dim] + expand_shape = shape[: len(shape) - fn.event_dim] return fn, expand_shape, event_dim def _wrap(self, fn, expand_shape, event_dim): @@ -74,6 +75,7 @@ class LocScaleReparam(Reparam): the centered to decentered distribution. :type shape_params: tuple or list """ + def __init__(self, centered=None, shape_params=()): assert centered is None or isinstance(centered, (int, float)) assert isinstance(shape_params, (tuple, list)) @@ -94,16 +96,17 @@ def __call__(self, name, fn, obs): # Apply a partial decentering transform. params = {key: getattr(fn, key) for key in self.shape_params} if self.centered is None: - centered = numpyro.param("{}_centered".format(name), - jnp.full(event_shape, 0.5), - constraint=constraints.unit_interval) + centered = numpyro.param( + "{}_centered".format(name), + jnp.full(event_shape, 0.5), + constraint=constraints.unit_interval, + ) params["loc"] = fn.loc * centered params["scale"] = fn.scale ** centered decentered_fn = self._wrap(type(fn)(**params), expand_shape, event_dim) # Draw decentered noise. - decentered_value = numpyro.sample("{}_decentered".format(name), - decentered_fn) + decentered_value = numpyro.sample("{}_decentered".format(name), decentered_fn) # Differentiably transform. delta = decentered_value - centered * fn.loc @@ -124,22 +127,27 @@ class TransformReparam(Reparam): This reparameterization works only for latent variables, not likelihoods. """ + def __call__(self, name, fn, obs): assert obs is None, "TransformReparam does not support observe statements" fn, expand_shape, event_dim = self._unwrap(fn) if isinstance(fn, (dist.Uniform, dist.TruncatedCauchy, dist.TruncatedNormal)): - raise ValueError("TransformReparam does not automatically work with {}" - " distribution anymore. Please explicitly using" - " TransformedDistribution(base_dist, AffineTransform(...)) pattern" - " with TransformReparam.".format(type(fn).__name__)) + raise ValueError( + "TransformReparam does not automatically work with {}" + " distribution anymore. Please explicitly using" + " TransformedDistribution(base_dist, AffineTransform(...)) pattern" + " with TransformReparam.".format(type(fn).__name__) + ) assert isinstance(fn, dist.TransformedDistribution) # Draw noise from the base distribution. base_event_dim = event_dim for t in reversed(fn.transforms): base_event_dim += t.domain.event_dim - t.codomain.event_dim - x = numpyro.sample("{}_base".format(name), - self._wrap(fn.base_dist, expand_shape, base_event_dim)) + x = numpyro.sample( + "{}_base".format(name), + self._wrap(fn.base_dist, expand_shape, base_event_dim), + ) # Differentiably transform. for t in fn.transforms: @@ -156,6 +164,7 @@ class ProjectedNormalReparam(Reparam): This reparameterization works only for latent variables, not likelihoods. """ + def __call__(self, name, fn, obs): assert obs is None, "ProjectedNormalReparam does not support observe statements" fn, expand_shape, event_dim = self._unwrap(fn) @@ -163,8 +172,9 @@ def __call__(self, name, fn, obs): # Draw parameter-free noise. new_fn = dist.Normal(jnp.zeros(fn.concentration.shape), 1).to_event(1) - x = numpyro.sample("{}_normal".format(name), - self._wrap(new_fn, expand_shape, event_dim)) + x = numpyro.sample( + "{}_normal".format(name), self._wrap(new_fn, expand_shape, event_dim) + ) # Differentiably transform. value = safe_normalize(x + fn.concentration) @@ -203,22 +213,30 @@ class NeuTraReparam(Reparam): :param ~numpyro.infer.autoguide.AutoContinuous guide: A guide. :param params: trained parameters of the guide. """ + def __init__(self, guide, params): if not isinstance(guide, AutoContinuous): - raise TypeError("NeuTraReparam expected an AutoContinuous guide, but got {}" - .format(type(guide))) + raise TypeError( + "NeuTraReparam expected an AutoContinuous guide, but got {}".format( + type(guide) + ) + ) self.guide = guide self.params = params try: self.transform = self.guide.get_transform(params) except (NotImplementedError, TypeError) as e: - raise ValueError("NeuTraReparam only supports guides that implement " - "`get_transform` method that does not depend on the " - "model's `*args, **kwargs`") from e + raise ValueError( + "NeuTraReparam only supports guides that implement " + "`get_transform` method that does not depend on the " + "model's `*args, **kwargs`" + ) from e self._x_unconstrained = {} def _reparam_config(self, site): - if site["name"] in self.guide.prototype_trace and not site.get("is_observed", False): + if site["name"] in self.guide.prototype_trace and not site.get( + "is_observed", False + ): return self def reparam(self, fn=None): @@ -229,17 +247,21 @@ def __call__(self, name, fn, obs): return fn, obs assert obs is None, "NeuTraReparam does not support observe statements" - log_density = 0. - compute_density = (numpyro.get_mask() is not False) + log_density = 0.0 + compute_density = numpyro.get_mask() is not False if not self._x_unconstrained: # On first sample site. # Sample a shared latent. - z_unconstrained = numpyro.sample("{}_shared_latent".format(self.guide.prefix), - self.guide.get_base_dist().mask(False)) + z_unconstrained = numpyro.sample( + "{}_shared_latent".format(self.guide.prefix), + self.guide.get_base_dist().mask(False), + ) # Differentiably transform. x_unconstrained = self.transform(z_unconstrained) if compute_density: - log_density = self.transform.log_abs_det_jacobian(z_unconstrained, x_unconstrained) + log_density = self.transform.log_abs_det_jacobian( + z_unconstrained, x_unconstrained + ) self._x_unconstrained = self.guide._unpack_latent(x_unconstrained) # Extract a single site's value from the shared latent. @@ -248,7 +270,9 @@ def __call__(self, name, fn, obs): value = transform(unconstrained_value) if compute_density: logdet = transform.log_abs_det_jacobian(unconstrained_value, value) - logdet = sum_rightmost(logdet, jnp.ndim(logdet) - jnp.ndim(value) + len(fn.event_shape)) + logdet = sum_rightmost( + logdet, jnp.ndim(logdet) - jnp.ndim(value) + len(fn.event_shape) + ) log_density = log_density + fn.log_prob(value) + logdet numpyro.factor("_{}_log_prob".format(name), log_density) return None, value diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index 5959423ee..31bb8db7a 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -24,7 +24,9 @@ def _get_proposal_loc_and_scale(samples, loc, scale, new_sample): if scale.ndim > loc.ndim: new_scale = cholesky_update(scale, new_sample - loc, weight) proposal_scale = cholesky_update(new_scale, samples - loc, -weight) - proposal_scale = cholesky_update(proposal_scale, new_sample - samples, - (weight ** 2)) + proposal_scale = cholesky_update( + proposal_scale, new_sample - samples, -(weight ** 2) + ) else: var = jnp.square(scale) + weight * jnp.square(new_sample - loc) proposal_var = var - weight * jnp.square(samples - loc) @@ -46,9 +48,20 @@ def _sample_proposal(inv_mass_matrix_sqrt, rng_key, batch_shape=()): return r -SAAdaptState = namedtuple('SAAdaptState', ['zs', 'pes', 'loc', 'inv_mass_matrix_sqrt']) -SAState = namedtuple('SAState', ['i', 'z', 'potential_energy', 'accept_prob', - 'mean_accept_prob', 'diverging', 'adapt_state', 'rng_key']) +SAAdaptState = namedtuple("SAAdaptState", ["zs", "pes", "loc", "inv_mass_matrix_sqrt"]) +SAState = namedtuple( + "SAState", + [ + "i", + "z", + "potential_energy", + "accept_prob", + "mean_accept_prob", + "diverging", + "adapt_state", + "rng_key", + ], +) """ A :func:`~collections.namedtuple` used in Sample Adaptive MCMC. This consists of the following fields: @@ -87,22 +100,26 @@ def _numpy_delete(x, idx): # TODO: consider to expose this functional style def _sa(potential_fn=None, potential_fn_gen=None): wa_steps = None - max_delta_energy = 1000. - - def init_kernel(init_params, - num_warmup, - adapt_state_size=None, - inverse_mass_matrix=None, - dense_mass=False, - model_args=(), - model_kwargs=None, - rng_key=random.PRNGKey(0)): + max_delta_energy = 1000.0 + + def init_kernel( + init_params, + num_warmup, + adapt_state_size=None, + inverse_mass_matrix=None, + dense_mass=False, + model_args=(), + model_kwargs=None, + rng_key=random.PRNGKey(0), + ): nonlocal wa_steps wa_steps = num_warmup pe_fn = potential_fn if potential_fn_gen: if pe_fn is not None: - raise ValueError('Only one of `potential_fn` or `potential_fn_gen` must be provided.') + raise ValueError( + "Only one of `potential_fn` or `potential_fn_gen` must be provided." + ) else: kwargs = {} if model_kwargs is None else model_kwargs pe_fn = potential_fn_gen(*model_args, **kwargs) @@ -110,16 +127,25 @@ def init_kernel(init_params, z = init_params z_flat, unravel_fn = ravel_pytree(z) if inverse_mass_matrix is None: - inverse_mass_matrix = jnp.identity(z_flat.shape[-1]) if dense_mass else jnp.ones(z_flat.shape[-1]) - inv_mass_matrix_sqrt = jnp.linalg.cholesky(inverse_mass_matrix) if dense_mass \ + inverse_mass_matrix = ( + jnp.identity(z_flat.shape[-1]) + if dense_mass + else jnp.ones(z_flat.shape[-1]) + ) + inv_mass_matrix_sqrt = ( + jnp.linalg.cholesky(inverse_mass_matrix) + if dense_mass else jnp.sqrt(inverse_mass_matrix) + ) if adapt_state_size is None: # XXX: heuristic choice adapt_state_size = 2 * z_flat.shape[-1] else: - assert adapt_state_size > 1, 'adapt_state_size should be greater than 1.' + assert adapt_state_size > 1, "adapt_state_size should be greater than 1." # NB: mean is init_params - zs = z_flat + _sample_proposal(inv_mass_matrix_sqrt, rng_key_zs, (adapt_state_size,)) + zs = z_flat + _sample_proposal( + inv_mass_matrix_sqrt, rng_key_zs, (adapt_state_size,) + ) # compute potential energies pes = lax.map(lambda z: pe_fn(unravel_fn(z)), zs) if dense_mass: @@ -128,15 +154,25 @@ def init_kernel(init_params, cov = cov.reshape((1, 1)) cholesky = jnp.linalg.cholesky(cov) # if cholesky is NaN, we use the scale from `sample_proposal` here - inv_mass_matrix_sqrt = jnp.where(jnp.any(jnp.isnan(cholesky)), inv_mass_matrix_sqrt, cholesky) + inv_mass_matrix_sqrt = jnp.where( + jnp.any(jnp.isnan(cholesky)), inv_mass_matrix_sqrt, cholesky + ) else: inv_mass_matrix_sqrt = jnp.std(zs, 0) adapt_state = SAAdaptState(zs, pes, jnp.mean(zs, 0), inv_mass_matrix_sqrt) k = random.categorical(rng_key_z, jnp.zeros(zs.shape[0])) z = unravel_fn(zs[k]) pe = pes[k] - sa_state = SAState(jnp.array(0), z, pe, jnp.zeros(()), jnp.zeros(()), jnp.array(False), - adapt_state, rng_key_sa) + sa_state = SAState( + jnp.array(0), + z, + pe, + jnp.zeros(()), + jnp.zeros(()), + jnp.array(False), + adapt_state, + rng_key_sa, + ) return device_put(sa_state) def sample_kernel(sa_state, model_args=(), model_kwargs=None): @@ -157,7 +193,9 @@ def sample_kernel(sa_state, model_args=(), model_kwargs=None): else: scale = jnp.std(zs, 0) - rng_key, rng_key_z, rng_key_reject, rng_key_accept = random.split(sa_state.rng_key, 4) + rng_key, rng_key_z, rng_key_reject, rng_key_accept = random.split( + sa_state.rng_key, 4 + ) _, unravel_fn = ravel_pytree(sa_state.z) z = loc + _sample_proposal(scale, rng_key_z) @@ -173,7 +211,9 @@ def sample_kernel(sa_state, model_args=(), model_kwargs=None): locs_ = jnp.concatenate([locs, loc[None, :]]) scales_ = jnp.concatenate([scales, scale[None, ...]]) if scale.ndim == 2: # dense_mass - log_weights_ = dist.MultivariateNormal(locs_, scale_tril=scales_).log_prob(zs_) + pes_ + log_weights_ = ( + dist.MultivariateNormal(locs_, scale_tril=scales_).log_prob(zs_) + pes_ + ) else: log_weights_ = dist.Normal(locs_, scales_).log_prob(zs_).sum(-1) + pes_ # mask invalid values (nan, +inf) by -inf @@ -190,7 +230,9 @@ def sample_kernel(sa_state, model_args=(), model_kwargs=None): accept_prob = 1 - jnp.exp(log_weights_[-1] - logsumexp(log_weights_)) itr = sa_state.i + 1 n = jnp.where(sa_state.i < wa_steps, itr, itr - wa_steps) - mean_accept_prob = sa_state.mean_accept_prob + (accept_prob - sa_state.mean_accept_prob) / n + mean_accept_prob = ( + sa_state.mean_accept_prob + (accept_prob - sa_state.mean_accept_prob) / n + ) # XXX: we make a modification of SA sampler in [1] # in [1], each MCMC state contains N points `zs` @@ -198,7 +240,9 @@ def sample_kernel(sa_state, model_args=(), model_kwargs=None): k = random.categorical(rng_key_accept, jnp.zeros(zs.shape[0])) z = unravel_fn(zs[k]) pe = pes[k] - return SAState(itr, z, pe, accept_prob, mean_accept_prob, diverging, adapt_state, rng_key) + return SAState( + itr, z, pe, accept_prob, mean_accept_prob, diverging, adapt_state, rng_key + ) return init_kernel, sample_kernel @@ -237,10 +281,17 @@ class SA(MCMCKernel): :param callable init_strategy: a per-site initialization function. See :ref:`init_strategy` section for available functions. """ - def __init__(self, model=None, potential_fn=None, adapt_state_size=None, - dense_mass=True, init_strategy=init_to_uniform): + + def __init__( + self, + model=None, + potential_fn=None, + adapt_state_size=None, + dense_mass=True, + init_strategy=init_to_uniform, + ): if not (model is None) ^ (potential_fn is None): - raise ValueError('Only one of `model` or `potential_fn` must be specified.') + raise ValueError("Only one of `model` or `potential_fn` must be specified.") self._model = model self._potential_fn = potential_fn self._adapt_state_size = adapt_state_size @@ -259,7 +310,8 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): dynamic_args=True, init_strategy=self._init_strategy, model_args=model_args, - model_kwargs=model_kwargs) + model_kwargs=model_kwargs, + ) init_params = init_params[0] # NB: init args is different from HMC self._init_fn, sample_fn = _sa(potential_fn_gen=potential_fn) @@ -273,19 +325,26 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): self._sample_fn = sample_fn return init_params - def init(self, rng_key, num_warmup, init_params=None, model_args=(), model_kwargs={}): + def init( + self, rng_key, num_warmup, init_params=None, model_args=(), model_kwargs={} + ): # non-vectorized if rng_key.ndim == 1: rng_key, rng_key_init_model = random.split(rng_key) # vectorized else: - rng_key, rng_key_init_model = jnp.swapaxes(vmap(random.split)(rng_key), 0, 1) + rng_key, rng_key_init_model = jnp.swapaxes( + vmap(random.split)(rng_key), 0, 1 + ) # we need only a single key for initializing PE / constraints fn rng_key_init_model = rng_key_init_model[0] - init_params = self._init_state(rng_key_init_model, model_args, model_kwargs, init_params) + init_params = self._init_state( + rng_key_init_model, model_args, model_kwargs, init_params + ) if self._potential_fn and init_params is None: - raise ValueError('Valid value of `init_params` must be provided with' - ' `potential_fn`.') + raise ValueError( + "Valid value of `init_params` must be provided with" " `potential_fn`." + ) # NB: init args is different from HMC sa_init_fn = lambda init_params, rng_key: self._init_fn( # noqa: E731 @@ -307,14 +366,14 @@ def init(self, rng_key, num_warmup, init_params=None, model_args=(), model_kwarg @property def sample_field(self): - return 'z' + return "z" @property def default_fields(self): - return ('z', 'diverging') + return ("z", "diverging") def get_diagnostics_str(self, state): - return 'acc. prob={:.2f}'.format(state.mean_accept_prob) + return "acc. prob={:.2f}".format(state.mean_accept_prob) def postprocess_fn(self, args, kwargs): if self._postprocess_fn is None: diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 313a9fad1..25961b06a 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -14,7 +14,7 @@ from numpyro.handlers import replay, seed, trace from numpyro.infer.util import transform_fn -SVIState = namedtuple('SVIState', ['optim_state', 'rng_key']) +SVIState = namedtuple("SVIState", ["optim_state", "rng_key"]) """ A :func:`~collections.namedtuple` consisting of the following fields: - **optim_state** - current optimizer's state. @@ -22,7 +22,7 @@ """ -SVIRunResult = namedtuple('SVIRunResult', ['params', 'losses']) +SVIRunResult = namedtuple("SVIRunResult", ["params", "losses"]) """ A :func:`~collections.namedtuple` consisting of the following fields: - **params** - the optimized parameters. @@ -30,9 +30,12 @@ """ -def _apply_loss_fn(loss_fn, rng_key, constrain_fn, model, guide, - args, kwargs, static_kwargs, params): - return loss_fn(rng_key, constrain_fn(params), model, guide, *args, **kwargs, **static_kwargs) +def _apply_loss_fn( + loss_fn, rng_key, constrain_fn, model, guide, args, kwargs, static_kwargs, params +): + return loss_fn( + rng_key, constrain_fn(params), model, guide, *args, **kwargs, **static_kwargs + ) class SVI(object): @@ -82,6 +85,7 @@ class SVI(object): that remain constant during fitting. :return: tuple of `(init_fn, update_fn, evaluate)`. """ + def __init__(self, model, guide, optim, loss, **static_kwargs): self.model = model self.guide = guide @@ -105,21 +109,25 @@ def init(self, rng_key, *args, **kwargs): model_init = seed(self.model, model_seed) guide_init = seed(self.guide, guide_seed) guide_trace = trace(guide_init).get_trace(*args, **kwargs, **self.static_kwargs) - model_trace = trace(replay(model_init, guide_trace)).get_trace(*args, **kwargs, **self.static_kwargs) + model_trace = trace(replay(model_init, guide_trace)).get_trace( + *args, **kwargs, **self.static_kwargs + ) params = {} inv_transforms = {} # NB: params in model_trace will be overwritten by params in guide_trace for site in list(model_trace.values()) + list(guide_trace.values()): - if site['type'] == 'param': - constraint = site['kwargs'].pop('constraint', constraints.real) + if site["type"] == "param": + constraint = site["kwargs"].pop("constraint", constraints.real) transform = biject_to(constraint) - inv_transforms[site['name']] = transform - params[site['name']] = transform.inv(site['value']) + inv_transforms[site["name"]] = transform + params[site["name"]] = transform.inv(site["value"]) self.constrain_fn = partial(transform_fn, inv_transforms) # we convert weak types like float to float32/float64 # to avoid recompiling body_fn in svi.run - params = tree_map(lambda x: lax.convert_element_type(x, jnp.result_type(x)), params) + params = tree_map( + lambda x: lax.convert_element_type(x, jnp.result_type(x)), params + ) return SVIState(self.optim.init(params), rng_key) def get_params(self, svi_state): @@ -145,9 +153,20 @@ def update(self, svi_state, *args, **kwargs): :return: tuple of `(svi_state, loss)`. """ rng_key, rng_key_step = random.split(svi_state.rng_key) - loss_fn = partial(_apply_loss_fn, self.loss.loss, rng_key_step, self.constrain_fn, self.model, - self.guide, args, kwargs, self.static_kwargs) - loss_val, optim_state = self.optim.eval_and_update(loss_fn, svi_state.optim_state) + loss_fn = partial( + _apply_loss_fn, + self.loss.loss, + rng_key_step, + self.constrain_fn, + self.model, + self.guide, + args, + kwargs, + self.static_kwargs, + ) + loss_val, optim_state = self.optim.eval_and_update( + loss_fn, svi_state.optim_state + ) return SVIState(optim_state, rng_key), loss_val def stable_update(self, svi_state, *args, **kwargs): @@ -163,12 +182,31 @@ def stable_update(self, svi_state, *args, **kwargs): :return: tuple of `(svi_state, loss)`. """ rng_key, rng_key_step = random.split(svi_state.rng_key) - loss_fn = partial(_apply_loss_fn, self.loss.loss, rng_key_step, self.constrain_fn, self.model, - self.guide, args, kwargs, self.static_kwargs) - loss_val, optim_state = self.optim.eval_and_stable_update(loss_fn, svi_state.optim_state) + loss_fn = partial( + _apply_loss_fn, + self.loss.loss, + rng_key_step, + self.constrain_fn, + self.model, + self.guide, + args, + kwargs, + self.static_kwargs, + ) + loss_val, optim_state = self.optim.eval_and_stable_update( + loss_fn, svi_state.optim_state + ) return SVIState(optim_state, rng_key), loss_val - def run(self, rng_key, num_steps, *args, progress_bar=True, stable_update=False, **kwargs): + def run( + self, + rng_key, + num_steps, + *args, + progress_bar=True, + stable_update=False, + **kwargs + ): """ (EXPERIMENTAL INTERFACE) Run SVI with `num_steps` iterations, then return the optimized parameters and the stacked losses at every step. If `num_steps` @@ -192,6 +230,7 @@ def run(self, rng_key, num_steps, *args, progress_bar=True, stable_update=False, and `losses` is the collected loss during the process. :rtype: SVIRunResult """ + def body_fn(svi_state, _): if stable_update: svi_state, loss = self.stable_update(svi_state, *args, **kwargs) @@ -209,17 +248,20 @@ def body_fn(svi_state, _): losses.append(loss) if i % batch == 0: if stable_update: - valid_losses = [x for x in losses[i - batch:] if x == x] + valid_losses = [x for x in losses[i - batch :] if x == x] num_valid = len(valid_losses) if num_valid == 0: - avg_loss = float('nan') + avg_loss = float("nan") else: avg_loss = sum(valid_losses) / num_valid else: - avg_loss = sum(losses[i-batch:]) / batch - t.set_postfix_str("init loss: {:.4f}, avg. loss [{}-{}]: {:.4f}" - .format(losses[0], i - batch + 1, i, avg_loss), - refresh=False) + avg_loss = sum(losses[i - batch :]) / batch + t.set_postfix_str( + "init loss: {:.4f}, avg. loss [{}-{}]: {:.4f}".format( + losses[0], i - batch + 1, i, avg_loss + ), + refresh=False, + ) losses = jnp.stack(losses) else: svi_state, losses = lax.scan(body_fn, svi_state, None, length=num_steps) @@ -240,5 +282,12 @@ def evaluate(self, svi_state, *args, **kwargs): # we split to have the same seed as `update_fn` given an svi_state _, rng_key_eval = random.split(svi_state.rng_key) params = self.get_params(svi_state) - return self.loss.loss(rng_key_eval, params, self.model, self.guide, - *args, **kwargs, **self.static_kwargs) + return self.loss.loss( + rng_key_eval, + params, + self.model, + self.guide, + *args, + **kwargs, + **self.static_kwargs + ) diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 73e657f65..505558c8b 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -20,17 +20,19 @@ from numpyro.util import not_jax_tracer, soft_vmap, while_loop __all__ = [ - 'find_valid_initial_params', - 'get_potential_fn', - 'log_density', - 'log_likelihood', - 'potential_energy', - 'initialize_model', - 'Predictive', + "find_valid_initial_params", + "get_potential_fn", + "log_density", + "log_likelihood", + "potential_energy", + "initialize_model", + "Predictive", ] -ModelInfo = namedtuple('ModelInfo', ['param_info', 'potential_fn', 'postprocess_fn', 'model_trace']) -ParamInfo = namedtuple('ParamInfo', ['z', 'potential_energy', 'z_grad']) +ModelInfo = namedtuple( + "ModelInfo", ["param_info", "potential_fn", "postprocess_fn", "model_trace"] +) +ParamInfo = namedtuple("ParamInfo", ["z", "potential_energy", "z_grad"]) def log_density(model, model_args, model_kwargs, params): @@ -49,14 +51,14 @@ def log_density(model, model_args, model_kwargs, params): model_trace = trace(model).get_trace(*model_args, **model_kwargs) log_joint = jnp.zeros(()) for site in model_trace.values(): - if site['type'] == 'sample': - value = site['value'] - intermediates = site['intermediates'] - scale = site['scale'] + if site["type"] == "sample": + value = site["value"] + intermediates = site["intermediates"] + scale = site["scale"] if intermediates: - log_prob = site['fn'].log_prob(value, intermediates) + log_prob = site["fn"].log_prob(value, intermediates) else: - log_prob = site['fn'].log_prob(value) + log_prob = site["fn"].log_prob(value) if (scale is not None) and (not is_identically_one(scale)): log_prob = scale * log_prob @@ -80,8 +82,7 @@ def transform_fn(transforms, params, invert=False): """ if invert: transforms = {k: v.inv for k, v in transforms.items()} - return {k: transforms[k](v) if k in transforms else v - for k, v in params.items()} + return {k: transforms[k](v) if k in transforms else v for k, v in params.items()} def constrain_fn(model, model_args, model_kwargs, params, return_deterministic=False): @@ -104,23 +105,26 @@ def constrain_fn(model, model_args, model_kwargs, params, return_deterministic=F """ def substitute_fn(site): - if site['name'] in params: - return biject_to(site['fn'].support)(params[site['name']]) + if site["name"] in params: + return biject_to(site["fn"].support)(params[site["name"]]) substituted_model = substitute(model, substitute_fn=substitute_fn) model_trace = trace(substituted_model).get_trace(*model_args, **model_kwargs) - return {k: v['value'] for k, v in model_trace.items() if (k in params) or - (return_deterministic and (v['type'] == 'deterministic'))} + return { + k: v["value"] + for k, v in model_trace.items() + if (k in params) or (return_deterministic and (v["type"] == "deterministic")) + } def _unconstrain_reparam(params, site): - name = site['name'] + name = site["name"] if name in params: p = params[name] - support = site['fn'].support + support = site["fn"].support t = biject_to(support) # in scan, we might only want to substitute an item at index i, rather than the whole sequence - i = site['infer'].get('_scan_current_index', None) + i = site["infer"].get("_scan_current_index", None) if i is not None: event_dim_shift = t.codomain.event_dim - t.domain.event_dim expected_unconstrained_dim = len(site["fn"].shape()) - event_dim_shift @@ -133,10 +137,12 @@ def _unconstrain_reparam(params, site): value = t(p) log_det = t.log_abs_det_jacobian(p, value) - log_det = sum_rightmost(log_det, jnp.ndim(log_det) - jnp.ndim(value) + len(site['fn'].event_shape)) - if site['scale'] is not None: - log_det = site['scale'] * log_det - numpyro.factor('_{}_log_det'.format(name), log_det) + log_det = sum_rightmost( + log_det, jnp.ndim(log_det) - jnp.ndim(value) + len(site["fn"].event_shape) + ) + if site["scale"] is not None: + log_det = site["scale"] * log_det + numpyro.factor("_{}_log_det".format(name), log_det) return value @@ -158,10 +164,14 @@ def potential_energy(model, model_args, model_kwargs, params, enum=False): else: log_density_ = log_density - substituted_model = substitute(model, substitute_fn=partial(_unconstrain_reparam, params)) + substituted_model = substitute( + model, substitute_fn=partial(_unconstrain_reparam, params) + ) # no param is needed for log_density computation because we already substitute - log_joint, model_trace = log_density_(substituted_model, model_args, model_kwargs, {}) - return - log_joint + log_joint, model_trace = log_density_( + substituted_model, model_args, model_kwargs, {} + ) + return -log_joint def _init_to_unconstrained_value(site=None, values={}): @@ -169,13 +179,16 @@ def _init_to_unconstrained_value(site=None, values={}): return partial(_init_to_unconstrained_value, values=values) -def find_valid_initial_params(rng_key, model, - init_strategy=init_to_uniform, - enum=False, - model_args=(), - model_kwargs=None, - prototype_params=None, - forward_mode_differentiation=False): +def find_valid_initial_params( + rng_key, + model, + init_strategy=init_to_uniform, + enum=False, + model_args=(), + model_kwargs=None, + prototype_params=None, + forward_mode_differentiation=False, +): """ (EXPERIMENTAL INTERFACE) Given a model with Pyro primitives, returns an initial valid unconstrained value for all the parameters. This function also returns @@ -198,7 +211,9 @@ def find_valid_initial_params(rng_key, model, containing the initial params, their potential energy, and their gradients. """ model_kwargs = {} if model_kwargs is None else model_kwargs - init_strategy = init_strategy if isinstance(init_strategy, partial) else init_strategy() + init_strategy = ( + init_strategy if isinstance(init_strategy, partial) else init_strategy() + ) # handle those init strategies differently to save computation if init_strategy.func is init_to_uniform: radius = init_strategy.keywords.get("radius") @@ -223,22 +238,32 @@ def body_fn(state): model_trace = trace(seeded_model).get_trace(*model_args, **model_kwargs) constrained_values, inv_transforms = {}, {} for k, v in model_trace.items(): - if v['type'] == 'sample' and not v['is_observed'] and not v['fn'].is_discrete: - constrained_values[k] = v['value'] - inv_transforms[k] = biject_to(v['fn'].support) - params = transform_fn(inv_transforms, - {k: v for k, v in constrained_values.items()}, - invert=True) + if ( + v["type"] == "sample" + and not v["is_observed"] + and not v["fn"].is_discrete + ): + constrained_values[k] = v["value"] + inv_transforms[k] = biject_to(v["fn"].support) + params = transform_fn( + inv_transforms, + {k: v for k, v in constrained_values.items()}, + invert=True, + ) else: # this branch doesn't require tracing the model params = {} for k, v in prototype_params.items(): if k in init_values: params[k] = init_values[k] else: - params[k] = random.uniform(subkey, jnp.shape(v), minval=-radius, maxval=radius) + params[k] = random.uniform( + subkey, jnp.shape(v), minval=-radius, maxval=radius + ) key, subkey = random.split(key) - potential_fn = partial(potential_energy, model, model_args, model_kwargs, enum=enum) + potential_fn = partial( + potential_energy, model, model_args, model_kwargs, enum=enum + ) if forward_mode_differentiation: pe = potential_fn(params) z_grad = jacfwd(potential_fn)(params) @@ -249,7 +274,7 @@ def body_fn(state): return i + 1, key, (params, pe, z_grad), is_valid def _find_valid_params(rng_key, exit_early=False): - init_state = (0, rng_key, (prototype_params, 0., prototype_params), False) + init_state = (0, rng_key, (prototype_params, 0.0, prototype_params), False) if exit_early and not_jax_tracer(rng_key): # Early return if valid params found. This is only helpful for single chain, # where we can avoid compiling body_fn in while_loop. @@ -260,12 +285,16 @@ def _find_valid_params(rng_key, exit_early=False): # XXX: this requires compiling the model, so for multi-chain, we trace the model 2-times # even if the init_state is a valid result - _, _, (init_params, pe, z_grad), is_valid = while_loop(cond_fn, body_fn, init_state) + _, _, (init_params, pe, z_grad), is_valid = while_loop( + cond_fn, body_fn, init_state + ) return (init_params, pe, z_grad), is_valid # Handle possible vectorization if rng_key.ndim == 1: - (init_params, pe, z_grad), is_valid = _find_valid_params(rng_key, exit_early=True) + (init_params, pe, z_grad), is_valid = _find_valid_params( + rng_key, exit_early=True + ) else: (init_params, pe, z_grad), is_valid = lax.map(_find_valid_params, rng_key) return (init_params, pe, z_grad), is_valid @@ -279,31 +308,40 @@ def _get_model_transforms(model, model_args=(), model_kwargs=None): replay_model = False has_enumerate_support = False for k, v in model_trace.items(): - if v['type'] == 'sample' and not v['is_observed']: - if v['fn'].is_discrete: + if v["type"] == "sample" and not v["is_observed"]: + if v["fn"].is_discrete: has_enumerate_support = True - if not v['fn'].has_enumerate_support: - raise RuntimeError("MCMC only supports continuous sites or discrete sites " - f"with enumerate support, but got {type(v['fn']).__name__}.") + if not v["fn"].has_enumerate_support: + raise RuntimeError( + "MCMC only supports continuous sites or discrete sites " + f"with enumerate support, but got {type(v['fn']).__name__}." + ) else: - support = v['fn'].support + support = v["fn"].support inv_transforms[k] = biject_to(support) # XXX: the following code filters out most situations with dynamic supports args = () if isinstance(support, constraints._GreaterThan): - args = ('lower_bound',) + args = ("lower_bound",) elif isinstance(support, constraints._Interval): - args = ('lower_bound', 'upper_bound') + args = ("lower_bound", "upper_bound") for arg in args: if not isinstance(getattr(support, arg), (int, float)): replay_model = True - elif v['type'] == 'deterministic': + elif v["type"] == "deterministic": replay_model = True return inv_transforms, replay_model, has_enumerate_support, model_trace -def get_potential_fn(model, inv_transforms, enum=False, replay_model=False, - dynamic_args=False, model_args=(), model_kwargs=None): +def get_potential_fn( + model, + inv_transforms, + enum=False, + replay_model=False, + dynamic_args=False, + model_args=(), + model_kwargs=None, +): """ (EXPERIMENTAL INTERFACE) Given a model with Pyro primitives, returns a function which, given unconstrained parameters, evaluates the potential @@ -328,6 +366,7 @@ def get_potential_fn(model, inv_transforms, enum=False, replay_model=False, `deterministic` sites in the model. """ if dynamic_args: + def potential_fn(*args, **kwargs): return partial(potential_energy, model, args, kwargs, enum=enum) @@ -335,16 +374,26 @@ def postprocess_fn(*args, **kwargs): if replay_model: # XXX: we seed to sample discrete sites (but not collect them) model_ = seed(model.fn, 0) if enum else model - return partial(constrain_fn, model_, args, kwargs, return_deterministic=True) + return partial( + constrain_fn, model_, args, kwargs, return_deterministic=True + ) else: return partial(transform_fn, inv_transforms) + else: model_kwargs = {} if model_kwargs is None else model_kwargs - potential_fn = partial(potential_energy, model, model_args, model_kwargs, enum=enum) + potential_fn = partial( + potential_energy, model, model_args, model_kwargs, enum=enum + ) if replay_model: model_ = seed(model.fn, 0) if enum else model - postprocess_fn = partial(constrain_fn, model_, model_args, model_kwargs, - return_deterministic=True) + postprocess_fn = partial( + constrain_fn, + model_, + model_args, + model_kwargs, + return_deterministic=True, + ) else: postprocess_fn = partial(transform_fn, inv_transforms) @@ -357,13 +406,14 @@ def _guess_max_plate_nesting(model_trace): This optimistically assumes static model structure. """ - sites = [site for site in model_trace.values() - if site["type"] == "sample"] - - dims = [frame.dim - for site in sites - for frame in site["cond_indep_stack"] - if frame.dim is not None] + sites = [site for site in model_trace.values() if site["type"] == "sample"] + + dims = [ + frame.dim + for site in sites + for frame in site["cond_indep_stack"] + if frame.dim is not None + ] max_plate_nesting = -min(dims) if dims else 0 return max_plate_nesting @@ -371,24 +421,29 @@ def _guess_max_plate_nesting(model_trace): # TODO: follow pyro.util.check_site_shape logics for more complete validation def _validate_model(model_trace): # XXX: this validates plate statements under `enum` - sites = [site for site in model_trace.values() - if site["type"] == "sample"] + sites = [site for site in model_trace.values() if site["type"] == "sample"] for site in sites: batch_dims = len(site["fn"].batch_shape) - if site.get('_control_flow_done', False): + if site.get("_control_flow_done", False): batch_dims = batch_dims - 1 # remove time dimension under scan plate_dims = -min([0] + [frame.dim for frame in site["cond_indep_stack"]]) - assert plate_dims >= batch_dims, \ - "Missing plate statement for batch dimensions at site {}".format(site["name"]) - - -def initialize_model(rng_key, model, - init_strategy=init_to_uniform, - dynamic_args=False, - model_args=(), - model_kwargs=None, - forward_mode_differentiation=False): + assert ( + plate_dims >= batch_dims + ), "Missing plate statement for batch dimensions at site {}".format( + site["name"] + ) + + +def initialize_model( + rng_key, + model, + init_strategy=init_to_uniform, + dynamic_args=False, + model_args=(), + model_kwargs=None, + forward_mode_differentiation=False, +): """ (EXPERIMENTAL INTERFACE) Helper function that calls :func:`~numpyro.infer.util.get_potential_fn` and :func:`~numpyro.infer.util.find_valid_initial_params` under the hood @@ -423,17 +478,31 @@ def initialize_model(rng_key, model, at `deterministic` sites in the model. """ model_kwargs = {} if model_kwargs is None else model_kwargs - substituted_model = substitute(seed(model, rng_key if jnp.ndim(rng_key) == 1 else rng_key[0]), - substitute_fn=init_strategy) - inv_transforms, replay_model, has_enumerate_support, model_trace = _get_model_transforms( - substituted_model, model_args, model_kwargs) + substituted_model = substitute( + seed(model, rng_key if jnp.ndim(rng_key) == 1 else rng_key[0]), + substitute_fn=init_strategy, + ) + ( + inv_transforms, + replay_model, + has_enumerate_support, + model_trace, + ) = _get_model_transforms(substituted_model, model_args, model_kwargs) # substitute param sites from model_trace to model so # we don't need to generate again parameters of `numpyro.module` - model = substitute(model, data={k: site["value"] for k, site in model_trace.items() - if site["type"] in ["param"]}) - constrained_values = {k: v['value'] for k, v in model_trace.items() - if v['type'] == 'sample' and not v['is_observed'] - and not v['fn'].is_discrete} + model = substitute( + model, + data={ + k: site["value"] + for k, site in model_trace.items() + if site["type"] in ["param"] + }, + ) + constrained_values = { + k: v["value"] + for k, v in model_trace.items() + if v["type"] == "sample" and not v["is_observed"] and not v["fn"].is_discrete + } if has_enumerate_support: from numpyro.contrib.funsor import config_enumerate, enum @@ -443,29 +512,41 @@ def initialize_model(rng_key, model, _validate_model(model_trace) model = enum(config_enumerate(model), -max_plate_nesting - 1) - potential_fn, postprocess_fn = get_potential_fn(model, - inv_transforms, - replay_model=replay_model, - enum=has_enumerate_support, - dynamic_args=dynamic_args, - model_args=model_args, - model_kwargs=model_kwargs) + potential_fn, postprocess_fn = get_potential_fn( + model, + inv_transforms, + replay_model=replay_model, + enum=has_enumerate_support, + dynamic_args=dynamic_args, + model_args=model_args, + model_kwargs=model_kwargs, + ) - init_strategy = init_strategy if isinstance(init_strategy, partial) else init_strategy() + init_strategy = ( + init_strategy if isinstance(init_strategy, partial) else init_strategy() + ) if (init_strategy.func is init_to_value) and not replay_model: init_values = init_strategy.keywords.get("values") unconstrained_values = transform_fn(inv_transforms, init_values, invert=True) init_strategy = _init_to_unconstrained_value(values=unconstrained_values) prototype_params = transform_fn(inv_transforms, constrained_values, invert=True) (init_params, pe, grad), is_valid = find_valid_initial_params( - rng_key, substitute(model, data={k: site["value"] for k, site in model_trace.items() - if site["type"] in ["plate"]}), + rng_key, + substitute( + model, + data={ + k: site["value"] + for k, site in model_trace.items() + if site["type"] in ["plate"] + }, + ), init_strategy=init_strategy, enum=has_enumerate_support, model_args=model_args, model_kwargs=model_kwargs, prototype_params=prototype_params, - forward_mode_differentiation=forward_mode_differentiation) + forward_mode_differentiation=forward_mode_differentiation, + ) if not_jax_tracer(is_valid): if device_get(~jnp.all(is_valid)): @@ -474,44 +555,76 @@ def initialize_model(rng_key, model, substituted_model(*model_args, **model_kwargs) # validate values for site in tr.values(): - if site['type'] == 'sample': + if site["type"] == "sample": with warnings.catch_warnings(record=True) as ws: - site['fn']._validate_sample(site['value']) + site["fn"]._validate_sample(site["value"]) if len(ws) > 0: for w in ws: # at site information to the warning message - w.message.args = ("Site {}: {}".format(site["name"], w.message.args[0]),) \ - + w.message.args[1:] - warnings.showwarning(w.message, w.category, w.filename, w.lineno, - file=w.file, line=w.line) - raise RuntimeError("Cannot find valid initial parameters. Please check your model again.") - return ModelInfo(ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace) - - -def _predictive(rng_key, model, posterior_samples, batch_shape, return_sites=None, - parallel=True, model_args=(), model_kwargs={}): + w.message.args = ( + "Site {}: {}".format( + site["name"], w.message.args[0] + ), + ) + w.message.args[1:] + warnings.showwarning( + w.message, + w.category, + w.filename, + w.lineno, + file=w.file, + line=w.line, + ) + raise RuntimeError( + "Cannot find valid initial parameters. Please check your model again." + ) + return ModelInfo( + ParamInfo(init_params, pe, grad), potential_fn, postprocess_fn, model_trace + ) + + +def _predictive( + rng_key, + model, + posterior_samples, + batch_shape, + return_sites=None, + parallel=True, + model_args=(), + model_kwargs={}, +): model = numpyro.handlers.mask(model, mask=False) def single_prediction(val): rng_key, samples = val model_trace = trace(seed(substitute(model, samples), rng_key)).get_trace( - *model_args, **model_kwargs) + *model_args, **model_kwargs + ) if return_sites is not None: - if return_sites == '': - sites = {k for k, site in model_trace.items() if site['type'] != 'plate'} + if return_sites == "": + sites = { + k for k, site in model_trace.items() if site["type"] != "plate" + } else: sites = return_sites else: - sites = {k for k, site in model_trace.items() - if (site['type'] == 'sample' and k not in samples) or (site['type'] == 'deterministic')} - return {name: site['value'] for name, site in model_trace.items() if name in sites} + sites = { + k + for k, site in model_trace.items() + if (site["type"] == "sample" and k not in samples) + or (site["type"] == "deterministic") + } + return { + name: site["value"] for name, site in model_trace.items() if name in sites + } num_samples = int(np.prod(batch_shape)) if num_samples > 1: rng_key = random.split(rng_key, num_samples) rng_key = rng_key.reshape(batch_shape + (2,)) chunk_size = num_samples if parallel else 1 - return soft_vmap(single_prediction, (rng_key, posterior_samples), len(batch_shape), chunk_size) + return soft_vmap( + single_prediction, (rng_key, posterior_samples), len(batch_shape), chunk_size + ) class Predictive(object): @@ -547,31 +660,50 @@ class Predictive(object): :return: dict of samples from the predictive distribution. """ - def __init__(self, model, posterior_samples=None, guide=None, params=None, num_samples=None, - return_sites=None, parallel=False, batch_ndims=1): + def __init__( + self, + model, + posterior_samples=None, + guide=None, + params=None, + num_samples=None, + return_sites=None, + parallel=False, + batch_ndims=1, + ): if posterior_samples is None and num_samples is None: - raise ValueError("Either posterior_samples or num_samples must be specified.") + raise ValueError( + "Either posterior_samples or num_samples must be specified." + ) posterior_samples = {} if posterior_samples is None else posterior_samples prototype_site = batch_shape = batch_size = None for name, sample in posterior_samples.items(): if batch_shape is not None and sample.shape[:batch_ndims] != batch_shape: - raise ValueError(f"Batch shapes at site {name} and {prototype_site} " - f"should be the same, but got " - f"{sample.shape[:batch_ndims]} and {batch_shape}") + raise ValueError( + f"Batch shapes at site {name} and {prototype_site} " + f"should be the same, but got " + f"{sample.shape[:batch_ndims]} and {batch_shape}" + ) else: prototype_site = name batch_shape = sample.shape[:batch_ndims] batch_size = int(np.prod(batch_shape)) if (num_samples is not None) and (num_samples != batch_size): - warnings.warn("Sample's batch dimension size {} is different from the " - "provided {} num_samples argument. Defaulting to {}." - .format(batch_size, num_samples, batch_size), UserWarning) + warnings.warn( + "Sample's batch dimension size {} is different from the " + "provided {} num_samples argument. Defaulting to {}.".format( + batch_size, num_samples, batch_size + ), + UserWarning, + ) num_samples = batch_size if num_samples is None: - raise ValueError("No sample sites in posterior samples to infer `num_samples`.") + raise ValueError( + "No sample sites in posterior samples to infer `num_samples`." + ) if batch_shape is None: batch_shape = (1,) * (batch_ndims - 1) + (num_samples,) @@ -604,16 +736,32 @@ def __call__(self, rng_key, *args, **kwargs): rng_key, guide_rng_key = random.split(rng_key) # use return_sites='' as a special signal to return all sites guide = substitute(self.guide, self.params) - posterior_samples = _predictive(guide_rng_key, guide, posterior_samples, - self._batch_shape, return_sites='', parallel=self.parallel, - model_args=args, model_kwargs=kwargs) + posterior_samples = _predictive( + guide_rng_key, + guide, + posterior_samples, + self._batch_shape, + return_sites="", + parallel=self.parallel, + model_args=args, + model_kwargs=kwargs, + ) model = substitute(self.model, self.params) - return _predictive(rng_key, model, posterior_samples, self._batch_shape, - return_sites=self.return_sites, parallel=self.parallel, - model_args=args, model_kwargs=kwargs) - - -def log_likelihood(model, posterior_samples, *args, parallel=False, batch_ndims=1, **kwargs): + return _predictive( + rng_key, + model, + posterior_samples, + self._batch_shape, + return_sites=self.return_sites, + parallel=self.parallel, + model_args=args, + model_kwargs=kwargs, + ) + + +def log_likelihood( + model, posterior_samples, *args, parallel=False, batch_ndims=1, **kwargs +): """ (EXPERIMENTAL INTERFACE) Returns log likelihood at observation nodes of model, given samples of all latent variables. @@ -636,17 +784,24 @@ def log_likelihood(model, posterior_samples, *args, parallel=False, batch_ndims= """ def single_loglik(samples): - substituted_model = substitute(model, samples) if isinstance(samples, dict) else model + substituted_model = ( + substitute(model, samples) if isinstance(samples, dict) else model + ) model_trace = trace(substituted_model).get_trace(*args, **kwargs) - return {name: site['fn'].log_prob(site['value']) for name, site in model_trace.items() - if site['type'] == 'sample' and site['is_observed']} + return { + name: site["fn"].log_prob(site["value"]) + for name, site in model_trace.items() + if site["type"] == "sample" and site["is_observed"] + } prototype_site = batch_shape = None for name, sample in posterior_samples.items(): if batch_shape is not None and jnp.shape(sample)[:batch_ndims] != batch_shape: - raise ValueError(f"Batch shapes at site {name} and {prototype_site} " - f"should be the same, but got " - f"{sample.shape[:batch_ndims]} and {batch_shape}") + raise ValueError( + f"Batch shapes at site {name} and {prototype_site} " + f"should be the same, but got " + f"{sample.shape[:batch_ndims]} and {batch_shape}" + ) else: prototype_site = name batch_shape = jnp.shape(sample)[:batch_ndims] diff --git a/numpyro/nn/__init__.py b/numpyro/nn/__init__.py index 8ea11caec..fcc55c4ba 100644 --- a/numpyro/nn/__init__.py +++ b/numpyro/nn/__init__.py @@ -5,4 +5,8 @@ from numpyro.nn.block_neural_arn import BlockNeuralAutoregressiveNN from numpyro.nn.masked_dense import MaskedDense -__all__ = ['MaskedDense', 'AutoregressiveNN', 'BlockNeuralAutoregressiveNN'] +__all__ = [ + "MaskedDense", + "AutoregressiveNN", + "BlockNeuralAutoregressiveNN", +] diff --git a/numpyro/nn/auto_reg_nn.py b/numpyro/nn/auto_reg_nn.py index 85ae12044..a14ee707b 100644 --- a/numpyro/nn/auto_reg_nn.py +++ b/numpyro/nn/auto_reg_nn.py @@ -63,8 +63,14 @@ def create_mask(input_dim, hidden_dims, permutation, output_dim_multiplier): return masks, mask_skip -def AutoregressiveNN(input_dim, hidden_dims, param_dims=[1, 1], permutation=None, - skip_connections=False, nonlinearity=stax.Relu): +def AutoregressiveNN( + input_dim, + hidden_dims, + param_dims=[1, 1], + permutation=None, + skip_connections=False, + nonlinearity=stax.Relu, +): """ An implementation of a MADE-like auto-regressive neural network. @@ -111,15 +117,18 @@ def AutoregressiveNN(input_dim, hidden_dims, param_dims=[1, 1], permutation=None # possible to connect to the outputs correctly for h in hidden_dims: if h < input_dim: - raise ValueError('Hidden dimension must not be less than input dimension.') + raise ValueError("Hidden dimension must not be less than input dimension.") if permutation is None: permutation = jnp.arange(input_dim) # Create masks - masks, mask_skip = create_mask(input_dim=input_dim, hidden_dims=hidden_dims, - permutation=permutation, - output_dim_multiplier=output_multiplier) + masks, mask_skip = create_mask( + input_dim=input_dim, + hidden_dims=hidden_dims, + permutation=permutation, + output_dim_multiplier=output_multiplier, + ) main_layers = [] # Create masked layers @@ -129,10 +138,13 @@ def AutoregressiveNN(input_dim, hidden_dims, param_dims=[1, 1], permutation=None main_layers.append(nonlinearity) if skip_connections: - net_init, net = stax.serial(stax.FanOut(2), - stax.parallel(stax.serial(*main_layers), - MaskedDense(mask_skip, bias=False)), - stax.FanInSum) + net_init, net = stax.serial( + stax.FanOut(2), + stax.parallel( + stax.serial(*main_layers), MaskedDense(mask_skip, bias=False) + ), + stax.FanInSum, + ) else: net_init, net = stax.serial(*main_layers) diff --git a/numpyro/nn/block_neural_arn.py b/numpyro/nn/block_neural_arn.py index 44d96b8f3..8eb8598be 100644 --- a/numpyro/nn/block_neural_arn.py +++ b/numpyro/nn/block_neural_arn.py @@ -12,7 +12,9 @@ from numpyro.distributions.util import logmatmulexp, vec_to_tril_matrix -def BlockMaskedDense(num_blocks, in_factor, out_factor, bias=True, W_init=glorot_uniform()): +def BlockMaskedDense( + num_blocks, in_factor, out_factor, bias=True, W_init=glorot_uniform() +): """ Module that implements a linear layer with block matrices with positive diagonal blocks. Moreover, it uses Weight Normalization (https://arxiv.org/abs/1602.07868) for stability. @@ -29,7 +31,9 @@ def BlockMaskedDense(num_blocks, in_factor, out_factor, bias=True, W_init=glorot mask_d = np.identity(num_blocks)[..., None] mask_d = np.tile(mask_d, (1, in_factor, out_factor)).reshape(input_dim, out_dim) # Off-diagonal block mask for upper triangular weight matrix - mask_o = vec_to_tril_matrix(jnp.ones(num_blocks * (num_blocks - 1) // 2), diagonal=-1).T[..., None] + mask_o = vec_to_tril_matrix( + jnp.ones(num_blocks * (num_blocks - 1) // 2), diagonal=-1 + ).T[..., None] mask_o = jnp.tile(mask_o, (1, in_factor, out_factor)).reshape(input_dim, out_dim) def init_fun(rng, input_shape): @@ -41,15 +45,15 @@ def init_fun(rng, input_shape): for i in range(num_blocks): W = ops.index_add( W, - ops.index[:(i + 1) * in_factor, i * out_factor:(i + 1) * out_factor], - W_init(k1[i], ((i + 1) * in_factor, out_factor)) + ops.index[: (i + 1) * in_factor, i * out_factor : (i + 1) * out_factor], + W_init(k1[i], ((i + 1) * in_factor, out_factor)), ) # initialize weight scale - ws = jnp.log(uniform(1.)(k2, (out_dim,))) + ws = jnp.log(uniform(1.0)(k2, (out_dim,))) if bias: - b = (uniform(1.)(k3, (out_dim,)) - 0.5) * (2 / jnp.sqrt(out_dim)) + b = (uniform(1.0)(k3, (out_dim,)) - 0.5) * (2 / jnp.sqrt(out_dim)) params = (W, ws, b) else: params = (W, ws) @@ -77,7 +81,9 @@ def apply_fun(params, inputs, **kwargs): dense_logdet = ws + W - jnp.log(w_norm) # logdet of block diagonal - dense_logdet = dense_logdet[mask_d.astype(bool)].reshape(num_blocks, in_factor, out_factor) + dense_logdet = dense_logdet[mask_d.astype(bool)].reshape( + num_blocks, in_factor, out_factor + ) if logdet is None: logdet = jnp.broadcast_to(dense_logdet, x.shape[:-1] + dense_logdet.shape) else: @@ -93,13 +99,14 @@ def Tanh(): :return: an (`init_fn`, `update_fn`) pair. """ + def init_fun(rng, input_shape): return input_shape, () def apply_fun(params, inputs, **kwargs): x, logdet = inputs out = jnp.tanh(x) - tanh_logdet = -2 * (x + softplus(-2 * x) - jnp.log(2.)) + tanh_logdet = -2 * (x + softplus(-2 * x) - jnp.log(2.0)) # logdet.shape = batch_shape + (num_blocks, in_factor, out_factor) # tanh_logdet.shape = batch_shape + (num_blocks x out_factor,) # so we need to reshape tanh_logdet to: batch_shape + (num_blocks, 1, out_factor) @@ -116,6 +123,7 @@ def FanInResidualNormal(): :return: an (`init_fn`, `update_fn`) pair. """ + def init_fun(rng, input_shape): return input_shape[0], () @@ -127,7 +135,7 @@ def apply_fun(params, inputs, **kwargs): return init_fun, apply_fun -def FanInResidualGated(gate_init=normal(1.)): +def FanInResidualGated(gate_init=normal(1.0)): """ Similar to FanInNormal uses a learnable parameter `gate` to interpolate two fan-in branches. It is required that the second fan-in branch is identity. @@ -135,6 +143,7 @@ def FanInResidualGated(gate_init=normal(1.)): :param gate_init: initialization method for the gate. :return: an (`init_fn`, `update_fn`) pair. """ + def init_fun(rng, input_shape): return input_shape[0], gate_init(rng, ()) @@ -174,8 +183,12 @@ def BlockNeuralAutoregressiveNN(input_dim, hidden_factors=[8, 8], residual=None) layers.append(BlockMaskedDense(input_dim, in_factor, 1)) arn = stax.serial(*layers) if residual is not None: - FanInResidual = FanInResidualGated if residual == "gated" else FanInResidualNormal - arn = stax.serial(stax.FanOut(2), stax.parallel(arn, stax.Identity), FanInResidual()) + FanInResidual = ( + FanInResidualGated if residual == "gated" else FanInResidualNormal + ) + arn = stax.serial( + stax.FanOut(2), stax.parallel(arn, stax.Identity), FanInResidual() + ) def init_fun(rng, input_shape): return arn[0](rng, input_shape) diff --git a/numpyro/nn/masked_dense.py b/numpyro/nn/masked_dense.py index 3d7e82aa7..c211a2685 100644 --- a/numpyro/nn/masked_dense.py +++ b/numpyro/nn/masked_dense.py @@ -19,6 +19,7 @@ def MaskedDense(mask, bias=True, W_init=glorot_normal(), b_init=normal()): :param array b_init: initialization method for the bias terms. :return: a (`init_fn`, `update_fn`) pair. """ + def init_fun(rng_key, input_shape): k1, k2 = random.split(rng_key) W = W_init(k1, mask.shape) diff --git a/numpyro/optim.py b/numpyro/optim.py index abba1d83a..bf205e860 100644 --- a/numpyro/optim.py +++ b/numpyro/optim.py @@ -18,19 +18,19 @@ from jax.tree_util import register_pytree_node, tree_map __all__ = [ - 'Adam', - 'Adagrad', - 'ClippedAdam', - 'Minimize', - 'Momentum', - 'RMSProp', - 'RMSPropMomentum', - 'SGD', - 'SM3', + "Adam", + "Adagrad", + "ClippedAdam", + "Minimize", + "Momentum", + "RMSProp", + "RMSPropMomentum", + "SGD", + "SM3", ] -_Params = TypeVar('_Params') -_OptState = TypeVar('_OptState') +_Params = TypeVar("_Params") +_OptState = TypeVar("_OptState") _IterOptState = Tuple[int, _OptState] @@ -77,7 +77,9 @@ def eval_and_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: out, grads = value_and_grad(fn)(params) return out, self.update(grads, state) - def eval_and_stable_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: + def eval_and_stable_update( + self, fn: Callable, state: _IterOptState + ) -> _IterOptState: """ Like :meth:`eval_and_update` but when the value of the objective function or the gradients are not finite, we will not update the input `state` @@ -89,10 +91,12 @@ def eval_and_stable_update(self, fn: Callable, state: _IterOptState) -> _IterOpt """ params = self.get_params(state) out, grads = value_and_grad(fn)(params) - out, state = lax.cond(jnp.isfinite(out) & jnp.isfinite(ravel_pytree(grads)[0]).all(), - lambda _: (out, self.update(grads, state)), - lambda _: (jnp.nan, state), - None) + out, state = lax.cond( + jnp.isfinite(out) & jnp.isfinite(ravel_pytree(grads)[0]).all(), + lambda _: (out, self.update(grads, state)), + lambda _: (jnp.nan, state), + None, + ) return out, state def get_params(self, state: _IterOptState) -> _Params: @@ -108,8 +112,9 @@ def get_params(self, state: _IterOptState) -> _Params: def _add_doc(fn): def _wrapped(cls): - cls.__doc__ = 'Wrapper class for the JAX optimizer: :func:`~jax.experimental.optimizers.{}`'\ - .format(fn.__name__) + cls.__doc__ = "Wrapper class for the JAX optimizer: :func:`~jax.experimental.optimizers.{}`".format( + fn.__name__ + ) return cls return _wrapped @@ -133,14 +138,17 @@ class ClippedAdam(_NumPyroOptim): `A Method for Stochastic Optimization`, Diederik P. Kingma, Jimmy Ba https://arxiv.org/abs/1412.6980 """ - def __init__(self, *args, clip_norm=10., **kwargs): + + def __init__(self, *args, clip_norm=10.0, **kwargs): self.clip_norm = clip_norm super(ClippedAdam, self).__init__(optimizers.adam, *args, **kwargs) def update(self, g, state): i, opt_state = state # clip norm - g = tree_map(lambda g_: jnp.clip(g_, a_min=-self.clip_norm, a_max=self.clip_norm), g) + g = tree_map( + lambda g_: jnp.clip(g_, a_min=-self.clip_norm, a_max=self.clip_norm), g + ) opt_state = self.update_fn(i, g, opt_state) return i + 1, opt_state @@ -166,7 +174,9 @@ def __init__(self, *args, **kwargs): @_add_doc(optimizers.rmsprop_momentum) class RMSPropMomentum(_NumPyroOptim): def __init__(self, *args, **kwargs): - super(RMSPropMomentum, self).__init__(optimizers.rmsprop_momentum, *args, **kwargs) + super(RMSPropMomentum, self).__init__( + optimizers.rmsprop_momentum, *args, **kwargs + ) @_add_doc(optimizers.sgd) @@ -190,7 +200,8 @@ def __init__(self, *args, **kwargs): register_pytree_node( _MinimizeState, lambda state: ((state.flat_params,), (state.unravel_fn,)), - lambda data, xs: _MinimizeState(xs[0], data[0])) + lambda data, xs: _MinimizeState(xs[0], data[0]), +) def _minimize_wrapper(): @@ -248,6 +259,7 @@ class Minimize(_NumPyroOptim): >>> assert_allclose(quantiles["a"], 2., atol=1e-3) >>> assert_allclose(quantiles["b"], 3., atol=1e-3) """ + def __init__(self, method="BFGS", **kwargs): super().__init__(_minimize_wrapper) self._method = method @@ -255,8 +267,13 @@ def __init__(self, method="BFGS", **kwargs): def eval_and_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: i, (flat_params, unravel_fn) = state - results = minimize(lambda x: fn(unravel_fn(x)), flat_params, (), - method=self._method, **self._kwargs) + results = minimize( + lambda x: fn(unravel_fn(x)), + flat_params, + (), + method=self._method, + **self._kwargs + ) flat_params, out = results.x, results.fun state = (i + 1, _MinimizeState(flat_params, unravel_fn)) return out, state diff --git a/numpyro/patch.py b/numpyro/patch.py index ca02562de..20b3d8286 100644 --- a/numpyro/patch.py +++ b/numpyro/patch.py @@ -3,14 +3,14 @@ def patch_dependency(target, root_module): - parts = target.split('.') + parts = target.split(".") assert parts[0] == root_module.__name__ module = root_module for part in parts[1:-1]: module = getattr(module, part) name = parts[-1] old_fn = getattr(module, name) - old_fn = getattr(old_fn, '_pyro_unpatched', old_fn) # ensure patching is idempotent + old_fn = getattr(old_fn, "_pyro_unpatched", old_fn) # ensure patching is idempotent def decorator(new_fn): new_fn.__name__ = name diff --git a/numpyro/primitives.py b/numpyro/primitives.py index df928c72b..94253ee89 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -15,7 +15,7 @@ _PYRO_STACK = [] -CondIndepStackFrame = namedtuple('CondIndepStackFrame', ['name', 'dim', 'size']) +CondIndepStackFrame = namedtuple("CondIndepStackFrame", ["name", "dim", "size"]) def apply_stack(msg): @@ -26,18 +26,18 @@ def apply_stack(msg): # it prevents any Messengers above it on the stack from being applied. if msg.get("stop"): break - if msg['value'] is None: - if msg['type'] == 'sample': - msg['value'], msg['intermediates'] = msg['fn'](*msg['args'], - sample_intermediates=True, - **msg['kwargs']) + if msg["value"] is None: + if msg["type"] == "sample": + msg["value"], msg["intermediates"] = msg["fn"]( + *msg["args"], sample_intermediates=True, **msg["kwargs"] + ) else: - msg['value'] = msg['fn'](*msg['args'], **msg['kwargs']) + msg["value"] = msg["fn"](*msg["args"], **msg["kwargs"]) # A Messenger that sets msg["stop"] == True also prevents application # of postprocess_message by Messengers above it on the stack # via the pointer variable from the process_message loop - for handler in _PYRO_STACK[-pointer - 1:]: + for handler in _PYRO_STACK[-pointer - 1 :]: handler.postprocess_message(msg) return msg @@ -45,8 +45,10 @@ def apply_stack(msg): class Messenger(object): def __init__(self, fn=None): if fn is not None and not callable(fn): - raise ValueError("Expected `fn` to be a Python callable object; " - "instead found type(fn) = {}.".format(type(fn))) + raise ValueError( + "Expected `fn` to be a Python callable object; " + "instead found type(fn) = {}.".format(type(fn)) + ) self.fn = fn functools.update_wrapper(self, fn, updated=[]) @@ -94,7 +96,9 @@ def _masked_observe(name, fn, obs, obs_mask, **kwargs): return deterministic(name, value) -def sample(name, fn, obs=None, rng_key=None, sample_shape=(), infer=None, obs_mask=None): +def sample( + name, fn, obs=None, rng_key=None, sample_shape=(), infer=None, obs_mask=None +): """ Returns a random sample from the stochastic function `fn`. This can have additional side effects when wrapped inside effect handlers like @@ -127,26 +131,28 @@ def sample(name, fn, obs=None, rng_key=None, sample_shape=(), infer=None, obs_ma return fn(rng_key=rng_key, sample_shape=sample_shape) if obs_mask is not None: - return _masked_observe(name, fn, obs, obs_mask, rng_key=rng_key, sample_shape=(), infer=infer) + return _masked_observe( + name, fn, obs, obs_mask, rng_key=rng_key, sample_shape=(), infer=infer + ) # Otherwise, we initialize a message... initial_msg = { - 'type': 'sample', - 'name': name, - 'fn': fn, - 'args': (), - 'kwargs': {'rng_key': rng_key, 'sample_shape': sample_shape}, - 'value': obs, - 'scale': None, - 'is_observed': obs is not None, - 'intermediates': [], - 'cond_indep_stack': [], - 'infer': {} if infer is None else infer, + "type": "sample", + "name": name, + "fn": fn, + "args": (), + "kwargs": {"rng_key": rng_key, "sample_shape": sample_shape}, + "value": obs, + "scale": None, + "is_observed": obs is not None, + "intermediates": [], + "cond_indep_stack": [], + "infer": {} if infer is None else infer, } # ...and use apply_stack to send it to the Messengers msg = apply_stack(initial_msg) - return msg['value'] + return msg["value"] def param(name, init_value=None, **kwargs): @@ -176,31 +182,34 @@ def param(name, init_value=None, **kwargs): """ # if there are no active Messengers, we just draw a sample and return it as expected: if not _PYRO_STACK: - assert not callable(init_value), \ - "A callable init_value needs to be put inside a numpyro.handlers.seed handler." + assert not callable( + init_value + ), "A callable init_value needs to be put inside a numpyro.handlers.seed handler." return init_value if callable(init_value): + def fn(init_fn, *args, **kwargs): return init_fn(prng_key()) + else: fn = identity # Otherwise, we initialize a message... initial_msg = { - 'type': 'param', - 'name': name, - 'fn': fn, - 'args': (init_value,), - 'kwargs': kwargs, - 'value': None, - 'scale': None, - 'cond_indep_stack': [], + "type": "param", + "name": name, + "fn": fn, + "args": (init_value,), + "kwargs": kwargs, + "value": None, + "scale": None, + "cond_indep_stack": [], } # ...and use apply_stack to send it to the Messengers msg = apply_stack(initial_msg) - return msg['value'] + return msg["value"] def deterministic(name, value): @@ -217,15 +226,11 @@ def deterministic(name, value): if not _PYRO_STACK: return value - initial_msg = { - 'type': 'deterministic', - 'name': name, - 'value': value, - } + initial_msg = {"type": "deterministic", "name": name, "value": value} # ...and use apply_stack to send it to the Messengers msg = apply_stack(initial_msg) - return msg['value'] + return msg["value"] def _inspect(): @@ -286,12 +291,12 @@ def module(name, nn, input_shape=None): as an input and returns the neural network transformed output array. """ - module_key = name + '$params' + module_key = name + "$params" nn_init, nn_apply = nn nn_params = param(module_key) if nn_params is None: if input_shape is None: - raise ValueError('Valid value for `input_shape` needed to initialize.') + raise ValueError("Valid value for `input_shape` needed to initialize.") rng_key = prng_key() _, nn_params = nn_init(rng_key, input_shape) param(module_key, nn_params) @@ -300,7 +305,7 @@ def module(name, nn, input_shape=None): def _subsample_fn(size, subsample_size, rng_key=None): assert rng_key is not None, "Missing random key to generate subsample indices." - if jax.default_backend() == 'cpu': + if jax.default_backend() == "cpu": # ref: https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#The_modern_algorithm rng_keys = random.split(rng_key, subsample_size) @@ -308,7 +313,17 @@ def body_fn(val, idx): i_p1 = size - idx i = i_p1 - 1 j = random.randint(rng_keys[idx], (), 0, i_p1) - val = ops.index_update(val, ops.index[[i, j], ], val[ops.index[[j, i], ]]) + val = ops.index_update( + val, + ops.index[ + [i, j], + ], + val[ + ops.index[ + [j, i], + ] + ], + ) return val, None val, _ = lax.scan(body_fn, jnp.arange(size), jnp.arange(subsample_size)) @@ -347,9 +362,10 @@ def __init__(self, name, size, subsample_size=None, dim=None): assert size > 0, "size of plate should be positive" self.size = size if dim is not None and dim >= 0: - raise ValueError('dim arg must be negative.') + raise ValueError("dim arg must be negative.") self.dim, self._indices = self._subsample( - self.name, self.size, subsample_size, dim) + self.name, self.size, subsample_size, dim + ) self.subsample_size = self._indices.shape[0] super(plate, self).__init__() @@ -357,25 +373,30 @@ def __init__(self, name, size, subsample_size=None, dim=None): @staticmethod def _subsample(name, size, subsample_size, dim): msg = { - 'type': 'plate', - 'fn': _subsample_fn, - 'name': name, - 'args': (size, subsample_size), - 'kwargs': {'rng_key': None}, - 'value': (None - if (subsample_size is not None and size != subsample_size) - else jnp.arange(size)), - 'scale': 1.0, - 'cond_indep_stack': [], + "type": "plate", + "fn": _subsample_fn, + "name": name, + "args": (size, subsample_size), + "kwargs": {"rng_key": None}, + "value": ( + None + if (subsample_size is not None and size != subsample_size) + else jnp.arange(size) + ), + "scale": 1.0, + "cond_indep_stack": [], } apply_stack(msg) - subsample = msg['value'] - subsample_size = msg['args'][1] + subsample = msg["value"] + subsample_size = msg["args"][1] if subsample_size is not None and subsample_size != subsample.shape[0]: - warnings.warn("subsample_size does not match len(subsample), {} vs {}.".format( - subsample_size, len(subsample)) + - " Did you accidentally use different subsample_size in the model and guide?") - cond_indep_stack = msg['cond_indep_stack'] + warnings.warn( + "subsample_size does not match len(subsample), {} vs {}.".format( + subsample_size, len(subsample) + ) + + " Did you accidentally use different subsample_size in the model and guide?" + ) + cond_indep_stack = msg["cond_indep_stack"] occupied_dims = {f.dim for f in cond_indep_stack} if dim is None: new_dim = -1 @@ -399,30 +420,36 @@ def _get_batch_shape(cond_indep_stack): return tuple(batch_shape) def process_message(self, msg): - if msg['type'] not in ('param', 'sample', 'plate'): - if msg['type'] == 'control_flow': - raise NotImplementedError('Cannot use control flow primitive under a `plate` primitive.' - ' Please move those `plate` statements into the control flow' - ' body function. See `scan` documentation for more information.') + if msg["type"] not in ("param", "sample", "plate"): + if msg["type"] == "control_flow": + raise NotImplementedError( + "Cannot use control flow primitive under a `plate` primitive." + " Please move those `plate` statements into the control flow" + " body function. See `scan` documentation for more information." + ) return - cond_indep_stack = msg['cond_indep_stack'] + cond_indep_stack = msg["cond_indep_stack"] frame = CondIndepStackFrame(self.name, self.dim, self.subsample_size) cond_indep_stack.append(frame) - if msg['type'] == 'sample': + if msg["type"] == "sample": expected_shape = self._get_batch_shape(cond_indep_stack) - dist_batch_shape = msg['fn'].batch_shape - if 'sample_shape' in msg['kwargs']: - dist_batch_shape = msg['kwargs']['sample_shape'] + dist_batch_shape - msg['kwargs']['sample_shape'] = () + dist_batch_shape = msg["fn"].batch_shape + if "sample_shape" in msg["kwargs"]: + dist_batch_shape = msg["kwargs"]["sample_shape"] + dist_batch_shape + msg["kwargs"]["sample_shape"] = () overlap_idx = max(len(expected_shape) - len(dist_batch_shape), 0) trailing_shape = expected_shape[overlap_idx:] - broadcast_shape = lax.broadcast_shapes(trailing_shape, tuple(dist_batch_shape)) + broadcast_shape = lax.broadcast_shapes( + trailing_shape, tuple(dist_batch_shape) + ) batch_shape = expected_shape[:overlap_idx] + broadcast_shape - msg['fn'] = msg['fn'].expand(batch_shape) + msg["fn"] = msg["fn"].expand(batch_shape) if self.size != self.subsample_size: - scale = 1. if msg['scale'] is None else msg['scale'] - msg['scale'] = scale * (self.size / self.subsample_size if self.subsample_size else 1) + scale = 1.0 if msg["scale"] is None else msg["scale"] + msg["scale"] = scale * ( + self.size / self.subsample_size if self.subsample_size else 1 + ) def postprocess_message(self, msg): if msg["type"] in ("subsample", "param") and self.dim is not None: @@ -434,12 +461,18 @@ def postprocess_message(self, msg): if len(shape) >= -dim and shape[dim] != 1: if shape[dim] != self.size: if msg["type"] == "param": - statement = "numpyro.param({}, ..., event_dim={})".format(msg["name"], event_dim) + statement = "numpyro.param({}, ..., event_dim={})".format( + msg["name"], event_dim + ) else: - statement = "numpyro.subsample(..., event_dim={})".format(event_dim) + statement = "numpyro.subsample(..., event_dim={})".format( + event_dim + ) raise ValueError( - "Inside numpyro.plate({}, {}, dim={}) invalid shape of {}: {}" - .format(self.name, self.size, self.dim, statement, shape)) + "Inside numpyro.plate({}, {}, dim={}) invalid shape of {}: {}".format( + self.name, self.size, self.dim, statement, shape + ) + ) if self.subsample_size < self.size: value = msg["value"] new_value = jnp.take(value, self._indices, dim) @@ -489,15 +522,15 @@ def prng_key(): return initial_msg = { - 'type': 'prng_key', - 'fn': lambda rng_key: rng_key, - 'args': (), - 'kwargs': {'rng_key': None}, - 'value': None, + "type": "prng_key", + "fn": lambda rng_key: rng_key, + "args": (), + "kwargs": {"rng_key": None}, + "value": None, } msg = apply_stack(initial_msg) - return msg['value'] + return msg["value"] def subsample(data, event_dim): @@ -532,10 +565,10 @@ def model(data): assert isinstance(event_dim, int) and event_dim >= 0 initial_msg = { - 'type': 'subsample', - 'value': data, - 'kwargs': {'event_dim': event_dim} + "type": "subsample", + "value": data, + "kwargs": {"event_dim": event_dim}, } msg = apply_stack(initial_msg) - return msg['value'] + return msg["value"] diff --git a/numpyro/util.py b/numpyro/util.py index 8b247e0b6..14963c5c2 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -39,8 +39,8 @@ def enable_x64(use_x64=True): else 32 bits. """ if not use_x64: - use_x64 = os.getenv('JAX_ENABLE_X64', 0) - jax.config.update('jax_enable_x64', use_x64) + use_x64 = os.getenv("JAX_ENABLE_X64", 0) + jax.config.update("jax_enable_x64", use_x64) def set_platform(platform=None): @@ -51,8 +51,8 @@ def set_platform(platform=None): :param str platform: either 'cpu', 'gpu', or 'tpu'. """ if platform is None: - platform = os.getenv('JAX_PLATFORM_NAME', 'cpu') - jax.config.update('jax_platform_name', platform) + platform = os.getenv("JAX_PLATFORM_NAME", "cpu") + jax.config.update("jax_platform_name", platform) def set_host_device_count(n): @@ -74,10 +74,13 @@ def set_host_device_count(n): :param int n: number of CPU devices to use. """ - xla_flags = os.getenv('XLA_FLAGS', '').lstrip('--') - xla_flags = re.sub(r'xla_force_host_platform_device_count=.+\s', '', xla_flags).split() - os.environ['XLA_FLAGS'] = ' '.join(['--xla_force_host_platform_device_count={}'.format(n)] - + xla_flags) + xla_flags = os.getenv("XLA_FLAGS", "").lstrip("--") + xla_flags = re.sub( + r"xla_force_host_platform_device_count=.+\s", "", xla_flags + ).split() + os.environ["XLA_FLAGS"] = " ".join( + ["--xla_force_host_platform_device_count={}".format(n)] + xla_flags + ) @contextmanager @@ -147,7 +150,7 @@ def identity(x, *args, **kwargs): def cached_by(outer_fn, *keys): # Restrict cache size to prevent ref cycles. max_size = 8 - outer_fn._cache = getattr(outer_fn, '_cache', OrderedDict()) + outer_fn._cache = getattr(outer_fn, "_cache", OrderedDict()) def _wrapped(fn): fn_cache = outer_fn._cache @@ -181,11 +184,11 @@ def progress_bar_factory(num_samples, num_chains): finished_chains = [] for chain in range(num_chains): tqdm_bars[chain] = tqdm_auto(range(num_samples), position=chain) - tqdm_bars[chain].set_description("Compiling.. ", refresh=True,) + tqdm_bars[chain].set_description("Compiling.. ", refresh=True) def _update_tqdm(arg, transform, device): chain = int(str(device)[4:]) - tqdm_bars[chain].set_description(f"Running chain {chain}", refresh=False,) + tqdm_bars[chain].set_description(f"Running chain {chain}", refresh=False) tqdm_bars[chain].update(arg) def _close_tqdm(arg, transform, device): @@ -203,19 +206,25 @@ def _update_progress_bar(iter_num): _ = lax.cond( iter_num == 1, - lambda _: host_callback.id_tap(_update_tqdm, 0, result=iter_num, tap_with_device=True), + lambda _: host_callback.id_tap( + _update_tqdm, 0, result=iter_num, tap_with_device=True + ), lambda _: iter_num, operand=None, ) _ = lax.cond( iter_num % print_rate == 0, - lambda _: host_callback.id_tap(_update_tqdm, print_rate, result=iter_num, tap_with_device=True), + lambda _: host_callback.id_tap( + _update_tqdm, print_rate, result=iter_num, tap_with_device=True + ), lambda _: iter_num, operand=None, ) _ = lax.cond( iter_num == num_samples, - lambda _: host_callback.id_tap(_close_tqdm, remainder, result=iter_num, tap_with_device=True), + lambda _: host_callback.id_tap( + _close_tqdm, remainder, result=iter_num, tap_with_device=True + ), lambda _: iter_num, operand=None, ) @@ -225,18 +234,29 @@ def progress_bar_fori_loop(func): Note that `body_fun` must be looping over a tuple who's first element is `np.arange(num_samples)`. This means that `iter_num` is the current iteration number """ + def wrapper_progress_bar(i, vals): result = func(i, vals) _update_progress_bar(i + 1) return result + return wrapper_progress_bar return progress_bar_fori_loop -def fori_collect(lower, upper, body_fun, init_val, transform=identity, - progbar=True, return_last_val=False, collection_size=None, - thinning=1, **progbar_opts): +def fori_collect( + lower, + upper, + body_fun, + init_val, + transform=identity, + progbar=True, + return_last_val=False, + collection_size=None, + thinning=1, + **progbar_opts, +): """ This looping construct works like :func:`~jax.lax.fori_loop` but with the additional effect of collecting values from the loop body. In addition, this allows for @@ -272,34 +292,42 @@ def fori_collect(lower, upper, body_fun, init_val, transform=identity, """ assert lower <= upper assert thinning >= 1 - collection_size = (upper - lower) // thinning if collection_size is None else collection_size + collection_size = ( + (upper - lower) // thinning if collection_size is None else collection_size + ) assert collection_size >= (upper - lower) // thinning init_val_flat, unravel_fn = ravel_pytree(transform(init_val)) start_idx = lower + (upper - lower) % thinning - num_chains = progbar_opts.pop('num_chains', 1) + num_chains = progbar_opts.pop("num_chains", 1) @cached_by(fori_collect, body_fun, transform) def _body_fn(i, vals): val, collection, start_idx, thinning = vals val = body_fun(val) idx = (i - start_idx) // thinning - collection = cond(idx >= 0, - collection, - lambda x: ops.index_update(x, idx, ravel_pytree(transform(val))[0]), - collection, - identity) + collection = cond( + idx >= 0, + collection, + lambda x: ops.index_update(x, idx, ravel_pytree(transform(val))[0]), + collection, + identity, + ) return val, collection, start_idx, thinning collection = jnp.zeros((collection_size,) + init_val_flat.shape) if not progbar: - last_val, collection, _, _ = fori_loop(0, upper, _body_fn, (init_val, collection, start_idx, thinning)) + last_val, collection, _, _ = fori_loop( + 0, upper, _body_fn, (init_val, collection, start_idx, thinning) + ) elif num_chains > 1: progress_bar_fori_loop = progress_bar_factory(upper, num_chains) _body_fn_pbar = progress_bar_fori_loop(_body_fn) - last_val, collection, _, _ = fori_loop(0, upper, _body_fn_pbar, (init_val, collection, start_idx, thinning)) + last_val, collection, _, _ = fori_loop( + 0, upper, _body_fn_pbar, (init_val, collection, start_idx, thinning) + ) else: - diagnostics_fn = progbar_opts.pop('diagnostics_fn', None) - progbar_desc = progbar_opts.pop('progbar_desc', lambda x: '') + diagnostics_fn = progbar_opts.pop("diagnostics_fn", None) + progbar_desc = progbar_opts.pop("progbar_desc", lambda x: "") vals = (init_val, collection, device_put(start_idx), device_put(thinning)) if upper == 0: @@ -319,20 +347,31 @@ def _body_fn(i, vals): return (unravel_collection, last_val) if return_last_val else unravel_collection -pytree_metadata = namedtuple('pytree_metadata', ['flat', 'shape', 'size', 'dtype']) +pytree_metadata = namedtuple("pytree_metadata", ["flat", "shape", "size", "dtype"]) def _ravel_list(*leaves): - leaves_metadata = tree_map(lambda l: pytree_metadata( - jnp.ravel(l), jnp.shape(l), jnp.size(l), jnp.result_type(l)), leaves) + leaves_metadata = tree_map( + lambda l: pytree_metadata( + jnp.ravel(l), jnp.shape(l), jnp.size(l), jnp.result_type(l) + ), + leaves, + ) leaves_idx = jnp.cumsum(jnp.array((0,) + tuple(d.size for d in leaves_metadata))) def unravel_list(arr): - return [jnp.reshape(lax.dynamic_slice_in_dim(arr, leaves_idx[i], m.size), - m.shape).astype(m.dtype) - for i, m in enumerate(leaves_metadata)] - - flat = jnp.concatenate([m.flat for m in leaves_metadata]) if leaves_metadata else jnp.array([]) + return [ + jnp.reshape( + lax.dynamic_slice_in_dim(arr, leaves_idx[i], m.size), m.shape + ).astype(m.dtype) + for i, m in enumerate(leaves_metadata) + ] + + flat = ( + jnp.concatenate([m.flat for m in leaves_metadata]) + if leaves_metadata + else jnp.array([]) + ) return flat, unravel_list @@ -368,19 +407,28 @@ def soft_vmap(fn, xs, batch_ndims=1, chunk_size=None): # we'll do map(vmap(fn), xs) and make xs.shape = (num_chunks, chunk_size, ...) num_chunks = batch_size = int(np.prod(batch_shape)) prepend_shape = (-1,) if batch_size > 1 else () - xs = tree_map(lambda x: jnp.reshape(x, prepend_shape + jnp.shape(x)[batch_ndims:]), xs) + xs = tree_map( + lambda x: jnp.reshape(x, prepend_shape + jnp.shape(x)[batch_ndims:]), xs + ) # XXX: probably for the default behavior with chunk_size=None, # it is better to catch OOM error and reduce chunk_size by half until OOM disappears. chunk_size = batch_size if chunk_size is None else min(batch_size, chunk_size) if chunk_size > 1: pad = chunk_size - (batch_size % chunk_size) - xs = tree_map(lambda x: jnp.pad(x, ((0, pad),) + ((0, 0),) * (np.ndim(x) - 1)), xs) + xs = tree_map( + lambda x: jnp.pad(x, ((0, pad),) + ((0, 0),) * (np.ndim(x) - 1)), xs + ) num_chunks = batch_size // chunk_size + int(pad > 0) prepend_shape = (-1,) if num_chunks > 1 else () - xs = tree_map(lambda x: jnp.reshape(x, prepend_shape + (chunk_size,) + jnp.shape(x)[1:]), xs) + xs = tree_map( + lambda x: jnp.reshape(x, prepend_shape + (chunk_size,) + jnp.shape(x)[1:]), + xs, + ) fn = vmap(fn) ys = lax.map(fn, xs) if num_chunks > 1 else fn(xs) map_ndims = int(num_chunks > 1) + int(chunk_size > 1) - ys = tree_map(lambda y: jnp.reshape(y, (-1,) + jnp.shape(y)[map_ndims:])[:batch_size], ys) + ys = tree_map( + lambda y: jnp.reshape(y, (-1,) + jnp.shape(y)[map_ndims:])[:batch_size], ys + ) return tree_map(lambda y: jnp.reshape(y, batch_shape + jnp.shape(y)[1:]), ys) diff --git a/numpyro/version.py b/numpyro/version.py index 48baadee9..3720decc6 100644 --- a/numpyro/version.py +++ b/numpyro/version.py @@ -1,4 +1,4 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -__version__ = '0.6.0' +__version__ = "0.6.0" diff --git a/scripts/update_headers.py b/scripts/update_headers.py index 284d2d219..45438019a 100644 --- a/scripts/update_headers.py +++ b/scripts/update_headers.py @@ -8,10 +8,7 @@ root = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) blacklist = ["/build/", "/dist/", "/pyro_api.egg"] -file_types = [ - ("*.py", "# {}"), - ("*.cpp", "// {}"), -] +file_types = [("*.py", "# {}"), ("*.cpp", "// {}")] parser = argparse.ArgumentParser() parser.add_argument("--check", action="store_true") @@ -69,7 +66,7 @@ with open(filename, "w") as f: f.write("".join(lines)) - print("updated {}".format(filename[len(root) + 1:])) + print("updated {}".format(filename[len(root) + 1 :])) if dirty: print("The following files need license headers:\n{}".format("\n".join(dirty))) diff --git a/scripts/update_version.py b/scripts/update_version.py index 5cb590545..ed9e38fd9 100644 --- a/scripts/update_version.py +++ b/scripts/update_version.py @@ -17,12 +17,11 @@ filenames = [] for path in ["examples", "notebooks/source"]: for ext in ["*.py", "*.ipynb"]: - filenames.extend(glob.glob(os.path.join(root, path, "**", ext), - recursive=True)) + filenames.extend(glob.glob(os.path.join(root, path, "**", ext), recursive=True)) filenames.sort() # Update version string. -pattern1 = re.compile("assert numpyro.__version__.startswith\\(\"[^\"]*\"\\)") +pattern1 = re.compile('assert numpyro.__version__.startswith\\("[^"]*"\\)') pattern2 = re.compile("assert numpyro.__version__.startswith\\('[^']*'\\)") text = f"assert numpyro.__version__.startswith({new_version})" for filename in filenames: diff --git a/setup.cfg b/setup.cfg index 93f080d30..edc653778 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,15 +1,17 @@ [flake8] max-line-length = 120 exclude = docs/src, build, dist, .ipynb_checkpoints +ignore = W503,E203 [isort] -line_length = 120 +profile = black skip_glob = .ipynb_checkpoints known_first_party = funsor, numpyro, test known_third_party = opt_einsum known_jax = flax, haiku, jax, tensorflow_probability sections = FUTURE, STDLIB, THIRDPARTY, JAX, FIRSTPARTY, LOCALFOLDER force_sort_within_sections = true +combine_as_imports = true multi_line_output = 3 skip=docs diff --git a/setup.py b/setup.py index 7b37dbd33..511893df0 100644 --- a/setup.py +++ b/setup.py @@ -11,67 +11,72 @@ PROJECT_PATH = os.path.dirname(os.path.abspath(__file__)) # Find version -for line in open(os.path.join(PROJECT_PATH, 'numpyro', 'version.py')): - if line.startswith('__version__ = '): +for line in open(os.path.join(PROJECT_PATH, "numpyro", "version.py")): + if line.startswith("__version__ = "): version = line.strip().split()[2][1:-1] # READ README.md for long description on PyPi. try: - long_description = open('README.md', encoding='utf-8').read() + long_description = open("README.md", encoding="utf-8").read() except Exception as e: - sys.stderr.write('Failed to read README.md:\n {}\n'.format(e)) + sys.stderr.write("Failed to read README.md:\n {}\n".format(e)) sys.stderr.flush() - long_description = '' + long_description = "" setup( - name='numpyro', + name="numpyro", version=version, - description='Pyro PPL on NumPy', - packages=find_packages(include=['numpyro', 'numpyro.*']), - url='https://github.com/pyro-ppl/numpyro', - author='Uber AI Labs', + description="Pyro PPL on NumPy", + packages=find_packages(include=["numpyro", "numpyro.*"]), + url="https://github.com/pyro-ppl/numpyro", + author="Uber AI Labs", install_requires=[ # TODO: pin to a specific version for the release (until JAX's API becomes stable) - 'jax==0.2.10', + "jax==0.2.10", # check min version here: https://github.com/google/jax/blob/master/jax/lib/__init__.py#L26 - 'jaxlib==0.1.62', - 'tqdm', + "jaxlib==0.1.62", + "tqdm", ], extras_require={ - 'doc': ['nbsphinx', 'sphinx', 'sphinx_rtd_theme', 'sphinx-gallery'], - 'test': [ - 'flake8', - 'ipython', - 'pytest>=4.1', - 'pyro-api>=0.1.1', - 'scipy>=1.1', + "doc": [ + "ipython", # sphinx needs this to render codes + "nbsphinx", + "sphinx", + "sphinx_rtd_theme", + "sphinx-gallery", ], - 'dev': [ - 'dm-haiku', - 'flax', - 'funsor @ git+https://github.com/pyro-ppl/funsor.git@d5574988665dd822ec64e41f2b54b9dc929959dc', - 'ipython', - 'isort', - 'tensorflow_probability', - 'graphviz', + "test": [ + "black", + "flake8", + "isort>=5.0", + "pytest>=4.1", + "pyro-api>=0.1.1", + "scipy>=1.1", ], - 'examples': ['matplotlib', 'seaborn', 'arviz'], + "dev": [ + "dm-haiku", + "flax", + "funsor @ git+https://github.com/pyro-ppl/funsor.git@d5574988665dd822ec64e41f2b54b9dc929959dc", + "graphviz", + "tensorflow_probability", + ], + "examples": ["arviz", "jupyter", "matplotlib", "pandas", "seaborn"], }, long_description=long_description, - long_description_content_type='text/markdown', - keywords='probabilistic machine learning bayesian statistics', - license='Apache License 2.0', + long_description_content_type="text/markdown", + keywords="probabilistic machine learning bayesian statistics", + license="Apache License 2.0", classifiers=[ - 'Intended Audience :: Developers', - 'Intended Audience :: Education', - 'Intended Audience :: Science/Research', - 'License :: OSI Approved :: Apache Software License', - 'Operating System :: POSIX :: Linux', - 'Operating System :: MacOS :: MacOS X', - 'Programming Language :: Python :: 3.6', - 'Programming Language :: Python :: 3.7', - 'Programming Language :: Python :: 3.8', - 'Programming Language :: Python :: 3.9', + "Intended Audience :: Developers", + "Intended Audience :: Education", + "Intended Audience :: Science/Research", + "License :: OSI Approved :: Apache Software License", + "Operating System :: POSIX :: Linux", + "Operating System :: MacOS :: MacOS X", + "Programming Language :: Python :: 3.6", + "Programming Language :: Python :: 3.7", + "Programming Language :: Python :: 3.8", + "Programming Language :: Python :: 3.9", ], ) diff --git a/test/conftest.py b/test/conftest.py index 5c38ae12c..98b91aec9 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -3,12 +3,14 @@ import os +from jax.config import config + from numpyro.util import set_rng_seed -from jax.config import config; config.update('jax_platform_name', 'cpu') # noqa: E702 +config.update("jax_platform_name", "cpu") # noqa: E702 def pytest_runtest_setup(item): - if 'JAX_ENABLE_x64' in os.environ: - config.update('jax_enable_x64', True) + if "JAX_ENABLE_x64" in os.environ: + config.update("jax_enable_x64", True) set_rng_seed(0) diff --git a/test/contrib/einstein/test_einstein_kernels.py b/test/contrib/einstein/test_einstein_kernels.py index 2b1837edc..556080c5a 100644 --- a/test/contrib/einstein/test_einstein_kernels.py +++ b/test/contrib/einstein/test_einstein_kernels.py @@ -16,58 +16,65 @@ MixtureKernel, PrecondMatrixKernel, RandomFeatureKernel, - RBFKernel + RBFKernel, ) jnp.set_printoptions(precision=100) -T = namedtuple('TestSteinKernel', ['kernel', 'particle_info', 'loss_fn', 'kval']) +T = namedtuple("TestSteinKernel", ["kernel", "particle_info", "loss_fn", "kval"]) -PARTICLES_2D = jnp.array([[1., 2.], [-10., 10.], [7., 3.], [2., -1]]) +PARTICLES_2D = jnp.array([[1.0, 2.0], [-10.0, 10.0], [7.0, 3.0], [2.0, -1]]) -TPARTICLES_2D = (jnp.array([1., 2.]), jnp.array([10., 5.])) # transformed particles +TPARTICLES_2D = (jnp.array([1.0, 2.0]), jnp.array([10.0, 5.0])) # transformed particles TEST_CASES = [ - T(RBFKernel, - lambda d: {}, - lambda x: x, - {'norm': 0.040711474, - 'vector': jnp.array([0.056071877, 0.7260586]), - 'matrix': jnp.array([[0.040711474, 0.], - [0., 0.040711474]])} - ), - T(RandomFeatureKernel, - lambda d: {}, - lambda x: x, - {'norm': 12.190277}), - T(IMQKernel, - lambda d: {}, - lambda x: x, - {'norm': .104828484, - 'vector': jnp.array([0.11043153, 0.31622776])} - ), - T(LinearKernel, - lambda d: {}, - lambda x: x, - {'norm': 21.} - ), - T(lambda mode: MixtureKernel(mode=mode, ws=jnp.array([.2, .8]), kernel_fns=[RBFKernel(mode), RBFKernel(mode)]), - lambda d: {}, - lambda x: x, - {'matrix': jnp.array([[0.040711474, 0.], - [0., 0.040711474]])} - ), - T(lambda mode: GraphicalKernel(mode=mode, local_kernel_fns={'p1': RBFKernel('norm')}), - lambda d: {'p1': (0, d)}, - lambda x: x, - {'matrix': jnp.array([[0.040711474, 0.], - [0., 0.040711474]])} - ), - T(lambda mode: PrecondMatrixKernel(HessianPrecondMatrix(), RBFKernel(mode='matrix'), precond_mode='const'), - lambda d: {}, - lambda x: -.02 / 12 * x[0] ** 4 - .5 / 12 * x[1] ** 4 - x[0] * x[1], # -hess = [[.02x_0^2 1] [1 .5x_1^2]] - {'matrix': jnp.array([[2.3780507e-04, - 1.6688075e-05], - [-1.6688075e-05, 1.2849815e-05]])} - ) + T( + RBFKernel, + lambda d: {}, + lambda x: x, + { + "norm": 0.040711474, + "vector": jnp.array([0.056071877, 0.7260586]), + "matrix": jnp.array([[0.040711474, 0.0], [0.0, 0.040711474]]), + }, + ), + T(RandomFeatureKernel, lambda d: {}, lambda x: x, {"norm": 12.190277}), + T( + IMQKernel, + lambda d: {}, + lambda x: x, + {"norm": 0.104828484, "vector": jnp.array([0.11043153, 0.31622776])}, + ), + T(LinearKernel, lambda d: {}, lambda x: x, {"norm": 21.0}), + T( + lambda mode: MixtureKernel( + mode=mode, + ws=jnp.array([0.2, 0.8]), + kernel_fns=[RBFKernel(mode), RBFKernel(mode)], + ), + lambda d: {}, + lambda x: x, + {"matrix": jnp.array([[0.040711474, 0.0], [0.0, 0.040711474]])}, + ), + T( + lambda mode: GraphicalKernel( + mode=mode, local_kernel_fns={"p1": RBFKernel("norm")} + ), + lambda d: {"p1": (0, d)}, + lambda x: x, + {"matrix": jnp.array([[0.040711474, 0.0], [0.0, 0.040711474]])}, + ), + T( + lambda mode: PrecondMatrixKernel( + HessianPrecondMatrix(), RBFKernel(mode="matrix"), precond_mode="const" + ), + lambda d: {}, + lambda x: -0.02 / 12 * x[0] ** 4 - 0.5 / 12 * x[1] ** 4 - x[0] * x[1], + { + "matrix": jnp.array( + [[2.3780507e-04, -1.6688075e-05], [-1.6688075e-05, 1.2849815e-05]] + ) + }, + ), # -hess = [[.02x_0^2 1] [1 .5x_1^2]] ] PARTICLES = [(PARTICLES_2D, TPARTICLES_2D)] @@ -75,13 +82,17 @@ TEST_IDS = [t[0].__class__.__name__ for t in TEST_CASES] -@pytest.mark.parametrize('kernel, particle_info, loss_fn, kval', TEST_CASES, ids=TEST_IDS) -@pytest.mark.parametrize('particles, tparticles', PARTICLES) -@pytest.mark.parametrize('mode', ['norm', 'vector', 'matrix']) -def test_kernel_forward(kernel, particles, particle_info, loss_fn, tparticles, mode, kval): +@pytest.mark.parametrize( + "kernel, particle_info, loss_fn, kval", TEST_CASES, ids=TEST_IDS +) +@pytest.mark.parametrize("particles, tparticles", PARTICLES) +@pytest.mark.parametrize("mode", ["norm", "vector", "matrix"]) +def test_kernel_forward( + kernel, particles, particle_info, loss_fn, tparticles, mode, kval +): if mode not in kval: return - d, = tparticles[0].shape + (d,) = tparticles[0].shape kernel_fn = kernel(mode=mode).compute(particles, particle_info(d), loss_fn) value = kernel_fn(*tparticles) diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 6d636c3cb..09d40afa1 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -16,18 +16,17 @@ def test_scan(): - def model(T=10, q=1, r=1, phi=0., beta=0.): - + def model(T=10, q=1, r=1, phi=0.0, beta=0.0): def transition(state, i): x0, mu0 = state - x1 = numpyro.sample('x', dist.Normal(phi * x0, q)) + x1 = numpyro.sample("x", dist.Normal(phi * x0, q)) mu1 = beta * mu0 + x1 - y1 = numpyro.sample('y', dist.Normal(mu1, r)) - numpyro.deterministic('y2', y1 * 2) + y1 = numpyro.sample("y", dist.Normal(mu1, r)) + numpyro.deterministic("y2", y1 * 2) return (x1, mu1), (x1, y1) - mu0 = x0 = numpyro.sample('x_0', dist.Normal(0, q)) - y0 = numpyro.sample('y_0', dist.Normal(mu0, r)) + mu0 = x0 = numpyro.sample("x_0", dist.Normal(0, q)) + y0 = numpyro.sample("y_0", dist.Normal(mu0, r)) _, xy = scan(transition, (x0, mu0), jnp.arange(T)) x, y = xy @@ -39,23 +38,27 @@ def transition(state, i): kernel = NUTS(model) mcmc = MCMC(kernel, 100, num_samples) mcmc.run(random.PRNGKey(0), T=T) - assert set(mcmc.get_samples()) == {'x', 'y', 'y2', 'x_0', 'y_0'} + assert set(mcmc.get_samples()) == {"x", "y", "y2", "x_0", "y_0"} mcmc.print_summary() samples = mcmc.get_samples() - x = samples.pop('x')[0] # take 1 sample of x + x = samples.pop("x")[0] # take 1 sample of x # this tests for the composition of condition and substitute # this also tests if we can use `vmap` for predictive. future = 5 - predictive = Predictive(numpyro.handlers.condition(model, {'x': x}), - samples, return_sites=['x', 'y', 'y2'], parallel=True) + predictive = Predictive( + numpyro.handlers.condition(model, {"x": x}), + samples, + return_sites=["x", "y", "y2"], + parallel=True, + ) result = predictive(random.PRNGKey(1), T=T + future) expected_shape = (num_samples, T + future) - assert result['x'].shape == expected_shape - assert result['y'].shape == expected_shape - assert result['y2'].shape == expected_shape - assert_allclose(result['x'][:, :T], jnp.broadcast_to(x, (num_samples, T))) - assert_allclose(result['y'][:, :T], samples['y']) + assert result["x"].shape == expected_shape + assert result["y"].shape == expected_shape + assert result["y2"].shape == expected_shape + assert_allclose(result["x"][:, :T], jnp.broadcast_to(x, (num_samples, T))) + assert_allclose(result["y"][:, :T], samples["y"]) @pytest.mark.xfail(raises=RuntimeError) @@ -82,30 +85,30 @@ def body_fn(z, val): def test_scan_constrain_reparam_compatible(): - def model(T, q=1, r=1, phi=0., beta=0.): - x = 0. - mu = 0. + def model(T, q=1, r=1, phi=0.0, beta=0.0): + x = 0.0 + mu = 0.0 for i in range(T): - x = numpyro.sample(f'x_{i}', dist.LogNormal(phi * x, q)) + x = numpyro.sample(f"x_{i}", dist.LogNormal(phi * x, q)) mu = beta * mu + x - numpyro.sample(f'y_{i}', dist.Normal(mu, r)) + numpyro.sample(f"y_{i}", dist.Normal(mu, r)) - def fun_model(T, q=1, r=1, phi=0., beta=0.): + def fun_model(T, q=1, r=1, phi=0.0, beta=0.0): def transition(state, i): x, mu = state - x = numpyro.sample('x', dist.LogNormal(phi * x, q)) + x = numpyro.sample("x", dist.LogNormal(phi * x, q)) mu = beta * mu + x - numpyro.sample('y', dist.Normal(mu, r)) + numpyro.sample("y", dist.Normal(mu, r)) return (x, mu), None - scan(transition, (0., 0.), jnp.arange(T)) + scan(transition, (0.0, 0.0), jnp.arange(T)) T = 10 params = {} for i in range(T): - params[f'x_{i}'] = (i + 1.) / 10 - params[f'y_{i}'] = -i / 5 - fun_params = {'x': jnp.arange(1, T + 1) / 10, 'y': -jnp.arange(T) / 5} + params[f"x_{i}"] = (i + 1.0) / 10 + params[f"y_{i}"] = -i / 5 + fun_params = {"x": jnp.arange(1, T + 1) / 10, "y": -jnp.arange(T) / 5} actual_log_joint = potential_energy(fun_model, (T,), {}, fun_params) expected_log_joint = potential_energy(model, (T,), {}, params) assert_allclose(actual_log_joint, expected_log_joint) diff --git a/test/contrib/test_funsor.py b/test/contrib/test_funsor.py index b990d604e..915a2b963 100644 --- a/test/contrib/test_funsor.py +++ b/test/contrib/test_funsor.py @@ -15,8 +15,7 @@ import numpyro from numpyro.contrib.control_flow import scan from numpyro.contrib.funsor import config_enumerate, enum, markov, to_data, to_funsor -from numpyro.contrib.funsor.enum_messenger import NamedMessenger -from numpyro.contrib.funsor.enum_messenger import plate as enum_plate +from numpyro.contrib.funsor.enum_messenger import NamedMessenger, plate as enum_plate from numpyro.contrib.funsor.infer_util import log_density from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist @@ -30,37 +29,49 @@ def test_gaussian_mixture_model(): def gmm(data): mix_proportions = numpyro.sample("phi", dist.Dirichlet(jnp.ones(K))) with numpyro.plate("num_clusters", K, dim=-1): - cluster_means = numpyro.sample("cluster_means", dist.Normal(jnp.arange(K), 1.)) + cluster_means = numpyro.sample( + "cluster_means", dist.Normal(jnp.arange(K), 1.0) + ) with numpyro.plate("data", data.shape[0], dim=-1): - assignments = numpyro.sample("assignments", dist.Categorical(mix_proportions)) - numpyro.sample("obs", dist.Normal(cluster_means[assignments], 1.), obs=data) - - true_cluster_means = jnp.array([1., 5., 10.]) + assignments = numpyro.sample( + "assignments", dist.Categorical(mix_proportions) + ) + numpyro.sample( + "obs", dist.Normal(cluster_means[assignments], 1.0), obs=data + ) + + true_cluster_means = jnp.array([1.0, 5.0, 10.0]) true_mix_proportions = jnp.array([0.1, 0.3, 0.6]) - cluster_assignments = dist.Categorical(true_mix_proportions).sample(random.PRNGKey(0), (N,)) - data = dist.Normal(true_cluster_means[cluster_assignments], 1.0).sample(random.PRNGKey(1)) + cluster_assignments = dist.Categorical(true_mix_proportions).sample( + random.PRNGKey(0), (N,) + ) + data = dist.Normal(true_cluster_means[cluster_assignments], 1.0).sample( + random.PRNGKey(1) + ) nuts_kernel = NUTS(gmm) mcmc = MCMC(nuts_kernel, num_warmup=500, num_samples=500) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() assert_allclose(samples["phi"].mean(0).sort(), true_mix_proportions, atol=0.05) - assert_allclose(samples["cluster_means"].mean(0).sort(), true_cluster_means, atol=0.2) + assert_allclose( + samples["cluster_means"].mean(0).sort(), true_cluster_means, atol=0.2 + ) def test_bernoulli_latent_model(): def model(data): - y_prob = numpyro.sample("y_prob", dist.Beta(1., 1.)) + y_prob = numpyro.sample("y_prob", dist.Beta(1.0, 1.0)) with numpyro.plate("data", data.shape[0]): y = numpyro.sample("y", dist.Bernoulli(y_prob)) z = numpyro.sample("z", dist.Bernoulli(0.65 * y + 0.1)) - numpyro.sample("obs", dist.Normal(2. * z, 1.), obs=data) + numpyro.sample("obs", dist.Normal(2.0 * z, 1.0), obs=data) N = 2000 y_prob = 0.3 y = dist.Bernoulli(y_prob).sample(random.PRNGKey(0), (N,)) z = dist.Bernoulli(0.65 * y + 0.1).sample(random.PRNGKey(1)) - data = dist.Normal(2. * z, 1.0).sample(random.PRNGKey(2)) + data = dist.Normal(2.0 * z, 1.0).sample(random.PRNGKey(2)) nuts_kernel = NUTS(model) mcmc = MCMC(nuts_kernel, num_warmup=500, num_samples=500) @@ -73,28 +84,99 @@ def test_change_point(): def model(count_data): n_count_data = count_data.shape[0] alpha = 1 / jnp.mean(count_data.astype(np.float32)) - lambda_1 = numpyro.sample('lambda_1', dist.Exponential(alpha)) - lambda_2 = numpyro.sample('lambda_2', dist.Exponential(alpha)) + lambda_1 = numpyro.sample("lambda_1", dist.Exponential(alpha)) + lambda_2 = numpyro.sample("lambda_2", dist.Exponential(alpha)) # this is the same as DiscreteUniform(0, 69) - tau = numpyro.sample('tau', dist.Categorical(logits=jnp.zeros(70))) + tau = numpyro.sample("tau", dist.Categorical(logits=jnp.zeros(70))) idx = jnp.arange(n_count_data) lambda_ = jnp.where(tau > idx, lambda_1, lambda_2) with numpyro.plate("data", n_count_data): - numpyro.sample('obs', dist.Poisson(lambda_), obs=count_data) - - count_data = jnp.array([ - 13, 24, 8, 24, 7, 35, 14, 11, 15, 11, 22, 22, 11, 57, 11, - 19, 29, 6, 19, 12, 22, 12, 18, 72, 32, 9, 7, 13, 19, 23, - 27, 20, 6, 17, 13, 10, 14, 6, 16, 15, 7, 2, 15, 15, 19, - 70, 49, 7, 53, 22, 21, 31, 19, 11, 1, 20, 12, 35, 17, 23, - 17, 4, 2, 31, 30, 13, 27, 0, 39, 37, 5, 14, 13, 22, - ]) + numpyro.sample("obs", dist.Poisson(lambda_), obs=count_data) + + count_data = jnp.array( + [ + 13, + 24, + 8, + 24, + 7, + 35, + 14, + 11, + 15, + 11, + 22, + 22, + 11, + 57, + 11, + 19, + 29, + 6, + 19, + 12, + 22, + 12, + 18, + 72, + 32, + 9, + 7, + 13, + 19, + 23, + 27, + 20, + 6, + 17, + 13, + 10, + 14, + 6, + 16, + 15, + 7, + 2, + 15, + 15, + 19, + 70, + 49, + 7, + 53, + 22, + 21, + 31, + 19, + 11, + 1, + 20, + 12, + 35, + 17, + 23, + 17, + 4, + 2, + 31, + 30, + 13, + 27, + 0, + 39, + 37, + 5, + 14, + 13, + 22, + ] + ) kernel = NUTS(model) mcmc = MCMC(kernel, num_warmup=500, num_samples=500) mcmc.run(random.PRNGKey(0), count_data) samples = mcmc.get_samples() - assert_allclose(samples["lambda_1"].mean(0), 18., atol=1.) + assert_allclose(samples["lambda_1"].mean(0), 18.0, atol=1.0) assert_allclose(samples["lambda_2"].mean(0), 22.5, atol=1.5) @@ -111,14 +193,16 @@ def model(data): trans_prob = numpyro.sample("initialize", dist.Dirichlet(jnp.ones(dim))) for t, y in markov(enumerate(data)): x = numpyro.sample("x_{}".format(t), dist.Categorical(trans_prob)) - numpyro.sample("y_{}".format(t), dist.Normal(emission_loc[x], emission_scale[x]), obs=y) + numpyro.sample( + "y_{}".format(t), dist.Normal(emission_loc[x], emission_scale[x]), obs=y + ) trans_prob = transition[x] def _generate_data(): transition_probs = np.random.rand(dim, dim) transition_probs = transition_probs / transition_probs.sum(-1, keepdims=True) emissions_loc = np.arange(dim) - emissions_scale = 1. + emissions_scale = 1.0 state = np.random.choice(3) obs = [np.random.normal(emissions_loc[state], emissions_scale)] for _ in range(num_steps - 1): @@ -133,11 +217,10 @@ def _generate_data(): def test_iteration(): - def testing(): for i in markov(range(5)): - v1 = to_data(Tensor(jnp.ones(2), OrderedDict([(str(i), Bint[2])]), 'real')) - v2 = to_data(Tensor(jnp.zeros(2), OrderedDict([('a', Bint[2])]), 'real')) + v1 = to_data(Tensor(jnp.ones(2), OrderedDict([(str(i), Bint[2])]), "real")) + v2 = to_data(Tensor(jnp.zeros(2), OrderedDict([("a", Bint[2])]), "real")) fv1 = to_funsor(v1, Real) fv2 = to_funsor(v2, Real) print(i, v1.shape) # shapes should alternate @@ -147,34 +230,37 @@ def testing(): assert v1.shape == (2, 1, 1) assert v2.shape == (2, 1) print(i, fv1.inputs) - print('a', v2.shape) # shapes should stay the same - print('a', fv2.inputs) + print("a", v2.shape) # shapes should stay the same + print("a", fv2.inputs) with NamedMessenger(): testing() def test_nesting(): - def testing(): with markov(): - v1 = to_data(Tensor(jnp.ones(2), OrderedDict([("1", Bint[2])]), 'real')) + v1 = to_data(Tensor(jnp.ones(2), OrderedDict([("1", Bint[2])]), "real")) print(1, v1.shape) # shapes should alternate assert v1.shape == (2,) with markov(): - v2 = to_data(Tensor(jnp.ones(2), OrderedDict([("2", Bint[2])]), 'real')) + v2 = to_data(Tensor(jnp.ones(2), OrderedDict([("2", Bint[2])]), "real")) print(2, v2.shape) # shapes should alternate assert v2.shape == (2, 1) with markov(): - v3 = to_data(Tensor(jnp.ones(2), OrderedDict([("3", Bint[2])]), 'real')) + v3 = to_data( + Tensor(jnp.ones(2), OrderedDict([("3", Bint[2])]), "real") + ) print(3, v3.shape) # shapes should alternate assert v3.shape == (2,) with markov(): - v4 = to_data(Tensor(jnp.ones(2), OrderedDict([("4", Bint[2])]), 'real')) + v4 = to_data( + Tensor(jnp.ones(2), OrderedDict([("4", Bint[2])]), "real") + ) print(4, v4.shape) # shapes should alternate assert v4.shape == (2, 1) @@ -184,15 +270,16 @@ def testing(): def test_staggered(): - def testing(): for i in markov(range(12)): if i % 4 == 0: - v2 = to_data(Tensor(jnp.zeros(2), OrderedDict([('a', Bint[2])]), 'real')) + v2 = to_data( + Tensor(jnp.zeros(2), OrderedDict([("a", Bint[2])]), "real") + ) fv2 = to_funsor(v2, Real) assert v2.shape == (2,) - print('a', v2.shape) - print('a', fv2.inputs) + print("a", v2.shape) + print("a", fv2.inputs) with NamedMessenger(): testing() @@ -206,7 +293,7 @@ def test_nested_plate(): assert x.shape == (2, 5) -@pytest.mark.parametrize('num_steps', [1, 10, 11]) +@pytest.mark.parametrize("num_steps", [1, 10, 11]) def test_scan_enum_one_latent(num_steps): data = random.normal(random.PRNGKey(0), (num_steps,)) init_probs = jnp.array([0.6, 0.4]) @@ -233,7 +320,9 @@ def transition_fn(x, y): return x expected_log_joint = log_density(enum(config_enumerate(model)), (data,), {}, {})[0] - actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[0] + actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[ + 0 + ] assert_allclose(actual_log_joint, expected_log_joint) actual_last_x = enum(config_enumerate(fun_model))(data) @@ -267,8 +356,12 @@ def transition_fn(x, y): scan(transition_fn, None, data) - expected_log_joint = log_density(enum(config_enumerate(model), -2), (data,), {}, {})[0] - actual_log_joint = log_density(enum(config_enumerate(fun_model), -2), (data,), {}, {})[0] + expected_log_joint = log_density( + enum(config_enumerate(model), -2), (data,), {}, {} + )[0] + actual_log_joint = log_density( + enum(config_enumerate(fun_model), -2), (data,), {}, {} + )[0] assert_allclose(actual_log_joint, expected_log_joint) @@ -305,8 +398,12 @@ def transition_fn(x, y): scan(transition_fn, None, (data1, data2)) - actual_log_joint = log_density(enum(config_enumerate(fun_model), -2), (data1, data2), {}, {})[0] - expected_log_joint = log_density(enum(config_enumerate(model), -2), (data1, data2), {}, {})[0] + actual_log_joint = log_density( + enum(config_enumerate(fun_model), -2), (data1, data2), {}, {} + )[0] + expected_log_joint = log_density( + enum(config_enumerate(model), -2), (data1, data2), {}, {} + )[0] assert_allclose(actual_log_joint, expected_log_joint) @@ -337,15 +434,18 @@ def transition_fn(x, y): scan(transition_fn, 0, data) - actual_log_joint = log_density(enum(config_enumerate(fun_model), -2), (data,), {}, {})[0] - expected_log_joint = log_density(enum(config_enumerate(model), -2), (data,), {}, {})[0] + actual_log_joint = log_density( + enum(config_enumerate(fun_model), -2), (data,), {}, {} + )[0] + expected_log_joint = log_density( + enum(config_enumerate(model), -2), (data,), {}, {} + )[0] assert_allclose(actual_log_joint, expected_log_joint) def test_scan_enum_discrete_outside(): data = random.normal(random.PRNGKey(0), (10,)) - probs = jnp.array([[[0.8, 0.2], [0.1, 0.9]], - [[0.7, 0.3], [0.6, 0.4]]]) + probs = jnp.array([[[0.8, 0.2], [0.1, 0.9]], [[0.7, 0.3], [0.6, 0.4]]]) locs = jnp.array([-1.0, 1.0]) def model(data): @@ -365,7 +465,9 @@ def transition_fn(x, y): scan(transition_fn, 0, data) - actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[0] + actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[ + 0 + ] expected_log_joint = log_density(enum(config_enumerate(model)), (data,), {}, {})[0] assert_allclose(actual_log_joint, expected_log_joint) @@ -395,7 +497,9 @@ def transition_fn(carry, y): scan(transition_fn, (0, 0), data) - actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[0] + actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data,), {}, {})[ + 0 + ] expected_log_joint = log_density(enum(config_enumerate(model)), (data,), {}, {})[0] assert_allclose(actual_log_joint, expected_log_joint) @@ -428,13 +532,17 @@ def transition_fn(name, probs, locs, x, y): scan(partial(transition_fn, "x", probs_x, locs_x), 0, data_x) scan(partial(transition_fn, "w", probs_w, locs_w), 0, data_w) - actual_log_joint = log_density(enum(config_enumerate(fun_model)), (data_x, data_w), {}, {})[0] - expected_log_joint = log_density(enum(config_enumerate(model)), (data_x, data_w), {}, {})[0] + actual_log_joint = log_density( + enum(config_enumerate(fun_model)), (data_x, data_w), {}, {} + )[0] + expected_log_joint = log_density( + enum(config_enumerate(model)), (data_x, data_w), {}, {} + )[0] assert_allclose(actual_log_joint, expected_log_joint) -@pytest.mark.parametrize('history', [2, 3]) -@pytest.mark.parametrize('T', [1, 2, 3, 4, 10, 11, 12, 13]) +@pytest.mark.parametrize("history", [2, 3]) +@pytest.mark.parametrize("T", [1, 2, 3, 4, 10, 11, 12, 13]) def test_scan_history(history, T): def model(): p = numpyro.param("p", 0.25 * jnp.ones((2, 2, 2))) @@ -444,7 +552,9 @@ def model(): x_curr = 0 for t in markov(range(T), history=history): probs = p[x_prev, x_curr, z] - x_prev, x_curr = x_curr, numpyro.sample("x_{}".format(t), dist.Bernoulli(probs)) + x_prev, x_curr = x_curr, numpyro.sample( + "x_{}".format(t), dist.Bernoulli(probs) + ) numpyro.sample("y_{}".format(t), dist.Bernoulli(q[x_curr]), obs=0) return x_prev, x_curr @@ -479,16 +589,24 @@ def test_missing_plate(monkeypatch): def gmm(data): mix_proportions = numpyro.sample("phi", dist.Dirichlet(jnp.ones(K))) # plate/to_event is missing here - cluster_means = numpyro.sample("cluster_means", dist.Normal(jnp.arange(K), 1.)) + cluster_means = numpyro.sample("cluster_means", dist.Normal(jnp.arange(K), 1.0)) with numpyro.plate("data", data.shape[0], dim=-1): - assignments = numpyro.sample("assignments", dist.Categorical(mix_proportions)) - numpyro.sample("obs", dist.Normal(cluster_means[assignments], 1.), obs=data) - - true_cluster_means = jnp.array([1., 5., 10.]) + assignments = numpyro.sample( + "assignments", dist.Categorical(mix_proportions) + ) + numpyro.sample( + "obs", dist.Normal(cluster_means[assignments], 1.0), obs=data + ) + + true_cluster_means = jnp.array([1.0, 5.0, 10.0]) true_mix_proportions = jnp.array([0.1, 0.3, 0.6]) - cluster_assignments = dist.Categorical(true_mix_proportions).sample(random.PRNGKey(0), (N,)) - data = dist.Normal(true_cluster_means[cluster_assignments], 1.0).sample(random.PRNGKey(1)) + cluster_assignments = dist.Categorical(true_mix_proportions).sample( + random.PRNGKey(0), (N,) + ) + data = dist.Normal(true_cluster_means[cluster_assignments], 1.0).sample( + random.PRNGKey(1) + ) nuts_kernel = NUTS(gmm) mcmc = MCMC(nuts_kernel, num_warmup=500, num_samples=500) diff --git a/test/contrib/test_indexing.py b/test/contrib/test_indexing.py index 7a01268ec..568bda865 100644 --- a/test/contrib/test_indexing.py +++ b/test/contrib/test_indexing.py @@ -19,92 +19,92 @@ def z(*shape): SHAPE_EXAMPLES = [ - ('Vindex(z())[...]', ()), - ('Vindex(z(2))[...]', (2,)), - ('Vindex(z(2))[...,0]', ()), - ('Vindex(z(2))[...,:]', (2,)), - ('Vindex(z(2))[...,z(3)]', (3,)), - ('Vindex(z(2))[0]', ()), - ('Vindex(z(2))[:]', (2,)), - ('Vindex(z(2))[z(3)]', (3,)), - ('Vindex(z(2,3))[...]', (2, 3)), - ('Vindex(z(2,3))[...,0]', (2,)), - ('Vindex(z(2,3))[...,:]', (2, 3)), - ('Vindex(z(2,3))[...,z(2)]', (2,)), - ('Vindex(z(2,3))[...,z(4,1)]', (4, 2)), - ('Vindex(z(2,3))[...,0,0]', ()), - ('Vindex(z(2,3))[...,0,:]', (3,)), - ('Vindex(z(2,3))[...,0,z(4)]', (4,)), - ('Vindex(z(2,3))[...,:,0]', (2,)), - ('Vindex(z(2,3))[...,:,:]', (2, 3)), - ('Vindex(z(2,3))[...,:,z(4)]', (4, 2)), - ('Vindex(z(2,3))[...,z(4),0]', (4,)), - ('Vindex(z(2,3))[...,z(4),:]', (4, 3)), - ('Vindex(z(2,3))[...,z(4),z(4)]', (4,)), - ('Vindex(z(2,3))[...,z(5,1),z(4)]', (5, 4)), - ('Vindex(z(2,3))[...,z(4),z(5,1)]', (5, 4)), - ('Vindex(z(2,3))[0,0]', ()), - ('Vindex(z(2,3))[0,:]', (3,)), - ('Vindex(z(2,3))[0,z(4)]', (4,)), - ('Vindex(z(2,3))[:,0]', (2,)), - ('Vindex(z(2,3))[:,:]', (2, 3)), - ('Vindex(z(2,3))[:,z(4)]', (4, 2)), - ('Vindex(z(2,3))[z(4),0]', (4,)), - ('Vindex(z(2,3))[z(4),:]', (4, 3)), - ('Vindex(z(2,3))[z(4)]', (4, 3)), - ('Vindex(z(2,3))[z(4),z(4)]', (4,)), - ('Vindex(z(2,3))[z(5,1),z(4)]', (5, 4)), - ('Vindex(z(2,3))[z(4),z(5,1)]', (5, 4)), - ('Vindex(z(2,3,4))[...]', (2, 3, 4)), - ('Vindex(z(2,3,4))[...,z(3)]', (2, 3)), - ('Vindex(z(2,3,4))[...,z(2,1)]', (2, 3)), - ('Vindex(z(2,3,4))[...,z(2,3)]', (2, 3)), - ('Vindex(z(2,3,4))[...,z(5,1,1)]', (5, 2, 3)), - ('Vindex(z(2,3,4))[...,z(2),0]', (2,)), - ('Vindex(z(2,3,4))[...,z(5,1),0]', (5, 2)), - ('Vindex(z(2,3,4))[...,z(2),:]', (2, 4)), - ('Vindex(z(2,3,4))[...,z(5,1),:]', (5, 2, 4)), - ('Vindex(z(2,3,4))[...,z(5),0,0]', (5,)), - ('Vindex(z(2,3,4))[...,z(5),0,:]', (5, 4)), - ('Vindex(z(2,3,4))[...,z(5),:,0]', (5, 3)), - ('Vindex(z(2,3,4))[...,z(5),:,:]', (5, 3, 4)), - ('Vindex(z(2,3,4))[0,0,z(5)]', (5,)), - ('Vindex(z(2,3,4))[0,:,z(5)]', (5, 3)), - ('Vindex(z(2,3,4))[0,z(5),0]', (5,)), - ('Vindex(z(2,3,4))[0,z(5),:]', (5, 4)), - ('Vindex(z(2,3,4))[0,z(5),z(5)]', (5,)), - ('Vindex(z(2,3,4))[0,z(5,1),z(6)]', (5, 6)), - ('Vindex(z(2,3,4))[0,z(6),z(5,1)]', (5, 6)), - ('Vindex(z(2,3,4))[:,0,z(5)]', (5, 2)), - ('Vindex(z(2,3,4))[:,:,z(5)]', (5, 2, 3)), - ('Vindex(z(2,3,4))[:,z(5),0]', (5, 2)), - ('Vindex(z(2,3,4))[:,z(5),:]', (5, 2, 4)), - ('Vindex(z(2,3,4))[:,z(5),z(5)]', (5, 2)), - ('Vindex(z(2,3,4))[:,z(5,1),z(6)]', (5, 6, 2)), - ('Vindex(z(2,3,4))[:,z(6),z(5,1)]', (5, 6, 2)), - ('Vindex(z(2,3,4))[z(5),0,0]', (5,)), - ('Vindex(z(2,3,4))[z(5),0,:]', (5, 4)), - ('Vindex(z(2,3,4))[z(5),:,0]', (5, 3)), - ('Vindex(z(2,3,4))[z(5),:,:]', (5, 3, 4)), - ('Vindex(z(2,3,4))[z(5),0,z(5)]', (5,)), - ('Vindex(z(2,3,4))[z(5,1),0,z(6)]', (5, 6)), - ('Vindex(z(2,3,4))[z(6),0,z(5,1)]', (5, 6)), - ('Vindex(z(2,3,4))[z(5),:,z(5)]', (5, 3)), - ('Vindex(z(2,3,4))[z(5,1),:,z(6)]', (5, 6, 3)), - ('Vindex(z(2,3,4))[z(6),:,z(5,1)]', (5, 6, 3)), + ("Vindex(z())[...]", ()), + ("Vindex(z(2))[...]", (2,)), + ("Vindex(z(2))[...,0]", ()), + ("Vindex(z(2))[...,:]", (2,)), + ("Vindex(z(2))[...,z(3)]", (3,)), + ("Vindex(z(2))[0]", ()), + ("Vindex(z(2))[:]", (2,)), + ("Vindex(z(2))[z(3)]", (3,)), + ("Vindex(z(2,3))[...]", (2, 3)), + ("Vindex(z(2,3))[...,0]", (2,)), + ("Vindex(z(2,3))[...,:]", (2, 3)), + ("Vindex(z(2,3))[...,z(2)]", (2,)), + ("Vindex(z(2,3))[...,z(4,1)]", (4, 2)), + ("Vindex(z(2,3))[...,0,0]", ()), + ("Vindex(z(2,3))[...,0,:]", (3,)), + ("Vindex(z(2,3))[...,0,z(4)]", (4,)), + ("Vindex(z(2,3))[...,:,0]", (2,)), + ("Vindex(z(2,3))[...,:,:]", (2, 3)), + ("Vindex(z(2,3))[...,:,z(4)]", (4, 2)), + ("Vindex(z(2,3))[...,z(4),0]", (4,)), + ("Vindex(z(2,3))[...,z(4),:]", (4, 3)), + ("Vindex(z(2,3))[...,z(4),z(4)]", (4,)), + ("Vindex(z(2,3))[...,z(5,1),z(4)]", (5, 4)), + ("Vindex(z(2,3))[...,z(4),z(5,1)]", (5, 4)), + ("Vindex(z(2,3))[0,0]", ()), + ("Vindex(z(2,3))[0,:]", (3,)), + ("Vindex(z(2,3))[0,z(4)]", (4,)), + ("Vindex(z(2,3))[:,0]", (2,)), + ("Vindex(z(2,3))[:,:]", (2, 3)), + ("Vindex(z(2,3))[:,z(4)]", (4, 2)), + ("Vindex(z(2,3))[z(4),0]", (4,)), + ("Vindex(z(2,3))[z(4),:]", (4, 3)), + ("Vindex(z(2,3))[z(4)]", (4, 3)), + ("Vindex(z(2,3))[z(4),z(4)]", (4,)), + ("Vindex(z(2,3))[z(5,1),z(4)]", (5, 4)), + ("Vindex(z(2,3))[z(4),z(5,1)]", (5, 4)), + ("Vindex(z(2,3,4))[...]", (2, 3, 4)), + ("Vindex(z(2,3,4))[...,z(3)]", (2, 3)), + ("Vindex(z(2,3,4))[...,z(2,1)]", (2, 3)), + ("Vindex(z(2,3,4))[...,z(2,3)]", (2, 3)), + ("Vindex(z(2,3,4))[...,z(5,1,1)]", (5, 2, 3)), + ("Vindex(z(2,3,4))[...,z(2),0]", (2,)), + ("Vindex(z(2,3,4))[...,z(5,1),0]", (5, 2)), + ("Vindex(z(2,3,4))[...,z(2),:]", (2, 4)), + ("Vindex(z(2,3,4))[...,z(5,1),:]", (5, 2, 4)), + ("Vindex(z(2,3,4))[...,z(5),0,0]", (5,)), + ("Vindex(z(2,3,4))[...,z(5),0,:]", (5, 4)), + ("Vindex(z(2,3,4))[...,z(5),:,0]", (5, 3)), + ("Vindex(z(2,3,4))[...,z(5),:,:]", (5, 3, 4)), + ("Vindex(z(2,3,4))[0,0,z(5)]", (5,)), + ("Vindex(z(2,3,4))[0,:,z(5)]", (5, 3)), + ("Vindex(z(2,3,4))[0,z(5),0]", (5,)), + ("Vindex(z(2,3,4))[0,z(5),:]", (5, 4)), + ("Vindex(z(2,3,4))[0,z(5),z(5)]", (5,)), + ("Vindex(z(2,3,4))[0,z(5,1),z(6)]", (5, 6)), + ("Vindex(z(2,3,4))[0,z(6),z(5,1)]", (5, 6)), + ("Vindex(z(2,3,4))[:,0,z(5)]", (5, 2)), + ("Vindex(z(2,3,4))[:,:,z(5)]", (5, 2, 3)), + ("Vindex(z(2,3,4))[:,z(5),0]", (5, 2)), + ("Vindex(z(2,3,4))[:,z(5),:]", (5, 2, 4)), + ("Vindex(z(2,3,4))[:,z(5),z(5)]", (5, 2)), + ("Vindex(z(2,3,4))[:,z(5,1),z(6)]", (5, 6, 2)), + ("Vindex(z(2,3,4))[:,z(6),z(5,1)]", (5, 6, 2)), + ("Vindex(z(2,3,4))[z(5),0,0]", (5,)), + ("Vindex(z(2,3,4))[z(5),0,:]", (5, 4)), + ("Vindex(z(2,3,4))[z(5),:,0]", (5, 3)), + ("Vindex(z(2,3,4))[z(5),:,:]", (5, 3, 4)), + ("Vindex(z(2,3,4))[z(5),0,z(5)]", (5,)), + ("Vindex(z(2,3,4))[z(5,1),0,z(6)]", (5, 6)), + ("Vindex(z(2,3,4))[z(6),0,z(5,1)]", (5, 6)), + ("Vindex(z(2,3,4))[z(5),:,z(5)]", (5, 3)), + ("Vindex(z(2,3,4))[z(5,1),:,z(6)]", (5, 6, 3)), + ("Vindex(z(2,3,4))[z(6),:,z(5,1)]", (5, 6, 3)), ] -@pytest.mark.parametrize('expression,expected_shape', SHAPE_EXAMPLES, ids=str) +@pytest.mark.parametrize("expression,expected_shape", SHAPE_EXAMPLES, ids=str) def test_shape(expression, expected_shape): result = eval(expression) assert result.shape == expected_shape -@pytest.mark.parametrize('event_shape', [(), (7,)], ids=str) -@pytest.mark.parametrize('j_shape', [(), (2,), (3, 1), (4, 1, 1), (4, 3, 2)], ids=str) -@pytest.mark.parametrize('i_shape', [(), (2,), (3, 1), (4, 1, 1), (4, 3, 2)], ids=str) -@pytest.mark.parametrize('x_shape', [(), (2,), (3, 1), (4, 1, 1), (4, 3, 2)], ids=str) +@pytest.mark.parametrize("event_shape", [(), (7,)], ids=str) +@pytest.mark.parametrize("j_shape", [(), (2,), (3, 1), (4, 1, 1), (4, 3, 2)], ids=str) +@pytest.mark.parametrize("i_shape", [(), (2,), (3, 1), (4, 1, 1), (4, 3, 2)], ids=str) +@pytest.mark.parametrize("x_shape", [(), (2,), (3, 1), (4, 1, 1), (4, 3, 2)], ids=str) def test_value(x_shape, i_shape, j_shape, event_shape): x = jnp.array(np.random.rand(*(x_shape + (5, 6) + event_shape))) i = dist.Categorical(jnp.ones((5,))).sample(random.PRNGKey(1), i_shape) @@ -119,21 +119,23 @@ def test_value(x_shape, i_shape, j_shape, event_shape): i = jnp.broadcast_to(i, shape) j = jnp.broadcast_to(j, shape) expected = np.empty(shape + event_shape, dtype=x.dtype) - for ind in (itertools.product(*map(range, shape)) if shape else [()]): + for ind in itertools.product(*map(range, shape)) if shape else [()]: expected[ind] = x[ind + (i[ind].item(), j[ind].item())] assert jnp.all(actual == jnp.array(expected, dtype=x.dtype)) -@pytest.mark.parametrize('prev_enum_dim,curr_enum_dim', [(-3, -4), (-4, -5), (-5, -3)]) +@pytest.mark.parametrize("prev_enum_dim,curr_enum_dim", [(-3, -4), (-4, -5), (-5, -3)]) def test_hmm_example(prev_enum_dim, curr_enum_dim): hidden_dim = 8 probs_x = jnp.array(np.random.rand(hidden_dim, hidden_dim, hidden_dim)) x_prev = jnp.arange(hidden_dim).reshape((-1,) + (1,) * (-1 - prev_enum_dim)) x_curr = jnp.arange(hidden_dim).reshape((-1,) + (1,) * (-1 - curr_enum_dim)) - expected = probs_x[x_prev.reshape(x_prev.shape + (1,)), - x_curr.reshape(x_curr.shape + (1,)), - jnp.arange(hidden_dim)] + expected = probs_x[ + x_prev.reshape(x_prev.shape + (1,)), + x_curr.reshape(x_curr.shape + (1,)), + jnp.arange(hidden_dim), + ] actual = Vindex(probs_x)[x_prev, x_curr, :] assert jnp.all(actual == expected) diff --git a/test/contrib/test_infer_discrete.py b/test/contrib/test_infer_discrete.py index a3b48b2d1..78b24d15b 100644 --- a/test/contrib/test_infer_discrete.py +++ b/test/contrib/test_infer_discrete.py @@ -30,14 +30,14 @@ def log_prob_sum(trace): log_joint = jnp.zeros(()) for site in trace.values(): - if site['type'] == 'sample': - value = site['value'] - intermediates = site['intermediates'] - scale = site['scale'] + if site["type"] == "sample": + value = site["value"] + intermediates = site["intermediates"] + scale = site["scale"] if intermediates: - log_prob = site['fn'].log_prob(value, intermediates) + log_prob = site["fn"].log_prob(value, intermediates) else: - log_prob = site['fn'].log_prob(value) + log_prob = site["fn"].log_prob(value) if (scale is not None) and (not is_identically_one(scale)): log_prob = scale * log_prob @@ -47,8 +47,8 @@ def log_prob_sum(trace): return log_joint -@pytest.mark.parametrize('length', [1, 2, 10]) -@pytest.mark.parametrize('temperature', [0, 1]) +@pytest.mark.parametrize("length", [1, 2, 10]) +@pytest.mark.parametrize("temperature", [0, 1]) def test_hmm_smoke(length, temperature): # This should match the example in the infer_discrete docstring. @@ -57,18 +57,23 @@ def hmm(data, hidden_dim=10): means = jnp.arange(float(hidden_dim)) states = [0] for t in markov(range(len(data))): - states.append(numpyro.sample("states_{}".format(t), - dist.Categorical(transition[states[-1]]))) - data[t] = numpyro.sample("obs_{}".format(t), - dist.Normal(means[states[-1]], 1.), - obs=data[t]) + states.append( + numpyro.sample( + "states_{}".format(t), dist.Categorical(transition[states[-1]]) + ) + ) + data[t] = numpyro.sample( + "obs_{}".format(t), dist.Normal(means[states[-1]], 1.0), obs=data[t] + ) return states, data true_states, data = handlers.seed(hmm, 0)([None] * length) assert len(data) == length assert len(true_states) == 1 + len(data) - decoder = infer_discrete(config_enumerate(hmm), temperature=temperature, rng_key=random.PRNGKey(1)) + decoder = infer_discrete( + config_enumerate(hmm), temperature=temperature, rng_key=random.PRNGKey(1) + ) inferred_states, _ = decoder(data) assert len(inferred_states) == len(true_states) @@ -90,36 +95,43 @@ def test_distribution_1(temperature): # z --|--> x | # +-------+ num_particles = 10000 - data = np.array([1., 2., 3.]) + data = np.array([1.0, 2.0, 3.0]) @config_enumerate def model(z=None): p = numpyro.param("p", np.array([0.75, 0.25])) iz = numpyro.sample("z", dist.Categorical(p), obs=z) - z = jnp.array([0., 1.])[iz] + z = jnp.array([0.0, 1.0])[iz] logger.info("z.shape = {}".format(z.shape)) with numpyro.plate("data", 3): - numpyro.sample("x", dist.Normal(z, 1.), obs=data) + numpyro.sample("x", dist.Normal(z, 1.0), obs=data) first_available_dim = -3 - vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + vectorized_model = ( + model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + ) sampled_model = infer_discrete( - vectorized_model, - first_available_dim, - temperature, - rng_key=random.PRNGKey(1), + vectorized_model, first_available_dim, temperature, rng_key=random.PRNGKey(1) ) sampled_trace = handlers.trace(sampled_model).get_trace() - conditioned_traces = {z: handlers.trace(model).get_trace(z=np.array(z)) for z in [0, 1]} + conditioned_traces = { + z: handlers.trace(model).get_trace(z=np.array(z)) for z in [0, 1] + } # Check posterior over z. actual_z_mean = sampled_trace["z"]["value"].astype(float).mean() if temperature: - expected_z_mean = 1 / (1 + np.exp(log_prob_sum(conditioned_traces[0]) - - log_prob_sum(conditioned_traces[1]))) + expected_z_mean = 1 / ( + 1 + + np.exp( + log_prob_sum(conditioned_traces[0]) + - log_prob_sum(conditioned_traces[1]) + ) + ) else: - expected_z_mean = (log_prob_sum(conditioned_traces[1]) > - log_prob_sum(conditioned_traces[0])).astype(float) + expected_z_mean = ( + log_prob_sum(conditioned_traces[1]) > log_prob_sum(conditioned_traces[0]) + ).astype(float) expected_max = max(log_prob_sum(t) for t in conditioned_traces.values()) actual_max = log_prob_sum(sampled_trace) assert_allclose(expected_max, actual_max, atol=1e-5) @@ -135,40 +147,47 @@ def test_distribution_2(temperature): # z2 --|--> x2 | # +--------+ num_particles = 10000 - data = np.array([[-1., -1., 0.], [-1., 1., 1.]]) + data = np.array([[-1.0, -1.0, 0.0], [-1.0, 1.0, 1.0]]) @config_enumerate def model(z1=None, z2=None): p = numpyro.param("p", jnp.array([[0.25, 0.75], [0.1, 0.9]])) - loc = numpyro.param("loc", jnp.array([-1., 1.])) + loc = numpyro.param("loc", jnp.array([-1.0, 1.0])) z1 = numpyro.sample("z1", dist.Categorical(p[0]), obs=z1) z2 = numpyro.sample("z2", dist.Categorical(p[z1]), obs=z2) logger.info("z1.shape = {}".format(z1.shape)) logger.info("z2.shape = {}".format(z2.shape)) with numpyro.plate("data", 3): - numpyro.sample("x1", dist.Normal(loc[z1], 1.), obs=data[0]) - numpyro.sample("x2", dist.Normal(loc[z2], 1.), obs=data[1]) + numpyro.sample("x1", dist.Normal(loc[z1], 1.0), obs=data[0]) + numpyro.sample("x2", dist.Normal(loc[z2], 1.0), obs=data[1]) first_available_dim = -3 - vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + vectorized_model = ( + model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + ) sampled_model = infer_discrete( - vectorized_model, - first_available_dim, - temperature, - rng_key=random.PRNGKey(1), + vectorized_model, first_available_dim, temperature, rng_key=random.PRNGKey(1) ) sampled_trace = handlers.trace(sampled_model).get_trace() - conditioned_traces = {(z1, z2): handlers.trace(model).get_trace(z1=np.array(z1), - z2=np.array(z2)) - for z1 in [0, 1] for z2 in [0, 1]} + conditioned_traces = { + (z1, z2): handlers.trace(model).get_trace(z1=np.array(z1), z2=np.array(z2)) + for z1 in [0, 1] + for z2 in [0, 1] + } # Check joint posterior over (z1, z2). actual_probs = np.zeros((2, 2)) expected_probs = np.zeros((2, 2)) for (z1, z2), tr in conditioned_traces.items(): expected_probs[z1, z2] = np.exp(log_prob_sum(tr)) - actual_probs[z1, z2] = ((sampled_trace["z1"]["value"] == z1) & - (sampled_trace["z2"]["value"] == z2)).astype(float).mean() + actual_probs[z1, z2] = ( + ( + (sampled_trace["z1"]["value"] == z1) + & (sampled_trace["z2"]["value"] == z2) + ) + .astype(float) + .mean() + ) if temperature: expected_probs = expected_probs / expected_probs.sum() @@ -189,35 +208,43 @@ def test_distribution_3_simple(temperature): # | 2 | # +---------------+ num_particles = 10000 - data = np.array([-1., 1.]) + data = np.array([-1.0, 1.0]) @config_enumerate def model(z2=None): p = numpyro.param("p", np.array([0.25, 0.75])) - loc = numpyro.param("loc", jnp.array([-1., 1.])) + loc = numpyro.param("loc", jnp.array([-1.0, 1.0])) with numpyro.plate("data", 2): z2 = numpyro.sample("z2", dist.Categorical(p), obs=z2) - numpyro.sample("x2", dist.Normal(loc[z2], 1.), obs=data) + numpyro.sample("x2", dist.Normal(loc[z2], 1.0), obs=data) first_available_dim = -3 - vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + vectorized_model = ( + model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + ) sampled_model = infer_discrete( - vectorized_model, - first_available_dim, - temperature, - random.PRNGKey(1), + vectorized_model, first_available_dim, temperature, random.PRNGKey(1) ) sampled_trace = handlers.trace(sampled_model).get_trace() - conditioned_traces = {(z20, z21): handlers.trace(model).get_trace(z2=np.array([z20, z21])) - for z20 in [0, 1] for z21 in [0, 1]} + conditioned_traces = { + (z20, z21): handlers.trace(model).get_trace(z2=np.array([z20, z21])) + for z20 in [0, 1] + for z21 in [0, 1] + } # Check joint posterior over (z2[0], z2[1]). actual_probs = np.zeros((2, 2)) expected_probs = np.zeros((2, 2)) for (z20, z21), tr in conditioned_traces.items(): expected_probs[z20, z21] = np.exp(log_prob_sum(tr)) - actual_probs[z20, z21] = ((sampled_trace["z2"]["value"][..., :1] == z20) & - (sampled_trace["z2"]["value"][..., 1:] == z21)).astype(float).mean() + actual_probs[z20, z21] = ( + ( + (sampled_trace["z2"]["value"][..., :1] == z20) + & (sampled_trace["z2"]["value"][..., 1:] == z21) + ) + .astype(float) + .mean() + ) if temperature: expected_probs = expected_probs / expected_probs.sum() else: @@ -237,40 +264,50 @@ def test_distribution_3(temperature): # | 3 | | 2 | # +---------+ +---------------+ num_particles = 10000 - data = [np.array([-1., -1., 0.]), np.array([-1., 1.])] + data = [np.array([-1.0, -1.0, 0.0]), np.array([-1.0, 1.0])] @config_enumerate def model(z1=None, z2=None): p = numpyro.param("p", np.array([0.25, 0.75])) - loc = numpyro.param("loc", jnp.array([-1., 1.])) + loc = numpyro.param("loc", jnp.array([-1.0, 1.0])) z1 = numpyro.sample("z1", dist.Categorical(p), obs=z1) with numpyro.plate("data[0]", 3): - numpyro.sample("x1", dist.Normal(loc[z1], 1.), obs=data[0]) + numpyro.sample("x1", dist.Normal(loc[z1], 1.0), obs=data[0]) with numpyro.plate("data[1]", 2): z2 = numpyro.sample("z2", dist.Categorical(p), obs=z2) - numpyro.sample("x2", dist.Normal(loc[z2], 1.), obs=data[1]) + numpyro.sample("x2", dist.Normal(loc[z2], 1.0), obs=data[1]) first_available_dim = -3 - vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + vectorized_model = ( + model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + ) sampled_model = infer_discrete( - vectorized_model, - first_available_dim, - temperature, - rng_key=random.PRNGKey(1), + vectorized_model, first_available_dim, temperature, rng_key=random.PRNGKey(1) ) sampled_trace = handlers.trace(sampled_model).get_trace() - conditioned_traces = {(z1, z20, z21): handlers.trace(model).get_trace(z1=np.array(z1), - z2=np.array([z20, z21])) - for z1 in [0, 1] for z20 in [0, 1] for z21 in [0, 1]} + conditioned_traces = { + (z1, z20, z21): handlers.trace(model).get_trace( + z1=np.array(z1), z2=np.array([z20, z21]) + ) + for z1 in [0, 1] + for z20 in [0, 1] + for z21 in [0, 1] + } # Check joint posterior over (z1, z2[0], z2[1]). actual_probs = np.zeros((2, 2, 2)) expected_probs = np.zeros((2, 2, 2)) for (z1, z20, z21), tr in conditioned_traces.items(): expected_probs[z1, z20, z21] = jnp.exp(log_prob_sum(tr)) - actual_probs[z1, z20, z21] = ((sampled_trace["z1"]["value"] == z1) & - (sampled_trace["z2"]["value"][..., :1] == z20) & - (sampled_trace["z2"]["value"][..., 1:] == z21)).astype(float).mean() + actual_probs[z1, z20, z21] = ( + ( + (sampled_trace["z1"]["value"] == z1) + & (sampled_trace["z2"]["value"][..., :1] == z20) + & (sampled_trace["z2"]["value"][..., 1:] == z21) + ) + .astype(float) + .mean() + ) if temperature: expected_probs = expected_probs / expected_probs.sum() else: @@ -290,7 +327,7 @@ def model_zzxx(): # z1 --|--> x1 | | z2 ---> x2 | # | 3 | | 2 | # +---------+ +---------------+ - data = [np.array([-1., -1., 0.]), np.array([-1., 1.])] + data = [np.array([-1.0, -1.0, 0.0]), np.array([-1.0, 1.0])] p = numpyro.param("p", np.array([0.25, 0.75])) loc = numpyro.sample("loc", dist.Normal(0, 1).expand([2]).to_event(1)) # FIXME results in infinite loop in transformeddist_to_funsor. @@ -306,13 +343,13 @@ def model_zzxx(): def model2(): - data = [np.array([-1., -1., 0.]), np.array([-1., 1.])] + data = [np.array([-1.0, -1.0, 0.0]), np.array([-1.0, 1.0])] p = numpyro.param("p", np.array([0.25, 0.75])) loc = numpyro.sample("loc", dist.Normal(0, 1).expand([2]).to_event(1)) # FIXME results in infinite loop in transformeddist_to_funsor. # scale = numpyro.sample("scale", dist.LogNormal(0, 1)) z1 = numpyro.sample("z1", dist.Categorical(p)) - scale = numpyro.sample("scale", dist.LogNormal(jnp.array([0., 1.])[z1], 1)) + scale = numpyro.sample("scale", dist.LogNormal(jnp.array([0.0, 1.0])[z1], 1)) with numpyro.plate("data[0]", 3): numpyro.sample("x1", dist.Normal(loc[z1], scale), obs=data[0]) with numpyro.plate("data[1]", 2): @@ -325,7 +362,9 @@ def model2(): def test_mcmc_model_side_enumeration(model, temperature): mcmc = infer.MCMC(infer.NUTS(model), 0, 1) mcmc.run(random.PRNGKey(0)) - mcmc_data = {k: v[0] for k, v in mcmc.get_samples().items() if k in ["loc", "scale"]} + mcmc_data = { + k: v[0] for k, v in mcmc.get_samples().items() if k in ["loc", "scale"] + } # MAP estimate discretes, conditioned on posterior sampled continous latents. model = handlers.seed(model, rng_seed=1) @@ -336,7 +375,7 @@ def test_mcmc_model_side_enumeration(model, temperature): handlers.condition(config_enumerate(model), mcmc_data), temperature=temperature, rng_key=random.PRNGKey(1), - ), + ) ).get_trace() # Check site names and shapes. @@ -344,13 +383,13 @@ def test_mcmc_model_side_enumeration(model, temperature): assert set(actual_trace) == set(expected_trace) -@pytest.mark.parametrize('temperature', [0, 1]) +@pytest.mark.parametrize("temperature", [0, 1]) def test_distribution_masked(temperature): # +-------+ # z --|--> x | # +-------+ num_particles = 10000 - data = np.array([1., 2., 3.]) + data = np.array([1.0, 2.0, 3.0]) mask = np.array([True, False, False]) @config_enumerate @@ -359,25 +398,32 @@ def model(z=None): z = numpyro.sample("z", dist.Categorical(p), obs=z) logger.info("z.shape = {}".format(z.shape)) with numpyro.plate("data", 3), handlers.mask(mask=mask): - numpyro.sample("x", dist.Normal(z, 1.), obs=data) + numpyro.sample("x", dist.Normal(z, 1.0), obs=data) first_available_dim = -3 - vectorized_model = model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + vectorized_model = ( + model if temperature == 0 else vectorize_model(model, num_particles, dim=-2) + ) sampled_model = infer_discrete( - vectorized_model, - first_available_dim, - temperature, - rng_key=random.PRNGKey(1), + vectorized_model, first_available_dim, temperature, rng_key=random.PRNGKey(1) ) sampled_trace = handlers.trace(sampled_model).get_trace() - conditioned_traces = {z: handlers.trace(model).get_trace(z=np.array(z)) for z in [0., 1.]} + conditioned_traces = { + z: handlers.trace(model).get_trace(z=np.array(z)) for z in [0.0, 1.0] + } # Check posterior over z. actual_z_mean = sampled_trace["z"]["value"].astype(float).mean() if temperature: - expected_z_mean = 1 / (1 + jnp.exp(log_prob_sum(conditioned_traces[0]) - - log_prob_sum(conditioned_traces[1]))) + expected_z_mean = 1 / ( + 1 + + jnp.exp( + log_prob_sum(conditioned_traces[0]) + - log_prob_sum(conditioned_traces[1]) + ) + ) else: - expected_z_mean = (log_prob_sum(conditioned_traces[1]) > - log_prob_sum(conditioned_traces[0])).astype(float) + expected_z_mean = ( + log_prob_sum(conditioned_traces[1]) > log_prob_sum(conditioned_traces[0]) + ).astype(float) assert_allclose(actual_z_mean, expected_z_mean, atol=1e-2) diff --git a/test/contrib/test_module.py b/test/contrib/test_module.py index 55ace045e..ef34ca3d9 100644 --- a/test/contrib/test_module.py +++ b/test/contrib/test_module.py @@ -17,7 +17,7 @@ flax_module, haiku_module, random_flax_module, - random_haiku_module + random_haiku_module, ) import numpyro.distributions as dist from numpyro.infer import MCMC, NUTS @@ -85,13 +85,13 @@ def test_flax_module(): with handlers.trace() as flax_tr, handlers.seed(rng_seed=1): flax_model_by_shape(X, Y) - assert flax_tr["nn$params"]['value']['kernel'].shape == (100, 100) - assert flax_tr["nn$params"]['value']['bias'].shape == (100,) + assert flax_tr["nn$params"]["value"]["kernel"].shape == (100, 100) + assert flax_tr["nn$params"]["value"]["bias"].shape == (100,) with handlers.trace() as flax_tr, handlers.seed(rng_seed=1): flax_model_by_kwargs(X, Y) - assert flax_tr["nn$params"]['value']['kernel'].shape == (100, 100) - assert flax_tr["nn$params"]['value']['bias'].shape == (100,) + assert flax_tr["nn$params"]["value"]["kernel"].shape == (100, 100) + assert flax_tr["nn$params"]["value"]["bias"].shape == (100,) def test_haiku_module(): @@ -101,31 +101,50 @@ def test_haiku_module(): with handlers.trace() as haiku_tr, handlers.seed(rng_seed=1): haiku_model_by_shape(X, Y) - assert haiku_tr["nn$params"]['value']['linear']['w'].shape == (100, 100) - assert haiku_tr["nn$params"]['value']['linear']['b'].shape == (100,) + assert haiku_tr["nn$params"]["value"]["linear"]["w"].shape == (100, 100) + assert haiku_tr["nn$params"]["value"]["linear"]["b"].shape == (100,) with handlers.trace() as haiku_tr, handlers.seed(rng_seed=1): haiku_model_by_kwargs_1(X, Y) - assert haiku_tr["nn$params"]['value']['linear']['w'].shape == (100, 100) - assert haiku_tr["nn$params"]['value']['linear']['b'].shape == (100,) + assert haiku_tr["nn$params"]["value"]["linear"]["w"].shape == (100, 100) + assert haiku_tr["nn$params"]["value"]["linear"]["b"].shape == (100,) with handlers.trace() as haiku_tr, handlers.seed(rng_seed=1): haiku_model_by_kwargs_2(W, X, Y) - assert haiku_tr["nn$params"]['value']['test_haiku_module/w_linear']['w'].shape == (100, 100) - assert haiku_tr["nn$params"]['value']['test_haiku_module/w_linear']['b'].shape == (100,) - assert haiku_tr["nn$params"]['value']['test_haiku_module/x_linear']['w'].shape == (100, 100) - assert haiku_tr["nn$params"]['value']['test_haiku_module/x_linear']['b'].shape == (100,) + assert haiku_tr["nn$params"]["value"]["test_haiku_module/w_linear"]["w"].shape == ( + 100, + 100, + ) + assert haiku_tr["nn$params"]["value"]["test_haiku_module/w_linear"]["b"].shape == ( + 100, + ) + assert haiku_tr["nn$params"]["value"]["test_haiku_module/x_linear"]["w"].shape == ( + 100, + 100, + ) + assert haiku_tr["nn$params"]["value"]["test_haiku_module/x_linear"]["b"].shape == ( + 100, + ) def test_update_params(): - params = {'a': {'b': {'c': {'d': 1}, 'e': np.array(2)}, 'f': np.ones(4)}} - prior = {'a.b.c.d': dist.Delta(4), 'a.f': dist.Delta(5)} + params = {"a": {"b": {"c": {"d": 1}, "e": np.array(2)}, "f": np.ones(4)}} + prior = {"a.b.c.d": dist.Delta(4), "a.f": dist.Delta(5)} new_params = deepcopy(params) with handlers.seed(rng_seed=0): _update_params(params, new_params, prior) - assert params == {'a': {'b': {'c': {'d': ParamShape(())}, 'e': 2}, 'f': ParamShape((4,))}} - test_util.check_eq(new_params, {'a': {'b': {'c': {'d': np.array(4.)}, 'e': np.array(2)}, - 'f': np.full((4,), 5.)}}) + assert params == { + "a": {"b": {"c": {"d": ParamShape(())}, "e": 2}, "f": ParamShape((4,))} + } + test_util.check_eq( + new_params, + { + "a": { + "b": {"c": {"d": np.array(4.0)}, "e": np.array(2)}, + "f": np.full((4,), 5.0), + } + }, + ) @pytest.mark.parametrize("backend", ["flax", "haiku"]) @@ -152,7 +171,7 @@ def test_random_module__mcmc(backend, init): N, dim = 3000, 3 warmup_steps, num_samples = (1000, 1000) data = random.normal(random.PRNGKey(0), (N, dim)) - true_coefs = np.arange(1., dim + 1.) + true_coefs = np.arange(1.0, dim + 1.0) logits = np.sum(true_coefs * data, axis=-1) labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) @@ -162,9 +181,12 @@ def test_random_module__mcmc(backend, init): kwargs = {kwargs_name: data} def model(data, labels): - nn = random_module("nn", linear_module, - {bias_name: dist.Cauchy(), weight_name: dist.Normal()}, - **kwargs) + nn = random_module( + "nn", + linear_module, + {bias_name: dist.Cauchy(), weight_name: dist.Normal()}, + **kwargs + ) logits = nn(data).squeeze(-1) numpyro.sample("y", dist.Bernoulli(logits=logits), obs=labels) @@ -173,5 +195,12 @@ def model(data, labels): mcmc.run(random.PRNGKey(2), data, labels) mcmc.print_summary() samples = mcmc.get_samples() - assert set(samples.keys()) == {"nn/{}".format(bias_name), "nn/{}".format(weight_name)} - assert_allclose(np.mean(samples["nn/{}".format(weight_name)].squeeze(-1), 0), true_coefs, atol=0.22) + assert set(samples.keys()) == { + "nn/{}".format(bias_name), + "nn/{}".format(weight_name), + } + assert_allclose( + np.mean(samples["nn/{}".format(weight_name)].squeeze(-1), 0), + true_coefs, + atol=0.22, + ) diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index 09677d25d..1e47e859d 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -45,7 +45,9 @@ def f(x): def test_independent(): from numpyro.contrib.tfp import distributions as tfd - d = tfd.Independent(tfd.Normal(jnp.zeros(10), jnp.ones(10)), reinterpreted_batch_ndims=1) + d = tfd.Independent( + tfd.Normal(jnp.zeros(10), jnp.ones(10)), reinterpreted_batch_ndims=1 + ) assert d.event_shape == (10,) assert d.batch_shape == () @@ -58,7 +60,9 @@ def test_transformed_distributions(): d = dist.TransformedDistribution(dist.Normal(0, 1), dist.transforms.ExpTransform()) d1 = tfd.TransformedDistribution(tfd.Normal(0, 1), tfb.Exp()) - d2 = dist.TransformedDistribution(dist.Normal(0, 1), tfd.BijectorTransform(tfb.Exp())) + d2 = dist.TransformedDistribution( + dist.Normal(0, 1), tfd.BijectorTransform(tfb.Exp()) + ) x = random.normal(random.PRNGKey(0), (1000,)) d_x = d.log_prob(x).sum() d1_x = d1.log_prob(x).sum() @@ -74,23 +78,23 @@ def test_logistic_regression(): N, dim = 3000, 3 num_warmup, num_samples = (1000, 1000) data = random.normal(random.PRNGKey(0), (N, dim)) - true_coefs = jnp.arange(1., dim + 1.) + true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) labels = dist.Bernoulli(logits=logits)(rng_key=random.PRNGKey(1)) def model(labels): - coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) - logits = numpyro.deterministic('logits', jnp.sum(coefs * data, axis=-1)) - return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) + coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + logits = numpyro.deterministic("logits", jnp.sum(coefs * data, axis=-1)) + return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) kernel = NUTS(model) mcmc = MCMC(kernel, num_warmup, num_samples) mcmc.run(random.PRNGKey(2), labels) mcmc.print_summary() samples = mcmc.get_samples() - assert samples['logits'].shape == (num_samples, N) + assert samples["logits"].shape == (num_samples, N) expected_coefs = jnp.array([0.97, 2.05, 3.18]) - assert_allclose(jnp.mean(samples['coefs'], 0), expected_coefs, atol=0.22) + assert_allclose(jnp.mean(samples["coefs"], 0), expected_coefs, atol=0.22) @pytest.mark.filterwarnings("ignore:can't resolve package") @@ -104,8 +108,8 @@ def test_beta_bernoulli(): def model(data): alpha = jnp.array([1.1, 1.1]) beta = jnp.array([1.1, 1.1]) - p_latent = numpyro.sample('p_latent', dist.Beta(alpha, beta)) - numpyro.sample('obs', dist.Bernoulli(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", dist.Beta(alpha, beta)) + numpyro.sample("obs", dist.Bernoulli(p_latent), obs=data) return p_latent true_probs = jnp.array([0.9, 0.1]) @@ -115,7 +119,7 @@ def model(data): mcmc.run(random.PRNGKey(2), data) mcmc.print_summary() samples = mcmc.get_samples() - assert_allclose(jnp.mean(samples['p_latent'], 0), true_probs, atol=0.05) + assert_allclose(jnp.mean(samples["p_latent"], 0), true_probs, atol=0.05) def make_kernel_fn(target_log_prob_fn): @@ -123,33 +127,46 @@ def make_kernel_fn(target_log_prob_fn): return tfp.mcmc.HamiltonianMonteCarlo( target_log_prob_fn=target_log_prob_fn, - step_size=0.5 / jnp.sqrt(0.5 ** jnp.arange(4)[..., None]), num_leapfrog_steps=5) - - -@pytest.mark.parametrize('kernel, kwargs', [ - ('HamiltonianMonteCarlo', dict(step_size=0.05, num_leapfrog_steps=10)), - ('NoUTurnSampler', dict(step_size=0.05)), - ('RandomWalkMetropolis', dict()), - ('SliceSampler', dict(step_size=1.0, max_doublings=5)), - ('UncalibratedHamiltonianMonteCarlo', dict(step_size=0.05, num_leapfrog_steps=10)), - ('UncalibratedRandomWalk', dict()), -]) + step_size=0.5 / jnp.sqrt(0.5 ** jnp.arange(4)[..., None]), + num_leapfrog_steps=5, + ) + + +@pytest.mark.parametrize( + "kernel, kwargs", + [ + ("HamiltonianMonteCarlo", dict(step_size=0.05, num_leapfrog_steps=10)), + ("NoUTurnSampler", dict(step_size=0.05)), + ("RandomWalkMetropolis", dict()), + ("SliceSampler", dict(step_size=1.0, max_doublings=5)), + ( + "UncalibratedHamiltonianMonteCarlo", + dict(step_size=0.05, num_leapfrog_steps=10), + ), + ("UncalibratedRandomWalk", dict()), + ], +) @pytest.mark.filterwarnings("ignore:can't resolve package") # TODO: remove after https://github.com/tensorflow/probability/issues/1072 is resolved @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_mcmc_kernels(kernel, kwargs): from numpyro.contrib.tfp import mcmc + kernel_class = getattr(mcmc, kernel) true_coef = 0.9 num_warmup, num_samples = 1000, 1000 def model(data): - alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) - with numpyro.handlers.reparam(config={'loc': TransformReparam()}): + alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) + with numpyro.handlers.reparam(config={"loc": TransformReparam()}): loc = numpyro.sample( - 'loc', dist.TransformedDistribution(dist.Uniform(0, 1), AffineTransform(0, alpha))) - numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) + "loc", + dist.TransformedDistribution( + dist.Uniform(0, 1), AffineTransform(0, alpha) + ), + ) + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) tfp_kernel = kernel_class(model=model, **kwargs) @@ -158,20 +175,31 @@ def model(data): warmup_samples = mcmc.get_samples() mcmc.run(random.PRNGKey(3), data) samples = mcmc.get_samples() - assert len(warmup_samples['loc']) == num_warmup - assert len(samples['loc']) == num_samples - assert_allclose(jnp.mean(samples['loc'], 0), true_coef, atol=0.05) - - -@pytest.mark.parametrize('kernel, kwargs', [ - ('MetropolisAdjustedLangevinAlgorithm', dict(step_size=1.0)), - ('RandomWalkMetropolis', dict()), - ('SliceSampler', dict(step_size=1.0, max_doublings=5)), - ('UncalibratedLangevin', dict(step_size=0.1)), - ('ReplicaExchangeMC', dict(inverse_temperatures=0.5 ** jnp.arange(4), make_kernel_fn=make_kernel_fn)) -]) -@pytest.mark.parametrize('num_chains', [1, 2]) -@pytest.mark.skipif('XLA_FLAGS' not in os.environ, reason='without this mark, we have duplicated tests in Travis') + assert len(warmup_samples["loc"]) == num_warmup + assert len(samples["loc"]) == num_samples + assert_allclose(jnp.mean(samples["loc"], 0), true_coef, atol=0.05) + + +@pytest.mark.parametrize( + "kernel, kwargs", + [ + ("MetropolisAdjustedLangevinAlgorithm", dict(step_size=1.0)), + ("RandomWalkMetropolis", dict()), + ("SliceSampler", dict(step_size=1.0, max_doublings=5)), + ("UncalibratedLangevin", dict(step_size=0.1)), + ( + "ReplicaExchangeMC", + dict( + inverse_temperatures=0.5 ** jnp.arange(4), make_kernel_fn=make_kernel_fn + ), + ), + ], +) +@pytest.mark.parametrize("num_chains", [1, 2]) +@pytest.mark.skipif( + "XLA_FLAGS" not in os.environ, + reason="without this mark, we have duplicated tests in Travis", +) @pytest.mark.filterwarnings("ignore:There are not enough devices:UserWarning") @pytest.mark.filterwarnings("ignore:can't resolve package") # TODO: remove after https://github.com/tensorflow/probability/issues/1072 is resolved @@ -186,15 +214,17 @@ def test_unnormalized_normal_chain(kernel, kwargs, num_chains): kernel_class = getattr(mcmc, kernel) - true_mean, true_std = 1., 0.5 + true_mean, true_std = 1.0, 0.5 warmup_steps, num_samples = (1000, 8000) def potential_fn(z): return 0.5 * ((z - true_mean) / true_std) ** 2 - init_params = jnp.array(0.) if num_chains == 1 else jnp.array([0., 2.]) + init_params = jnp.array(0.0) if num_chains == 1 else jnp.array([0.0, 2.0]) tfp_kernel = kernel_class(potential_fn=potential_fn, **kwargs) - mcmc = MCMC(tfp_kernel, warmup_steps, num_samples, num_chains=num_chains, progress_bar=False) + mcmc = MCMC( + tfp_kernel, warmup_steps, num_samples, num_chains=num_chains, progress_bar=False + ) mcmc.run(random.PRNGKey(0), init_params=init_params) mcmc.print_summary() hmc_states = mcmc.get_samples() diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 8c7bd372e..9146cb879 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -27,7 +27,7 @@ AutoLaplaceApproximation, AutoLowRankMultivariateNormal, AutoMultivariateNormal, - AutoNormal + AutoNormal, ) from numpyro.infer.initialization import init_to_median from numpyro.infer.reparam import TransformReparam @@ -37,23 +37,25 @@ init_strategy = init_to_median(num_samples=2) -@pytest.mark.parametrize('auto_class', [ - AutoDiagonalNormal, - AutoIAFNormal, - AutoBNAFNormal, - AutoMultivariateNormal, - AutoLaplaceApproximation, - AutoLowRankMultivariateNormal, - AutoNormal, - AutoDelta, -]) +@pytest.mark.parametrize( + "auto_class", + [ + AutoDiagonalNormal, + AutoIAFNormal, + AutoBNAFNormal, + AutoMultivariateNormal, + AutoLaplaceApproximation, + AutoLowRankMultivariateNormal, + AutoNormal, + AutoDelta, + ], +) def test_beta_bernoulli(auto_class): - data = jnp.array([[1.0] * 8 + [0.0] * 2, - [1.0] * 4 + [0.0] * 6]).T + data = jnp.array([[1.0] * 8 + [0.0] * 2, [1.0] * 4 + [0.0] * 6]).T def model(data): - f = numpyro.sample('beta', dist.Beta(jnp.ones(2), jnp.ones(2))) - numpyro.sample('obs', dist.Bernoulli(f), obs=data) + f = numpyro.sample("beta", dist.Beta(jnp.ones(2), jnp.ones(2))) + numpyro.sample("obs", dist.Bernoulli(f), obs=data) adam = optim.Adam(0.01) guide = auto_class(model, init_loc_fn=init_strategy) @@ -68,32 +70,37 @@ def body_fn(i, val): params = svi.get_params(svi_state) true_coefs = (jnp.sum(data, axis=0) + 1) / (data.shape[0] + 2) # test .sample_posterior method - posterior_samples = guide.sample_posterior(random.PRNGKey(1), params, sample_shape=(1000,)) - assert_allclose(jnp.mean(posterior_samples['beta'], 0), true_coefs, atol=0.05) - - -@pytest.mark.parametrize('auto_class', [ - AutoDiagonalNormal, - AutoIAFNormal, - AutoBNAFNormal, - AutoMultivariateNormal, - AutoLaplaceApproximation, - AutoLowRankMultivariateNormal, - AutoNormal, - AutoDelta, -]) -@pytest.mark.parametrize('Elbo', [Trace_ELBO, TraceMeanField_ELBO]) + posterior_samples = guide.sample_posterior( + random.PRNGKey(1), params, sample_shape=(1000,) + ) + assert_allclose(jnp.mean(posterior_samples["beta"], 0), true_coefs, atol=0.05) + + +@pytest.mark.parametrize( + "auto_class", + [ + AutoDiagonalNormal, + AutoIAFNormal, + AutoBNAFNormal, + AutoMultivariateNormal, + AutoLaplaceApproximation, + AutoLowRankMultivariateNormal, + AutoNormal, + AutoDelta, + ], +) +@pytest.mark.parametrize("Elbo", [Trace_ELBO, TraceMeanField_ELBO]) def test_logistic_regression(auto_class, Elbo): N, dim = 3000, 3 data = random.normal(random.PRNGKey(0), (N, dim)) - true_coefs = jnp.arange(1., dim + 1.) + true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) def model(data, labels): - coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) logits = numpyro.deterministic("logits", jnp.sum(coefs * data, axis=-1)) - return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) + return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -117,30 +124,32 @@ def body_fn(i, val): params = svi.get_params(svi_state) if auto_class not in (AutoIAFNormal, AutoBNAFNormal): median = guide.median(params) - assert_allclose(median['coefs'], true_coefs, rtol=0.1) + assert_allclose(median["coefs"], true_coefs, rtol=0.1) # test .quantile method if auto_class is not AutoDelta: median = guide.quantiles(params, [0.2, 0.5]) - assert_allclose(median['coefs'][1], true_coefs, rtol=0.1) + assert_allclose(median["coefs"][1], true_coefs, rtol=0.1) # test .sample_posterior method - posterior_samples = guide.sample_posterior(random.PRNGKey(1), params, sample_shape=(1000,)) + posterior_samples = guide.sample_posterior( + random.PRNGKey(1), params, sample_shape=(1000,) + ) expected_coefs = jnp.array([0.97, 2.05, 3.18]) - assert_allclose(jnp.mean(posterior_samples['coefs'], 0), expected_coefs, rtol=0.1) + assert_allclose(jnp.mean(posterior_samples["coefs"], 0), expected_coefs, rtol=0.1) def test_iaf(): # test for substitute logic for exposed methods `sample_posterior` and `get_transforms` N, dim = 3000, 3 data = random.normal(random.PRNGKey(0), (N, dim)) - true_coefs = jnp.arange(1., dim + 1.) + true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) def model(data, labels): - coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) - offset = numpyro.sample('offset', dist.Uniform(-1, 1)) + coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + offset = numpyro.sample("offset", dist.Uniform(-1, 1)) logits = offset + jnp.sum(coefs * data, axis=-1) - return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) + return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -158,21 +167,28 @@ def model(data, labels): for i in range(guide.num_flows): if i > 0: flows.append(transforms.PermuteTransform(jnp.arange(dim + 1)[::-1])) - arn_init, arn_apply = AutoregressiveNN(dim + 1, [dim + 1, dim + 1], - permutation=jnp.arange(dim + 1), - skip_connections=guide._skip_connections, - nonlinearity=guide._nonlinearity) - arn = partial(arn_apply, params['auto_arn__{}$params'.format(i)]) + arn_init, arn_apply = AutoregressiveNN( + dim + 1, + [dim + 1, dim + 1], + permutation=jnp.arange(dim + 1), + skip_connections=guide._skip_connections, + nonlinearity=guide._nonlinearity, + ) + arn = partial(arn_apply, params["auto_arn__{}$params".format(i)]) flows.append(InverseAutoregressiveTransform(arn)) flows.append(guide._unpack_latent) transform = transforms.ComposeTransform(flows) _, rng_key_sample = random.split(rng_key) - expected_sample = transform(dist.Normal(jnp.zeros(dim + 1), 1).sample(rng_key_sample)) + expected_sample = transform( + dist.Normal(jnp.zeros(dim + 1), 1).sample(rng_key_sample) + ) expected_output = transform(x) - assert_allclose(actual_sample['coefs'], expected_sample['coefs']) - assert_allclose(actual_sample['offset'], - transforms.biject_to(constraints.interval(-1, 1))(expected_sample['offset'])) + assert_allclose(actual_sample["coefs"], expected_sample["coefs"]) + assert_allclose( + actual_sample["offset"], + transforms.biject_to(constraints.interval(-1, 1))(expected_sample["offset"]), + ) check_eq(actual_output, expected_output) @@ -181,11 +197,15 @@ def test_uniform_normal(): data = true_coef + random.normal(random.PRNGKey(0), (1000,)) def model(data): - alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) - with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.TransformedDistribution( - dist.Uniform(0, 1), transforms.AffineTransform(0, alpha))) - numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) + alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) + with numpyro.handlers.reparam(config={"loc": TransformReparam()}): + loc = numpyro.sample( + "loc", + dist.TransformedDistribution( + dist.Uniform(0, 1), transforms.AffineTransform(0, alpha) + ), + ) + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -200,10 +220,10 @@ def body_fn(i, val): svi_state = fori_loop(0, 1000, body_fn, svi_state) params = svi.get_params(svi_state) median = guide.median(params) - assert_allclose(median['loc'], true_coef, rtol=0.05) + assert_allclose(median["loc"], true_coef, rtol=0.05) # test .quantile method median = guide.quantiles(params, [0.2, 0.5]) - assert_allclose(median['loc'][1], true_coef, rtol=0.1) + assert_allclose(median["loc"][1], true_coef, rtol=0.1) def test_param(): @@ -216,15 +236,16 @@ def test_param(): x_init = random.normal(rng_keys[2]) def model(): - a = numpyro.param('a', a_init, constraint=constraints.greater_than(a_minval)) - b = numpyro.param('b', b_init, constraint=constraints.positive) - numpyro.sample('x', dist.Normal(a, b)) + a = numpyro.param("a", a_init, constraint=constraints.greater_than(a_minval)) + b = numpyro.param("b", b_init, constraint=constraints.positive) + numpyro.sample("x", dist.Normal(a, b)) # this class is used to force init value of `x` to x_init class _AutoGuide(AutoDiagonalNormal): def __call__(self, *args, **kwargs): - return substitute(super(_AutoGuide, self).__call__, - {'_auto_latent': x_init})(*args, **kwargs) + return substitute( + super(_AutoGuide, self).__call__, {"_auto_latent": x_init} + )(*args, **kwargs) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -233,15 +254,16 @@ def __call__(self, *args, **kwargs): svi_state = svi.init(rng_key_init) params = svi.get_params(svi_state) - assert_allclose(params['a'], a_init, rtol=1e-6) - assert_allclose(params['b'], b_init, rtol=1e-6) - assert_allclose(params['auto_loc'], guide._init_latent, rtol=1e-6) - assert_allclose(params['auto_scale'], jnp.ones(1) * guide._init_scale, rtol=1e-6) + assert_allclose(params["a"], a_init, rtol=1e-6) + assert_allclose(params["b"], b_init, rtol=1e-6) + assert_allclose(params["auto_loc"], guide._init_latent, rtol=1e-6) + assert_allclose(params["auto_scale"], jnp.ones(1) * guide._init_scale, rtol=1e-6) actual_loss = svi.evaluate(svi_state) assert jnp.isfinite(actual_loss) - expected_loss = dist.Normal(guide._init_latent, guide._init_scale).log_prob(x_init) \ - - dist.Normal(a_init, b_init).log_prob(x_init) + expected_loss = dist.Normal(guide._init_latent, guide._init_scale).log_prob( + x_init + ) - dist.Normal(a_init, b_init).log_prob(x_init) assert_allclose(actual_loss, expected_loss, rtol=1e-6) @@ -250,16 +272,20 @@ def test_dynamic_supports(): data = true_coef + random.normal(random.PRNGKey(0), (1000,)) def actual_model(data): - alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) - with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.TransformedDistribution( - dist.Uniform(0, 1), transforms.AffineTransform(0, alpha))) - numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) + alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) + with numpyro.handlers.reparam(config={"loc": TransformReparam()}): + loc = numpyro.sample( + "loc", + dist.TransformedDistribution( + dist.Uniform(0, 1), transforms.AffineTransform(0, alpha) + ), + ) + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) def expected_model(data): - alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) - loc = numpyro.sample('loc', dist.Uniform(0, 1)) * alpha - numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) + alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) + loc = numpyro.sample("loc", dist.Uniform(0, 1)) * alpha + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -284,8 +310,8 @@ def expected_model(data): check_eq(actual_opt_params, expected_opt_params) check_eq(actual_params, expected_params) # test latent values - assert_allclose(actual_values['alpha'], expected_values['alpha']) - assert_allclose(actual_values['loc_base'], expected_values['loc']) + assert_allclose(actual_values["alpha"], expected_values["alpha"]) + assert_allclose(actual_values["loc_base"], expected_values["loc"]) assert_allclose(actual_loss, expected_loss) @@ -311,11 +337,17 @@ def test_improper(): y = random.normal(random.PRNGKey(0), (100,)) def model(y): - lambda1 = numpyro.sample('lambda1', dist.ImproperUniform(dist.constraints.real, (), ())) - lambda2 = numpyro.sample('lambda2', dist.ImproperUniform(dist.constraints.real, (), ())) - sigma = numpyro.sample('sigma', dist.ImproperUniform(dist.constraints.positive, (), ())) - mu = numpyro.deterministic('mu', lambda1 + lambda2) - numpyro.sample('y', dist.Normal(mu, sigma), obs=y) + lambda1 = numpyro.sample( + "lambda1", dist.ImproperUniform(dist.constraints.real, (), ()) + ) + lambda2 = numpyro.sample( + "lambda2", dist.ImproperUniform(dist.constraints.real, (), ()) + ) + sigma = numpyro.sample( + "sigma", dist.ImproperUniform(dist.constraints.positive, (), ()) + ) + mu = numpyro.deterministic("mu", lambda1 + lambda2) + numpyro.sample("y", dist.Normal(mu, sigma), obs=y) guide = AutoDiagonalNormal(model) svi = SVI(model, guide, optim.Adam(0.003), Trace_ELBO(), y=y) @@ -331,7 +363,7 @@ def model(x, y): nn = numpyro.module("nn", Dense(1), (10,)) mu = nn(x).squeeze(-1) sigma = numpyro.sample("sigma", dist.HalfNormal(1)) - numpyro.sample('y', dist.Normal(mu, sigma), obs=y) + numpyro.sample("y", dist.Normal(mu, sigma), obs=y) guide = AutoDiagonalNormal(model) svi = SVI(model, guide, optim.Adam(0.003), Trace_ELBO(), x=x, y=y) @@ -352,10 +384,14 @@ def model(batch, subsample, full_size): def transition_fn(z_prev, y_curr): with plate: z_curr = numpyro.sample("state", dist.Normal(z_prev, drift)) - y_curr = numpyro.sample("obs", dist.Bernoulli(logits=z_curr), obs=y_curr) + y_curr = numpyro.sample( + "obs", dist.Bernoulli(logits=z_curr), obs=y_curr + ) return z_curr, y_curr - _, result = scan(transition_fn, jnp.zeros(len(subsample)), batch, length=num_time_steps) + _, result = scan( + transition_fn, jnp.zeros(len(subsample)), batch, length=num_time_steps + ) return result def create_plates(batch, subsample, full_size): @@ -372,8 +408,12 @@ def create_plates(batch, subsample, full_size): assert data.shape == (num_time_steps, full_size) svi = SVI(model, guide, optim.Adam(0.02), Trace_ELBO()) - svi_state = svi.init(random.PRNGKey(0), data[:, :batch_size], - jnp.arange(batch_size), full_size=full_size) + svi_state = svi.init( + random.PRNGKey(0), + data[:, :batch_size], + jnp.arange(batch_size), + full_size=full_size, + ) update_fn = jit(svi.update, static_argnums=(3,)) for epoch in range(2): beg = 0 diff --git a/test/infer/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py index ea3ab0332..b51fed2d6 100644 --- a/test/infer/test_hmc_gibbs.py +++ b/test/infer/test_hmc_gibbs.py @@ -20,7 +20,11 @@ def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): N, P = X.shape - sigma = jnp.exp(hmc_sites['log_sigma']) if 'log_sigma' in hmc_sites else hmc_sites['sigma'] + sigma = ( + jnp.exp(hmc_sites["log_sigma"]) + if "log_sigma" in hmc_sites + else hmc_sites["sigma"] + ) sigma_sq = jnp.square(sigma) covar_inv = XX / sigma_sq + jnp.eye(P) @@ -31,11 +35,13 @@ def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): beta_proposal = dist.MultivariateNormal(loc=loc, scale_tril=L_inv).sample(rng_key) - return {'beta': beta_proposal} + return {"beta": beta_proposal} -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) -def test_linear_model_log_sigma(kernel_cls, N=100, P=50, sigma=0.11, warmup_steps=500, num_samples=500): +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) +def test_linear_model_log_sigma( + kernel_cls, N=100, P=50, sigma=0.11, warmup_steps=500, num_samples=500 +): np.random.seed(0) X = np.random.randn(N * P).reshape((N, P)) XX = np.matmul(np.transpose(X), X) @@ -56,20 +62,22 @@ def model(X, Y): gibbs_fn = partial(_linear_regression_gibbs_fn, X, XX, XY, Y) hmc_kernel = kernel_cls(model) - kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['beta']) + kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=["beta"]) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) mcmc.run(random.PRNGKey(0), X, Y) - beta_mean = np.mean(mcmc.get_samples()['beta'], axis=0) + beta_mean = np.mean(mcmc.get_samples()["beta"], axis=0) assert_allclose(beta_mean, np.array([1.0] + [0.0] * (P - 1)), atol=0.05) - sigma_mean = np.exp(np.mean(mcmc.get_samples()['log_sigma'], axis=0)) + sigma_mean = np.exp(np.mean(mcmc.get_samples()["log_sigma"], axis=0)) assert_allclose(sigma_mean, sigma, atol=0.25) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) -def test_linear_model_sigma(kernel_cls, N=90, P=40, sigma=0.07, warmup_steps=500, num_samples=500): +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) +def test_linear_model_sigma( + kernel_cls, N=90, P=40, sigma=0.07, warmup_steps=500, num_samples=500 +): np.random.seed(1) X = np.random.randn(N * P).reshape((N, P)) XX = np.matmul(np.transpose(X), X) @@ -88,19 +96,19 @@ def model(X, Y): gibbs_fn = partial(_linear_regression_gibbs_fn, X, XX, XY, Y) hmc_kernel = kernel_cls(model) - kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['beta']) + kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=["beta"]) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) mcmc.run(random.PRNGKey(0), X, Y) - beta_mean = np.mean(mcmc.get_samples()['beta'], axis=0) + beta_mean = np.mean(mcmc.get_samples()["beta"], axis=0) assert_allclose(beta_mean, np.array([1.0] + [0.0] * (P - 1)), atol=0.05) - sigma_mean = np.mean(mcmc.get_samples()['sigma'], axis=0) + sigma_mean = np.mean(mcmc.get_samples()["sigma"], axis=0) assert_allclose(sigma_mean, sigma, atol=0.25) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) def test_gaussian_model(kernel_cls, D=2, warmup_steps=5000, num_samples=5000): np.random.seed(0) cov = np.random.randn(4 * D * D).reshape((2 * D, 2 * D)) @@ -120,27 +128,36 @@ def test_gaussian_model(kernel_cls, D=2, warmup_steps=5000, num_samples=5000): # we consider a model in which (x0, x1) ~ MVN(0, cov) def gaussian_gibbs_fn(rng_key, hmc_sites, gibbs_sites): - x1 = hmc_sites['x1'] + x1 = hmc_sites["x1"] posterior_loc0 = jnp.matmul(cov_01_cov11_inv, x1) - x0_proposal = dist.MultivariateNormal(loc=posterior_loc0, covariance_matrix=posterior_cov0).sample(rng_key) - return {'x0': x0_proposal} + x0_proposal = dist.MultivariateNormal( + loc=posterior_loc0, covariance_matrix=posterior_cov0 + ).sample(rng_key) + return {"x0": x0_proposal} def model(): - x0 = numpyro.sample("x0", dist.MultivariateNormal(loc=jnp.zeros(D), covariance_matrix=cov00)) + x0 = numpyro.sample( + "x0", dist.MultivariateNormal(loc=jnp.zeros(D), covariance_matrix=cov00) + ) posterior_loc1 = jnp.matmul(cov_10_cov00_inv, x0) - numpyro.sample("x1", dist.MultivariateNormal(loc=posterior_loc1, covariance_matrix=posterior_cov1)) + numpyro.sample( + "x1", + dist.MultivariateNormal( + loc=posterior_loc1, covariance_matrix=posterior_cov1 + ), + ) hmc_kernel = kernel_cls(model, dense_mass=True) - kernel = HMCGibbs(hmc_kernel, gibbs_fn=gaussian_gibbs_fn, gibbs_sites=['x0']) + kernel = HMCGibbs(hmc_kernel, gibbs_fn=gaussian_gibbs_fn, gibbs_sites=["x0"]) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) mcmc.run(random.PRNGKey(0)) - x0_mean = np.mean(mcmc.get_samples()['x0'], axis=0) - x1_mean = np.mean(mcmc.get_samples()['x1'], axis=0) + x0_mean = np.mean(mcmc.get_samples()["x0"], axis=0) + x1_mean = np.mean(mcmc.get_samples()["x1"], axis=0) - x0_std = np.std(mcmc.get_samples()['x0'], axis=0) - x1_std = np.std(mcmc.get_samples()['x1'], axis=0) + x0_std = np.std(mcmc.get_samples()["x0"], axis=0) + x1_std = np.std(mcmc.get_samples()["x1"], axis=0) assert_allclose(x0_mean, np.zeros(D), atol=0.2) assert_allclose(x1_mean, np.zeros(D), atol=0.2) @@ -149,10 +166,10 @@ def model(): assert_allclose(x1_std, np.sqrt(np.diagonal(cov11)), rtol=0.1) -@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ - (MixedHMC, HMC, {"num_discrete_updates": 5}), - (DiscreteHMCGibbs, NUTS, {}) -]) +@pytest.mark.parametrize( + "kernel, inner_kernel, kwargs", + [(MixedHMC, HMC, {"num_discrete_updates": 5}), (DiscreteHMCGibbs, NUTS, {})], +) @pytest.mark.parametrize("num_chains", [1, 2]) @pytest.mark.filterwarnings("ignore:There are not enough devices:UserWarning") def test_discrete_gibbs_multiple_sites_chain(kernel, inner_kernel, kwargs, num_chains): @@ -169,10 +186,10 @@ def model(): assert_allclose(jnp.mean(samples["y"], 0), 0.3 * 10, atol=0.1) -@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ - (MixedHMC, HMC, {"num_discrete_updates": 6}), - (DiscreteHMCGibbs, NUTS, {}) -]) +@pytest.mark.parametrize( + "kernel, inner_kernel, kwargs", + [(MixedHMC, HMC, {"num_discrete_updates": 6}), (DiscreteHMCGibbs, NUTS, {})], +) def test_discrete_gibbs_enum(kernel, inner_kernel, kwargs): def model(): numpyro.sample("x", dist.Bernoulli(0.7), infer={"enumerate": "parallel"}) @@ -187,11 +204,14 @@ def model(): @pytest.mark.parametrize("random_walk", [False, True]) -@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ - (MixedHMC, HMC, {"num_discrete_updates": 6}), - (DiscreteHMCGibbs, NUTS, {"modified": True}), - (DiscreteHMCGibbs, NUTS, {"modified": False}), -]) +@pytest.mark.parametrize( + "kernel, inner_kernel, kwargs", + [ + (MixedHMC, HMC, {"num_discrete_updates": 6}), + (DiscreteHMCGibbs, NUTS, {"modified": True}), + (DiscreteHMCGibbs, NUTS, {"modified": False}), + ], +) def test_discrete_gibbs_bernoulli(random_walk, kernel, inner_kernel, kwargs): def model(): numpyro.sample("c", dist.Bernoulli(0.8)) @@ -204,10 +224,10 @@ def model(): @pytest.mark.parametrize("modified", [False, True]) -@pytest.mark.parametrize("kernel, inner_kernel, kwargs", [ - (MixedHMC, HMC, {"num_discrete_updates": 20}), - (DiscreteHMCGibbs, NUTS, {}) -]) +@pytest.mark.parametrize( + "kernel, inner_kernel, kwargs", + [(MixedHMC, HMC, {"num_discrete_updates": 20}), (DiscreteHMCGibbs, NUTS, {})], +) def test_discrete_gibbs_gmm_1d(modified, kernel, inner_kernel, kwargs): def model(probs, locs): c = numpyro.sample("c", dist.Categorical(probs)) @@ -215,7 +235,9 @@ def model(probs, locs): probs = jnp.array([0.15, 0.3, 0.3, 0.25]) locs = jnp.array([-2, 0, 2, 4]) - sampler = kernel(inner_kernel(model, trajectory_length=1.2), modified=modified, **kwargs) + sampler = kernel( + inner_kernel(model, trajectory_length=1.2), modified=modified, **kwargs + ) mcmc = MCMC(sampler, 1000, 200000, progress_bar=False) mcmc.run(random.PRNGKey(0), probs, locs) samples = mcmc.get_samples() @@ -225,22 +247,22 @@ def model(probs, locs): assert_allclose(jnp.var(samples["c"]), 1.03, atol=0.1) -@pytest.mark.parametrize('num_blocks', [1, 2, 50, 100]) +@pytest.mark.parametrize("num_blocks", [1, 2, 50, 100]) def test_block_update_partitioning(num_blocks): plate_size = 10000, 100 - plate_sizes = {'N': plate_size} - gibbs_sites = {'N': jnp.arange(plate_size[1])} + plate_sizes = {"N": plate_size} + gibbs_sites = {"N": jnp.arange(plate_size[1])} gibbs_state = {} - new_gibbs_sites, new_gibbs_state = numpyro.infer.hmc_gibbs._block_update(plate_sizes, - num_blocks, - random.PRNGKey(2), - gibbs_sites, - gibbs_state) + new_gibbs_sites, new_gibbs_state = numpyro.infer.hmc_gibbs._block_update( + plate_sizes, num_blocks, random.PRNGKey(2), gibbs_sites, gibbs_state + ) block_size = 100 // num_blocks for name in gibbs_sites: - assert block_size == jnp.not_equal(gibbs_sites[name], new_gibbs_sites[name]).sum() + assert ( + block_size == jnp.not_equal(gibbs_sites[name], new_gibbs_sites[name]).sum() + ) assert gibbs_state == new_gibbs_state @@ -258,21 +280,27 @@ def model(data): mcmc.run(random.PRNGKey(0), data) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) -@pytest.mark.parametrize('num_block', [1, 2, 50]) -@pytest.mark.parametrize('subsample_size', [50, 150]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) +@pytest.mark.parametrize("num_block", [1, 2, 50]) +@pytest.mark.parametrize("subsample_size", [50, 150]) def test_hmcecs_normal_normal(kernel_cls, num_block, subsample_size): true_loc = jnp.array([0.3, 0.1, 0.9]) num_warmup, num_samples = 200, 200 - data = true_loc + dist.Normal(jnp.zeros(3, ), jnp.ones(3, )).sample(random.PRNGKey(1), (10000,)) + data = true_loc + dist.Normal(jnp.zeros(3), jnp.ones(3)).sample( + random.PRNGKey(1), (10000,) + ) def model(data, subsample_size): - mean = numpyro.sample('mean', dist.Normal().expand((3,)).to_event(1)) - with numpyro.plate('batch', data.shape[0], dim=-2, subsample_size=subsample_size): + mean = numpyro.sample("mean", dist.Normal().expand((3,)).to_event(1)) + with numpyro.plate( + "batch", data.shape[0], dim=-2, subsample_size=subsample_size + ): sub_data = numpyro.subsample(data, 0) numpyro.sample("obs", dist.Normal(mean, 1), obs=sub_data) - ref_params = {'mean': true_loc + dist.Normal(true_loc, 5e-2).sample(random.PRNGKey(0))} + ref_params = { + "mean": true_loc + dist.Normal(true_loc, 5e-2).sample(random.PRNGKey(0)) + } proxy_fn = HMCECS.taylor_proxy(ref_params) kernel = HMCECS(kernel_cls(model), proxy=proxy_fn) @@ -280,23 +308,27 @@ def model(data, subsample_size): mcmc.run(random.PRNGKey(0), data, subsample_size) samples = mcmc.get_samples() - assert_allclose(np.mean(mcmc.get_samples()['mean'], axis=0), true_loc, atol=0.1) - assert len(samples['mean']) == num_samples + assert_allclose(np.mean(mcmc.get_samples()["mean"], axis=0), true_loc, atol=0.1) + assert len(samples["mean"]) == num_samples -@pytest.mark.parametrize('subsample_size', [5, 10, 15]) +@pytest.mark.parametrize("subsample_size", [5, 10, 15]) def test_taylor_proxy_norm(subsample_size): data_key, tr_key, rng_key = random.split(random.PRNGKey(0), 3) ref_params = jnp.array([0.1, 0.5, -0.2]) - sigma = .1 + sigma = 0.1 data = ref_params + dist.Normal(jnp.zeros(3), jnp.ones(3)).sample(data_key, (100,)) n, _ = data.shape def model(data, subsample_size): - mean = numpyro.sample('mean', dist.Normal(ref_params, jnp.ones_like(ref_params))) - with numpyro.plate('data', data.shape[0], subsample_size=subsample_size, dim=-2) as idx: - numpyro.sample('obs', dist.Normal(mean, sigma), obs=data[idx]) + mean = numpyro.sample( + "mean", dist.Normal(ref_params, jnp.ones_like(ref_params)) + ) + with numpyro.plate( + "data", data.shape[0], subsample_size=subsample_size, dim=-2 + ) as idx: + numpyro.sample("obs", dist.Normal(mean, sigma), obs=data[idx]) def log_prob_fn(params): return vmap(dist.Normal(params, sigma).log_prob)(data).sum(-1) @@ -305,55 +337,86 @@ def log_prob_fn(params): log_norm_jac = jacrev(log_prob_fn)(ref_params) log_norm_hessian = hessian(log_prob_fn)(ref_params) - tr = numpyro.handlers.trace(numpyro.handlers.seed(model, tr_key)).get_trace(data, subsample_size) - plate_sizes = {'data': (n, subsample_size)} + tr = numpyro.handlers.trace(numpyro.handlers.seed(model, tr_key)).get_trace( + data, subsample_size + ) + plate_sizes = {"data": (n, subsample_size)} - proxy_constructor = HMCECS.taylor_proxy({'mean': ref_params}) - proxy_fn, gibbs_init, gibbs_update = proxy_constructor(tr, plate_sizes, model, (data, subsample_size), {}) + proxy_constructor = HMCECS.taylor_proxy({"mean": ref_params}) + proxy_fn, gibbs_init, gibbs_update = proxy_constructor( + tr, plate_sizes, model, (data, subsample_size), {} + ) def taylor_expand_2nd_order(idx, pos): - return log_prob[idx] + (log_norm_jac[idx] @ pos) + .5 * (pos @ log_norm_hessian[idx]) @ pos + return ( + log_prob[idx] + + (log_norm_jac[idx] @ pos) + + 0.5 * (pos @ log_norm_hessian[idx]) @ pos + ) def taylor_expand_2nd_order_sum(pos): - return log_prob.sum() + log_norm_jac.sum(0) @ pos + .5 * pos @ log_norm_hessian.sum(0) @ pos + return ( + log_prob.sum() + + log_norm_jac.sum(0) @ pos + + 0.5 * pos @ log_norm_hessian.sum(0) @ pos + ) for _ in range(5): split_key, perturbe_key, rng_key = random.split(rng_key, 3) - perturbe_params = ref_params + dist.Normal(.1, 0.1).sample(perturbe_key, ref_params.shape) + perturbe_params = ref_params + dist.Normal(0.1, 0.1).sample( + perturbe_key, ref_params.shape + ) subsample_idx = random.randint(rng_key, (subsample_size,), 0, n) - gibbs_site = {'data': subsample_idx} + gibbs_site = {"data": subsample_idx} proxy_state = gibbs_init(None, gibbs_site) - actual_proxy_sum, actual_proxy_sub = proxy_fn({'data': perturbe_params}, ['data'], proxy_state) - assert_allclose(actual_proxy_sub['data'], - taylor_expand_2nd_order(subsample_idx, perturbe_params - ref_params), rtol=1e-5) - assert_allclose(actual_proxy_sum['data'], taylor_expand_2nd_order_sum(perturbe_params - ref_params), rtol=1e-5) - - -@pytest.mark.filterwarnings('ignore::UserWarning') -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) + actual_proxy_sum, actual_proxy_sub = proxy_fn( + {"data": perturbe_params}, ["data"], proxy_state + ) + assert_allclose( + actual_proxy_sub["data"], + taylor_expand_2nd_order(subsample_idx, perturbe_params - ref_params), + rtol=1e-5, + ) + assert_allclose( + actual_proxy_sum["data"], + taylor_expand_2nd_order_sum(perturbe_params - ref_params), + rtol=1e-5, + ) + + +@pytest.mark.filterwarnings("ignore::UserWarning") +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) def test_estimate_likelihood(kernel_cls): data_key, tr_key, sub_key, rng_key = random.split(random.PRNGKey(0), 4) ref_params = jnp.array([0.1, 0.5, -0.2]) - sigma = .1 - data = ref_params + dist.Normal(jnp.zeros(3), jnp.ones(3)).sample(data_key, (10_000,)) + sigma = 0.1 + data = ref_params + dist.Normal(jnp.zeros(3), jnp.ones(3)).sample( + data_key, (10_000,) + ) n, _ = data.shape num_warmup = 200 num_samples = 200 num_blocks = 20 def model(data): - mean = numpyro.sample('mean', dist.Normal(ref_params, jnp.ones_like(ref_params))) - with numpyro.plate('N', data.shape[0], subsample_size=100, dim=-2) as idx: - numpyro.sample('obs', dist.Normal(mean, sigma), obs=data[idx]) + mean = numpyro.sample( + "mean", dist.Normal(ref_params, jnp.ones_like(ref_params)) + ) + with numpyro.plate("N", data.shape[0], subsample_size=100, dim=-2) as idx: + numpyro.sample("obs", dist.Normal(mean, sigma), obs=data[idx]) - proxy_fn = HMCECS.taylor_proxy({'mean': ref_params}) + proxy_fn = HMCECS.taylor_proxy({"mean": ref_params}) kernel = HMCECS(kernel_cls(model), proxy=proxy_fn, num_blocks=num_blocks) mcmc = MCMC(kernel, num_warmup, num_samples) - mcmc.run(random.PRNGKey(0), data, extra_fields=['hmc_state.potential_energy']) + mcmc.run(random.PRNGKey(0), data, extra_fields=["hmc_state.potential_energy"]) - pes = mcmc.get_extra_fields()['hmc_state.potential_energy'] + pes = mcmc.get_extra_fields()["hmc_state.potential_energy"] samples = mcmc.get_samples() - pes_full = vmap(lambda sample: log_density(model, (data,), {}, {**sample, **{'N': jnp.arange(n)}})[0])(samples) + pes_full = vmap( + lambda sample: log_density( + model, (data,), {}, {**sample, **{"N": jnp.arange(n)}} + )[0] + )(samples) - assert jnp.var(jnp.exp(-pes - pes_full)) < 1. + assert jnp.var(jnp.exp(-pes - pes_full)) < 1.0 diff --git a/test/infer/test_hmc_util.py b/test/infer/test_hmc_util.py index ee8c5474b..8849028d4 100644 --- a/test/infer/test_hmc_util.py +++ b/test/infer/test_hmc_util.py @@ -25,14 +25,14 @@ parametric_draws, velocity_verlet, warmup_adapter, - welford_covariance + welford_covariance, ) from numpyro.util import control_flow_prims_disabled, fori_loop, optional logger = logging.getLogger(__name__) -@pytest.mark.parametrize('jitted', [True, False]) +@pytest.mark.parametrize("jitted", [True, False]) def test_dual_averaging(jitted): def optimize(f): da_init, da_update = dual_averaging(gamma=0.5) @@ -48,15 +48,17 @@ def optimize(f): fn = jit(optimize, static_argnums=(0,)) if jitted else optimize x_opt = fn(f) - assert_allclose(x_opt, -1., atol=1e-3) + assert_allclose(x_opt, -1.0, atol=1e-3) -@pytest.mark.parametrize('jitted', [True, False]) -@pytest.mark.parametrize('diagonal', [True, False]) -@pytest.mark.parametrize('regularize', [True, False]) -@pytest.mark.filterwarnings('ignore:numpy.linalg support is experimental:UserWarning') +@pytest.mark.parametrize("jitted", [True, False]) +@pytest.mark.parametrize("diagonal", [True, False]) +@pytest.mark.parametrize("regularize", [True, False]) +@pytest.mark.filterwarnings("ignore:numpy.linalg support is experimental:UserWarning") def test_welford_covariance(jitted, diagonal, regularize): - with optional(jitted, disable_jit()), optional(jitted, control_flow_prims_disabled()): + with optional(jitted, disable_jit()), optional( + jitted, control_flow_prims_disabled() + ): np.random.seed(0) loc = np.random.randn(3) a = np.random.randn(3, 3) @@ -80,7 +82,9 @@ def get_cov(x): assert_allclose(cov_inv_sqrt, jnp.sqrt(jnp.reciprocal(diag_cov)), rtol=0.06) else: assert_allclose(cov, target_cov, rtol=0.06) - assert_allclose(cov_inv_sqrt, jnp.linalg.cholesky(jnp.linalg.inv(cov)), rtol=0.06) + assert_allclose( + cov_inv_sqrt, jnp.linalg.cholesky(jnp.linalg.inv(cov)), rtol=0.06 + ) ######################################## @@ -90,8 +94,11 @@ def get_cov(x): TEST_EXAMPLES = [] EXAMPLE_IDS = [] -ModelArgs = namedtuple('model_args', ['step_size', 'num_steps', 'q_i', 'p_i', 'q_f', 'p_f', 'm_inv', 'prec']) -Example = namedtuple('test_case', ['model', 'args']) +ModelArgs = namedtuple( + "model_args", + ["step_size", "num_steps", "q_i", "p_i", "q_f", "p_f", "m_inv", "prec"], +) +Example = namedtuple("test_case", ["model", "args"]) def register_model(init_args): @@ -99,119 +106,129 @@ def register_model(init_args): Register the model along with each of the model arguments as test examples. """ + def register_fn(model): for args in init_args: test_example = Example(model, args) TEST_EXAMPLES.append(test_example) EXAMPLE_IDS.append(model.__name__) + return register_fn -@register_model([ - ModelArgs( - step_size=0.01, - num_steps=100, - q_i={'x': 0.0}, - p_i={'x': 1.0}, - q_f={'x': jnp.sin(1.0)}, - p_f={'x': jnp.cos(1.0)}, - m_inv=jnp.array([1.]), - prec=1e-4 - ) -]) +@register_model( + [ + ModelArgs( + step_size=0.01, + num_steps=100, + q_i={"x": 0.0}, + p_i={"x": 1.0}, + q_f={"x": jnp.sin(1.0)}, + p_f={"x": jnp.cos(1.0)}, + m_inv=jnp.array([1.0]), + prec=1e-4, + ) + ] +) class HarmonicOscillator(object): @staticmethod def kinetic_fn(m_inv, p): - return 0.5 * jnp.sum(m_inv * p['x'] ** 2) + return 0.5 * jnp.sum(m_inv * p["x"] ** 2) @staticmethod def potential_fn(q): - return 0.5 * q['x'] ** 2 - - -@register_model([ - ModelArgs( - step_size=0.01, - num_steps=628, - q_i={'x': 1.0, 'y': 0.0}, - p_i={'x': 0.0, 'y': 1.0}, - q_f={'x': 1.0, 'y': 0.0}, - p_f={'x': 0.0, 'y': 1.0}, - m_inv=jnp.array([1., 1.]), - prec=5.0e-3 - ) -]) + return 0.5 * q["x"] ** 2 + + +@register_model( + [ + ModelArgs( + step_size=0.01, + num_steps=628, + q_i={"x": 1.0, "y": 0.0}, + p_i={"x": 0.0, "y": 1.0}, + q_f={"x": 1.0, "y": 0.0}, + p_f={"x": 0.0, "y": 1.0}, + m_inv=jnp.array([1.0, 1.0]), + prec=5.0e-3, + ) + ] +) class CircularPlanetaryMotion(object): @staticmethod def kinetic_fn(m_inv, p): - z = jnp.stack([p['x'], p['y']], axis=-1) - return 0.5 * jnp.dot(m_inv, z**2) + z = jnp.stack([p["x"], p["y"]], axis=-1) + return 0.5 * jnp.dot(m_inv, z ** 2) @staticmethod def potential_fn(q): - return - 1.0 / jnp.power(q['x'] ** 2 + q['y'] ** 2, 0.5) - - -@register_model([ - ModelArgs( - step_size=0.1, - num_steps=1810, - q_i={'x': 0.02}, - p_i={'x': 0.0}, - q_f={'x': -0.02}, - p_f={'x': 0.0}, - m_inv=jnp.array([1.]), - prec=1.0e-4 - ) -]) + return -1.0 / jnp.power(q["x"] ** 2 + q["y"] ** 2, 0.5) + + +@register_model( + [ + ModelArgs( + step_size=0.1, + num_steps=1810, + q_i={"x": 0.02}, + p_i={"x": 0.0}, + q_f={"x": -0.02}, + p_f={"x": 0.0}, + m_inv=jnp.array([1.0]), + prec=1.0e-4, + ) + ] +) class QuarticOscillator(object): @staticmethod def kinetic_fn(m_inv, p): - return 0.5 * jnp.sum(m_inv * p['x'] ** 2) + return 0.5 * jnp.sum(m_inv * p["x"] ** 2) @staticmethod def potential_fn(q): - return 0.25 * jnp.power(q['x'], 4.0) + return 0.25 * jnp.power(q["x"], 4.0) -@pytest.mark.parametrize('jitted', [True, False]) -@pytest.mark.parametrize('example', TEST_EXAMPLES, ids=EXAMPLE_IDS) +@pytest.mark.parametrize("jitted", [True, False]) +@pytest.mark.parametrize("example", TEST_EXAMPLES, ids=EXAMPLE_IDS) def test_velocity_verlet(jitted, example): def get_final_state(model, step_size, num_steps, q_i, p_i): vv_init, vv_update = velocity_verlet(model.potential_fn, model.kinetic_fn) vv_state = vv_init(q_i, p_i) - q_f, p_f, _, _ = fori_loop(0, num_steps, - lambda i, val: vv_update(step_size, args.m_inv, val), - vv_state) + q_f, p_f, _, _ = fori_loop( + 0, num_steps, lambda i, val: vv_update(step_size, args.m_inv, val), vv_state + ) return (q_f, p_f) model, args = example fn = jit(get_final_state, static_argnums=(0,)) if jitted else get_final_state q_f, p_f = fn(model, args.step_size, args.num_steps, args.q_i, args.p_i) - logger.info('Test trajectory:') - logger.info('initial q: {}'.format(args.q_i)) - logger.info('final q: {}'.format(q_f)) + logger.info("Test trajectory:") + logger.info("initial q: {}".format(args.q_i)) + logger.info("final q: {}".format(q_f)) for node in args.q_f: assert_allclose(q_f[node], args.q_f[node], atol=args.prec) assert_allclose(p_f[node], args.p_f[node], atol=args.prec) - logger.info('Test energy conservation:') - energy_initial = model.kinetic_fn(args.m_inv, args.p_i) + model.potential_fn(args.q_i) + logger.info("Test energy conservation:") + energy_initial = model.kinetic_fn(args.m_inv, args.p_i) + model.potential_fn( + args.q_i + ) energy_final = model.kinetic_fn(args.m_inv, p_f) + model.potential_fn(q_f) - logger.info('initial energy: {}'.format(energy_initial)) - logger.info('final energy: {}'.format(energy_final)) + logger.info("initial energy: {}".format(energy_initial)) + logger.info("final energy: {}".format(energy_final)) assert_allclose(energy_initial, energy_final, atol=1e-5) - logger.info('Test time reversibility:') + logger.info("Test time reversibility:") p_reverse = tree_map(lambda x: -x, p_f) q_i, p_i = get_final_state(model, args.step_size, args.num_steps, q_f, p_reverse) for node in args.q_i: assert_allclose(q_i[node], args.q_i[node], atol=1e-4) -@pytest.mark.parametrize('jitted', [True, False]) -@pytest.mark.parametrize('init_step_size', [0.1, 10.0]) +@pytest.mark.parametrize("jitted", [True, False]) +@pytest.mark.parametrize("init_step_size", [0.1, 10.0]) def test_find_reasonable_step_size(jitted, init_step_size): def kinetic_fn(m_inv, p): return 0.5 * jnp.sum(m_inv * p ** 2) @@ -221,13 +238,23 @@ def potential_fn(q): p_generator = lambda prototype, m_inv, rng_key: 1.0 # noqa: E731 q = 0.0 - m_inv = jnp.array([1.]) + m_inv = jnp.array([1.0]) - fn = (jit(find_reasonable_step_size, static_argnums=(0, 1, 2)) - if jitted else find_reasonable_step_size) + fn = ( + jit(find_reasonable_step_size, static_argnums=(0, 1, 2)) + if jitted + else find_reasonable_step_size + ) rng_key = random.PRNGKey(0) - step_size = fn(potential_fn, kinetic_fn, p_generator, init_step_size, m_inv, - (q, None, None, None), rng_key) + step_size = fn( + potential_fn, + kinetic_fn, + p_generator, + init_step_size, + m_inv, + (q, None, None, None), + rng_key, + ) # Apply 1 velocity verlet step with step_size=eps, we have # z_new = eps, r_new = 1 - eps^2 / 2, hence energy_new = 0.5 + eps^4 / 8, @@ -246,31 +273,39 @@ def potential_fn(q): assert step_size < threshold -@pytest.mark.parametrize('num_steps, expected', [ - (18, [(0, 17)]), - (50, [(0, 6), (7, 44), (45, 49)]), - (100, [(0, 14), (15, 89), (90, 99)]), - (150, [(0, 74), (75, 99), (100, 149)]), - (200, [(0, 74), (75, 99), (100, 149), (150, 199)]), - (280, [(0, 74), (75, 99), (100, 229), (230, 279)]), -]) +@pytest.mark.parametrize( + "num_steps, expected", + [ + (18, [(0, 17)]), + (50, [(0, 6), (7, 44), (45, 49)]), + (100, [(0, 14), (15, 89), (90, 99)]), + (150, [(0, 74), (75, 99), (100, 149)]), + (200, [(0, 74), (75, 99), (100, 149), (150, 199)]), + (280, [(0, 74), (75, 99), (100, 229), (230, 279)]), + ], +) def test_build_adaptation_schedule(num_steps, expected): adaptation_schedule = build_adaptation_schedule(num_steps) expected_schedule = [AdaptWindow(i, j) for i, j in expected] assert adaptation_schedule == expected_schedule -@pytest.mark.parametrize('jitted', [ - True, - pytest.param(False, marks=pytest.mark.skipif("CI" in os.environ, reason="slow in Travis")) -]) +@pytest.mark.parametrize( + "jitted", + [ + True, + pytest.param( + False, marks=pytest.mark.skipif("CI" in os.environ, reason="slow in Travis") + ), + ], +) def test_warmup_adapter(jitted): def find_reasonable_step_size(step_size, m_inv, z, rng_key): return jnp.where(step_size < 1, step_size * 4, step_size / 4) num_steps = 150 adaptation_schedule = build_adaptation_schedule(num_steps) - init_step_size = 1. + init_step_size = 1.0 mass_matrix_size = 3 wa_init, wa_update = warmup_adapter(num_steps, find_reasonable_step_size) @@ -278,15 +313,24 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): rng_key = random.PRNGKey(0) z = jnp.ones(3) - wa_state = wa_init((z, None, None, None), rng_key, init_step_size, mass_matrix_size=mass_matrix_size) + wa_state = wa_init( + (z, None, None, None), + rng_key, + init_step_size, + mass_matrix_size=mass_matrix_size, + ) step_size, inverse_mass_matrix, _, _, _, _, window_idx, _ = wa_state - assert step_size == find_reasonable_step_size(init_step_size, inverse_mass_matrix, z, rng_key) + assert step_size == find_reasonable_step_size( + init_step_size, inverse_mass_matrix, z, rng_key + ) assert_allclose(inverse_mass_matrix, jnp.ones(mass_matrix_size)) assert window_idx == 0 window = adaptation_schedule[0] for t in range(window.start, window.end + 1): - wa_state = wa_update(t, 0.7 + 0.1 * t / (window.end - window.start), z, wa_state) + wa_state = wa_update( + t, 0.7 + 0.1 * t / (window.end - window.start), z, wa_state + ) last_step_size = step_size step_size, inverse_mass_matrix, _, _, _, _, window_idx, _ = wa_state assert window_idx == 1 @@ -298,7 +342,9 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): window = adaptation_schedule[1] window_len = window.end - window.start for t in range(window.start, window.end + 1): - wa_state = wa_update(t, 0.8 + 0.1 * (t - window.start) / window_len, 2 * z, wa_state) + wa_state = wa_update( + t, 0.8 + 0.1 * (t - window.start) / window_len, 2 * z, wa_state + ) last_step_size = step_size step_size, inverse_mass_matrix, _, _, _, _, window_idx, _ = wa_state assert window_idx == 2 @@ -310,9 +356,11 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): # This also verifies that z_flat terms in the first window does not affect # the second window. welford_regularize_term = 1e-3 * (5 / (window.end + 1 - window.start + 5)) - assert_allclose(inverse_mass_matrix, - jnp.full((mass_matrix_size,), welford_regularize_term), - atol=1e-7) + assert_allclose( + inverse_mass_matrix, + jnp.full((mass_matrix_size,), welford_regularize_term), + atol=1e-7, + ) window = adaptation_schedule[2] for t in range(window.start, window.end + 1): @@ -328,37 +376,32 @@ def find_reasonable_step_size(step_size, m_inv, z, rng_key): assert_allclose(final_inverse_mass_matrix, inverse_mass_matrix) -@pytest.mark.parametrize('leaf_idx, ckpt_idxs', [ - (0, (1, 0)), - (6, (3, 2)), - (7, (0, 2)), - (13, (2, 2)), - (15, (0, 3)), -]) +@pytest.mark.parametrize( + "leaf_idx, ckpt_idxs", + [(0, (1, 0)), (6, (3, 2)), (7, (0, 2)), (13, (2, 2)), (15, (0, 3))], +) def test_leaf_idx_to_ckpt_idx(leaf_idx, ckpt_idxs): assert _leaf_idx_to_ckpt_idxs(leaf_idx) == ckpt_idxs -@pytest.mark.parametrize('ckpt_idxs, expected_turning', [ - ((3, 2), False), - ((3, 3), True), - ((0, 0), False), - ((0, 1), True), - ((1, 3), True), -]) +@pytest.mark.parametrize( + "ckpt_idxs, expected_turning", + [((3, 2), False), ((3, 3), True), ((0, 0), False), ((0, 1), True), ((1, 3), True)], +) def test_is_iterative_turning(ckpt_idxs, expected_turning): inverse_mass_matrix = jnp.ones(1) - r = 1. - r_sum = 3. - r_ckpts = jnp.array([1., 2., 3., -2.]) - r_sum_ckpts = jnp.array([2., 4., 4., -1.]) + r = 1.0 + r_sum = 3.0 + r_ckpts = jnp.array([1.0, 2.0, 3.0, -2.0]) + r_sum_ckpts = jnp.array([2.0, 4.0, 4.0, -1.0]) - actual_turning = _is_iterative_turning(inverse_mass_matrix, r, r_sum, r_ckpts, r_sum_ckpts, - *ckpt_idxs) + actual_turning = _is_iterative_turning( + inverse_mass_matrix, r, r_sum, r_ckpts, r_sum_ckpts, *ckpt_idxs + ) assert expected_turning == actual_turning -@pytest.mark.parametrize('step_size', [0.01, 1., 100.]) +@pytest.mark.parametrize("step_size", [0.01, 1.0, 100.0]) def test_build_tree(step_size): def kinetic_fn(m_inv, p): return 0.5 * jnp.sum(m_inv * p ** 2) @@ -368,13 +411,14 @@ def potential_fn(q): vv_init, vv_update = velocity_verlet(potential_fn, kinetic_fn) vv_state = vv_init(0.0, 1.0) - inverse_mass_matrix = jnp.array([1.]) + inverse_mass_matrix = jnp.array([1.0]) rng_key = random.PRNGKey(0) @jit def fn(vv_state): - tree = build_tree(vv_update, kinetic_fn, vv_state, inverse_mass_matrix, - step_size, rng_key) + tree = build_tree( + vv_update, kinetic_fn, vv_state, inverse_mass_matrix, step_size, rng_key + ) return tree tree = fn(vv_state) @@ -396,8 +440,8 @@ def fn(vv_state): assert tree.num_proposals > 10 -@pytest.mark.parametrize('method', [consensus, parametric_draws]) -@pytest.mark.parametrize('diagonal', [True, False]) +@pytest.mark.parametrize("method", [consensus, parametric_draws]) +@pytest.mark.parametrize("diagonal", [True, False]) def test_gaussian_subposterior(method, diagonal): D = 10 n_samples = 10000 @@ -407,8 +451,11 @@ def test_gaussian_subposterior(method, diagonal): mean = jnp.arange(D) cov = jnp.ones((D, D)) * 0.9 + jnp.identity(D) * 0.1 subcov = n_subs * cov # subposterior's covariance - subposteriors = list(dist.MultivariateNormal(mean, subcov).sample( - random.PRNGKey(1), (n_subs, n_samples))) + subposteriors = list( + dist.MultivariateNormal(mean, subcov).sample( + random.PRNGKey(1), (n_subs, n_samples) + ) + ) draws = method(subposteriors, n_draws, diagonal=diagonal) assert draws.shape == (n_draws, D) @@ -419,9 +466,11 @@ def test_gaussian_subposterior(method, diagonal): assert_allclose(jnp.cov(draws.T), cov, atol=0.05) -@pytest.mark.parametrize('method', [consensus, parametric_draws]) +@pytest.mark.parametrize("method", [consensus, parametric_draws]) def test_subposterior_structure(method): - subposteriors = [{'x': jnp.ones((100, 3)), 'y': jnp.zeros((100,))} for i in range(10)] + subposteriors = [ + {"x": jnp.ones((100, 3)), "y": jnp.zeros((100,))} for i in range(10) + ] draws = method(subposteriors, num_draws=9) - assert draws['x'].shape == (9, 3) - assert draws['y'].shape == (9,) + assert draws["x"].shape == (9, 3) + assert draws["y"].shape == (9,) diff --git a/test/infer/test_infer_util.py b/test/infer/test_infer_util.py index c0900390a..e3d58161c 100644 --- a/test/infer/test_infer_util.py +++ b/test/infer/test_infer_util.py @@ -21,7 +21,7 @@ init_to_median, init_to_sample, init_to_uniform, - init_to_value + init_to_value, ) from numpyro.infer.reparam import TransformReparam from numpyro.infer.util import ( @@ -30,7 +30,7 @@ initialize_model, log_likelihood, potential_energy, - transform_fn + transform_fn, ) import numpyro.optim as optim @@ -42,7 +42,7 @@ def beta_bernoulli(): def model(data=None): with numpyro.plate("dim", 2): - beta = numpyro.sample("beta", dist.Beta(1., 1.)) + beta = numpyro.sample("beta", dist.Beta(1.0, 1.0)) with numpyro.plate("plate", N, dim=-2): numpyro.deterministic("beta_sq", beta ** 2) numpyro.sample("obs", dist.Bernoulli(beta), obs=data) @@ -50,7 +50,7 @@ def model(data=None): return model, data, true_probs -@pytest.mark.parametrize('parallel', [True, False]) +@pytest.mark.parametrize("parallel", [True, False]) def test_predictive(parallel): model, data, true_probs = beta_bernoulli() mcmc = MCMC(NUTS(model), num_warmup=100, num_samples=100) @@ -75,22 +75,22 @@ def test_predictive_with_guide(): data = jnp.array([1] * 8 + [0] * 2) def model(data): - f = numpyro.sample("beta", dist.Beta(1., 1.)) + f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) with numpyro.plate("plate", 10): numpyro.deterministic("beta_sq", f ** 2) numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): - alpha_q = numpyro.param("alpha_q", 1.0, - constraint=constraints.positive) - beta_q = numpyro.param("beta_q", 1.0, - constraint=constraints.positive) + alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) + beta_q = numpyro.param("beta_q", 1.0, constraint=constraints.positive) numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) svi = SVI(model, guide, optim.Adam(0.1), Trace_ELBO()) svi_result = svi.run(random.PRNGKey(1), 3000, data) params = svi_result.params - predictive = Predictive(model, guide=guide, params=params, num_samples=1000)(random.PRNGKey(2), data=None) + predictive = Predictive(model, guide=guide, params=params, num_samples=1000)( + random.PRNGKey(2), data=None + ) assert predictive["beta_sq"].shape == (1000,) obs_pred = predictive["obs"].astype(np.float32) assert_allclose(jnp.mean(obs_pred), 0.8, atol=0.05) @@ -100,12 +100,15 @@ def test_predictive_with_improper(): true_coef = 0.9 def model(data): - alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) - with handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.TransformedDistribution( - dist.Uniform(0, 1).mask(False), - AffineTransform(0, alpha))) - numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) + alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) + with handlers.reparam(config={"loc": TransformReparam()}): + loc = numpyro.sample( + "loc", + dist.TransformedDistribution( + dist.Uniform(0, 1).mask(False), AffineTransform(0, alpha) + ), + ) + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) kernel = NUTS(model=model) @@ -116,7 +119,7 @@ def model(data): assert_allclose(jnp.mean(obs_pred), true_coef, atol=0.05) -@pytest.mark.parametrize('batch_ndims', [0, 1, 2]) +@pytest.mark.parametrize("batch_ndims", [0, 1, 2]) def test_prior_predictive(batch_ndims): model, data, true_probs = beta_bernoulli() predictive = Predictive(model, num_samples=100, batch_ndims=batch_ndims) @@ -129,12 +132,14 @@ def test_prior_predictive(batch_ndims): assert predictive_samples["obs"].shape == batch_shape + data.shape -@pytest.mark.parametrize('batch_shape', [(), (100,), (2, 50)]) +@pytest.mark.parametrize("batch_shape", [(), (100,), (2, 50)]) def test_log_likelihood(batch_shape): model, data, _ = beta_bernoulli() - samples = Predictive(model, return_sites=["beta"], num_samples=200)(random.PRNGKey(1)) + samples = Predictive(model, return_sites=["beta"], num_samples=200)( + random.PRNGKey(1) + ) batch_size = int(np.prod(batch_shape)) - samples = {'beta': samples['beta'][:batch_size].reshape(batch_shape + (1, -1))} + samples = {"beta": samples["beta"][:batch_size].reshape(batch_shape + (1, -1))} preds = Predictive(model, samples, batch_ndims=len(batch_shape))(random.PRNGKey(2)) loglik = log_likelihood(model, samples, data, batch_ndims=len(batch_shape)) @@ -148,32 +153,36 @@ def test_log_likelihood(batch_shape): def test_model_with_transformed_distribution(): x_prior = dist.HalfNormal(2) - y_prior = dist.LogNormal(scale=3.) # transformed distribution + y_prior = dist.LogNormal(scale=3.0) # transformed distribution def model(): - numpyro.sample('x', x_prior) - numpyro.sample('y', y_prior) + numpyro.sample("x", x_prior) + numpyro.sample("y", y_prior) - params = {'x': jnp.array(-5.), 'y': jnp.array(7.)} + params = {"x": jnp.array(-5.0), "y": jnp.array(7.0)} model = handlers.seed(model, random.PRNGKey(0)) - inv_transforms = {'x': biject_to(x_prior.support), 'y': biject_to(y_prior.support)} + inv_transforms = {"x": biject_to(x_prior.support), "y": biject_to(y_prior.support)} expected_samples = partial(transform_fn, inv_transforms)(params) expected_potential_energy = ( - - x_prior.log_prob(expected_samples['x']) - - y_prior.log_prob(expected_samples['y']) - - inv_transforms['x'].log_abs_det_jacobian(params['x'], expected_samples['x']) - - inv_transforms['y'].log_abs_det_jacobian(params['y'], expected_samples['y']) + -x_prior.log_prob(expected_samples["x"]) + - y_prior.log_prob(expected_samples["y"]) + - inv_transforms["x"].log_abs_det_jacobian(params["x"], expected_samples["x"]) + - inv_transforms["y"].log_abs_det_jacobian(params["y"], expected_samples["y"]) ) - reparam_model = handlers.reparam(model, {'y': TransformReparam()}) - base_params = {'x': params['x'], 'y_base': params['y']} + reparam_model = handlers.reparam(model, {"y": TransformReparam()}) + base_params = {"x": params["x"], "y_base": params["y"]} actual_samples = constrain_fn( handlers.seed(reparam_model, random.PRNGKey(0)), - (), {}, base_params, return_deterministic=True) + (), + {}, + base_params, + return_deterministic=True, + ) actual_potential_energy = potential_energy(reparam_model, (), {}, base_params) - assert_allclose(expected_samples['x'], actual_samples['x']) - assert_allclose(expected_samples['y'], actual_samples['y']) + assert_allclose(expected_samples["x"], actual_samples["x"]) + assert_allclose(expected_samples["y"], actual_samples["y"]) assert_allclose(actual_potential_energy, expected_potential_energy) @@ -186,106 +195,184 @@ def model(): kernel = NUTS(model) mcmc = MCMC(kernel, num_warmup=500, num_samples=500, num_chains=1) mcmc.run(random.PRNGKey(1)) - assert_allclose(mcmc.get_samples()['x'].mean(), 0., atol=0.15) - - -@pytest.mark.parametrize('init_strategy', [ - init_to_feasible(), - init_to_median(num_samples=2), - init_to_sample(), - init_to_uniform(radius=3), - init_to_value(values={'tau': 0.7}), - init_to_feasible, - init_to_median, - init_to_sample, - init_to_uniform, - init_to_value, -]) + assert_allclose(mcmc.get_samples()["x"].mean(), 0.0, atol=0.15) + + +@pytest.mark.parametrize( + "init_strategy", + [ + init_to_feasible(), + init_to_median(num_samples=2), + init_to_sample(), + init_to_uniform(radius=3), + init_to_value(values={"tau": 0.7}), + init_to_feasible, + init_to_median, + init_to_sample, + init_to_uniform, + init_to_value, + ], +) def test_initialize_model_change_point(init_strategy): def model(data): alpha = 1 / jnp.mean(data.astype(np.float32)) - lambda1 = numpyro.sample('lambda1', dist.Exponential(alpha)) - lambda2 = numpyro.sample('lambda2', dist.Exponential(alpha)) - tau = numpyro.sample('tau', dist.Uniform(0, 1)) + lambda1 = numpyro.sample("lambda1", dist.Exponential(alpha)) + lambda2 = numpyro.sample("lambda2", dist.Exponential(alpha)) + tau = numpyro.sample("tau", dist.Uniform(0, 1)) lambda12 = jnp.where(jnp.arange(len(data)) < tau * len(data), lambda1, lambda2) - numpyro.sample('obs', dist.Poisson(lambda12), obs=data) - - count_data = jnp.array([ - 13, 24, 8, 24, 7, 35, 14, 11, 15, 11, 22, 22, 11, 57, - 11, 19, 29, 6, 19, 12, 22, 12, 18, 72, 32, 9, 7, 13, - 19, 23, 27, 20, 6, 17, 13, 10, 14, 6, 16, 15, 7, 2, - 15, 15, 19, 70, 49, 7, 53, 22, 21, 31, 19, 11, 18, 20, - 12, 35, 17, 23, 17, 4, 2, 31, 30, 13, 27, 0, 39, 37, - 5, 14, 13, 22, - ]) + numpyro.sample("obs", dist.Poisson(lambda12), obs=data) + + count_data = jnp.array( + [ + 13, + 24, + 8, + 24, + 7, + 35, + 14, + 11, + 15, + 11, + 22, + 22, + 11, + 57, + 11, + 19, + 29, + 6, + 19, + 12, + 22, + 12, + 18, + 72, + 32, + 9, + 7, + 13, + 19, + 23, + 27, + 20, + 6, + 17, + 13, + 10, + 14, + 6, + 16, + 15, + 7, + 2, + 15, + 15, + 19, + 70, + 49, + 7, + 53, + 22, + 21, + 31, + 19, + 11, + 18, + 20, + 12, + 35, + 17, + 23, + 17, + 4, + 2, + 31, + 30, + 13, + 27, + 0, + 39, + 37, + 5, + 14, + 13, + 22, + ] + ) rng_keys = random.split(random.PRNGKey(1), 2) - init_params, _, _, _ = initialize_model(rng_keys, model, - init_strategy=init_strategy, - model_args=(count_data,)) + init_params, _, _, _ = initialize_model( + rng_keys, model, init_strategy=init_strategy, model_args=(count_data,) + ) if isinstance(init_strategy, partial) and init_strategy.func is init_to_value: - expected = biject_to(constraints.unit_interval).inv(init_strategy.keywords.get('values')['tau']) - assert_allclose(init_params[0]['tau'], jnp.repeat(expected, 2)) + expected = biject_to(constraints.unit_interval).inv( + init_strategy.keywords.get("values")["tau"] + ) + assert_allclose(init_params[0]["tau"], jnp.repeat(expected, 2)) for i in range(2): - init_params_i, _, _, _ = initialize_model(rng_keys[i], model, - init_strategy=init_strategy, - model_args=(count_data,)) + init_params_i, _, _, _ = initialize_model( + rng_keys[i], model, init_strategy=init_strategy, model_args=(count_data,) + ) for name, p in init_params[0].items(): # XXX: the result is equal if we disable fast-math-mode assert_allclose(p[i], init_params_i[0][name], atol=1e-6) -@pytest.mark.parametrize('init_strategy', [ - init_to_feasible(), - init_to_median(num_samples=2), - init_to_sample(), - init_to_uniform(), -]) +@pytest.mark.parametrize( + "init_strategy", + [ + init_to_feasible(), + init_to_median(num_samples=2), + init_to_sample(), + init_to_uniform(), + ], +) def test_initialize_model_dirichlet_categorical(init_strategy): def model(data): concentration = jnp.array([1.0, 1.0, 1.0]) - p_latent = numpyro.sample('p_latent', dist.Dirichlet(concentration)) - numpyro.sample('obs', dist.Categorical(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", dist.Dirichlet(concentration)) + numpyro.sample("obs", dist.Categorical(p_latent), obs=data) return p_latent true_probs = jnp.array([0.1, 0.6, 0.3]) data = dist.Categorical(true_probs).sample(random.PRNGKey(1), (2000,)) rng_keys = random.split(random.PRNGKey(1), 2) - init_params, _, _, _ = initialize_model(rng_keys, model, - init_strategy=init_strategy, - model_args=(data,)) + init_params, _, _, _ = initialize_model( + rng_keys, model, init_strategy=init_strategy, model_args=(data,) + ) for i in range(2): - init_params_i, _, _, _ = initialize_model(rng_keys[i], model, - init_strategy=init_strategy, - model_args=(data,)) + init_params_i, _, _, _ = initialize_model( + rng_keys[i], model, init_strategy=init_strategy, model_args=(data,) + ) for name, p in init_params[0].items(): # XXX: the result is equal if we disable fast-math-mode assert_allclose(p[i], init_params_i[0][name], atol=1e-6) -@pytest.mark.parametrize('event_shape', [(3,), ()]) +@pytest.mark.parametrize("event_shape", [(3,), ()]) def test_improper_expand(event_shape): - def model(): - population = jnp.array([1000., 2000., 3000.]) + population = jnp.array([1000.0, 2000.0, 3000.0]) with numpyro.plate("region", 3): - d = dist.ImproperUniform(support=constraints.interval(0, population), - batch_shape=(3,), - event_shape=event_shape) + d = dist.ImproperUniform( + support=constraints.interval(0, population), + batch_shape=(3,), + event_shape=event_shape, + ) incidence = numpyro.sample("incidence", d) assert d.log_prob(incidence).shape == (3,) model_info = initialize_model(random.PRNGKey(0), model) - assert model_info.param_info.z['incidence'].shape == (3,) + event_shape + assert model_info.param_info.z["incidence"].shape == (3,) + event_shape def test_get_mask_optimization(): - def model(): with numpyro.handlers.seed(rng_seed=0): x = numpyro.sample("x", dist.Normal(0, 1)) - numpyro.sample("y", dist.Normal(x, 1), obs=0.) + numpyro.sample("y", dist.Normal(x, 1), obs=0.0) called.add("model-always") if numpyro.get_mask() is not False: called.add("model-sometimes") diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index da53dcee2..f7f59ce23 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -24,22 +24,24 @@ from numpyro.util import fori_collect -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA, BarkerMH]) -@pytest.mark.parametrize('dense_mass', [False, True]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS, SA, BarkerMH]) +@pytest.mark.parametrize("dense_mass", [False, True]) def test_unnormalized_normal_x64(kernel_cls, dense_mass): - true_mean, true_std = 1., 0.5 + true_mean, true_std = 1.0, 0.5 warmup_steps, num_samples = (100000, 100000) if kernel_cls is SA else (1000, 8000) def potential_fn(z): return 0.5 * jnp.sum(((z - true_mean) / true_std) ** 2) - init_params = jnp.array(0.) + init_params = jnp.array(0.0) if kernel_cls is SA: kernel = SA(potential_fn=potential_fn, dense_mass=dense_mass) elif kernel_cls is BarkerMH: kernel = SA(potential_fn=potential_fn, dense_mass=dense_mass) else: - kernel = kernel_cls(potential_fn=potential_fn, trajectory_length=8, dense_mass=dense_mass) + kernel = kernel_cls( + potential_fn=potential_fn, trajectory_length=8, dense_mass=dense_mass + ) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) mcmc.run(random.PRNGKey(0), init_params=init_params) mcmc.print_summary() @@ -47,7 +49,7 @@ def potential_fn(z): assert_allclose(jnp.mean(hmc_states), true_mean, rtol=0.07) assert_allclose(jnp.std(hmc_states), true_std, rtol=0.07) - if 'JAX_ENABLE_X64' in os.environ: + if "JAX_ENABLE_X64" in os.environ: assert hmc_states.dtype == jnp.float64 @@ -57,8 +59,11 @@ def test_correlated_mvn(): warmup_steps, num_samples = 5000, 8000 - true_mean = 0. - a = jnp.tril(0.5 * jnp.fliplr(jnp.eye(D)) + 0.1 * jnp.exp(random.normal(random.PRNGKey(0), shape=(D, D)))) + true_mean = 0.0 + a = jnp.tril( + 0.5 * jnp.fliplr(jnp.eye(D)) + + 0.1 * jnp.exp(random.normal(random.PRNGKey(0), shape=(D, D))) + ) true_cov = jnp.dot(a, a.T) true_prec = jnp.linalg.inv(true_cov) @@ -71,10 +76,10 @@ def potential_fn(z): mcmc.run(random.PRNGKey(0), init_params=init_params) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples), true_mean, atol=0.02) - assert np.sum(np.abs(np.cov(samples.T) - true_cov)) / D**2 < 0.02 + assert np.sum(np.abs(np.cov(samples.T) - true_cov)) / D ** 2 < 0.02 -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA, BarkerMH]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS, SA, BarkerMH]) def test_logistic_regression_x64(kernel_cls): N, dim = 3000, 3 if kernel_cls is SA: @@ -84,32 +89,34 @@ def test_logistic_regression_x64(kernel_cls): else: warmup_steps, num_samples = (1000, 8000) data = random.normal(random.PRNGKey(0), (N, dim)) - true_coefs = jnp.arange(1., dim + 1.) + true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) def model(labels): - coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) - logits = numpyro.deterministic('logits', jnp.sum(coefs * data, axis=-1)) - return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) + coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + logits = numpyro.deterministic("logits", jnp.sum(coefs * data, axis=-1)) + return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) if kernel_cls is SA: kernel = SA(model=model, adapt_state_size=9) elif kernel_cls is BarkerMH: kernel = BarkerMH(model=model) else: - kernel = kernel_cls(model=model, trajectory_length=8, find_heuristic_step_size=True) + kernel = kernel_cls( + model=model, trajectory_length=8, find_heuristic_step_size=True + ) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) mcmc.run(random.PRNGKey(2), labels) mcmc.print_summary() samples = mcmc.get_samples() - assert samples['logits'].shape == (num_samples, N) + assert samples["logits"].shape == (num_samples, N) # those coefficients are found by doing MAP inference using AutoDelta expected_coefs = jnp.array([0.97, 2.05, 3.18]) - assert_allclose(jnp.mean(samples['coefs'], 0), expected_coefs, atol=0.1) + assert_allclose(jnp.mean(samples["coefs"], 0), expected_coefs, atol=0.1) - if 'JAX_ENABLE_X64' in os.environ: - assert samples['coefs'].dtype == jnp.float64 + if "JAX_ENABLE_X64" in os.environ: + assert samples["coefs"].dtype == jnp.float64 @pytest.mark.parametrize("forward_mode_differentiation", [True, False]) @@ -118,59 +125,68 @@ def test_uniform_normal(forward_mode_differentiation): num_warmup, num_samples = 1000, 1000 def model(data): - alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) - with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.TransformedDistribution( - dist.Uniform(0, 1), AffineTransform(0, alpha))) - numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) + alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) + with numpyro.handlers.reparam(config={"loc": TransformReparam()}): + loc = numpyro.sample( + "loc", + dist.TransformedDistribution( + dist.Uniform(0, 1), AffineTransform(0, alpha) + ), + ) + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) - kernel = NUTS(model=model, forward_mode_differentiation=forward_mode_differentiation) + kernel = NUTS( + model=model, forward_mode_differentiation=forward_mode_differentiation + ) mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.warmup(random.PRNGKey(2), data, collect_warmup=True) assert mcmc.post_warmup_state is not None warmup_samples = mcmc.get_samples() mcmc.run(random.PRNGKey(3), data) samples = mcmc.get_samples() - assert len(warmup_samples['loc']) == num_warmup - assert len(samples['loc']) == num_samples - assert_allclose(jnp.mean(samples['loc'], 0), true_coef, atol=0.05) + assert len(warmup_samples["loc"]) == num_warmup + assert len(samples["loc"]) == num_samples + assert_allclose(jnp.mean(samples["loc"], 0), true_coef, atol=0.05) mcmc.post_warmup_state = mcmc.last_state mcmc.run(random.PRNGKey(3), data) samples = mcmc.get_samples() - assert len(samples['loc']) == num_samples - assert_allclose(jnp.mean(samples['loc'], 0), true_coef, atol=0.05) + assert len(samples["loc"]) == num_samples + assert_allclose(jnp.mean(samples["loc"], 0), true_coef, atol=0.05) def test_improper_normal(): true_coef = 0.9 def model(data): - alpha = numpyro.sample('alpha', dist.Uniform(0, 1)) - with numpyro.handlers.reparam(config={'loc': TransformReparam()}): - loc = numpyro.sample('loc', dist.TransformedDistribution( - dist.Uniform(0, 1).mask(False), - AffineTransform(0, alpha))) - numpyro.sample('obs', dist.Normal(loc, 0.1), obs=data) + alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) + with numpyro.handlers.reparam(config={"loc": TransformReparam()}): + loc = numpyro.sample( + "loc", + dist.TransformedDistribution( + dist.Uniform(0, 1).mask(False), AffineTransform(0, alpha) + ), + ) + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) kernel = NUTS(model=model) mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000) mcmc.run(random.PRNGKey(0), data) samples = mcmc.get_samples() - assert_allclose(jnp.mean(samples['loc'], 0), true_coef, atol=0.05) + assert_allclose(jnp.mean(samples["loc"], 0), true_coef, atol=0.05) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, SA, BarkerMH]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS, SA, BarkerMH]) def test_beta_bernoulli_x64(kernel_cls): warmup_steps, num_samples = (100000, 100000) if kernel_cls is SA else (500, 20000) def model(data): alpha = jnp.array([1.1, 1.1]) beta = jnp.array([1.1, 1.1]) - p_latent = numpyro.sample('p_latent', dist.Beta(alpha, beta)) - numpyro.sample('obs', dist.Bernoulli(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", dist.Beta(alpha, beta)) + numpyro.sample("obs", dist.Bernoulli(p_latent), obs=data) return p_latent true_probs = jnp.array([0.9, 0.1]) @@ -181,25 +197,27 @@ def model(data): kernel = BarkerMH(model=model) else: kernel = kernel_cls(model=model, trajectory_length=0.1) - mcmc = MCMC(kernel, num_warmup=warmup_steps, num_samples=num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=warmup_steps, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(2), data) mcmc.print_summary() samples = mcmc.get_samples() - assert_allclose(jnp.mean(samples['p_latent'], 0), true_probs, atol=0.05) + assert_allclose(jnp.mean(samples["p_latent"], 0), true_probs, atol=0.05) - if 'JAX_ENABLE_X64' in os.environ: - assert samples['p_latent'].dtype == jnp.float64 + if "JAX_ENABLE_X64" in os.environ: + assert samples["p_latent"].dtype == jnp.float64 -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, BarkerMH]) -@pytest.mark.parametrize('dense_mass', [False, True]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS, BarkerMH]) +@pytest.mark.parametrize("dense_mass", [False, True]) def test_dirichlet_categorical_x64(kernel_cls, dense_mass): warmup_steps, num_samples = 100, 20000 def model(data): concentration = jnp.array([1.0, 1.0, 1.0]) - p_latent = numpyro.sample('p_latent', dist.Dirichlet(concentration)) - numpyro.sample('obs', dist.Categorical(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", dist.Dirichlet(concentration)) + numpyro.sample("obs", dist.Categorical(p_latent), obs=data) return p_latent true_probs = jnp.array([0.1, 0.6, 0.3]) @@ -207,28 +225,30 @@ def model(data): if kernel_cls is BarkerMH: kernel = BarkerMH(model=model, dense_mass=dense_mass) else: - kernel = kernel_cls(model, trajectory_length=1., dense_mass=dense_mass) + kernel = kernel_cls(model, trajectory_length=1.0, dense_mass=dense_mass) mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() - assert_allclose(jnp.mean(samples['p_latent'], 0), true_probs, atol=0.02) + assert_allclose(jnp.mean(samples["p_latent"], 0), true_probs, atol=0.02) - if 'JAX_ENABLE_X64' in os.environ: - assert samples['p_latent'].dtype == jnp.float64 + if "JAX_ENABLE_X64" in os.environ: + assert samples["p_latent"].dtype == jnp.float64 -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS, BarkerMH]) -@pytest.mark.parametrize('rho', [-0.7, 0.8]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS, BarkerMH]) +@pytest.mark.parametrize("rho", [-0.7, 0.8]) def test_dense_mass(kernel_cls, rho): warmup_steps, num_samples = 20000, 10000 true_cov = jnp.array([[10.0, rho], [rho, 0.1]]) def model(): - numpyro.sample("x", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=true_cov)) + numpyro.sample( + "x", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=true_cov) + ) if kernel_cls is HMC or kernel_cls is NUTS: - kernel = kernel_cls(model, trajectory_length=2., dense_mass=True) + kernel = kernel_cls(model, trajectory_length=2.0, dense_mass=True) elif kernel_cls is BarkerMH: kernel = BarkerMH(model, dense_mass=True) @@ -242,7 +262,7 @@ def model(): estimated_cov = jnp.linalg.inv(mass_matrix) assert_allclose(estimated_cov, true_cov, rtol=0.10) - samples = mcmc.get_samples()['x'] + samples = mcmc.get_samples()["x"] assert_allclose(jnp.mean(samples[:, 0]), jnp.array(0.0), atol=0.50) assert_allclose(jnp.mean(samples[:, 1]), jnp.array(0.0), atol=0.05) assert_allclose(jnp.mean(samples[:, 0] * samples[:, 1]), jnp.array(rho), atol=0.20) @@ -255,68 +275,142 @@ def test_change_point_x64(): def model(data): alpha = 1 / jnp.mean(data.astype(np.float32)) - lambda1 = numpyro.sample('lambda1', dist.Exponential(alpha)) - lambda2 = numpyro.sample('lambda2', dist.Exponential(alpha)) - tau = numpyro.sample('tau', dist.Uniform(0, 1)) + lambda1 = numpyro.sample("lambda1", dist.Exponential(alpha)) + lambda2 = numpyro.sample("lambda2", dist.Exponential(alpha)) + tau = numpyro.sample("tau", dist.Uniform(0, 1)) lambda12 = jnp.where(jnp.arange(len(data)) < tau * len(data), lambda1, lambda2) - numpyro.sample('obs', dist.Poisson(lambda12), obs=data) - - count_data = jnp.array([ - 13, 24, 8, 24, 7, 35, 14, 11, 15, 11, 22, 22, 11, 57, - 11, 19, 29, 6, 19, 12, 22, 12, 18, 72, 32, 9, 7, 13, - 19, 23, 27, 20, 6, 17, 13, 10, 14, 6, 16, 15, 7, 2, - 15, 15, 19, 70, 49, 7, 53, 22, 21, 31, 19, 11, 18, 20, - 12, 35, 17, 23, 17, 4, 2, 31, 30, 13, 27, 0, 39, 37, - 5, 14, 13, 22, - ]) + numpyro.sample("obs", dist.Poisson(lambda12), obs=data) + + count_data = jnp.array( + [ + 13, + 24, + 8, + 24, + 7, + 35, + 14, + 11, + 15, + 11, + 22, + 22, + 11, + 57, + 11, + 19, + 29, + 6, + 19, + 12, + 22, + 12, + 18, + 72, + 32, + 9, + 7, + 13, + 19, + 23, + 27, + 20, + 6, + 17, + 13, + 10, + 14, + 6, + 16, + 15, + 7, + 2, + 15, + 15, + 19, + 70, + 49, + 7, + 53, + 22, + 21, + 31, + 19, + 11, + 18, + 20, + 12, + 35, + 17, + 23, + 17, + 4, + 2, + 31, + 30, + 13, + 27, + 0, + 39, + 37, + 5, + 14, + 13, + 22, + ] + ) kernel = NUTS(model=model) mcmc = MCMC(kernel, warmup_steps, num_samples) mcmc.run(random.PRNGKey(4), count_data) samples = mcmc.get_samples() - tau_posterior = (samples['tau'] * len(count_data)).astype(jnp.int32) + tau_posterior = (samples["tau"] * len(count_data)).astype(jnp.int32) tau_values, counts = np.unique(tau_posterior, return_counts=True) mode_ind = jnp.argmax(counts) mode = tau_values[mode_ind] assert mode == 44 - if 'JAX_ENABLE_X64' in os.environ: - assert samples['lambda1'].dtype == jnp.float64 - assert samples['lambda2'].dtype == jnp.float64 - assert samples['tau'].dtype == jnp.float64 + if "JAX_ENABLE_X64" in os.environ: + assert samples["lambda1"].dtype == jnp.float64 + assert samples["lambda2"].dtype == jnp.float64 + assert samples["tau"].dtype == jnp.float64 -@pytest.mark.parametrize('with_logits', ['True', 'False']) +@pytest.mark.parametrize("with_logits", ["True", "False"]) def test_binomial_stable_x64(with_logits): # Ref: https://github.com/pyro-ppl/pyro/issues/1706 warmup_steps, num_samples = 200, 200 def model(data): - p = numpyro.sample('p', dist.Beta(1., 1.)) + p = numpyro.sample("p", dist.Beta(1.0, 1.0)) if with_logits: logits = logit(p) - numpyro.sample('obs', dist.Binomial(data['n'], logits=logits), obs=data['x']) + numpyro.sample( + "obs", dist.Binomial(data["n"], logits=logits), obs=data["x"] + ) else: - numpyro.sample('obs', dist.Binomial(data['n'], probs=p), obs=data['x']) + numpyro.sample("obs", dist.Binomial(data["n"], probs=p), obs=data["x"]) - data = {'n': 5000000, 'x': 3849} + data = {"n": 5000000, "x": 3849} kernel = NUTS(model=model) mcmc = MCMC(kernel, warmup_steps, num_samples) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() - assert_allclose(jnp.mean(samples['p'], 0), data['x'] / data['n'], rtol=0.05) + assert_allclose(jnp.mean(samples["p"], 0), data["x"] / data["n"], rtol=0.05) - if 'JAX_ENABLE_X64' in os.environ: - assert samples['p'].dtype == jnp.float64 + if "JAX_ENABLE_X64" in os.environ: + assert samples["p"].dtype == jnp.float64 def test_improper_prior(): - true_mean, true_std = 1., 2. + true_mean, true_std = 1.0, 2.0 num_warmup, num_samples = 1000, 8000 def model(data): - mean = numpyro.sample('mean', dist.Normal(0, 1).mask(False)) - std = numpyro.sample('std', dist.ImproperUniform(dist.constraints.positive, (), ())) - return numpyro.sample('obs', dist.Normal(mean, std), obs=data) + mean = numpyro.sample("mean", dist.Normal(0, 1).mask(False)) + std = numpyro.sample( + "std", dist.ImproperUniform(dist.constraints.positive, (), ()) + ) + return numpyro.sample("obs", dist.Normal(mean, std), obs=data) data = dist.Normal(true_mean, true_std).sample(random.PRNGKey(1), (2000,)) kernel = NUTS(model=model) @@ -324,18 +418,18 @@ def model(data): mcmc.warmup(random.PRNGKey(2), data) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() - assert_allclose(jnp.mean(samples['mean']), true_mean, rtol=0.05) - assert_allclose(jnp.mean(samples['std']), true_std, rtol=0.05) + assert_allclose(jnp.mean(samples["mean"]), true_mean, rtol=0.05) + assert_allclose(jnp.mean(samples["std"]), true_std, rtol=0.05) def test_mcmc_progbar(): - true_mean, true_std = 1., 2. + true_mean, true_std = 1.0, 2.0 num_warmup, num_samples = 10, 10 def model(data): - mean = numpyro.sample('mean', dist.Normal(0, 1).mask(False)) - std = numpyro.sample('std', dist.LogNormal(0, 1).mask(False)) - return numpyro.sample('obs', dist.Normal(mean, std), obs=data) + mean = numpyro.sample("mean", dist.Normal(0, 1).mask(False)) + std = numpyro.sample("std", dist.LogNormal(0, 1).mask(False)) + return numpyro.sample("obs", dist.Normal(mean, std), obs=data) data = dist.Normal(true_mean, true_std).sample(random.PRNGKey(1), (2000,)) kernel = NUTS(model=model) @@ -353,22 +447,26 @@ def model(data): check_close(mcmc1.post_warmup_state, mcmc.post_warmup_state, atol=1e-4, rtol=1e-4) -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) -@pytest.mark.parametrize('adapt_step_size', [True, False]) +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) +@pytest.mark.parametrize("adapt_step_size", [True, False]) def test_diverging(kernel_cls, adapt_step_size): data = random.normal(random.PRNGKey(0), (1000,)) def model(data): - loc = numpyro.sample('loc', dist.Normal(0., 1.)) - numpyro.sample('obs', dist.Normal(loc, 1), obs=data) + loc = numpyro.sample("loc", dist.Normal(0.0, 1.0)) + numpyro.sample("obs", dist.Normal(loc, 1), obs=data) - kernel = kernel_cls(model, step_size=10., adapt_step_size=adapt_step_size, adapt_mass_matrix=False) + kernel = kernel_cls( + model, step_size=10.0, adapt_step_size=adapt_step_size, adapt_mass_matrix=False + ) num_warmup = num_samples = 1000 mcmc = MCMC(kernel, num_warmup, num_samples) - mcmc.warmup(random.PRNGKey(1), data, extra_fields=['diverging'], collect_warmup=True) - warmup_divergences = mcmc.get_extra_fields()['diverging'].sum() - mcmc.run(random.PRNGKey(2), data, extra_fields=['diverging']) - num_divergences = warmup_divergences + mcmc.get_extra_fields()['diverging'].sum() + mcmc.warmup( + random.PRNGKey(1), data, extra_fields=["diverging"], collect_warmup=True + ) + warmup_divergences = mcmc.get_extra_fields()["diverging"].sum() + mcmc.run(random.PRNGKey(2), data, extra_fields=["diverging"]) + num_divergences = warmup_divergences + mcmc.get_extra_fields()["diverging"].sum() if adapt_step_size: assert num_divergences <= num_warmup else: @@ -383,84 +481,103 @@ def test_prior_with_sample_shape(): } def schools_model(): - mu = numpyro.sample('mu', dist.Normal(0, 5)) - tau = numpyro.sample('tau', dist.HalfCauchy(5)) - theta = numpyro.sample('theta', dist.Normal(mu, tau), sample_shape=(data['J'],)) - numpyro.sample('obs', dist.Normal(theta, data['sigma']), obs=data['y']) + mu = numpyro.sample("mu", dist.Normal(0, 5)) + tau = numpyro.sample("tau", dist.HalfCauchy(5)) + theta = numpyro.sample("theta", dist.Normal(mu, tau), sample_shape=(data["J"],)) + numpyro.sample("obs", dist.Normal(theta, data["sigma"]), obs=data["y"]) num_samples = 500 mcmc = MCMC(NUTS(schools_model), num_warmup=500, num_samples=num_samples) mcmc.run(random.PRNGKey(0)) - assert mcmc.get_samples()['theta'].shape == (num_samples, data['J']) + assert mcmc.get_samples()["theta"].shape == (num_samples, data["J"]) -@pytest.mark.parametrize('num_chains', [1, 2]) -@pytest.mark.parametrize('chain_method', ['parallel', 'sequential', 'vectorized']) -@pytest.mark.parametrize('progress_bar', [True, False]) +@pytest.mark.parametrize("num_chains", [1, 2]) +@pytest.mark.parametrize("chain_method", ["parallel", "sequential", "vectorized"]) +@pytest.mark.parametrize("progress_bar", [True, False]) @pytest.mark.filterwarnings("ignore:There are not enough devices:UserWarning") def test_empty_model(num_chains, chain_method, progress_bar): def model(): pass - mcmc = MCMC(NUTS(model), num_warmup=10, num_samples=10, num_chains=num_chains, - chain_method=chain_method, progress_bar=progress_bar) + mcmc = MCMC( + NUTS(model), + num_warmup=10, + num_samples=10, + num_chains=num_chains, + chain_method=chain_method, + progress_bar=progress_bar, + ) mcmc.run(random.PRNGKey(0)) assert mcmc.get_samples() == {} -@pytest.mark.parametrize('use_init_params', [False, True]) -@pytest.mark.parametrize('chain_method', ['parallel', 'sequential', 'vectorized']) -@pytest.mark.skipif('XLA_FLAGS' not in os.environ, reason='without this mark, we have duplicated tests in Travis') +@pytest.mark.parametrize("use_init_params", [False, True]) +@pytest.mark.parametrize("chain_method", ["parallel", "sequential", "vectorized"]) +@pytest.mark.skipif( + "XLA_FLAGS" not in os.environ, + reason="without this mark, we have duplicated tests in Travis", +) def test_chain(use_init_params, chain_method): N, dim = 3000, 3 num_chains = 2 num_warmup, num_samples = 5000, 5000 data = random.normal(random.PRNGKey(0), (N, dim)) - true_coefs = jnp.arange(1., dim + 1.) + true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) def model(labels): - coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) logits = jnp.sum(coefs * data, axis=-1) numpyro.deterministic("logits", logits) - return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) + return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) kernel = NUTS(model=model) mcmc = MCMC(kernel, num_warmup, num_samples, num_chains=num_chains) mcmc.chain_method = chain_method - init_params = None if not use_init_params else \ - {'coefs': jnp.tile(jnp.ones(dim), num_chains).reshape(num_chains, dim)} + init_params = ( + None + if not use_init_params + else {"coefs": jnp.tile(jnp.ones(dim), num_chains).reshape(num_chains, dim)} + ) mcmc.run(random.PRNGKey(2), labels, init_params=init_params) samples_flat = mcmc.get_samples() - assert samples_flat['coefs'].shape[0] == num_chains * num_samples + assert samples_flat["coefs"].shape[0] == num_chains * num_samples samples = mcmc.get_samples(group_by_chain=True) - assert samples['coefs'].shape[:2] == (num_chains, num_samples) - assert_allclose(jnp.mean(samples_flat['coefs'], 0), true_coefs, atol=0.21) + assert samples["coefs"].shape[:2] == (num_chains, num_samples) + assert_allclose(jnp.mean(samples_flat["coefs"], 0), true_coefs, atol=0.21) # test if reshape works - device_get(samples_flat['coefs'].reshape(-1)) - - -@pytest.mark.parametrize('kernel_cls', [HMC, NUTS]) -@pytest.mark.parametrize('chain_method', [ - pytest.param('parallel', marks=pytest.mark.xfail( - reason='jit+pmap does not work in CPU yet')), - 'sequential', - 'vectorized', -]) -@pytest.mark.skipif('CI' in os.environ, reason="Compiling time the whole sampling process is slow.") + device_get(samples_flat["coefs"].reshape(-1)) + + +@pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) +@pytest.mark.parametrize( + "chain_method", + [ + pytest.param( + "parallel", + marks=pytest.mark.xfail(reason="jit+pmap does not work in CPU yet"), + ), + "sequential", + "vectorized", + ], +) +@pytest.mark.skipif( + "CI" in os.environ, reason="Compiling time the whole sampling process is slow." +) def test_chain_inside_jit(kernel_cls, chain_method): # NB: this feature is useful for consensus MC. # Caution: compiling time will be slow (~ 90s) - if chain_method == 'parallel' and xla_bridge.device_count() == 1: - pytest.skip('parallel method requires device_count greater than 1.') + if chain_method == "parallel" and xla_bridge.device_count() == 1: + pytest.skip("parallel method requires device_count greater than 1.") warmup_steps, num_samples = 100, 2000 # Here are settings which is currently supported. rng_key = random.PRNGKey(2) - step_size = 1. + step_size = 1.0 target_accept_prob = 0.8 - trajectory_length = 1. + trajectory_length = 1.0 # Not supported yet: # + adapt_step_size # + adapt_mass_matrix @@ -470,46 +587,64 @@ def test_chain_inside_jit(kernel_cls, chain_method): def model(data): concentration = jnp.array([1.0, 1.0, 1.0]) - p_latent = numpyro.sample('p_latent', dist.Dirichlet(concentration)) - numpyro.sample('obs', dist.Categorical(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", dist.Dirichlet(concentration)) + numpyro.sample("obs", dist.Categorical(p_latent), obs=data) return p_latent @jit def get_samples(rng_key, data, step_size, trajectory_length, target_accept_prob): - kernel = kernel_cls(model, step_size=step_size, trajectory_length=trajectory_length, - target_accept_prob=target_accept_prob) - mcmc = MCMC(kernel, warmup_steps, num_samples, num_chains=2, chain_method=chain_method, - progress_bar=False) + kernel = kernel_cls( + model, + step_size=step_size, + trajectory_length=trajectory_length, + target_accept_prob=target_accept_prob, + ) + mcmc = MCMC( + kernel, + warmup_steps, + num_samples, + num_chains=2, + chain_method=chain_method, + progress_bar=False, + ) mcmc.run(rng_key, data) return mcmc.get_samples() true_probs = jnp.array([0.1, 0.6, 0.3]) data = dist.Categorical(true_probs).sample(random.PRNGKey(1), (2000,)) - samples = get_samples(rng_key, data, step_size, trajectory_length, target_accept_prob) - assert_allclose(jnp.mean(samples['p_latent'], 0), true_probs, atol=0.02) - - -@pytest.mark.parametrize('chain_method', [ - 'sequential', - 'parallel', - 'vectorized', -]) -@pytest.mark.parametrize('compile_args', [ - False, - True, -]) -@pytest.mark.skipif('CI' in os.environ, reason="Compiling time the whole sampling process is slow.") + samples = get_samples( + rng_key, data, step_size, trajectory_length, target_accept_prob + ) + assert_allclose(jnp.mean(samples["p_latent"], 0), true_probs, atol=0.02) + + +@pytest.mark.parametrize("chain_method", ["sequential", "parallel", "vectorized"]) +@pytest.mark.parametrize("compile_args", [False, True]) +@pytest.mark.skipif( + "CI" in os.environ, reason="Compiling time the whole sampling process is slow." +) def test_chain_jit_args_smoke(chain_method, compile_args): def model(data): concentration = jnp.array([1.0, 1.0, 1.0]) - p_latent = numpyro.sample('p_latent', dist.Dirichlet(concentration)) - numpyro.sample('obs', dist.Categorical(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", dist.Dirichlet(concentration)) + numpyro.sample("obs", dist.Categorical(p_latent), obs=data) return p_latent - data1 = dist.Categorical(jnp.array([0.1, 0.6, 0.3])).sample(random.PRNGKey(1), (50,)) - data2 = dist.Categorical(jnp.array([0.2, 0.4, 0.4])).sample(random.PRNGKey(1), (50,)) + data1 = dist.Categorical(jnp.array([0.1, 0.6, 0.3])).sample( + random.PRNGKey(1), (50,) + ) + data2 = dist.Categorical(jnp.array([0.2, 0.4, 0.4])).sample( + random.PRNGKey(1), (50,) + ) kernel = NUTS(model) - mcmc = MCMC(kernel, 2, 5, num_chains=2, chain_method=chain_method, jit_model_args=compile_args) + mcmc = MCMC( + kernel, + 2, + 5, + num_chains=2, + chain_method=chain_method, + jit_model_args=compile_args, + ) mcmc.warmup(random.PRNGKey(0), data1) mcmc.run(random.PRNGKey(1), data1) # this should be fast if jit_model_args=True @@ -518,83 +653,100 @@ def model(data): def test_extra_fields(): def model(): - numpyro.sample('x', dist.Normal(0, 1), sample_shape=(5,)) + numpyro.sample("x", dist.Normal(0, 1), sample_shape=(5,)) mcmc = MCMC(NUTS(model), 1000, 1000) - mcmc.run(random.PRNGKey(0), extra_fields=('num_steps', 'adapt_state.step_size')) + mcmc.run(random.PRNGKey(0), extra_fields=("num_steps", "adapt_state.step_size")) samples = mcmc.get_samples(group_by_chain=True) - assert samples['x'].shape == (1, 1000, 5) + assert samples["x"].shape == (1, 1000, 5) stats = mcmc.get_extra_fields(group_by_chain=True) - assert 'num_steps' in stats - assert stats['num_steps'].shape == (1, 1000) - assert 'adapt_state.step_size' in stats - assert stats['adapt_state.step_size'].shape == (1, 1000) + assert "num_steps" in stats + assert stats["num_steps"].shape == (1, 1000) + assert "adapt_state.step_size" in stats + assert stats["adapt_state.step_size"].shape == (1, 1000) -@pytest.mark.parametrize('algo', ['HMC', 'NUTS']) +@pytest.mark.parametrize("algo", ["HMC", "NUTS"]) def test_functional_beta_bernoulli_x64(algo): warmup_steps, num_samples = 410, 100 def model(data): alpha = jnp.array([1.1, 1.1]) beta = jnp.array([1.1, 1.1]) - p_latent = numpyro.sample('p_latent', dist.Beta(alpha, beta)) - numpyro.sample('obs', dist.Bernoulli(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", dist.Beta(alpha, beta)) + numpyro.sample("obs", dist.Bernoulli(p_latent), obs=data) return p_latent true_probs = jnp.array([0.9, 0.1]) data = dist.Bernoulli(true_probs).sample(random.PRNGKey(1), (1000, 2)) - init_params, potential_fn, constrain_fn, _ = initialize_model(random.PRNGKey(2), model, model_args=(data,)) + init_params, potential_fn, constrain_fn, _ = initialize_model( + random.PRNGKey(2), model, model_args=(data,) + ) init_kernel, sample_kernel = hmc(potential_fn, algo=algo) - hmc_state = init_kernel(init_params, - trajectory_length=1., - num_warmup=warmup_steps) - samples = fori_collect(0, num_samples, sample_kernel, hmc_state, - transform=lambda x: constrain_fn(x.z)) - assert_allclose(jnp.mean(samples['p_latent'], 0), true_probs, atol=0.05) - - if 'JAX_ENABLE_X64' in os.environ: - assert samples['p_latent'].dtype == jnp.float64 - - -@pytest.mark.parametrize('algo', ['HMC', 'NUTS']) -@pytest.mark.parametrize('map_fn', [vmap, pmap]) -@pytest.mark.skipif('XLA_FLAGS' not in os.environ, reason='without this mark, we have duplicated tests in Travis') + hmc_state = init_kernel(init_params, trajectory_length=1.0, num_warmup=warmup_steps) + samples = fori_collect( + 0, num_samples, sample_kernel, hmc_state, transform=lambda x: constrain_fn(x.z) + ) + assert_allclose(jnp.mean(samples["p_latent"], 0), true_probs, atol=0.05) + + if "JAX_ENABLE_X64" in os.environ: + assert samples["p_latent"].dtype == jnp.float64 + + +@pytest.mark.parametrize("algo", ["HMC", "NUTS"]) +@pytest.mark.parametrize("map_fn", [vmap, pmap]) +@pytest.mark.skipif( + "XLA_FLAGS" not in os.environ, + reason="without this mark, we have duplicated tests in Travis", +) def test_functional_map(algo, map_fn): if map_fn is pmap and xla_bridge.device_count() == 1: - pytest.skip('pmap test requires device_count greater than 1.') + pytest.skip("pmap test requires device_count greater than 1.") - true_mean, true_std = 1., 2. + true_mean, true_std = 1.0, 2.0 warmup_steps, num_samples = 1000, 8000 def potential_fn(z): return 0.5 * jnp.sum(((z - true_mean) / true_std) ** 2) init_kernel, sample_kernel = hmc(potential_fn, algo=algo) - init_params = jnp.array([0., -1.]) + init_params = jnp.array([0.0, -1.0]) rng_keys = random.split(random.PRNGKey(0), 2) - init_kernel_map = map_fn(lambda init_param, rng_key: init_kernel( - init_param, trajectory_length=9, num_warmup=warmup_steps, rng_key=rng_key)) + init_kernel_map = map_fn( + lambda init_param, rng_key: init_kernel( + init_param, trajectory_length=9, num_warmup=warmup_steps, rng_key=rng_key + ) + ) init_states = init_kernel_map(init_params, rng_keys) - fori_collect_map = map_fn(lambda hmc_state: fori_collect(0, num_samples, sample_kernel, hmc_state, - transform=lambda x: x.z, progbar=False)) + fori_collect_map = map_fn( + lambda hmc_state: fori_collect( + 0, + num_samples, + sample_kernel, + hmc_state, + transform=lambda x: x.z, + progbar=False, + ) + ) chain_samples = fori_collect_map(init_states) - assert_allclose(jnp.mean(chain_samples, axis=1), jnp.repeat(true_mean, 2), rtol=0.06) + assert_allclose( + jnp.mean(chain_samples, axis=1), jnp.repeat(true_mean, 2), rtol=0.06 + ) assert_allclose(jnp.std(chain_samples, axis=1), jnp.repeat(true_std, 2), rtol=0.06) -@pytest.mark.parametrize('jit_args', [False, True]) -@pytest.mark.parametrize('shape', [50, 100]) +@pytest.mark.parametrize("jit_args", [False, True]) +@pytest.mark.parametrize("shape", [50, 100]) def test_reuse_mcmc_run(jit_args, shape): y1 = np.random.normal(3, 0.1, (100,)) y2 = np.random.normal(-3, 0.1, (shape,)) def model(y_obs): - mu = numpyro.sample('mu', dist.Normal(0., 1.)) - sigma = numpyro.sample("sigma", dist.HalfCauchy(3.)) + mu = numpyro.sample("mu", dist.Normal(0.0, 1.0)) + sigma = numpyro.sample("sigma", dist.HalfCauchy(3.0)) numpyro.sample("y", dist.Normal(mu, sigma), obs=y_obs) # Run MCMC on zero observations. @@ -604,23 +756,23 @@ def model(y_obs): # Re-run on new data - should be much faster. mcmc.run(random.PRNGKey(32), y2) - assert_allclose(mcmc.get_samples()['mu'].mean(), -3., atol=0.1) + assert_allclose(mcmc.get_samples()["mu"].mean(), -3.0, atol=0.1) -@pytest.mark.parametrize('jit_args', [False, True]) +@pytest.mark.parametrize("jit_args", [False, True]) def test_model_with_multiple_exec_paths(jit_args): def model(a=None, b=None, z=None): - int_term = numpyro.sample('a', dist.Normal(0., 0.2)) - x_term, y_term = 0., 0. + int_term = numpyro.sample("a", dist.Normal(0.0, 0.2)) + x_term, y_term = 0.0, 0.0 if a is not None: - x = numpyro.sample('x', dist.HalfNormal(0.5)) + x = numpyro.sample("x", dist.HalfNormal(0.5)) x_term = a * x if b is not None: - y = numpyro.sample('y', dist.HalfNormal(0.5)) + y = numpyro.sample("y", dist.HalfNormal(0.5)) y_term = b * y - sigma = numpyro.sample('sigma', dist.Exponential(1.)) + sigma = numpyro.sample("sigma", dist.Exponential(1.0)) mu = int_term + x_term + y_term - numpyro.sample('obs', dist.Normal(mu, sigma), obs=z) + numpyro.sample("obs", dist.Normal(mu, sigma), obs=z) a = jnp.exp(np.random.randn(10)) b = jnp.exp(np.random.randn(10)) @@ -630,29 +782,35 @@ def model(a=None, b=None, z=None): kernel = NUTS(model) mcmc = MCMC(kernel, 20, 10, jit_model_args=jit_args) mcmc.run(random.PRNGKey(1), a, b=None, z=z) - assert set(mcmc.get_samples()) == {'a', 'x', 'sigma'} + assert set(mcmc.get_samples()) == {"a", "x", "sigma"} mcmc.run(random.PRNGKey(2), a=None, b=b, z=z) - assert set(mcmc.get_samples()) == {'a', 'y', 'sigma'} + assert set(mcmc.get_samples()) == {"a", "y", "sigma"} mcmc.run(random.PRNGKey(3), a=a, b=b, z=z) - assert set(mcmc.get_samples()) == {'a', 'x', 'y', 'sigma'} + assert set(mcmc.get_samples()) == {"a", "x", "y", "sigma"} -@pytest.mark.parametrize('num_chains', [1, 2]) -@pytest.mark.parametrize('chain_method', ['parallel', 'sequential', 'vectorized']) -@pytest.mark.parametrize('progress_bar', [True, False]) +@pytest.mark.parametrize("num_chains", [1, 2]) +@pytest.mark.parametrize("chain_method", ["parallel", "sequential", "vectorized"]) +@pytest.mark.parametrize("progress_bar", [True, False]) def test_compile_warmup_run(num_chains, chain_method, progress_bar): def model(): numpyro.sample("x", dist.Normal(0, 1)) - if num_chains == 1 and chain_method in ['sequential', 'vectorized']: - pytest.skip('duplicated test') - if num_chains > 1 and chain_method == 'parallel': - pytest.skip('duplicated test') + if num_chains == 1 and chain_method in ["sequential", "vectorized"]: + pytest.skip("duplicated test") + if num_chains > 1 and chain_method == "parallel": + pytest.skip("duplicated test") rng_key = random.PRNGKey(0) num_samples = 10 - mcmc = MCMC(NUTS(model), 10, num_samples, num_chains, - chain_method=chain_method, progress_bar=progress_bar) + mcmc = MCMC( + NUTS(model), + 10, + num_samples, + num_chains, + chain_method=chain_method, + progress_bar=progress_bar, + ) mcmc.run(rng_key) expected_samples = mcmc.get_samples()["x"] @@ -674,7 +832,7 @@ def model(): assert_allclose(actual_samples[:num_samples], first_chain_samples, atol=1e-5) -@pytest.mark.parametrize('dense_mass', [True, False]) +@pytest.mark.parametrize("dense_mass", [True, False]) def test_get_proposal_loc_and_scale(dense_mass): N = 10 dim = 3 @@ -684,13 +842,17 @@ def test_get_proposal_loc_and_scale(dense_mass): scale = jnp.linalg.cholesky(jnp.cov(samples[:-1], rowvar=False, bias=True)) else: scale = jnp.std(samples[:-1], 0) - actual_loc, actual_scale = _get_proposal_loc_and_scale(samples[:-1], loc, scale, samples[-1]) + actual_loc, actual_scale = _get_proposal_loc_and_scale( + samples[:-1], loc, scale, samples[-1] + ) expected_loc, expected_scale = [], [] for i in range(N - 1): samples_i = np.delete(samples, i, axis=0) expected_loc.append(jnp.mean(samples_i, 0)) if dense_mass: - expected_scale.append(jnp.linalg.cholesky(jnp.cov(samples_i, rowvar=False, bias=True))) + expected_scale.append( + jnp.linalg.cholesky(jnp.cov(samples_i, rowvar=False, bias=True)) + ) else: expected_scale.append(jnp.std(samples_i, 0)) expected_loc = jnp.stack(expected_loc) @@ -699,8 +861,8 @@ def test_get_proposal_loc_and_scale(dense_mass): assert_allclose(actual_scale, expected_scale, atol=1e-6, rtol=0.05) -@pytest.mark.parametrize('shape', [(4,), (3, 2)]) -@pytest.mark.parametrize('idx', [0, 1, 2]) +@pytest.mark.parametrize("shape", [(4,), (3, 2)]) +@pytest.mark.parametrize("idx", [0, 1, 2]) def test_numpy_delete(shape, idx): x = random.normal(random.PRNGKey(0), shape) expected = np.delete(x, idx, axis=0) @@ -708,7 +870,7 @@ def test_numpy_delete(shape, idx): assert_allclose(actual, expected) -@pytest.mark.parametrize('batch_shape', [(), (4,)]) +@pytest.mark.parametrize("batch_shape", [(), (4,)]) def test_trivial_dirichlet(batch_shape): def model(): x = numpyro.sample("x", dist.Dirichlet(jnp.ones(1)).expand(batch_shape)) @@ -718,14 +880,16 @@ def model(): mcmc = MCMC(NUTS(model), 10, num_samples) mcmc.run(random.PRNGKey(0)) # because event_shape of x is (1,), x should only take value 1 - assert_allclose(mcmc.get_samples()["x"], jnp.ones((num_samples,) + batch_shape + (1,))) + assert_allclose( + mcmc.get_samples()["x"], jnp.ones((num_samples,) + batch_shape + (1,)) + ) def test_forward_mode_differentiation(): def model(): x = numpyro.sample("x", dist.Normal(0, 1)) y = lax.while_loop(lambda x: x < 10, lambda x: x + 1, x) - numpyro.sample("obs", dist.Normal(y, 1), obs=1.) + numpyro.sample("obs", dist.Normal(y, 1), obs=1.0) # this fails in reverse mode mcmc = MCMC(NUTS(model, forward_mode_differentiation=True), 10, 10) @@ -734,11 +898,13 @@ def model(): def test_model_with_lift_handler(): def model(data): - c = numpyro.param("c", jnp.array(1.), constraint=dist.constraints.positive) - x = numpyro.sample("x", dist.LogNormal(c, 1.), obs=data) + c = numpyro.param("c", jnp.array(1.0), constraint=dist.constraints.positive) + x = numpyro.sample("x", dist.LogNormal(c, 1.0), obs=data) return x - nuts_kernel = NUTS(numpyro.handlers.lift(model, prior={"c": dist.Gamma(0.01, 0.01)})) + nuts_kernel = NUTS( + numpyro.handlers.lift(model, prior={"c": dist.Gamma(0.01, 0.01)}) + ) mcmc = MCMC(nuts_kernel, num_warmup=10, num_samples=10) mcmc.run(random.PRNGKey(1), jnp.exp(random.normal(random.PRNGKey(0), (1000,)))) @@ -753,7 +919,7 @@ def model(cov): numpyro.sample("obs", dist.MultivariateNormal(jnp.zeros(5), cov), obs=wxyz) w_cov = np.array([[1.5, 0.5], [0.5, 1.5]]) - xy_cov = np.array([[2., 1.], [1., 3.]]) + xy_cov = np.array([[2.0, 1.0], [1.0, 3.0]]) z_var = np.array([2.5]) cov = np.zeros((5, 5)) cov[:2, :2] = w_cov @@ -773,18 +939,26 @@ def model(cov): mcmc.run(random.PRNGKey(1), cov) inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix assert_allclose(inverse_mass_matrix[("w",)], w_cov, atol=0.5, rtol=0.5) - assert_allclose(inverse_mass_matrix[("y", "x")], xy_cov[::-1, ::-1], atol=0.5, rtol=0.5) + assert_allclose( + inverse_mass_matrix[("y", "x")], xy_cov[::-1, ::-1], atol=0.5, rtol=0.5 + ) assert_allclose(inverse_mass_matrix[("z",)], z_var, atol=0.5, rtol=0.5) -@pytest.mark.parametrize("dense_mass, expected_shapes", [ - (False, {("w", "x", "y", "z"): (16,)}), - (True, {("w", "x", "y", "z"): (16, 16)}), - ([("y", "w", "z", "x")], {("y", "w", "z", "x"): (16, 16)}), - ([("x", "w"), ("y",)], {("x", "w"): (11, 11), ("y",): (4, 4), ("z",): (1,)}), - ([("y",)], {("w", "x", "z"): (12,), ("y",): (4, 4)}), - ([("z",), ("w",), ("y",)], {("w",): (10, 10), ("x",): (1,), ("y",): (4, 4), ("z",): (1, 1)}), -]) +@pytest.mark.parametrize( + "dense_mass, expected_shapes", + [ + (False, {("w", "x", "y", "z"): (16,)}), + (True, {("w", "x", "y", "z"): (16, 16)}), + ([("y", "w", "z", "x")], {("y", "w", "z", "x"): (16, 16)}), + ([("x", "w"), ("y",)], {("x", "w"): (11, 11), ("y",): (4, 4), ("z",): (1,)}), + ([("y",)], {("w", "x", "z"): (12,), ("y",): (4, 4)}), + ( + [("z",), ("w",), ("y",)], + {("w",): (10, 10), ("x",): (1,), ("y",): (4, 4), ("z",): (1, 1)}, + ), + ], +) def test_structured_mass_smoke(dense_mass, expected_shapes): def model(): numpyro.sample("x", dist.Normal(0, 1)) @@ -806,9 +980,13 @@ def model(): numpyro.sample("x", dist.Normal(0, 1).expand([3])) numpyro.sample("z", dist.Normal(0, 1).expand([2])) - expected_mm = jnp.arange(1, 4.) - kernel = NUTS(model, dense_mass=dense_mass, - inverse_mass_matrix={("x",): expected_mm}, adapt_mass_matrix=False) + expected_mm = jnp.arange(1, 4.0) + kernel = NUTS( + model, + dense_mass=dense_mass, + inverse_mass_matrix={("x",): expected_mm}, + adapt_mass_matrix=False, + ) mcmc = MCMC(kernel, 1, 1) mcmc.run(random.PRNGKey(0)) inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix @@ -824,9 +1002,13 @@ def model(): numpyro.sample("z", dist.Normal(0, 1).expand([2])) numpyro.sample("x", dist.Normal(0, 1).expand([3])) - expected_mm = jnp.arange(1, 6.) - kernel = NUTS(model, dense_mass=dense_mass, - inverse_mass_matrix=expected_mm, adapt_mass_matrix=False) + expected_mm = jnp.arange(1, 6.0) + kernel = NUTS( + model, + dense_mass=dense_mass, + inverse_mass_matrix=expected_mm, + adapt_mass_matrix=False, + ) mcmc = MCMC(kernel, 1, 1) mcmc.run(random.PRNGKey(0)) inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index 928d221fa..e025885cc 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -14,7 +14,12 @@ import numpyro.handlers as handlers from numpyro.infer import MCMC, NUTS, SVI, Trace_ELBO from numpyro.infer.autoguide import AutoIAFNormal -from numpyro.infer.reparam import LocScaleReparam, NeuTraReparam, ProjectedNormalReparam, TransformReparam +from numpyro.infer.reparam import ( + LocScaleReparam, + NeuTraReparam, + ProjectedNormalReparam, + TransformReparam, +) from numpyro.infer.util import initialize_model from numpyro.optim import Adam @@ -32,12 +37,11 @@ def get_moments(x): return jnp.stack([m1, m2, m3, m4]) -@pytest.mark.parametrize("batch_shape,base_batch_shape", [ - ((), ()), - ((4,), (4,)), - ((2, 3), (2, 3)), - ((2, 3), ()), -], ids=str) +@pytest.mark.parametrize( + "batch_shape,base_batch_shape", + [((), ()), ((4,), (4,)), ((2, 3), (2, 3)), ((2, 3), ())], + ids=str, +) @pytest.mark.parametrize("event_shape", [(), (5,)], ids=str) def test_log_normal(batch_shape, base_batch_shape, event_shape): shape = batch_shape + event_shape @@ -48,7 +52,8 @@ def test_log_normal(batch_shape, base_batch_shape, event_shape): def model(): fn = dist.TransformedDistribution( dist.Normal(jnp.zeros_like(loc), jnp.ones_like(scale)), - [AffineTransform(loc, scale), ExpTransform()]).expand(shape) + [AffineTransform(loc, scale), ExpTransform()], + ).expand(shape) if event_shape: fn = fn.to_event(len(event_shape)).expand_by([100000]) with numpyro.plate_stack("plates", batch_shape): @@ -68,16 +73,16 @@ def model(): def neals_funnel(dim): - y = numpyro.sample('y', dist.Normal(0, 3)) - with numpyro.plate('D', dim): - numpyro.sample('x', dist.Normal(0, jnp.exp(y / 2))) + y = numpyro.sample("y", dist.Normal(0, 3)) + with numpyro.plate("D", dim): + numpyro.sample("x", dist.Normal(0, jnp.exp(y / 2))) def dirichlet_categorical(data): concentration = jnp.array([1.0, 1.0, 1.0]) - p_latent = numpyro.sample('p', dist.Dirichlet(concentration)) - with numpyro.plate('N', data.shape[0]): - numpyro.sample('obs', dist.Categorical(p_latent), obs=data) + p_latent = numpyro.sample("p", dist.Dirichlet(concentration)) + with numpyro.plate("N", data.shape[0]): + numpyro.sample("obs", dist.Categorical(p_latent), obs=data) return p_latent @@ -101,15 +106,18 @@ def body_fn(i, val): mcmc = MCMC(nuts, num_warmup=50, num_samples=50) mcmc.run(random.PRNGKey(1), dim) samples = mcmc.get_samples() - transformed_samples = neutra.transform_sample(samples['auto_shared_latent']) - assert 'x' in transformed_samples - assert 'y' in transformed_samples - - -@pytest.mark.parametrize('model, kwargs', [ - (neals_funnel, {'dim': 10}), - (dirichlet_categorical, {'data': jnp.ones(10, dtype=jnp.int32)}) -]) + transformed_samples = neutra.transform_sample(samples["auto_shared_latent"]) + assert "x" in transformed_samples + assert "y" in transformed_samples + + +@pytest.mark.parametrize( + "model, kwargs", + [ + (neals_funnel, {"dim": 10}), + (dirichlet_categorical, {"data": jnp.ones(10, dtype=jnp.int32)}), + ], +) def test_reparam_log_joint(model, kwargs): guide = AutoIAFNormal(model) svi = SVI(model, guide, Adam(1e-10), Trace_ELBO(), **kwargs) @@ -118,7 +126,9 @@ def test_reparam_log_joint(model, kwargs): neutra = NeuTraReparam(guide, params) reparam_model = neutra.reparam(model) _, pe_fn, _, _ = initialize_model(random.PRNGKey(1), model, model_kwargs=kwargs) - init_params, pe_fn_neutra, _, _ = initialize_model(random.PRNGKey(2), reparam_model, model_kwargs=kwargs) + init_params, pe_fn_neutra, _, _ = initialize_model( + random.PRNGKey(2), reparam_model, model_kwargs=kwargs + ) latent_x = list(init_params[0].values())[0] pe_transformed = pe_fn_neutra(init_params[0]) latent_y = neutra.transform(latent_x) @@ -128,21 +138,23 @@ def test_reparam_log_joint(model, kwargs): @pytest.mark.parametrize("shape", [(), (4,), (3, 2)], ids=str) -@pytest.mark.parametrize("centered", [0., 0.6, 1., None]) +@pytest.mark.parametrize("centered", [0.0, 0.6, 1.0, None]) @pytest.mark.parametrize("dist_type", ["Normal", "StudentT"]) @pytest.mark.parametrize("event_dim", [0, 1]) def test_loc_scale(dist_type, centered, shape, event_dim): - loc = np.random.uniform(-1., 1., shape) + loc = np.random.uniform(-1.0, 1.0, shape) scale = np.random.uniform(0.5, 1.5, shape) event_dim = min(event_dim, len(shape)) def model(loc, scale): - with numpyro.plate_stack("plates", shape[:len(shape) - event_dim]): + with numpyro.plate_stack("plates", shape[: len(shape) - event_dim]): with numpyro.plate("particles", 10000): if "dist_type" == "Normal": numpyro.sample("x", dist.Normal(loc, scale).to_event(event_dim)) else: - numpyro.sample("x", dist.StudentT(10.0, loc, scale).to_event(event_dim)) + numpyro.sample( + "x", dist.StudentT(10.0, loc, scale).to_event(event_dim) + ) def get_expected_probe(loc, scale): with numpyro.handlers.trace() as trace: @@ -175,7 +187,6 @@ def get_actual_probe(loc, scale): @pytest.mark.parametrize("shape", [(), (4,), (3, 2)], ids=str) @pytest.mark.parametrize("dim", [2, 3, 4]) def test_projected_normal(shape, dim): - def model(concentration): with numpyro.plate_stack("plates", shape): with numpyro.plate("particles", 10000): diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index 2989e7a9f..efd484012 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -18,7 +18,7 @@ from numpyro.util import fori_loop -@pytest.mark.parametrize('alpha', [0., 2.]) +@pytest.mark.parametrize("alpha", [0.0, 2.0]) def test_renyi_elbo(alpha): def model(x): numpyro.sample("obs", dist.Normal(0, 1), obs=x) @@ -30,36 +30,33 @@ def elbo_loss_fn(x): return Trace_ELBO().loss(random.PRNGKey(0), {}, model, guide, x) def renyi_loss_fn(x): - return RenyiELBO(alpha=alpha, num_particles=10).loss(random.PRNGKey(0), {}, model, guide, x) + return RenyiELBO(alpha=alpha, num_particles=10).loss( + random.PRNGKey(0), {}, model, guide, x + ) - elbo_loss, elbo_grad = value_and_grad(elbo_loss_fn)(2.) - renyi_loss, renyi_grad = value_and_grad(renyi_loss_fn)(2.) + elbo_loss, elbo_grad = value_and_grad(elbo_loss_fn)(2.0) + renyi_loss, renyi_grad = value_and_grad(renyi_loss_fn)(2.0) assert_allclose(elbo_loss, renyi_loss, rtol=1e-6) assert_allclose(elbo_grad, renyi_grad, rtol=1e-6) -@pytest.mark.parametrize('elbo', [ - Trace_ELBO(), - RenyiELBO(num_particles=10), -]) +@pytest.mark.parametrize("elbo", [Trace_ELBO(), RenyiELBO(num_particles=10)]) def test_beta_bernoulli(elbo): data = jnp.array([1.0] * 8 + [0.0] * 2) def model(data): - f = numpyro.sample("beta", dist.Beta(1., 1.)) + f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): - alpha_q = numpyro.param("alpha_q", 1.0, - constraint=constraints.positive) - beta_q = numpyro.param("beta_q", 1.0, - constraint=constraints.positive) + alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) + beta_q = numpyro.param("beta_q", 1.0, constraint=constraints.positive) numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) adam = optim.Adam(0.05) svi = SVI(model, guide, adam, elbo) svi_state = svi.init(random.PRNGKey(1), data) - assert_allclose(adam.get_params(svi_state.optim_state)['alpha_q'], 0.) + assert_allclose(adam.get_params(svi_state.optim_state)["alpha_q"], 0.0) def body_fn(i, val): svi_state, _ = svi.update(val, data) @@ -67,42 +64,54 @@ def body_fn(i, val): svi_state = fori_loop(0, 2000, body_fn, svi_state) params = svi.get_params(svi_state) - assert_allclose(params['alpha_q'] / (params['alpha_q'] + params['beta_q']), 0.8, atol=0.05, rtol=0.05) + assert_allclose( + params["alpha_q"] / (params["alpha_q"] + params["beta_q"]), + 0.8, + atol=0.05, + rtol=0.05, + ) -@pytest.mark.parametrize('progress_bar', [True, False]) +@pytest.mark.parametrize("progress_bar", [True, False]) def test_run(progress_bar): data = jnp.array([1.0] * 8 + [0.0] * 2) def model(data): - f = numpyro.sample("beta", dist.Beta(1., 1.)) + f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): - alpha_q = numpyro.param("alpha_q", lambda key: random.normal(key), - constraint=constraints.positive) - beta_q = numpyro.param("beta_q", lambda key: random.exponential(key), - constraint=constraints.positive) + alpha_q = numpyro.param( + "alpha_q", lambda key: random.normal(key), constraint=constraints.positive + ) + beta_q = numpyro.param( + "beta_q", + lambda key: random.exponential(key), + constraint=constraints.positive, + ) numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) svi = SVI(model, guide, optim.Adam(0.05), Trace_ELBO()) params, losses = svi.run(random.PRNGKey(1), 1000, data, progress_bar=progress_bar) assert losses.shape == (1000,) - assert_allclose(params['alpha_q'] / (params['alpha_q'] + params['beta_q']), 0.8, atol=0.05, rtol=0.05) + assert_allclose( + params["alpha_q"] / (params["alpha_q"] + params["beta_q"]), + 0.8, + atol=0.05, + rtol=0.05, + ) def test_jitted_update_fn(): data = jnp.array([1.0] * 8 + [0.0] * 2) def model(data): - f = numpyro.sample("beta", dist.Beta(1., 1.)) + f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): - alpha_q = numpyro.param("alpha_q", 1.0, - constraint=constraints.positive) - beta_q = numpyro.param("beta_q", 1.0, - constraint=constraints.positive) + alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) + beta_q = numpyro.param("beta_q", 1.0, constraint=constraints.positive) numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) adam = optim.Adam(0.05) @@ -128,46 +137,52 @@ def test_param(): obs = random.normal(rng_keys[4]) def model(): - a = numpyro.param('a', a_init, constraint=constraints.greater_than(a_minval)) - b = numpyro.param('b', b_init, constraint=constraints.positive) - numpyro.sample('x', dist.Normal(a, b), obs=obs) + a = numpyro.param("a", a_init, constraint=constraints.greater_than(a_minval)) + b = numpyro.param("b", b_init, constraint=constraints.positive) + numpyro.sample("x", dist.Normal(a, b), obs=obs) def guide(): - c = numpyro.param('c', c_init, constraint=constraints.interval(c_minval, c_maxval)) - d = numpyro.param('d', d_init, constraint=constraints.unit_interval) - numpyro.sample('y', dist.Normal(c, d), obs=obs) + c = numpyro.param( + "c", c_init, constraint=constraints.interval(c_minval, c_maxval) + ) + d = numpyro.param("d", d_init, constraint=constraints.unit_interval) + numpyro.sample("y", dist.Normal(c, d), obs=obs) adam = optim.Adam(0.01) svi = SVI(model, guide, adam, Trace_ELBO()) svi_state = svi.init(random.PRNGKey(0)) params = svi.get_params(svi_state) - assert_allclose(params['a'], a_init) - assert_allclose(params['b'], b_init) - assert_allclose(params['c'], c_init) - assert_allclose(params['d'], d_init) + assert_allclose(params["a"], a_init) + assert_allclose(params["b"], b_init) + assert_allclose(params["c"], c_init) + assert_allclose(params["d"], d_init) actual_loss = svi.evaluate(svi_state) assert jnp.isfinite(actual_loss) - expected_loss = dist.Normal(c_init, d_init).log_prob(obs) - dist.Normal(a_init, b_init).log_prob(obs) + expected_loss = dist.Normal(c_init, d_init).log_prob(obs) - dist.Normal( + a_init, b_init + ).log_prob(obs) # not so precisely because we do transform / inverse transform stuffs assert_allclose(actual_loss, expected_loss, rtol=1e-6) def test_elbo_dynamic_support(): x_prior = dist.TransformedDistribution( - dist.Normal(), [AffineTransform(0, 2), SigmoidTransform(), AffineTransform(0, 3)]) + dist.Normal(), + [AffineTransform(0, 2), SigmoidTransform(), AffineTransform(0, 3)], + ) x_guide = dist.Uniform(0, 3) def model(): - numpyro.sample('x', x_prior) + numpyro.sample("x", x_prior) def guide(): - numpyro.sample('x', x_guide) + numpyro.sample("x", x_guide) adam = optim.Adam(0.01) - x = 2. - guide = substitute(guide, data={'x': x}) + x = 2.0 + guide = substitute(guide, data={"x": x}) svi = SVI(model, guide, adam, Trace_ELBO()) svi_state = svi.init(random.PRNGKey(0)) actual_loss = svi.evaluate(svi_state) @@ -190,13 +205,12 @@ def guide(): @pytest.mark.parametrize("stable_run", [True, False]) def test_stable_run(stable_run): - def model(): var = numpyro.sample("var", dist.Exponential(1)) - numpyro.sample("obs", dist.Normal(0, jnp.sqrt(var)), obs=0.) + numpyro.sample("obs", dist.Normal(0, jnp.sqrt(var)), obs=0.0) def guide(): - loc = numpyro.param("loc", 0.) + loc = numpyro.param("loc", 0.0) numpyro.sample("var", dist.Normal(loc, 10)) svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) diff --git a/test/pyroapi/test_pyroapi.py b/test/pyroapi/test_pyroapi.py index d76c9d737..d8e89e764 100644 --- a/test/pyroapi/test_pyroapi.py +++ b/test/pyroapi/test_pyroapi.py @@ -5,10 +5,12 @@ from pyroapi.tests import * # noqa F401 import pytest -pytestmark = pytest.mark.filterwarnings("ignore::numpyro.compat.util.UnsupportedAPIWarning") +pytestmark = pytest.mark.filterwarnings( + "ignore::numpyro.compat.util.UnsupportedAPIWarning" +) @pytest.fixture def backend(): - with pyro_backend('numpy'): + with pyro_backend("numpy"): yield diff --git a/test/test_compile.py b/test/test_compile.py index b6d207294..bc606c34a 100644 --- a/test/test_compile.py +++ b/test/test_compile.py @@ -22,11 +22,13 @@ def model(deterministic=True): numpyro.deterministic("x_copy", x) -@pytest.mark.parametrize('deterministic', [True, False]) -@pytest.mark.parametrize('find_heuristic_step_size', [True, False]) +@pytest.mark.parametrize("deterministic", [True, False]) +@pytest.mark.parametrize("find_heuristic_step_size", [True, False]) def test_mcmc_one_chain(deterministic, find_heuristic_step_size): GLOBAL["count"] = 0 - mcmc = MCMC(NUTS(model, find_heuristic_step_size=find_heuristic_step_size), 100, 100) + mcmc = MCMC( + NUTS(model, find_heuristic_step_size=find_heuristic_step_size), 100, 100 + ) mcmc.run(random.PRNGKey(0), deterministic=deterministic) mcmc.get_samples() @@ -37,8 +39,10 @@ def test_mcmc_one_chain(deterministic, find_heuristic_step_size): assert GLOBAL["count"] == 3 + num_traces_for_heuristic -@pytest.mark.parametrize('deterministic', [True, False]) -@pytest.mark.skipif(xla_bridge.device_count() < 2, reason="only one device is available") +@pytest.mark.parametrize("deterministic", [True, False]) +@pytest.mark.skipif( + xla_bridge.device_count() < 2, reason="only one device is available" +) def test_mcmc_parallel_chain(deterministic): GLOBAL["count"] = 0 mcmc = MCMC(NUTS(model), 100, 100, num_chains=2) @@ -51,7 +55,7 @@ def test_mcmc_parallel_chain(deterministic): assert GLOBAL["count"] == 3 -@pytest.mark.parametrize('deterministic', [True, False]) +@pytest.mark.parametrize("deterministic", [True, False]) def test_autoguide(deterministic): GLOBAL["count"] = 0 guide = AutoDiagonalNormal(model) diff --git a/test/test_diagnostics.py b/test/test_diagnostics.py index b2068ee8e..d0a32df87 100644 --- a/test/test_diagnostics.py +++ b/test/test_diagnostics.py @@ -13,24 +13,27 @@ effective_sample_size, gelman_rubin, hpdi, - split_gelman_rubin + split_gelman_rubin, ) -@pytest.mark.parametrize('statistics, input_shape, output_shape', [ - (autocorrelation, (10,), (10,)), - (autocorrelation, (10, 3), (10, 3)), - (autocovariance, (10,), (10,)), - (autocovariance, (10, 3), (10, 3)), - (hpdi, (10,), (2,)), - (hpdi, (10, 3), (2, 3)), - (gelman_rubin, (4, 10), ()), - (gelman_rubin, (4, 10, 3), (3,)), - (split_gelman_rubin, (4, 10), ()), - (split_gelman_rubin, (4, 10, 3), (3,)), - (effective_sample_size, (4, 10), ()), - (effective_sample_size, (4, 10, 3), (3,)), -]) +@pytest.mark.parametrize( + "statistics, input_shape, output_shape", + [ + (autocorrelation, (10,), (10,)), + (autocorrelation, (10, 3), (10, 3)), + (autocovariance, (10,), (10,)), + (autocovariance, (10, 3), (10, 3)), + (hpdi, (10,), (2,)), + (hpdi, (10, 3), (2, 3)), + (gelman_rubin, (4, 10), ()), + (gelman_rubin, (4, 10, 3), (3,)), + (split_gelman_rubin, (4, 10), ()), + (split_gelman_rubin, (4, 10, 3), (3,)), + (effective_sample_size, (4, 10), ()), + (effective_sample_size, (4, 10, 3), (3,)), + ], +) def test_shape(statistics, input_shape, output_shape): x = np.random.normal(size=input_shape) y = statistics(x) @@ -42,7 +45,7 @@ def test_shape(statistics, input_shape, output_shape): assert_allclose(statistics(x[..., i]), y[..., i]) -@pytest.mark.parametrize('target', [433, 124, 25, 300, 1, 3, 7]) +@pytest.mark.parametrize("target", [433, 124, 25, 300, 1, 3, 7]) def test_fft_next_fast_len(target): assert _fft_next_fast_len(target) == next_fast_len(target) @@ -52,28 +55,30 @@ def test_hpdi(): assert_allclose(hpdi(x, prob=0.8), np.quantile(x, [0.1, 0.9]), atol=0.01) x = np.random.exponential(size=20000) - assert_allclose(hpdi(x, prob=0.2), np.array([0., 0.22]), atol=0.01) + assert_allclose(hpdi(x, prob=0.2), np.array([0.0, 0.22]), atol=0.01) def test_autocorrelation(): - x = np.arange(10.) + x = np.arange(10.0) actual = autocorrelation(x) expected = np.array([1, 0.78, 0.52, 0.21, -0.13, -0.52, -0.94, -1.4, -1.91, -2.45]) assert_allclose(actual, expected, atol=0.01) def test_autocovariance(): - x = np.arange(10.) + x = np.arange(10.0) actual = autocovariance(x) - expected = np.array([8.25, 6.42, 4.25, 1.75, -1.08, -4.25, -7.75, -11.58, -15.75, -20.25]) + expected = np.array( + [8.25, 6.42, 4.25, 1.75, -1.08, -4.25, -7.75, -11.58, -15.75, -20.25] + ) assert_allclose(actual, expected, atol=0.01) def test_gelman_rubin(): # only need to test precision for small data x = np.empty((2, 10)) - x[0, :] = np.arange(10.) - x[1, :] = np.arange(10.) + 1 + x[0, :] = np.arange(10.0) + x[1, :] = np.arange(10.0) + 1 r_hat = gelman_rubin(x) assert_allclose(r_hat, 0.98, atol=0.01) @@ -87,5 +92,5 @@ def test_split_gelman_rubin_agree_with_gelman_rubin(): def test_effective_sample_size(): - x = np.arange(1000.).reshape(100, 10) + x = np.arange(1000.0).reshape(100, 10) assert_allclose(effective_sample_size(x), 52.64, atol=0.01) diff --git a/test/test_distributions.py b/test/test_distributions.py index 720c84bb8..ea88e16fa 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -27,24 +27,25 @@ PermuteTransform, PowerTransform, SoftplusTransform, - biject_to + biject_to, ) from numpyro.distributions.util import ( matrix_to_tril_vec, multinomial, signed_stick_breaking_tril, sum_rightmost, - vec_to_tril_matrix + vec_to_tril_matrix, ) from numpyro.nn import AutoregressiveNN TEST_FAILURE_RATE = 2e-5 # For all goodness-of-fit tests. -def _identity(x): return x +def _identity(x): + return x -class T(namedtuple('TestCase', ['jax_dist', 'sp_dist', 'params'])): +class T(namedtuple("TestCase", ["jax_dist", "sp_dist", "params"])): def __new__(cls, jax_dist, *params): sp_dist = None if jax_dist in _DIST_MAP: @@ -93,9 +94,7 @@ def sample(self, key, sample_shape=()): prototype_value = jnp.zeros(self.event_shape) unconstrained_event_shape = jnp.shape(transform.inv(prototype_value)) shape = sample_shape + self.batch_shape + unconstrained_event_shape - unconstrained_samples = random.uniform(key, shape, - minval=-2, - maxval=2) + unconstrained_samples = random.uniform(key, shape, minval=-2, maxval=2) return transform(unconstrained_samples) @@ -104,23 +103,30 @@ def sample(self, key, sample_shape=()): dist.BernoulliLogits: lambda logits: osp.bernoulli(p=_to_probs_bernoulli(logits)), dist.Beta: lambda con1, con0: osp.beta(con1, con0), dist.BinomialProbs: lambda probs, total_count: osp.binom(n=total_count, p=probs), - dist.BinomialLogits: lambda logits, total_count: osp.binom(n=total_count, p=_to_probs_bernoulli(logits)), + dist.BinomialLogits: lambda logits, total_count: osp.binom( + n=total_count, p=_to_probs_bernoulli(logits) + ), dist.Cauchy: lambda loc, scale: osp.cauchy(loc=loc, scale=scale), dist.Chi2: lambda df: osp.chi2(df), dist.Dirichlet: lambda conc: osp.dirichlet(conc), dist.Exponential: lambda rate: osp.expon(scale=jnp.reciprocal(rate)), - dist.Gamma: lambda conc, rate: osp.gamma(conc, scale=1. / rate), + dist.Gamma: lambda conc, rate: osp.gamma(conc, scale=1.0 / rate), dist.GeometricProbs: lambda probs: osp.geom(p=probs, loc=-1), - dist.GeometricLogits: lambda logits: osp.geom(p=_to_probs_bernoulli(logits), loc=-1), + dist.GeometricLogits: lambda logits: osp.geom( + p=_to_probs_bernoulli(logits), loc=-1 + ), dist.Gumbel: lambda loc, scale: osp.gumbel_r(loc=loc, scale=scale), dist.HalfCauchy: lambda scale: osp.halfcauchy(scale=scale), dist.HalfNormal: lambda scale: osp.halfnorm(scale=scale), dist.InverseGamma: lambda conc, rate: osp.invgamma(conc, scale=rate), dist.Laplace: lambda loc, scale: osp.laplace(loc=loc, scale=scale), dist.LogNormal: lambda loc, scale: osp.lognorm(s=scale, scale=jnp.exp(loc)), - dist.MultinomialProbs: lambda probs, total_count: osp.multinomial(n=total_count, p=probs), - dist.MultinomialLogits: lambda logits, total_count: osp.multinomial(n=total_count, - p=_to_probs_multinom(logits)), + dist.MultinomialProbs: lambda probs, total_count: osp.multinomial( + n=total_count, p=probs + ), + dist.MultinomialLogits: lambda logits, total_count: osp.multinomial( + n=total_count, p=_to_probs_multinom(logits) + ), dist.MultivariateNormal: _mvn_to_scipy, dist.LowRankMultivariateNormal: _lowrank_mvn_to_scipy, dist.Normal: lambda loc, scale: osp.norm(loc=loc, scale=scale), @@ -129,138 +135,202 @@ def sample(self, key, sample_shape=()): dist.StudentT: lambda df, loc, scale: osp.t(df=df, loc=loc, scale=scale), dist.Uniform: lambda a, b: osp.uniform(a, b - a), dist.Logistic: lambda loc, scale: osp.logistic(loc=loc, scale=scale), - dist.VonMises: lambda loc, conc: osp.vonmises(loc=np.array(loc, dtype=np.float64), - kappa=np.array(conc, dtype=np.float64)), + dist.VonMises: lambda loc, conc: osp.vonmises( + loc=np.array(loc, dtype=np.float64), kappa=np.array(conc, dtype=np.float64) + ), _TruncatedNormal: _truncnorm_to_scipy, } CONTINUOUS = [ T(dist.Beta, 0.2, 1.1), - T(dist.Beta, 1., jnp.array([2., 2.])), - T(dist.Beta, 1., jnp.array([[1., 1.], [2., 2.]])), - T(dist.Chi2, 2.), + T(dist.Beta, 1.0, jnp.array([2.0, 2.0])), + T(dist.Beta, 1.0, jnp.array([[1.0, 1.0], [2.0, 2.0]])), + T(dist.Chi2, 2.0), T(dist.Chi2, jnp.array([0.3, 1.3])), - T(dist.Cauchy, 0., 1.), - T(dist.Cauchy, 0., jnp.array([1., 2.])), - T(dist.Cauchy, jnp.array([0., 1.]), jnp.array([[1.], [2.]])), + T(dist.Cauchy, 0.0, 1.0), + T(dist.Cauchy, 0.0, jnp.array([1.0, 2.0])), + T(dist.Cauchy, jnp.array([0.0, 1.0]), jnp.array([[1.0], [2.0]])), T(dist.Dirichlet, jnp.array([1.7])), T(dist.Dirichlet, jnp.array([0.2, 1.1])), - T(dist.Dirichlet, jnp.array([[0.2, 1.1], [2., 2.]])), - T(dist.Exponential, 2.), - T(dist.Exponential, jnp.array([4., 2.])), - T(dist.Gamma, jnp.array([1.7]), jnp.array([[2.], [3.]])), - T(dist.Gamma, jnp.array([0.5, 1.3]), jnp.array([[1.], [3.]])), + T(dist.Dirichlet, jnp.array([[0.2, 1.1], [2.0, 2.0]])), + T(dist.Exponential, 2.0), + T(dist.Exponential, jnp.array([4.0, 2.0])), + T(dist.Gamma, jnp.array([1.7]), jnp.array([[2.0], [3.0]])), + T(dist.Gamma, jnp.array([0.5, 1.3]), jnp.array([[1.0], [3.0]])), T(dist.GaussianRandomWalk, 0.1, 10), T(dist.GaussianRandomWalk, jnp.array([0.1, 0.3, 0.25]), 10), - T(dist.Gumbel, 0., 1.), - T(dist.Gumbel, 0.5, 2.), - T(dist.Gumbel, jnp.array([0., 0.5]), jnp.array([1., 2.])), - T(dist.HalfCauchy, 1.), - T(dist.HalfCauchy, jnp.array([1., 2.])), - T(dist.HalfNormal, 1.), - T(dist.HalfNormal, jnp.array([1., 2.])), + T(dist.Gumbel, 0.0, 1.0), + T(dist.Gumbel, 0.5, 2.0), + T(dist.Gumbel, jnp.array([0.0, 0.5]), jnp.array([1.0, 2.0])), + T(dist.HalfCauchy, 1.0), + T(dist.HalfCauchy, jnp.array([1.0, 2.0])), + T(dist.HalfNormal, 1.0), + T(dist.HalfNormal, jnp.array([1.0, 2.0])), T(_ImproperWrapper, constraints.positive, (), (3,)), - T(dist.InverseGamma, jnp.array([1.7]), jnp.array([[2.], [3.]])), - T(dist.InverseGamma, jnp.array([0.5, 1.3]), jnp.array([[1.], [3.]])), - T(dist.Laplace, 0., 1.), - T(dist.Laplace, 0.5, jnp.array([1., 2.5])), - T(dist.Laplace, jnp.array([1., -0.5]), jnp.array([2.3, 3.])), + T(dist.InverseGamma, jnp.array([1.7]), jnp.array([[2.0], [3.0]])), + T(dist.InverseGamma, jnp.array([0.5, 1.3]), jnp.array([[1.0], [3.0]])), + T(dist.Laplace, 0.0, 1.0), + T(dist.Laplace, 0.5, jnp.array([1.0, 2.5])), + T(dist.Laplace, jnp.array([1.0, -0.5]), jnp.array([2.3, 3.0])), T(dist.LKJ, 2, 0.5, "onion"), - T(dist.LKJ, 5, jnp.array([0.5, 1., 2.]), "cvine"), + T(dist.LKJ, 5, jnp.array([0.5, 1.0, 2.0]), "cvine"), T(dist.LKJCholesky, 2, 0.5, "onion"), T(dist.LKJCholesky, 2, 0.5, "cvine"), - T(dist.LKJCholesky, 5, jnp.array([0.5, 1., 2.]), "onion"), - pytest.param(*T(dist.LKJCholesky, 5, jnp.array([0.5, 1., 2.]), "cvine"), - marks=pytest.mark.skipif('CI' in os.environ, reason="reduce time for Travis")), - pytest.param(*T(dist.LKJCholesky, 3, jnp.array([[3., 0.6], [0.2, 5.]]), "onion"), - marks=pytest.mark.skipif('CI' in os.environ, reason="reduce time for Travis")), - T(dist.LKJCholesky, 3, jnp.array([[3., 0.6], [0.2, 5.]]), "cvine"), - T(dist.Logistic, 0., 1.), - T(dist.Logistic, 1., jnp.array([1., 2.])), - T(dist.Logistic, jnp.array([0., 1.]), jnp.array([[1.], [2.]])), - T(dist.LogNormal, 1., 0.2), - T(dist.LogNormal, -1., jnp.array([0.5, 1.3])), + T(dist.LKJCholesky, 5, jnp.array([0.5, 1.0, 2.0]), "onion"), + pytest.param( + *T(dist.LKJCholesky, 5, jnp.array([0.5, 1.0, 2.0]), "cvine"), + marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for Travis"), + ), + pytest.param( + *T(dist.LKJCholesky, 3, jnp.array([[3.0, 0.6], [0.2, 5.0]]), "onion"), + marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for Travis"), + ), + T(dist.LKJCholesky, 3, jnp.array([[3.0, 0.6], [0.2, 5.0]]), "cvine"), + T(dist.Logistic, 0.0, 1.0), + T(dist.Logistic, 1.0, jnp.array([1.0, 2.0])), + T(dist.Logistic, jnp.array([0.0, 1.0]), jnp.array([[1.0], [2.0]])), + T(dist.LogNormal, 1.0, 0.2), + T(dist.LogNormal, -1.0, jnp.array([0.5, 1.3])), T(dist.LogNormal, jnp.array([0.5, -0.7]), jnp.array([[0.1, 0.4], [0.5, 0.1]])), - T(dist.MultivariateNormal, 0., jnp.array([[1., 0.5], [0.5, 1.]]), None, None), - T(dist.MultivariateNormal, jnp.array([1., 3.]), None, jnp.array([[1., 0.5], [0.5, 1.]]), None), - T(dist.MultivariateNormal, jnp.array([1., 3.]), None, jnp.array([[[1., 0.5], [0.5, 1.]]]), None), - T(dist.MultivariateNormal, jnp.array([2.]), None, None, jnp.array([[1., 0.], [0.5, 1.]])), - T(dist.MultivariateNormal, jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), None, None, - jnp.array([[1., 0.], [0., 1.]])), - T(dist.MultivariateNormal, 0., None, jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), None), - T(dist.LowRankMultivariateNormal, jnp.zeros(2), jnp.array([[1.], [0.]]), jnp.array([1., 1.])), - T(dist.LowRankMultivariateNormal, jnp.arange(6, dtype=jnp.float32).reshape((2, 3)), - jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), jnp.array([1., 2., 3.])), - T(dist.Normal, 0., 1.), - T(dist.Normal, 1., jnp.array([1., 2.])), - T(dist.Normal, jnp.array([0., 1.]), jnp.array([[1.], [2.]])), - T(dist.Pareto, 1., 2.), - T(dist.Pareto, jnp.array([1., 0.5]), jnp.array([0.3, 2.])), - T(dist.Pareto, jnp.array([[1.], [3.]]), jnp.array([1., 0.5])), - T(dist.StudentT, 1., 1., 0.5), - T(dist.StudentT, 2., jnp.array([1., 2.]), 2.), - T(dist.StudentT, jnp.array([3., 5.]), jnp.array([[1.], [2.]]), 2.), - T(dist.TruncatedCauchy, -1., 0., 1.), - T(dist.TruncatedCauchy, 1., 0., jnp.array([1., 2.])), - T(dist.TruncatedCauchy, jnp.array([-2., 2.]), jnp.array([0., 1.]), jnp.array([[1.], [2.]])), - T(dist.TruncatedNormal, -1., 0., 1.), - T(dist.TruncatedNormal, 1., -1., jnp.array([1., 2.])), - T(dist.TruncatedNormal, jnp.array([-2., 2.]), jnp.array([0., 1.]), jnp.array([[1.], [2.]])), - T(_TruncatedNormal, -1., 2., 1., 5.), - T(_TruncatedNormal, jnp.array([-1., 4.]), 2., None, 5.), - T(_TruncatedNormal, -1., jnp.array([2., 3.]), 1., None), - T(_TruncatedNormal, -1., 2., jnp.array([-6., 4.]), jnp.array([-4., 6.])), - T(_TruncatedNormal, jnp.array([0., 1.]), jnp.array([[1.], [2.]]), None, jnp.array([-2., 2.])), - T(dist.continuous.TwoSidedTruncatedDistribution, dist.Laplace(0., 1.), -2., 3.), - T(dist.Uniform, 0., 2.), - T(dist.Uniform, 1., jnp.array([2., 3.])), - T(dist.Uniform, jnp.array([0., 0.]), jnp.array([[2.], [3.]])), + T(dist.MultivariateNormal, 0.0, jnp.array([[1.0, 0.5], [0.5, 1.0]]), None, None), + T( + dist.MultivariateNormal, + jnp.array([1.0, 3.0]), + None, + jnp.array([[1.0, 0.5], [0.5, 1.0]]), + None, + ), + T( + dist.MultivariateNormal, + jnp.array([1.0, 3.0]), + None, + jnp.array([[[1.0, 0.5], [0.5, 1.0]]]), + None, + ), + T( + dist.MultivariateNormal, + jnp.array([2.0]), + None, + None, + jnp.array([[1.0, 0.0], [0.5, 1.0]]), + ), + T( + dist.MultivariateNormal, + jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), + None, + None, + jnp.array([[1.0, 0.0], [0.0, 1.0]]), + ), + T( + dist.MultivariateNormal, + 0.0, + None, + jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), + None, + ), + T( + dist.LowRankMultivariateNormal, + jnp.zeros(2), + jnp.array([[1.0], [0.0]]), + jnp.array([1.0, 1.0]), + ), + T( + dist.LowRankMultivariateNormal, + jnp.arange(6, dtype=jnp.float32).reshape((2, 3)), + jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), + jnp.array([1.0, 2.0, 3.0]), + ), + T(dist.Normal, 0.0, 1.0), + T(dist.Normal, 1.0, jnp.array([1.0, 2.0])), + T(dist.Normal, jnp.array([0.0, 1.0]), jnp.array([[1.0], [2.0]])), + T(dist.Pareto, 1.0, 2.0), + T(dist.Pareto, jnp.array([1.0, 0.5]), jnp.array([0.3, 2.0])), + T(dist.Pareto, jnp.array([[1.0], [3.0]]), jnp.array([1.0, 0.5])), + T(dist.StudentT, 1.0, 1.0, 0.5), + T(dist.StudentT, 2.0, jnp.array([1.0, 2.0]), 2.0), + T(dist.StudentT, jnp.array([3.0, 5.0]), jnp.array([[1.0], [2.0]]), 2.0), + T(dist.TruncatedCauchy, -1.0, 0.0, 1.0), + T(dist.TruncatedCauchy, 1.0, 0.0, jnp.array([1.0, 2.0])), + T( + dist.TruncatedCauchy, + jnp.array([-2.0, 2.0]), + jnp.array([0.0, 1.0]), + jnp.array([[1.0], [2.0]]), + ), + T(dist.TruncatedNormal, -1.0, 0.0, 1.0), + T(dist.TruncatedNormal, 1.0, -1.0, jnp.array([1.0, 2.0])), + T( + dist.TruncatedNormal, + jnp.array([-2.0, 2.0]), + jnp.array([0.0, 1.0]), + jnp.array([[1.0], [2.0]]), + ), + T(_TruncatedNormal, -1.0, 2.0, 1.0, 5.0), + T(_TruncatedNormal, jnp.array([-1.0, 4.0]), 2.0, None, 5.0), + T(_TruncatedNormal, -1.0, jnp.array([2.0, 3.0]), 1.0, None), + T(_TruncatedNormal, -1.0, 2.0, jnp.array([-6.0, 4.0]), jnp.array([-4.0, 6.0])), + T( + _TruncatedNormal, + jnp.array([0.0, 1.0]), + jnp.array([[1.0], [2.0]]), + None, + jnp.array([-2.0, 2.0]), + ), + T(dist.continuous.TwoSidedTruncatedDistribution, dist.Laplace(0.0, 1.0), -2.0, 3.0), + T(dist.Uniform, 0.0, 2.0), + T(dist.Uniform, 1.0, jnp.array([2.0, 3.0])), + T(dist.Uniform, jnp.array([0.0, 0.0]), jnp.array([[2.0], [3.0]])), ] DIRECTIONAL = [ - T(dist.VonMises, 2., 10.), - T(dist.VonMises, 2., jnp.array([150., 10.])), - T(dist.VonMises, jnp.array([1 / 3 * jnp.pi, -1.]), jnp.array([20., 30.])), - T(dist.ProjectedNormal, jnp.array([0., 0.])), - T(dist.ProjectedNormal, jnp.array([[2., 3.]])), - T(dist.ProjectedNormal, jnp.array([0., 0., 0.])), - T(dist.ProjectedNormal, jnp.array([[-1., 2., 3.]])), + T(dist.VonMises, 2.0, 10.0), + T(dist.VonMises, 2.0, jnp.array([150.0, 10.0])), + T(dist.VonMises, jnp.array([1 / 3 * jnp.pi, -1.0]), jnp.array([20.0, 30.0])), + T(dist.ProjectedNormal, jnp.array([0.0, 0.0])), + T(dist.ProjectedNormal, jnp.array([[2.0, 3.0]])), + T(dist.ProjectedNormal, jnp.array([0.0, 0.0, 0.0])), + T(dist.ProjectedNormal, jnp.array([[-1.0, 2.0, 3.0]])), ] DISCRETE = [ - T(dist.BetaBinomial, 2., 5., 10), - T(dist.BetaBinomial, jnp.array([2., 4.]), jnp.array([5., 3.]), jnp.array([10, 12])), + T(dist.BetaBinomial, 2.0, 5.0, 10), + T( + dist.BetaBinomial, + jnp.array([2.0, 4.0]), + jnp.array([5.0, 3.0]), + jnp.array([10, 12]), + ), T(dist.BernoulliProbs, 0.2), T(dist.BernoulliProbs, jnp.array([0.2, 0.7])), - T(dist.BernoulliLogits, jnp.array([-1., 3.])), + T(dist.BernoulliLogits, jnp.array([-1.0, 3.0])), T(dist.BinomialProbs, jnp.array([0.2, 0.7]), jnp.array([10, 2])), T(dist.BinomialProbs, jnp.array([0.2, 0.7]), jnp.array([5, 8])), - T(dist.BinomialLogits, jnp.array([-1., 3.]), jnp.array([5, 8])), - T(dist.CategoricalProbs, jnp.array([1.])), + T(dist.BinomialLogits, jnp.array([-1.0, 3.0]), jnp.array([5, 8])), + T(dist.CategoricalProbs, jnp.array([1.0])), T(dist.CategoricalProbs, jnp.array([0.1, 0.5, 0.4])), T(dist.CategoricalProbs, jnp.array([[0.1, 0.5, 0.4], [0.4, 0.4, 0.2]])), - T(dist.CategoricalLogits, jnp.array([-5.])), - T(dist.CategoricalLogits, jnp.array([1., 2., -2.])), - T(dist.CategoricalLogits, jnp.array([[-1, 2., 3.], [3., -4., -2.]])), + T(dist.CategoricalLogits, jnp.array([-5.0])), + T(dist.CategoricalLogits, jnp.array([1.0, 2.0, -2.0])), + T(dist.CategoricalLogits, jnp.array([[-1, 2.0, 3.0], [3.0, -4.0, -2.0]])), T(dist.Delta, 1), - T(dist.Delta, jnp.array([0., 2.])), - T(dist.Delta, jnp.array([0., 2.]), jnp.array([-2., -4.])), + T(dist.Delta, jnp.array([0.0, 2.0])), + T(dist.Delta, jnp.array([0.0, 2.0]), jnp.array([-2.0, -4.0])), T(dist.DirichletMultinomial, jnp.array([1.0, 2.0, 3.9]), 10), T(dist.DirichletMultinomial, jnp.array([0.2, 0.7, 1.1]), jnp.array([5, 5])), - T(dist.GammaPoisson, 2., 2.), - T(dist.GammaPoisson, jnp.array([6., 2]), jnp.array([2., 8.])), + T(dist.GammaPoisson, 2.0, 2.0), + T(dist.GammaPoisson, jnp.array([6.0, 2]), jnp.array([2.0, 8.0])), T(dist.GeometricProbs, 0.2), T(dist.GeometricProbs, jnp.array([0.2, 0.7])), - T(dist.GeometricLogits, jnp.array([-1., 3.])), + T(dist.GeometricLogits, jnp.array([-1.0, 3.0])), T(dist.MultinomialProbs, jnp.array([0.2, 0.7, 0.1]), 10), T(dist.MultinomialProbs, jnp.array([0.2, 0.7, 0.1]), jnp.array([5, 8])), - T(dist.MultinomialLogits, jnp.array([-1., 3.]), jnp.array([[5], [8]])), - T(dist.OrderedLogistic, -2, jnp.array([-10., 4., 9.])), + T(dist.MultinomialLogits, jnp.array([-1.0, 3.0]), jnp.array([[5], [8]])), + T(dist.OrderedLogistic, -2, jnp.array([-10.0, 4.0, 9.0])), T(dist.OrderedLogistic, jnp.array([-4, 3, 4, 5]), jnp.array([-1.5])), - T(dist.Poisson, 2.), - T(dist.Poisson, jnp.array([2., 3., 5.])), - T(dist.ZeroInflatedPoisson, 0.6, 2.), - T(dist.ZeroInflatedPoisson, jnp.array([0.2, 0.7, 0.3]), jnp.array([2., 3., 5.])), + T(dist.Poisson, 2.0), + T(dist.Poisson, jnp.array([2.0, 3.0, 5.0])), + T(dist.ZeroInflatedPoisson, 0.6, 2.0), + T(dist.ZeroInflatedPoisson, jnp.array([0.2, 0.7, 0.3]), jnp.array([2.0, 3.0, 5.0])), ] @@ -291,13 +361,21 @@ def gen_values_within_bounds(constraint, size, key=random.PRNGKey(11)): return osp.dirichlet.rvs(alpha=jnp.ones((size[-1],)), size=size[:-1]) elif isinstance(constraint, constraints.multinomial): n = size[-1] - return multinomial(key, p=jnp.ones((n,)) / n, n=constraint.upper_bound, shape=size[:-1]) + return multinomial( + key, p=jnp.ones((n,)) / n, n=constraint.upper_bound, shape=size[:-1] + ) elif constraint is constraints.corr_cholesky: return signed_stick_breaking_tril( - random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1)) + random.uniform( + key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1 + ) + ) elif constraint is constraints.corr_matrix: cholesky = signed_stick_breaking_tril( - random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1)) + random.uniform( + key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1 + ) + ) return jnp.matmul(cholesky, jnp.swapaxes(cholesky, -2, -1)) elif constraint is constraints.lower_cholesky: return jnp.tril(random.uniform(key, size)) @@ -313,7 +391,7 @@ def gen_values_within_bounds(constraint, size, key=random.PRNGKey(11)): x = random.normal(key, size) return x / jnp.linalg.norm(x, axis=-1) else: - raise NotImplementedError('{} not implemented.'.format(constraint)) + raise NotImplementedError("{} not implemented.".format(constraint)) def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)): @@ -328,21 +406,37 @@ def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)): return constraint.lower_bound - random.poisson(key, np.array(5), shape=size) elif isinstance(constraint, constraints.interval): upper_bound = jnp.broadcast_to(constraint.upper_bound, size) - return random.uniform(key, size, minval=upper_bound, maxval=upper_bound + 1.) + return random.uniform(key, size, minval=upper_bound, maxval=upper_bound + 1.0) elif constraint in [constraints.real, constraints.real_vector]: return lax.full(size, jnp.nan) elif constraint is constraints.simplex: return osp.dirichlet.rvs(alpha=jnp.ones((size[-1],)), size=size[:-1]) + 1e-2 elif isinstance(constraint, constraints.multinomial): n = size[-1] - return multinomial(key, p=jnp.ones((n,)) / n, n=constraint.upper_bound, shape=size[:-1]) + 1 + return ( + multinomial( + key, p=jnp.ones((n,)) / n, n=constraint.upper_bound, shape=size[:-1] + ) + + 1 + ) elif constraint is constraints.corr_cholesky: - return signed_stick_breaking_tril( - random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), - minval=-1, maxval=1)) + 1e-2 + return ( + signed_stick_breaking_tril( + random.uniform( + key, + size[:-2] + (size[-1] * (size[-1] - 1) // 2,), + minval=-1, + maxval=1, + ) + ) + + 1e-2 + ) elif constraint is constraints.corr_matrix: cholesky = 1e-2 + signed_stick_breaking_tril( - random.uniform(key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1)) + random.uniform( + key, size[:-2] + (size[-1] * (size[-1] - 1) // 2,), minval=-1, maxval=1 + ) + ) return jnp.matmul(cholesky, jnp.swapaxes(cholesky, -2, -1)) elif constraint is constraints.lower_cholesky: return random.uniform(key, size) @@ -358,15 +452,13 @@ def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)): x = x / jnp.linalg.norm(x, axis=-1, keepdims=True) return 2 * x else: - raise NotImplementedError('{} not implemented.'.format(constraint)) + raise NotImplementedError("{} not implemented.".format(constraint)) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) -@pytest.mark.parametrize('prepend_shape', [ - (), - (2,), - (2, 3), -]) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) +@pytest.mark.parametrize("prepend_shape", [(), (2,), (2, 3)]) def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): jax_dist = jax_dist(*params) rng_key = random.PRNGKey(0) @@ -380,28 +472,34 @@ def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): assert jnp.shape(sp_samples) == expected_shape if isinstance(jax_dist, dist.MultivariateNormal): assert jax_dist.covariance_matrix.ndim == len(jax_dist.batch_shape) + 2 - assert_allclose(jax_dist.precision_matrix, jnp.linalg.inv(jax_dist.covariance_matrix), rtol=1e-6) + assert_allclose( + jax_dist.precision_matrix, + jnp.linalg.inv(jax_dist.covariance_matrix), + rtol=1e-6, + ) -@pytest.mark.parametrize('prepend_shape', [ - (), - (2,), - (2, 3), -], ids=str) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) +@pytest.mark.parametrize("prepend_shape", [(), (2,), (2, 3)], ids=str) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) def test_infer_shapes(jax_dist, sp_dist, params, prepend_shape): shapes = tuple(getattr(p, "shape", ()) for p in params) shapes = tuple(x() if callable(x) else x for x in shapes) jax_dist = jax_dist(*params) try: - expected_batch_shape, expected_event_shape = type(jax_dist).infer_shapes(*shapes) + expected_batch_shape, expected_event_shape = type(jax_dist).infer_shapes( + *shapes + ) except NotImplementedError: - pytest.skip(f'{type(jax_dist).__name__}.infer_shapes() is not implemented') + pytest.skip(f"{type(jax_dist).__name__}.infer_shapes() is not implemented") assert jax_dist.batch_shape == expected_batch_shape assert jax_dist.event_shape == expected_event_shape -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) def test_has_rsample(jax_dist, sp_dist, params): jax_dist = jax_dist(*params) masked_dist = jax_dist.mask(False) @@ -434,7 +532,7 @@ def test_has_rsample(jax_dist, sp_dist, params): transf_dist.rsample(random.PRNGKey(0)) -@pytest.mark.parametrize('batch_shape', [(), (4,), (3, 2)]) +@pytest.mark.parametrize("batch_shape", [(), (4,), (3, 2)]) def test_unit(batch_shape): log_factor = random.normal(random.PRNGKey(0), batch_shape) d = dist.Unit(log_factor=log_factor) @@ -443,7 +541,7 @@ def test_unit(batch_shape): assert (d.log_prob(x) == log_factor).all() -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) +@pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS) def test_sample_gradient(jax_dist, sp_dist, params): # we have pathwise gradient for gamma sampler gamma_derived_params = { @@ -454,31 +552,41 @@ def test_sample_gradient(jax_dist, sp_dist, params): "InverseGamma": ["concentration"], "LKJ": ["concentration"], "LKJCholesky": ["concentration"], - "StudentT": ["df"] + "StudentT": ["df"], }.get(jax_dist.__name__, []) - dist_args = [p for p in ( - inspect.getfullargspec(jax_dist.__init__)[0][1:] if inspect.isclass(jax_dist) - # account the the case jax_dist is a function - else inspect.getfullargspec(jax_dist)[0])] - params_dict = dict(zip(dist_args[:len(params)], params)) + dist_args = [ + p + for p in ( + inspect.getfullargspec(jax_dist.__init__)[0][1:] + if inspect.isclass(jax_dist) + # account the the case jax_dist is a function + else inspect.getfullargspec(jax_dist)[0] + ) + ] + params_dict = dict(zip(dist_args[: len(params)], params)) jax_class = type(jax_dist(**params_dict)) - reparameterized_params = [p for p in jax_class.reparametrized_params - if p not in gamma_derived_params] + reparameterized_params = [ + p for p in jax_class.reparametrized_params if p not in gamma_derived_params + ] if not reparameterized_params: - pytest.skip('{} not reparametrized.'.format(jax_class.__name__)) + pytest.skip("{} not reparametrized.".format(jax_class.__name__)) - nonrepara_params_dict = {k: v for k, v in params_dict.items() - if k not in reparameterized_params} - repara_params = tuple(v for k, v in params_dict.items() - if k in reparameterized_params) + nonrepara_params_dict = { + k: v for k, v in params_dict.items() if k not in reparameterized_params + } + repara_params = tuple( + v for k, v in params_dict.items() if k in reparameterized_params + ) rng_key = random.PRNGKey(0) def fn(args): args_dict = dict(zip(reparameterized_params, args)) - return jnp.sum(jax_dist(**args_dict, **nonrepara_params_dict).sample(key=rng_key)) + return jnp.sum( + jax_dist(**args_dict, **nonrepara_params_dict).sample(key=rng_key) + ) actual_grad = jax.grad(fn)(repara_params) assert len(actual_grad) == len(repara_params) @@ -492,30 +600,47 @@ def fn(args): fn_lhs = fn(args_lhs) fn_rhs = fn(args_rhs) # finite diff approximation - expected_grad = (fn_rhs - fn_lhs) / (2. * eps) + expected_grad = (fn_rhs - fn_lhs) / (2.0 * eps) assert jnp.shape(actual_grad[i]) == jnp.shape(repara_params[i]) assert_allclose(jnp.sum(actual_grad[i]), expected_grad, rtol=0.02) -@pytest.mark.parametrize('jax_dist, sp_dist, params', [ - (dist.Gamma, osp.gamma, (1.,)), - (dist.Gamma, osp.gamma, (0.1,)), - (dist.Gamma, osp.gamma, (10.,)), - (dist.Chi2, osp.chi2, (1.,)), - (dist.Chi2, osp.chi2, (0.1,)), - (dist.Chi2, osp.chi2, (10.,)), - # TODO: add more test cases for Beta/StudentT (and Dirichlet too) when - # their pathwise grad (independent of standard_gamma grad) is implemented. - pytest.param(dist.Beta, osp.beta, (1., 1.), marks=pytest.mark.xfail( - reason='currently, variance of grad of beta sampler is large')), - pytest.param(dist.StudentT, osp.t, (1.,), marks=pytest.mark.xfail( - reason='currently, variance of grad of t sampler is large')), -]) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", + [ + (dist.Gamma, osp.gamma, (1.0,)), + (dist.Gamma, osp.gamma, (0.1,)), + (dist.Gamma, osp.gamma, (10.0,)), + (dist.Chi2, osp.chi2, (1.0,)), + (dist.Chi2, osp.chi2, (0.1,)), + (dist.Chi2, osp.chi2, (10.0,)), + # TODO: add more test cases for Beta/StudentT (and Dirichlet too) when + # their pathwise grad (independent of standard_gamma grad) is implemented. + pytest.param( + dist.Beta, + osp.beta, + (1.0, 1.0), + marks=pytest.mark.xfail( + reason="currently, variance of grad of beta sampler is large" + ), + ), + pytest.param( + dist.StudentT, + osp.t, + (1.0,), + marks=pytest.mark.xfail( + reason="currently, variance of grad of t sampler is large" + ), + ), + ], +) def test_pathwise_gradient(jax_dist, sp_dist, params): rng_key = random.PRNGKey(0) N = 100 z = jax_dist(*params).sample(key=rng_key, sample_shape=(N,)) - actual_grad = jacfwd(lambda x: jax_dist(*x).sample(key=rng_key, sample_shape=(N,)))(params) + actual_grad = jacfwd(lambda x: jax_dist(*x).sample(key=rng_key, sample_shape=(N,)))( + params + ) eps = 1e-3 for i in range(len(params)): args_lhs = [p if j != i else p - eps for j, p in enumerate(params)] @@ -525,13 +650,11 @@ def test_pathwise_gradient(jax_dist, sp_dist, params): assert_allclose(actual_grad[i], expected_grad, rtol=0.005) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) -@pytest.mark.parametrize('prepend_shape', [ - (), - (2,), - (2, 3), -]) -@pytest.mark.parametrize('jit', [False, True]) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) +@pytest.mark.parametrize("prepend_shape", [(), (2,), (2, 3)]) +@pytest.mark.parametrize("jit", [False, True]) def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): jit_fn = _identity if not jit else jax.jit jax_dist = jax_dist(*params) @@ -539,11 +662,22 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): samples = jax_dist.sample(key=rng_key, sample_shape=prepend_shape) assert jax_dist.log_prob(samples).shape == prepend_shape + jax_dist.batch_shape if sp_dist is None: - if isinstance(jax_dist, (dist.LeftTruncatedDistribution, dist.RightTruncatedDistribution, - dist.TwoSidedTruncatedDistribution)): + if isinstance( + jax_dist, + ( + dist.LeftTruncatedDistribution, + dist.RightTruncatedDistribution, + dist.TwoSidedTruncatedDistribution, + ), + ): if isinstance(params[0], dist.Distribution): # new api - loc, scale, low, high = params[0].loc, params[0].scale, params[1], params[2] + loc, scale, low, high = ( + params[0].loc, + params[0].scale, + params[1], + params[2], + ) if low is None: low = -np.inf if high is None: @@ -553,18 +687,20 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): low, loc, scale = params high = jnp.inf sp_dist = _DIST_MAP[type(jax_dist.base_dist)](loc, scale) - expected = sp_dist.logpdf(samples) - jnp.log(sp_dist.cdf(high) - sp_dist.cdf(low)) + expected = sp_dist.logpdf(samples) - jnp.log( + sp_dist.cdf(high) - sp_dist.cdf(low) + ) assert_allclose(jit_fn(jax_dist.log_prob)(samples), expected, atol=1e-5) return - pytest.skip('no corresponding scipy distn.') + pytest.skip("no corresponding scipy distn.") if _is_batched_multivariate(jax_dist): - pytest.skip('batching not allowed in multivariate distns.') + pytest.skip("batching not allowed in multivariate distns.") if jax_dist.event_shape and prepend_shape: # >>> d = sp.dirichlet([1.1, 1.1]) # >>> samples = d.rvs(size=(2,)) # >>> d.logpdf(samples) # ValueError: The input vector 'x' must lie within the normal simplex ... - pytest.skip('batched samples cannot be scored by multivariate distributions.') + pytest.skip("batched samples cannot be scored by multivariate distributions.") sp_dist = sp_dist(*params) try: expected = sp_dist.logpdf(samples) @@ -573,7 +709,7 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): except ValueError as e: # precision issue: jnp.sum(x / jnp.sum(x)) = 0.99999994 != 1 if "The input vector 'x' must lie within the normal simplex." in str(e): - samples = samples.copy().astype('float64') + samples = samples.copy().astype("float64") samples = samples / samples.sum(axis=-1, keepdims=True) expected = sp_dist.logpdf(samples) else: @@ -581,20 +717,28 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): assert_allclose(jit_fn(jax_dist.log_prob)(samples), expected, atol=1e-5) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) +@pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS) def test_cdf_and_icdf(jax_dist, sp_dist, params): d = jax_dist(*params) if d.event_dim > 0: - pytest.skip('skip testing cdf/icdf methods of multivariate distributions') + pytest.skip("skip testing cdf/icdf methods of multivariate distributions") samples = d.sample(key=random.PRNGKey(0), sample_shape=(100,)) quantiles = random.uniform(random.PRNGKey(1), (100,) + d.shape()) try: if d.shape() == (): rtol = 1e-3 if jax_dist is dist.StudentT else 1e-5 - assert_allclose(jax.vmap(jax.grad(d.cdf))(samples), - jnp.exp(d.log_prob(samples)), atol=1e-5, rtol=rtol) - assert_allclose(jax.vmap(jax.grad(d.icdf))(quantiles), - jnp.exp(-d.log_prob(d.icdf(quantiles))), atol=1e-5, rtol=rtol) + assert_allclose( + jax.vmap(jax.grad(d.cdf))(samples), + jnp.exp(d.log_prob(samples)), + atol=1e-5, + rtol=rtol, + ) + assert_allclose( + jax.vmap(jax.grad(d.icdf))(quantiles), + jnp.exp(-d.log_prob(d.icdf(quantiles))), + atol=1e-5, + rtol=rtol, + ) assert_allclose(d.cdf(d.icdf(quantiles)), quantiles, atol=1e-5, rtol=1e-5) assert_allclose(d.icdf(d.cdf(samples)), samples, atol=1e-5, rtol=1e-5) except NotImplementedError: @@ -602,7 +746,7 @@ def test_cdf_and_icdf(jax_dist, sp_dist, params): # test against scipy if not sp_dist: - pytest.skip('no corresponding scipy distn.') + pytest.skip("no corresponding scipy distn.") sp_dist = sp_dist(*params) try: actual_cdf = d.cdf(samples) @@ -615,7 +759,7 @@ def test_cdf_and_icdf(jax_dist, sp_dist, params): pass -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DIRECTIONAL) +@pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS + DIRECTIONAL) def test_gof(jax_dist, sp_dist, params): if "Improper" in jax_dist.__name__: pytest.skip("distribution has improper .log_prob()") @@ -647,7 +791,7 @@ def test_gof(jax_dist, sp_dist, params): assert gof > TEST_FAILURE_RATE -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE) +@pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS + DISCRETE) def test_independent_shape(jax_dist, sp_dist, params): d = jax_dist(*params) batch_shape, event_shape = d.batch_shape, d.event_shape @@ -669,7 +813,7 @@ def _tril_cholesky_to_tril_corr(x): return matrix_to_tril_vec(corr, diagonal=-1) -@pytest.mark.parametrize('dimension', [2, 3, 5]) +@pytest.mark.parametrize("dimension", [2, 3, 5]) def test_log_prob_LKJCholesky_uniform(dimension): # When concentration=1, the distribution of correlation matrices is uniform. # We will test that fact here. @@ -681,13 +825,17 @@ def test_log_prob_LKJCholesky_uniform(dimension): log_prob = d.log_prob(sample) sample_tril = matrix_to_tril_vec(sample, diagonal=-1) cholesky_to_corr_jac = np.linalg.slogdet( - jax.jacobian(_tril_cholesky_to_tril_corr)(sample_tril))[1] + jax.jacobian(_tril_cholesky_to_tril_corr)(sample_tril) + )[1] corr_log_prob.append(log_prob - cholesky_to_corr_jac) corr_log_prob = jnp.array(corr_log_prob) # test if they are constant - assert_allclose(corr_log_prob, jnp.broadcast_to(corr_log_prob[0], corr_log_prob.shape), - rtol=1e-6) + assert_allclose( + corr_log_prob, + jnp.broadcast_to(corr_log_prob[0], corr_log_prob.shape), + rtol=1e-6, + ) if dimension == 2: # when concentration = 1, LKJ gives a uniform distribution over correlation matrix, @@ -720,8 +868,7 @@ def test_log_prob_LKJCholesky(dimension, concentration): inv_tanh_logdet = jnp.sum(jnp.log(vmap(grad(inv_tanh))(partial_correlation))) unconstrained = inv_tanh(partial_correlation) corr_cholesky_logdet = biject_to(constraints.corr_cholesky).log_abs_det_jacobian( - unconstrained, - sample, + unconstrained, sample ) signed_stick_breaking_logdet = corr_cholesky_logdet + inv_tanh_logdet @@ -732,10 +879,10 @@ def test_log_prob_LKJCholesky(dimension, concentration): assert_allclose(jax.jit(d.log_prob)(sample), d.log_prob(sample), atol=2e-6) -@pytest.mark.parametrize('rate', [0.1, 0.5, 0.9, 1.0, 1.1, 2.0, 10.0]) +@pytest.mark.parametrize("rate", [0.1, 0.5, 0.9, 1.0, 1.1, 2.0, 10.0]) def test_ZIP_log_prob(rate): # if gate is 0 ZIP is Poisson - zip_ = dist.ZeroInflatedPoisson(0., rate) + zip_ = dist.ZeroInflatedPoisson(0.0, rate) pois = dist.Poisson(rate) s = zip_.sample(random.PRNGKey(0), (20,)) zip_prob = zip_.log_prob(s) @@ -743,9 +890,9 @@ def test_ZIP_log_prob(rate): assert_allclose(zip_prob, pois_prob) # if gate is 1 ZIP is Delta(0) - zip_ = dist.ZeroInflatedPoisson(1., rate) - delta = dist.Delta(0.) - s = jnp.array([0., 1.]) + zip_ = dist.ZeroInflatedPoisson(1.0, rate) + delta = dist.Delta(0.0) + s = jnp.array([0.0, 1.0]) zip_prob = zip_.log_prob(s) delta_prob = delta.log_prob(s) assert_allclose(zip_prob, delta_prob) @@ -763,7 +910,9 @@ def test_beta_binomial_log_prob(total_count, shape): log_probs = dist.Binomial(total_count, probs).log_prob(value) expected = logsumexp(log_probs, 0) - jnp.log(num_samples) - actual = dist.BetaBinomial(concentration1, concentration0, total_count).log_prob(value) + actual = dist.BetaBinomial(concentration1, concentration0, total_count).log_prob( + value + ) assert_allclose(actual, expected, rtol=0.02) @@ -773,7 +922,9 @@ def test_dirichlet_multinomial_log_prob(total_count, batch_shape): event_shape = (3,) concentration = np.exp(np.random.normal(size=batch_shape + event_shape)) # test on one-hots - value = total_count * jnp.eye(event_shape[-1]).reshape(event_shape + (1,) * len(batch_shape) + event_shape) + value = total_count * jnp.eye(event_shape[-1]).reshape( + event_shape + (1,) * len(batch_shape) + event_shape + ) num_samples = 100000 probs = dist.Dirichlet(concentration).sample(random.PRNGKey(0), (num_samples, 1)) @@ -791,19 +942,23 @@ def test_gamma_poisson_log_prob(shape): value = jnp.arange(15) num_samples = 300000 - poisson_rate = np.random.gamma(gamma_conc, 1 / gamma_rate, size=(num_samples,) + shape) + poisson_rate = np.random.gamma( + gamma_conc, 1 / gamma_rate, size=(num_samples,) + shape + ) log_probs = dist.Poisson(poisson_rate).log_prob(value) expected = logsumexp(log_probs, 0) - jnp.log(num_samples) actual = dist.GammaPoisson(gamma_conc, gamma_rate).log_prob(value) assert_allclose(actual, expected, rtol=0.05) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) def test_log_prob_gradient(jax_dist, sp_dist, params): if jax_dist in [dist.LKJ, dist.LKJCholesky]: - pytest.skip('we have separated tests for LKJCholesky distribution') + pytest.skip("we have separated tests for LKJCholesky distribution") if jax_dist is _ImproperWrapper: - pytest.skip('no param for ImproperUniform to test for log_prob gradient') + pytest.skip("no param for ImproperUniform to test for log_prob gradient") rng_key = random.PRNGKey(0) value = jax_dist(*params).sample(rng_key) @@ -813,7 +968,9 @@ def fn(*args): eps = 1e-3 for i in range(len(params)): - if isinstance(params[i], dist.Distribution): # skip taking grad w.r.t. base_dist + if isinstance( + params[i], dist.Distribution + ): # skip taking grad w.r.t. base_dist continue if params[i] is None or jnp.result_type(params[i]) in (jnp.int32, jnp.int64): continue @@ -823,21 +980,27 @@ def fn(*args): fn_lhs = fn(*args_lhs) fn_rhs = fn(*args_rhs) # finite diff approximation - expected_grad = (fn_rhs - fn_lhs) / (2. * eps) + expected_grad = (fn_rhs - fn_lhs) / (2.0 * eps) assert jnp.shape(actual_grad) == jnp.shape(params[i]) if i == 0 and jax_dist is dist.Delta: # grad w.r.t. `value` of Delta distribution will be 0 # but numerical value will give nan (= inf - inf) - expected_grad = 0. + expected_grad = 0.0 assert_allclose(jnp.sum(actual_grad), expected_grad, rtol=0.01, atol=0.01) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) def test_mean_var(jax_dist, sp_dist, params): if jax_dist is _ImproperWrapper: pytest.skip("Improper distribution does not has mean/var implemented") - if jax_dist in (_TruncatedNormal, dist.LeftTruncatedDistribution, dist.RightTruncatedDistribution, - dist.TwoSidedTruncatedDistribution): + if jax_dist in ( + _TruncatedNormal, + dist.LeftTruncatedDistribution, + dist.RightTruncatedDistribution, + dist.TwoSidedTruncatedDistribution, + ): pytest.skip("Truncated distributions do not has mean/var implemented") if jax_dist is dist.ProjectedNormal: pytest.skip("Mean is defined in submanifold") @@ -848,7 +1011,11 @@ def test_mean_var(jax_dist, sp_dist, params): samples = d_jax.sample(k, sample_shape=(n,)).astype(np.float32) # check with suitable scipy implementation if available # XXX: VonMises is already tested below - if sp_dist and not _is_batched_multivariate(d_jax) and jax_dist not in [dist.VonMises]: + if ( + sp_dist + and not _is_batched_multivariate(d_jax) + and jax_dist not in [dist.VonMises] + ): d_sp = sp_dist(*params) try: sp_mean = d_sp.mean() @@ -869,7 +1036,9 @@ def test_mean_var(jax_dist, sp_dist, params): if jnp.all(jnp.isfinite(sp_mean)): assert_allclose(jnp.mean(samples, 0), d_jax.mean, rtol=0.05, atol=1e-2) if jnp.all(jnp.isfinite(sp_var)): - assert_allclose(jnp.std(samples, 0), jnp.sqrt(d_jax.variance), rtol=0.05, atol=1e-2) + assert_allclose( + jnp.std(samples, 0), jnp.sqrt(d_jax.variance), rtol=0.05, atol=1e-2 + ) elif jax_dist in [dist.LKJ, dist.LKJCholesky]: if jax_dist is dist.LKJCholesky: corr_samples = jnp.matmul(samples, jnp.swapaxes(samples, -2, -1)) @@ -877,17 +1046,24 @@ def test_mean_var(jax_dist, sp_dist, params): corr_samples = samples dimension, concentration, _ = params # marginal of off-diagonal entries - marginal = dist.Beta(concentration + 0.5 * (dimension - 2), - concentration + 0.5 * (dimension - 2)) + marginal = dist.Beta( + concentration + 0.5 * (dimension - 2), concentration + 0.5 * (dimension - 2) + ) # scale statistics due to linear mapping marginal_mean = 2 * marginal.mean - 1 marginal_std = 2 * jnp.sqrt(marginal.variance) - expected_mean = jnp.broadcast_to(jnp.reshape(marginal_mean, jnp.shape(marginal_mean) + (1, 1)), - jnp.shape(marginal_mean) + d_jax.event_shape) - expected_std = jnp.broadcast_to(jnp.reshape(marginal_std, jnp.shape(marginal_std) + (1, 1)), - jnp.shape(marginal_std) + d_jax.event_shape) + expected_mean = jnp.broadcast_to( + jnp.reshape(marginal_mean, jnp.shape(marginal_mean) + (1, 1)), + jnp.shape(marginal_mean) + d_jax.event_shape, + ) + expected_std = jnp.broadcast_to( + jnp.reshape(marginal_std, jnp.shape(marginal_std) + (1, 1)), + jnp.shape(marginal_std) + d_jax.event_shape, + ) # diagonal elements of correlation matrices are 1 - expected_mean = expected_mean * (1 - jnp.identity(dimension)) + jnp.identity(dimension) + expected_mean = expected_mean * (1 - jnp.identity(dimension)) + jnp.identity( + dimension + ) expected_std = expected_std * (1 - jnp.identity(dimension)) assert_allclose(jnp.mean(corr_samples, axis=0), expected_mean, atol=0.01) @@ -905,15 +1081,15 @@ def test_mean_var(jax_dist, sp_dist, params): if jnp.all(jnp.isfinite(d_jax.mean)): assert_allclose(jnp.mean(samples, 0), d_jax.mean, rtol=0.05, atol=1e-2) if jnp.all(jnp.isfinite(d_jax.variance)): - assert_allclose(jnp.std(samples, 0), jnp.sqrt(d_jax.variance), rtol=0.05, atol=1e-2) + assert_allclose( + jnp.std(samples, 0), jnp.sqrt(d_jax.variance), rtol=0.05, atol=1e-2 + ) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) -@pytest.mark.parametrize('prepend_shape', [ - (), - (2,), - (2, 3), -]) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) +@pytest.mark.parametrize("prepend_shape", [(), (2,), (2, 3)]) def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): if jax_dist is _TruncatedNormal: pytest.skip("_TruncatedNormal is a function, not a class") @@ -923,9 +1099,15 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): key = random.PRNGKey(1) dependent_constraint = False for i in range(len(params)): - if jax_dist in (_ImproperWrapper, dist.LKJ, dist.LKJCholesky) and dist_args[i] != "concentration": + if ( + jax_dist in (_ImproperWrapper, dist.LKJ, dist.LKJCholesky) + and dist_args[i] != "concentration" + ): continue - if jax_dist is dist.continuous.TwoSidedTruncatedDistribution and dist_args[i] == "base_dist": + if ( + jax_dist is dist.continuous.TwoSidedTruncatedDistribution + and dist_args[i] == "base_dist" + ): continue if jax_dist is dist.GaussianRandomWalk and dist_args[i] == "num_steps": continue @@ -938,8 +1120,12 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): dependent_constraint = True break key, key_gen = random.split(key) - oob_params[i] = gen_values_outside_bounds(constraint, jnp.shape(params[i]), key_gen) - valid_params[i] = gen_values_within_bounds(constraint, jnp.shape(params[i]), key_gen) + oob_params[i] = gen_values_outside_bounds( + constraint, jnp.shape(params[i]), key_gen + ) + valid_params[i] = gen_values_within_bounds( + constraint, jnp.shape(params[i]), key_gen + ) assert jax_dist(*oob_params) @@ -962,10 +1148,14 @@ def dist_gen_fn(): # Test agreement of log density evaluation on randomly generated samples # with scipy's implementation when available. - if sp_dist and \ - not _is_batched_multivariate(d) and \ - not (d.event_shape and prepend_shape): - valid_samples = gen_values_within_bounds(d.support, size=prepend_shape + d.batch_shape + d.event_shape) + if ( + sp_dist + and not _is_batched_multivariate(d) + and not (d.event_shape and prepend_shape) + ): + valid_samples = gen_values_within_bounds( + d.support, size=prepend_shape + d.batch_shape + d.event_shape + ) try: expected = sp_dist(*valid_params).logpdf(valid_samples) except AttributeError: @@ -973,7 +1163,9 @@ def dist_gen_fn(): assert_allclose(d.log_prob(valid_samples), expected, atol=1e-5, rtol=1e-5) # Out of support samples throw ValueError - oob_samples = gen_values_outside_bounds(d.support, size=prepend_shape + d.batch_shape + d.event_shape) + oob_samples = gen_values_outside_bounds( + d.support, size=prepend_shape + d.batch_shape + d.event_shape + ) with pytest.warns(UserWarning, match="Out-of-support"): d.log_prob(oob_samples) @@ -1009,7 +1201,9 @@ def test_categorical_log_prob_grad(): data = jnp.repeat(jnp.arange(3), 10) def f(x): - return dist.Categorical(jax.nn.softmax(x * jnp.arange(1, 4))).log_prob(data).sum() + return ( + dist.Categorical(jax.nn.softmax(x * jnp.arange(1, 4))).log_prob(data).sum() + ) def g(x): return dist.Categorical(logits=x * jnp.arange(1, 4)).log_prob(data).sum() @@ -1026,57 +1220,123 @@ def g(x): ######################################## -@pytest.mark.parametrize('constraint, x, expected', [ - (constraints.boolean, jnp.array([True, False]), jnp.array([True, True])), - (constraints.boolean, jnp.array([1, 1]), jnp.array([True, True])), - (constraints.boolean, jnp.array([-1, 1]), jnp.array([False, True])), - (constraints.corr_cholesky, jnp.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), - jnp.array([True, False])), # NB: not lower_triangular - (constraints.corr_cholesky, jnp.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), - jnp.array([False, False])), # NB: not positive_diagonal & not unit_norm_row - (constraints.corr_matrix, jnp.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), - jnp.array([True, False])), # NB: not lower_triangular - (constraints.corr_matrix, jnp.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), - jnp.array([False, False])), # NB: not unit diagonal - (constraints.greater_than(1), 3, True), - (constraints.greater_than(1), jnp.array([-1, 1, 5]), jnp.array([False, False, True])), - (constraints.integer_interval(-3, 5), 0, True), - (constraints.integer_interval(-3, 5), jnp.array([-5, -3, 0, 1.1, 5, 7]), - jnp.array([False, True, True, False, True, False])), - (constraints.interval(-3, 5), 0, True), - (constraints.interval(-3, 5), jnp.array([-5, -3, 0, 5, 7]), - jnp.array([False, True, True, True, False])), - (constraints.less_than(1), -2, True), - (constraints.less_than(1), jnp.array([-1, 1, 5]), jnp.array([True, False, False])), - (constraints.lower_cholesky, jnp.array([[1., 0.], [-2., 0.1]]), True), - (constraints.lower_cholesky, jnp.array([[[1., 0.], [-2., -0.1]], [[1., 0.1], [2., 0.2]]]), - jnp.array([False, False])), - (constraints.nonnegative_integer, 3, True), - (constraints.nonnegative_integer, jnp.array([-1., 0., 5.]), jnp.array([False, True, True])), - (constraints.positive, 3, True), - (constraints.positive, jnp.array([-1, 0, 5]), jnp.array([False, False, True])), - (constraints.positive_definite, jnp.array([[1., 0.3], [0.3, 1.]]), True), - (constraints.positive_definite, jnp.array([[[2., 0.4], [0.3, 2.]], [[1., 0.1], [0.1, 0.]]]), - jnp.array([False, False])), - (constraints.positive_integer, 3, True), - (constraints.positive_integer, jnp.array([-1., 0., 5.]), jnp.array([False, False, True])), - (constraints.real, -1, True), - (constraints.real, jnp.array([jnp.inf, jnp.NINF, jnp.nan, jnp.pi]), - jnp.array([False, False, False, True])), - (constraints.simplex, jnp.array([0.1, 0.3, 0.6]), True), - (constraints.simplex, jnp.array([[0.1, 0.3, 0.6], [-0.1, 0.6, 0.5], [0.1, 0.6, 0.5]]), - jnp.array([True, False, False])), - (constraints.softplus_positive, 3, True), - (constraints.softplus_positive, jnp.array([-1, 0, 5]), jnp.array([False, False, True])), - (constraints.softplus_lower_cholesky, jnp.array([[1., 0.], [-2., 0.1]]), True), - (constraints.softplus_lower_cholesky, jnp.array([[[1., 0.], [-2., -0.1]], [[1., 0.1], [2., 0.2]]]), - jnp.array([False, False])), - (constraints.unit_interval, 0.1, True), - (constraints.unit_interval, jnp.array([-5, 0, 0.5, 1, 7]), - jnp.array([False, True, True, True, False])), - (constraints.sphere, jnp.array([[1, 0, 0], [0.5, 0.5, 0]]), - jnp.array([True, False])), -]) +@pytest.mark.parametrize( + "constraint, x, expected", + [ + (constraints.boolean, jnp.array([True, False]), jnp.array([True, True])), + (constraints.boolean, jnp.array([1, 1]), jnp.array([True, True])), + (constraints.boolean, jnp.array([-1, 1]), jnp.array([False, True])), + ( + constraints.corr_cholesky, + jnp.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), + jnp.array([True, False]), + ), # NB: not lower_triangular + ( + constraints.corr_cholesky, + jnp.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), + jnp.array([False, False]), + ), # NB: not positive_diagonal & not unit_norm_row + ( + constraints.corr_matrix, + jnp.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), + jnp.array([True, False]), + ), # NB: not lower_triangular + ( + constraints.corr_matrix, + jnp.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), + jnp.array([False, False]), + ), # NB: not unit diagonal + (constraints.greater_than(1), 3, True), + ( + constraints.greater_than(1), + jnp.array([-1, 1, 5]), + jnp.array([False, False, True]), + ), + (constraints.integer_interval(-3, 5), 0, True), + ( + constraints.integer_interval(-3, 5), + jnp.array([-5, -3, 0, 1.1, 5, 7]), + jnp.array([False, True, True, False, True, False]), + ), + (constraints.interval(-3, 5), 0, True), + ( + constraints.interval(-3, 5), + jnp.array([-5, -3, 0, 5, 7]), + jnp.array([False, True, True, True, False]), + ), + (constraints.less_than(1), -2, True), + ( + constraints.less_than(1), + jnp.array([-1, 1, 5]), + jnp.array([True, False, False]), + ), + (constraints.lower_cholesky, jnp.array([[1.0, 0.0], [-2.0, 0.1]]), True), + ( + constraints.lower_cholesky, + jnp.array([[[1.0, 0.0], [-2.0, -0.1]], [[1.0, 0.1], [2.0, 0.2]]]), + jnp.array([False, False]), + ), + (constraints.nonnegative_integer, 3, True), + ( + constraints.nonnegative_integer, + jnp.array([-1.0, 0.0, 5.0]), + jnp.array([False, True, True]), + ), + (constraints.positive, 3, True), + (constraints.positive, jnp.array([-1, 0, 5]), jnp.array([False, False, True])), + (constraints.positive_definite, jnp.array([[1.0, 0.3], [0.3, 1.0]]), True), + ( + constraints.positive_definite, + jnp.array([[[2.0, 0.4], [0.3, 2.0]], [[1.0, 0.1], [0.1, 0.0]]]), + jnp.array([False, False]), + ), + (constraints.positive_integer, 3, True), + ( + constraints.positive_integer, + jnp.array([-1.0, 0.0, 5.0]), + jnp.array([False, False, True]), + ), + (constraints.real, -1, True), + ( + constraints.real, + jnp.array([jnp.inf, jnp.NINF, jnp.nan, jnp.pi]), + jnp.array([False, False, False, True]), + ), + (constraints.simplex, jnp.array([0.1, 0.3, 0.6]), True), + ( + constraints.simplex, + jnp.array([[0.1, 0.3, 0.6], [-0.1, 0.6, 0.5], [0.1, 0.6, 0.5]]), + jnp.array([True, False, False]), + ), + (constraints.softplus_positive, 3, True), + ( + constraints.softplus_positive, + jnp.array([-1, 0, 5]), + jnp.array([False, False, True]), + ), + ( + constraints.softplus_lower_cholesky, + jnp.array([[1.0, 0.0], [-2.0, 0.1]]), + True, + ), + ( + constraints.softplus_lower_cholesky, + jnp.array([[[1.0, 0.0], [-2.0, -0.1]], [[1.0, 0.1], [2.0, 0.2]]]), + jnp.array([False, False]), + ), + (constraints.unit_interval, 0.1, True), + ( + constraints.unit_interval, + jnp.array([-5, 0, 0.5, 1, 7]), + jnp.array([False, True, True, True, False]), + ), + ( + constraints.sphere, + jnp.array([[1, 0, 0], [0.5, 0.5, 0]]), + jnp.array([True, False]), + ), + ], +) def test_constraints(constraint, x, expected): assert_array_equal(constraint(x), expected) @@ -1092,25 +1352,29 @@ def test_constraints(constraint, x, expected): assert_allclose(inverse, jnp.zeros_like(inverse), atol=2e-7) -@pytest.mark.parametrize('constraint', [ - constraints.corr_cholesky, - constraints.corr_matrix, - constraints.greater_than(2), - constraints.interval(-3, 5), - constraints.less_than(1), - constraints.lower_cholesky, - constraints.ordered_vector, - constraints.positive, - constraints.positive_definite, - constraints.positive_ordered_vector, - constraints.real, - constraints.real_vector, - constraints.simplex, - constraints.softplus_positive, - constraints.softplus_lower_cholesky, - constraints.unit_interval, -], ids=lambda x: x.__class__) -@pytest.mark.parametrize('shape', [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) +@pytest.mark.parametrize( + "constraint", + [ + constraints.corr_cholesky, + constraints.corr_matrix, + constraints.greater_than(2), + constraints.interval(-3, 5), + constraints.less_than(1), + constraints.lower_cholesky, + constraints.ordered_vector, + constraints.positive, + constraints.positive_definite, + constraints.positive_ordered_vector, + constraints.real, + constraints.real_vector, + constraints.simplex, + constraints.softplus_positive, + constraints.softplus_lower_cholesky, + constraints.unit_interval, + ], + ids=lambda x: x.__class__, +) +@pytest.mark.parametrize("shape", [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) def test_biject_to(constraint, shape): transform = biject_to(constraint) @@ -1133,7 +1397,7 @@ def test_biject_to(constraint, shape): # test inv work for NaN arrays: x_nan = transform.inv(jnp.full(jnp.shape(y), jnp.nan)) - assert (x_nan.shape == x.shape) + assert x_nan.shape == x.shape # test codomain batch_shape = shape if event_dim == 0 else shape[:-1] @@ -1153,25 +1417,37 @@ def test_biject_to(constraint, shape): if constraint is constraints.simplex: expected = np.linalg.slogdet(jax.jacobian(transform)(x)[:-1, :])[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y)[:, :-1])[1] - elif constraint in [constraints.real_vector, constraints.ordered_vector, - constraints.positive_ordered_vector]: + elif constraint in [ + constraints.real_vector, + constraints.ordered_vector, + constraints.positive_ordered_vector, + ]: expected = np.linalg.slogdet(jax.jacobian(transform)(x))[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y))[1] elif constraint in [constraints.corr_cholesky, constraints.corr_matrix]: - vec_transform = lambda x: matrix_to_tril_vec(transform(x), diagonal=-1) # noqa: E731 + vec_transform = lambda x: matrix_to_tril_vec( # noqa: E731 + transform(x), diagonal=-1 + ) y_tril = matrix_to_tril_vec(y, diagonal=-1) def inv_vec_transform(y): matrix = vec_to_tril_matrix(y, diagonal=-1) if constraint is constraints.corr_matrix: # fill the upper triangular part - matrix = matrix + jnp.swapaxes(matrix, -2, -1) + jnp.identity(matrix.shape[-1]) + matrix = ( + matrix + + jnp.swapaxes(matrix, -2, -1) + + jnp.identity(matrix.shape[-1]) + ) return transform.inv(matrix) expected = np.linalg.slogdet(jax.jacobian(vec_transform)(x))[1] inv_expected = np.linalg.slogdet(jax.jacobian(inv_vec_transform)(y_tril))[1] - elif constraint in [constraints.lower_cholesky, constraints.positive_definite, - constraints.softplus_lower_cholesky]: + elif constraint in [ + constraints.lower_cholesky, + constraints.positive_definite, + constraints.softplus_lower_cholesky, + ]: vec_transform = lambda x: matrix_to_tril_vec(transform(x)) # noqa: E731 y_tril = matrix_to_tril_vec(y) @@ -1179,7 +1455,11 @@ def inv_vec_transform(y): matrix = vec_to_tril_matrix(y) if constraint is constraints.positive_definite: # fill the upper triangular part - matrix = matrix + jnp.swapaxes(matrix, -2, -1) - jnp.diag(jnp.diag(matrix)) + matrix = ( + matrix + + jnp.swapaxes(matrix, -2, -1) + - jnp.diag(jnp.diag(matrix)) + ) return transform.inv(matrix) expected = np.linalg.slogdet(jax.jacobian(vec_transform)(x))[1] @@ -1193,13 +1473,21 @@ def inv_vec_transform(y): # NB: skip transforms which are tested in `test_biject_to` -@pytest.mark.parametrize('transform, event_shape', [ - (PermuteTransform(jnp.array([3, 0, 4, 1, 2])), (5,)), - (PowerTransform(2.), ()), - (SoftplusTransform(), ()), - (LowerCholeskyAffine(jnp.array([1., 2.]), jnp.array([[0.6, 0.], [1.5, 0.4]])), (2,)) -]) -@pytest.mark.parametrize('batch_shape', [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) +@pytest.mark.parametrize( + "transform, event_shape", + [ + (PermuteTransform(jnp.array([3, 0, 4, 1, 2])), (5,)), + (PowerTransform(2.0), ()), + (SoftplusTransform(), ()), + ( + LowerCholeskyAffine( + jnp.array([1.0, 2.0]), jnp.array([[0.6, 0.0], [1.5, 0.4]]) + ), + (2,), + ), + ], +) +@pytest.mark.parametrize("batch_shape", [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) def test_bijective_transforms(transform, event_shape, batch_shape): shape = batch_shape + event_shape rng_key = random.PRNGKey(0) @@ -1236,7 +1524,7 @@ def test_bijective_transforms(transform, event_shape, batch_shape): assert_allclose(actual, -inv_expected, atol=1e-6) -@pytest.mark.parametrize('batch_shape', [(), (5,)]) +@pytest.mark.parametrize("batch_shape", [(), (5,)]) def test_composed_transform(batch_shape): t1 = transforms.AffineTransform(0, 2) t2 = transforms.LowerCholeskyTransform() @@ -1248,11 +1536,13 @@ def test_composed_transform(batch_shape): y = t(x) log_det = t.log_abs_det_jacobian(x, y) assert log_det.shape == batch_shape - expected_log_det = jnp.log(2) * 6 + t2.log_abs_det_jacobian(x * 2, y / 2) + jnp.log(2) * 9 + expected_log_det = ( + jnp.log(2) * 6 + t2.log_abs_det_jacobian(x * 2, y / 2) + jnp.log(2) * 9 + ) assert_allclose(log_det, expected_log_det) -@pytest.mark.parametrize('batch_shape', [(), (5,)]) +@pytest.mark.parametrize("batch_shape", [(), (5,)]) def test_composed_transform_1(batch_shape): t1 = transforms.AffineTransform(0, 2) t2 = transforms.LowerCholeskyTransform() @@ -1265,17 +1555,22 @@ def test_composed_transform_1(batch_shape): log_det = t.log_abs_det_jacobian(x, y) assert log_det.shape == batch_shape z = t2(x * 2) - expected_log_det = jnp.log(2) * 6 + t2.log_abs_det_jacobian(x * 2, z) + \ - t2.log_abs_det_jacobian(z, t2(z)).sum(-1) + expected_log_det = ( + jnp.log(2) * 6 + + t2.log_abs_det_jacobian(x * 2, z) + + t2.log_abs_det_jacobian(z, t2(z)).sum(-1) + ) assert_allclose(log_det, expected_log_det) -@pytest.mark.parametrize('batch_shape', [(), (5,)]) -@pytest.mark.parametrize('prepend_event_shape', [(), (4,)]) -@pytest.mark.parametrize('sample_shape', [(), (7,)]) +@pytest.mark.parametrize("batch_shape", [(), (5,)]) +@pytest.mark.parametrize("prepend_event_shape", [(), (4,)]) +@pytest.mark.parametrize("sample_shape", [(), (7,)]) def test_transformed_distribution(batch_shape, prepend_event_shape, sample_shape): - base_dist = dist.Normal(0, 1).expand(batch_shape + prepend_event_shape + (6,)).to_event( - 1 + len(prepend_event_shape) + base_dist = ( + dist.Normal(0, 1) + .expand(batch_shape + prepend_event_shape + (6,)) + .to_event(1 + len(prepend_event_shape)) ) t1 = transforms.AffineTransform(0, 2) t2 = transforms.LowerCholeskyTransform() @@ -1295,21 +1590,36 @@ def test_transformed_distribution(batch_shape, prepend_event_shape, sample_shape assert_allclose(log_prob, expected_log_prob, atol=1e-5) -@pytest.mark.parametrize('transformed_dist', [ - dist.TransformedDistribution(dist.Normal(jnp.array([2., 3.]), 1.), transforms.ExpTransform()), - dist.TransformedDistribution(dist.Exponential(jnp.ones(2)), [ - transforms.PowerTransform(0.7), - transforms.AffineTransform(0., jnp.ones(2) * 3) - ]), -]) +@pytest.mark.parametrize( + "transformed_dist", + [ + dist.TransformedDistribution( + dist.Normal(jnp.array([2.0, 3.0]), 1.0), transforms.ExpTransform() + ), + dist.TransformedDistribution( + dist.Exponential(jnp.ones(2)), + [ + transforms.PowerTransform(0.7), + transforms.AffineTransform(0.0, jnp.ones(2) * 3), + ], + ), + ], +) def test_transformed_distribution_intermediates(transformed_dist): - sample, intermediates = transformed_dist.sample_with_intermediates(random.PRNGKey(1)) - assert_allclose(transformed_dist.log_prob(sample, intermediates), transformed_dist.log_prob(sample)) + sample, intermediates = transformed_dist.sample_with_intermediates( + random.PRNGKey(1) + ) + assert_allclose( + transformed_dist.log_prob(sample, intermediates), + transformed_dist.log_prob(sample), + ) def test_transformed_transformed_distribution(): loc, scale = -2, 3 - dist1 = dist.TransformedDistribution(dist.Normal(2, 3), transforms.PowerTransform(2.)) + dist1 = dist.TransformedDistribution( + dist.Normal(2, 3), transforms.PowerTransform(2.0) + ) dist2 = dist.TransformedDistribution(dist1, transforms.AffineTransform(-2, 3)) assert isinstance(dist2.base_dist, dist.Normal) assert len(dist2.transforms) == 2 @@ -1328,16 +1638,24 @@ def _make_iaf(input_dim, hidden_dims, rng_key): return InverseAutoregressiveTransform(partial(arn, init_params)) -@pytest.mark.parametrize('ts', [ - [transforms.PowerTransform(0.7), transforms.AffineTransform(2., 3.)], - [transforms.ExpTransform()], - [transforms.ComposeTransform([transforms.AffineTransform(-2, 3), - transforms.ExpTransform()]), - transforms.PowerTransform(3.)], - [_make_iaf(5, hidden_dims=[10], rng_key=random.PRNGKey(0)), - transforms.PermuteTransform(jnp.arange(5)[::-1]), - _make_iaf(5, hidden_dims=[10], rng_key=random.PRNGKey(1))] -]) +@pytest.mark.parametrize( + "ts", + [ + [transforms.PowerTransform(0.7), transforms.AffineTransform(2.0, 3.0)], + [transforms.ExpTransform()], + [ + transforms.ComposeTransform( + [transforms.AffineTransform(-2, 3), transforms.ExpTransform()] + ), + transforms.PowerTransform(3.0), + ], + [ + _make_iaf(5, hidden_dims=[10], rng_key=random.PRNGKey(0)), + transforms.PermuteTransform(jnp.arange(5)[::-1]), + _make_iaf(5, hidden_dims=[10], rng_key=random.PRNGKey(1)), + ], + ], +) def test_compose_transform_with_intermediates(ts): transform = transforms.ComposeTransform(ts) x = random.normal(random.PRNGKey(2), (7, 5)) @@ -1347,10 +1665,10 @@ def test_compose_transform_with_intermediates(ts): assert_allclose(logdet, transform.log_abs_det_jacobian(x, y)) -@pytest.mark.parametrize('x_dim, y_dim', [(3, 3), (3, 4)]) +@pytest.mark.parametrize("x_dim, y_dim", [(3, 3), (3, 4)]) def test_unpack_transform(x_dim, y_dim): xy = np.random.randn(x_dim + y_dim) - unpack_fn = lambda xy: {'x': xy[:x_dim], 'y': xy[x_dim:]} # noqa: E731 + unpack_fn = lambda xy: {"x": xy[:x_dim], "y": xy[x_dim:]} # noqa: E731 transform = transforms.UnpackTransform(unpack_fn) z = transform(xy) if x_dim == y_dim: @@ -1362,19 +1680,21 @@ def test_unpack_transform(x_dim, y_dim): assert_allclose(t, xy) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS) -def test_generated_sample_distribution(jax_dist, sp_dist, params, - N_sample=100_000, - key=random.PRNGKey(11)): - """ On samplers that we do not get directly from JAX, (e.g. we only get +@pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS) +def test_generated_sample_distribution( + jax_dist, sp_dist, params, N_sample=100_000, key=random.PRNGKey(11) +): + """On samplers that we do not get directly from JAX, (e.g. we only get Gumbel(0,1) but also provide samplers for Gumbel(loc, scale)), also test agreement in the empirical distribution of generated samples between our samplers and those from SciPy. """ if jax_dist not in [dist.Gumbel]: - pytest.skip("{} sampling method taken from upstream, no need to" - "test generated samples.".format(jax_dist.__name__)) + pytest.skip( + "{} sampling method taken from upstream, no need to" + "test generated samples.".format(jax_dist.__name__) + ) jax_dist = jax_dist(*params) if sp_dist and not jax_dist.event_shape and not jax_dist.batch_shape: @@ -1383,17 +1703,20 @@ def test_generated_sample_distribution(jax_dist, sp_dist, params, assert ks_result.pvalue > 0.05 -@pytest.mark.parametrize('jax_dist, params, support', [ - (dist.BernoulliLogits, (5.,), jnp.arange(2)), - (dist.BernoulliProbs, (0.5,), jnp.arange(2)), - (dist.BinomialLogits, (4.5, 10), jnp.arange(11)), - (dist.BinomialProbs, (0.5, 11), jnp.arange(12)), - (dist.BetaBinomial, (2., 0.5, 12), jnp.arange(13)), - (dist.CategoricalLogits, (jnp.array([3., 4., 5.]),), jnp.arange(3)), - (dist.CategoricalProbs, (jnp.array([0.1, 0.5, 0.4]),), jnp.arange(3)), -]) -@pytest.mark.parametrize('batch_shape', [(5,), ()]) -@pytest.mark.parametrize('expand', [False, True]) +@pytest.mark.parametrize( + "jax_dist, params, support", + [ + (dist.BernoulliLogits, (5.0,), jnp.arange(2)), + (dist.BernoulliProbs, (0.5,), jnp.arange(2)), + (dist.BinomialLogits, (4.5, 10), jnp.arange(11)), + (dist.BinomialProbs, (0.5, 11), jnp.arange(12)), + (dist.BetaBinomial, (2.0, 0.5, 12), jnp.arange(13)), + (dist.CategoricalLogits, (jnp.array([3.0, 4.0, 5.0]),), jnp.arange(3)), + (dist.CategoricalProbs, (jnp.array([0.1, 0.5, 0.4]),), jnp.arange(3)), + ], +) +@pytest.mark.parametrize("batch_shape", [(5,), ()]) +@pytest.mark.parametrize("expand", [False, True]) def test_enumerate_support_smoke(jax_dist, params, support, batch_shape, expand): p0 = jnp.broadcast_to(params[0], batch_shape + jnp.shape(params[0])) actual = jax_dist(p0, *params[1:]).enumerate_support(expand=expand) @@ -1403,15 +1726,9 @@ def test_enumerate_support_smoke(jax_dist, params, support, batch_shape, expand) assert_allclose(actual, expected) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE) -@pytest.mark.parametrize('prepend_shape', [ - (), - (2, 3), -]) -@pytest.mark.parametrize('sample_shape', [ - (), - (4,), -]) +@pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS + DISCRETE) +@pytest.mark.parametrize("prepend_shape", [(), (2, 3)]) +@pytest.mark.parametrize("sample_shape", [(), (4,)]) def test_expand(jax_dist, sp_dist, params, prepend_shape, sample_shape): jax_dist = jax_dist(*params) new_batch_shape = prepend_shape + jax_dist.batch_shape @@ -1422,38 +1739,40 @@ def test_expand(jax_dist, sp_dist, params, prepend_shape, sample_shape): assert samples.shape == sample_shape + new_batch_shape + jax_dist.event_shape assert expanded_dist.log_prob(samples).shape == sample_shape + new_batch_shape # test expand of expand - assert expanded_dist.expand((3,) + new_batch_shape).batch_shape == (3,) + new_batch_shape + assert ( + expanded_dist.expand((3,) + new_batch_shape).batch_shape + == (3,) + new_batch_shape + ) # test expand error if prepend_shape: with pytest.raises(ValueError, match="Cannot broadcast distribution of shape"): assert expanded_dist.expand((3,) + jax_dist.batch_shape) -@pytest.mark.parametrize('base_shape', [(2, 1, 5), (3, 1), (2, 1, 1), (1, 1, 5)]) -@pytest.mark.parametrize('event_dim', [0, 1, 2, 3]) -@pytest.mark.parametrize('sample_shape', [(1000,), (1000, 7, 1), (1000, 1, 7)]) +@pytest.mark.parametrize("base_shape", [(2, 1, 5), (3, 1), (2, 1, 1), (1, 1, 5)]) +@pytest.mark.parametrize("event_dim", [0, 1, 2, 3]) +@pytest.mark.parametrize("sample_shape", [(1000,), (1000, 7, 1), (1000, 1, 7)]) def test_expand_shuffle_regression(base_shape, event_dim, sample_shape): expand_shape = (2, 3, 5) event_dim = min(event_dim, len(base_shape)) loc = random.normal(random.PRNGKey(0), base_shape) * 10 base_dist = dist.Normal(loc, 0.1).to_event(event_dim) - expanded_dist = base_dist.expand(expand_shape[:len(expand_shape) - event_dim]) + expanded_dist = base_dist.expand(expand_shape[: len(expand_shape) - event_dim]) samples = expanded_dist.sample(random.PRNGKey(1), sample_shape) expected_mean = jnp.broadcast_to(loc, sample_shape[1:] + expanded_dist.shape()) assert_allclose(samples.mean(0), expected_mean, atol=0.1) -@pytest.mark.parametrize('batch_shape', [ - (), - (4,), -]) +@pytest.mark.parametrize("batch_shape", [(), (4,)]) def test_polya_gamma(batch_shape, num_points=20000): d = dist.TruncatedPolyaGamma(batch_shape=batch_shape) rng_key = random.PRNGKey(0) # test density approximately normalized x = jnp.linspace(1.0e-6, d.truncation_point, num_points) - prob = (d.truncation_point / num_points) * jnp.exp(logsumexp(d.log_prob(x), axis=-1)) + prob = (d.truncation_point / num_points) * jnp.exp( + logsumexp(d.log_prob(x), axis=-1) + ) assert_allclose(prob, jnp.ones(batch_shape), rtol=1.0e-4) # test mean of approximate sampler @@ -1462,12 +1781,10 @@ def test_polya_gamma(batch_shape, num_points=20000): assert_allclose(mean, 0.25 * jnp.ones(batch_shape), rtol=0.07) -@pytest.mark.parametrize("extra_event_dims,expand_shape", [ - (0, (4, 3, 2, 1)), - (0, (4, 3, 2, 2)), - (1, (5, 4, 3, 2)), - (2, (5, 4, 3)), -]) +@pytest.mark.parametrize( + "extra_event_dims,expand_shape", + [(0, (4, 3, 2, 1)), (0, (4, 3, 2, 2)), (1, (5, 4, 3, 2)), (2, (5, 4, 3))], +) def test_expand_reshaped_distribution(extra_event_dims, expand_shape): loc = jnp.zeros((1, 6)) scale_tril = jnp.eye(6) @@ -1491,58 +1808,58 @@ def test_expand_reshaped_distribution(extra_event_dims, expand_shape): large.expand(expand_shape[1:]) -@pytest.mark.parametrize('batch_shape, mask_shape', [ - ((), ()), - ((2,), ()), - ((), (2,)), - ((2,), (2,)), - ((4, 2), (1, 2)), - ((2,), (4, 2)), -]) -@pytest.mark.parametrize('event_shape', [ - (), - (3,) -]) +@pytest.mark.parametrize( + "batch_shape, mask_shape", + [((), ()), ((2,), ()), ((), (2,)), ((2,), (2,)), ((4, 2), (1, 2)), ((2,), (4, 2))], +) +@pytest.mark.parametrize("event_shape", [(), (3,)]) def test_mask(batch_shape, event_shape, mask_shape): - jax_dist = dist.Normal().expand(batch_shape + event_shape).to_event(len(event_shape)) + jax_dist = ( + dist.Normal().expand(batch_shape + event_shape).to_event(len(event_shape)) + ) mask = dist.Bernoulli(0.5).sample(random.PRNGKey(0), mask_shape) if mask_shape == (): mask = bool(mask) samples = jax_dist.sample(random.PRNGKey(1)) actual = jax_dist.mask(mask).log_prob(samples) - assert_allclose(actual != 0, jnp.broadcast_to(mask, lax.broadcast_shapes(batch_shape, mask_shape))) + assert_allclose( + actual != 0, + jnp.broadcast_to(mask, lax.broadcast_shapes(batch_shape, mask_shape)), + ) -@pytest.mark.parametrize('event_shape', [(), (4,), (2, 4)]) +@pytest.mark.parametrize("event_shape", [(), (4,), (2, 4)]) def test_mask_grad(event_shape): def f(x, data): base_dist = dist.Beta(jnp.exp(x), jnp.ones(event_shape)).to_event() - mask = jnp.all(jnp.isfinite(data), tuple(-i-1 for i in range(len(event_shape)))) + mask = jnp.all( + jnp.isfinite(data), tuple(-i - 1 for i in range(len(event_shape))) + ) log_prob = base_dist.mask(mask).log_prob(data) - assert log_prob.shape == data.shape[:len(data.shape) - len(event_shape)] + assert log_prob.shape == data.shape[: len(data.shape) - len(event_shape)] return log_prob.sum() data = jnp.array([[0.4, jnp.nan, 0.2, jnp.nan], [0.5, 0.5, 0.5, 0.5]]) - log_prob, grad = jax.value_and_grad(f)(1., data) + log_prob, grad = jax.value_and_grad(f)(1.0, data) assert jnp.isfinite(grad) and jnp.isfinite(log_prob) -@pytest.mark.parametrize('jax_dist, sp_dist, params', CONTINUOUS + DISCRETE + DIRECTIONAL) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) def test_dist_pytree(jax_dist, sp_dist, params): def f(x): return jax_dist(*params) if jax_dist is _ImproperWrapper: - pytest.skip('Cannot flattening ImproperUniform') + pytest.skip("Cannot flattening ImproperUniform") jax.jit(f)(0) # this test for flatten/unflatten lax.map(f, np.ones(3)) # this test for compatibility w.r.t. scan -@pytest.mark.parametrize('method, arg', [ - ('to_event', 1), - ('mask', False), - ('expand', [5]), -]) +@pytest.mark.parametrize( + "method, arg", [("to_event", 1), ("mask", False), ("expand", [5])] +) def test_special_dist_pytree(method, arg): def f(x): d = dist.Normal(np.zeros(1), np.ones(1)) @@ -1560,7 +1877,7 @@ def g(x): assert jax.tree_map(lambda x: x[None], g(0)).batch_shape == (1, 10, 3) -@pytest.mark.parametrize('batch_shape', [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("batch_shape", [(), (4,), (2, 3)], ids=str) def test_kl_delta_normal_shape(batch_shape): v = np.random.normal(size=batch_shape) loc = np.random.normal(size=batch_shape) @@ -1570,31 +1887,33 @@ def test_kl_delta_normal_shape(batch_shape): assert kl_divergence(p, q).shape == batch_shape -@pytest.mark.parametrize('batch_shape', [(), (4,), (2, 3)], ids=str) -@pytest.mark.parametrize('event_shape', [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("batch_shape", [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("event_shape", [(), (4,), (2, 3)], ids=str) def test_kl_independent_normal(batch_shape, event_shape): shape = batch_shape + event_shape p = dist.Normal(np.random.normal(size=shape), np.exp(np.random.normal(size=shape))) q = dist.Normal(np.random.normal(size=shape), np.exp(np.random.normal(size=shape))) - actual = kl_divergence(dist.Independent(p, len(event_shape)), - dist.Independent(q, len(event_shape))) + actual = kl_divergence( + dist.Independent(p, len(event_shape)), dist.Independent(q, len(event_shape)) + ) expected = sum_rightmost(kl_divergence(p, q), len(event_shape)) assert_allclose(actual, expected) -@pytest.mark.parametrize('batch_shape', [(), (4,), (2, 3)], ids=str) -@pytest.mark.parametrize('event_shape', [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("batch_shape", [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("event_shape", [(), (4,), (2, 3)], ids=str) def test_kl_expanded_normal(batch_shape, event_shape): shape = batch_shape + event_shape p = dist.Normal(np.random.normal(), np.exp(np.random.normal())).expand(shape) q = dist.Normal(np.random.normal(), np.exp(np.random.normal())).expand(shape) - actual = kl_divergence(dist.Independent(p, len(event_shape)), - dist.Independent(q, len(event_shape))) + actual = kl_divergence( + dist.Independent(p, len(event_shape)), dist.Independent(q, len(event_shape)) + ) expected = sum_rightmost(kl_divergence(p, q), len(event_shape)) assert_allclose(actual, expected) -@pytest.mark.parametrize('shape', [(), (4,), (2, 3)], ids=str) +@pytest.mark.parametrize("shape", [(), (4,), (2, 3)], ids=str) def test_kl_normal_normal(shape): p = dist.Normal(np.random.normal(size=shape), np.exp(np.random.normal(size=shape))) q = dist.Normal(np.random.normal(size=shape), np.exp(np.random.normal(size=shape))) diff --git a/test/test_distributions_util.py b/test/test_distributions_util.py index b11e01612..2be645056 100644 --- a/test/test_distributions_util.py +++ b/test/test_distributions_util.py @@ -20,29 +20,23 @@ multinomial, safe_normalize, vec_to_tril_matrix, - von_mises_centered + von_mises_centered, ) -@pytest.mark.parametrize('x, y', [ - (0.2, 10.), - (0.6, -10.), -]) +@pytest.mark.parametrize("x, y", [(0.2, 10.0), (0.6, -10.0)]) def test_binary_cross_entropy_with_logits(x, y): actual = -y * jnp.log(expit(x)) - (1 - y) * jnp.log(expit(-x)) expect = binary_cross_entropy_with_logits(x, y) assert_allclose(actual, expect, rtol=1e-6) -@pytest.mark.parametrize('prim', [ - xlogy, - xlog1py, -]) +@pytest.mark.parametrize("prim", [xlogy, xlog1py]) def test_binop_batch_rule(prim): - bx = jnp.array([1., 2., 3.]) - by = jnp.array([2., 3., 4.]) - x = jnp.array(1.) - y = jnp.array(2.) + bx = jnp.array([1.0, 2.0, 3.0]) + by = jnp.array([2.0, 3.0, 4.0]) + x = jnp.array(1.0) + y = jnp.array(2.0) actual_bx_by = vmap(lambda x, y: prim(x, y))(bx, by) for i in range(3): @@ -57,22 +51,22 @@ def test_binop_batch_rule(prim): assert_allclose(actual_bx_y[i], prim(bx[i], y)) -@pytest.mark.parametrize('p, shape', [ - (jnp.array([0.1, 0.9]), ()), - (jnp.array([0.2, 0.8]), (2,)), - (jnp.array([[0.1, 0.9], [0.2, 0.8]]), ()), - (jnp.array([[0.1, 0.9], [0.2, 0.8]]), (3, 2)), -]) +@pytest.mark.parametrize( + "p, shape", + [ + (np.array([0.1, 0.9]), ()), + (np.array([0.2, 0.8]), (2,)), + (np.array([[0.1, 0.9], [0.2, 0.8]]), ()), + (np.array([[0.1, 0.9], [0.2, 0.8]]), (3, 2)), + ], +) def test_categorical_shape(p, shape): rng_key = random.PRNGKey(0) expected_shape = lax.broadcast_shapes(p.shape[:-1], shape) assert jnp.shape(categorical(rng_key, p, shape)) == expected_shape -@pytest.mark.parametrize("p", [ - jnp.array([0.2, 0.3, 0.5]), - jnp.array([0.8, 0.1, 0.1]), -]) +@pytest.mark.parametrize("p", [jnp.array([0.2, 0.3, 0.5]), jnp.array([0.8, 0.1, 0.1])]) def test_categorical_stats(p): rng_key = random.PRNGKey(0) n = 10000 @@ -81,12 +75,15 @@ def test_categorical_stats(p): assert_allclose(counts / float(n), p, atol=0.01) -@pytest.mark.parametrize('p, shape', [ - (jnp.array([0.1, 0.9]), ()), - (jnp.array([0.2, 0.8]), (2,)), - (jnp.array([[0.1, 0.9], [0.2, 0.8]]), ()), - (jnp.array([[0.1, 0.9], [0.2, 0.8]]), (3, 2)), -]) +@pytest.mark.parametrize( + "p, shape", + [ + (np.array([0.1, 0.9]), ()), + (np.array([0.2, 0.8]), (2,)), + (np.array([[0.1, 0.9], [0.2, 0.8]]), ()), + (np.array([[0.1, 0.9], [0.2, 0.8]]), (3, 2)), + ], +) def test_multinomial_shape(p, shape): rng_key = random.PRNGKey(0) n = 10000 @@ -94,14 +91,8 @@ def test_multinomial_shape(p, shape): assert jnp.shape(multinomial(rng_key, p, n, shape)) == expected_shape -@pytest.mark.parametrize("p", [ - jnp.array([0.2, 0.3, 0.5]), - jnp.array([0.8, 0.1, 0.1]), -]) -@pytest.mark.parametrize("n", [ - 10000, - jnp.array([10000, 20000]), -]) +@pytest.mark.parametrize("p", [np.array([0.2, 0.3, 0.5]), np.array([0.8, 0.1, 0.1])]) +@pytest.mark.parametrize("n", [10000, np.array([10000, 20000])]) def test_multinomial_stats(p, n): rng_key = random.PRNGKey(0) z = multinomial(rng_key, p, n) @@ -110,16 +101,8 @@ def test_multinomial_stats(p, n): assert_allclose(z / n, p, atol=0.01) -@pytest.mark.parametrize("shape", [ - (6,), - (5, 10), - (3, 4, 3), -]) -@pytest.mark.parametrize("diagonal", [ - 0, - -1, - -2, -]) +@pytest.mark.parametrize("shape", [(6,), (5, 10), (3, 4, 3)]) +@pytest.mark.parametrize("diagonal", [0, -1, -2]) def test_vec_to_tril_matrix(shape, diagonal): rng_key = random.PRNGKey(0) x = random.normal(rng_key, shape) @@ -145,7 +128,7 @@ def test_cholesky_update(chol_batch_shape, vec_batch_shape, dim, coef): @pytest.mark.parametrize("n", [10, 100, 1000]) -@pytest.mark.parametrize("p", [0., 0.01, 0.05, 0.3, 0.5, 0.7, 0.95, 1.]) +@pytest.mark.parametrize("p", [0.0, 0.01, 0.05, 0.3, 0.5, 0.7, 0.95, 1.0]) def test_binomial_mean(n, p): samples = binomial(random.PRNGKey(1), p, n, shape=(100, 100)).astype(np.float32) expected_mean = n * p diff --git a/test/test_example_utils.py b/test/test_example_utils.py index 6aef746a2..65221d2d7 100644 --- a/test/test_example_utils.py +++ b/test/test_example_utils.py @@ -3,12 +3,19 @@ import jax.numpy as jnp -from numpyro.examples.datasets import BASEBALL, COVTYPE, JSB_CHORALES, MNIST, SP500, load_dataset +from numpyro.examples.datasets import ( + BASEBALL, + COVTYPE, + JSB_CHORALES, + MNIST, + SP500, + load_dataset, +) from numpyro.util import fori_loop def test_baseball_data_load(): - init, fetch = load_dataset(BASEBALL, split='train', shuffle=False) + init, fetch = load_dataset(BASEBALL, split="train", shuffle=False) num_batches, idx = init() dataset = fetch(0, idx) assert jnp.shape(dataset[0]) == (18, 2) @@ -27,19 +34,19 @@ def mean_pixels(i, mean_pix): batch, _ = fetch(i, idx) return mean_pix + jnp.sum(batch) / batch.size - init, fetch = load_dataset(MNIST, batch_size=128, split='train') + init, fetch = load_dataset(MNIST, batch_size=128, split="train") num_batches, idx = init() - assert fori_loop(0, num_batches, mean_pixels, jnp.float32(0.)) / num_batches < 0.15 + assert fori_loop(0, num_batches, mean_pixels, jnp.float32(0.0)) / num_batches < 0.15 def test_sp500_data_load(): - _, fetch = load_dataset(SP500, split='train', shuffle=False) + _, fetch = load_dataset(SP500, split="train", shuffle=False) date, value = fetch() assert jnp.shape(date) == jnp.shape(date) == (2427,) def test_jsb_chorales(): - _, fetch = load_dataset(JSB_CHORALES, split='train', shuffle=False) + _, fetch = load_dataset(JSB_CHORALES, split="train", shuffle=False) lengths, sequences = fetch() assert jnp.shape(lengths) == (229,) assert jnp.shape(sequences) == (229, 129, 88) diff --git a/test/test_examples.py b/test/test_examples.py index 771c7b660..9f29f6e9f 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -8,45 +8,45 @@ import pytest TESTS_DIR = os.path.dirname(os.path.abspath(__file__)) -EXAMPLES_DIR = os.path.join(os.path.dirname(TESTS_DIR), 'examples') +EXAMPLES_DIR = os.path.join(os.path.dirname(TESTS_DIR), "examples") EXAMPLES = [ - 'annotation.py --model mn', - 'annotation.py --model ds', - 'annotation.py --model mace', - 'annotation.py --model hds', - 'annotation.py --model id', - 'annotation.py --model lre', - 'baseball.py --num-samples 100 --num-warmup 100 --num-chains 2', - 'bnn.py --num-samples 10 --num-warmup 10 --num-data 7 --num-chains 2', - 'capture_recapture.py --num-samples 4 --num-warmup 1 -m 3', - 'capture_recapture.py --num-samples 4 --num-warmup 1 -m 5', - 'covtype.py --algo HMC --num-samples 10 --num-warmup 10', - 'gp.py --num-samples 10 --num-warmup 10 --num-chains 2', - 'hmcecs.py --subsample_size 5 --num_svi_steps 1 --num_blocks 1 ' - '--dataset mock --num_warmup 1 --num_samples 5 --num_datapoints 100', - 'hmm.py --num-samples 100 --num-warmup 100 --num-chains 2', - 'hmm_enum.py -m 1 -t 3 -d 4 --num-warmup 1 -n 4', - 'hmm_enum.py -m 2 -t 3 -d 4 --num-warmup 1 -n 4', - 'hmm_enum.py -m 3 -t 3 -d 3 --num-warmup 1 -n 4', - 'hmm_enum.py -m 3 -t 3 -d 4 --num-warmup 1 -n 4', - 'hmm_enum.py -m 4 -t 3 -d 4 --num-warmup 1 -n 4', - 'hmm_enum.py -m 6 -t 4 -d 3 --num-warmup 1 -n 4', - 'minipyro.py', - 'neutra.py --num-samples 100 --num-warmup 100', - 'ode.py --num-samples 100 --num-warmup 100 --num-chains 1', - 'sparse_regression.py --num-samples 10 --num-warmup 10 --num-data 10 --num-dimensions 10', - 'stochastic_volatility.py --num-samples 100 --num-warmup 100', - 'ucbadmit.py --num-chains 2', - 'vae.py -n 1', + "annotation.py --model mn", + "annotation.py --model ds", + "annotation.py --model mace", + "annotation.py --model hds", + "annotation.py --model id", + "annotation.py --model lre", + "baseball.py --num-samples 100 --num-warmup 100 --num-chains 2", + "bnn.py --num-samples 10 --num-warmup 10 --num-data 7 --num-chains 2", + "capture_recapture.py --num-samples 4 --num-warmup 1 -m 3", + "capture_recapture.py --num-samples 4 --num-warmup 1 -m 5", + "covtype.py --algo HMC --num-samples 10 --num-warmup 10", + "gp.py --num-samples 10 --num-warmup 10 --num-chains 2", + "hmcecs.py --subsample_size 5 --num_svi_steps 1 --num_blocks 1 " + "--dataset mock --num_warmup 1 --num_samples 5 --num_datapoints 100", + "hmm.py --num-samples 100 --num-warmup 100 --num-chains 2", + "hmm_enum.py -m 1 -t 3 -d 4 --num-warmup 1 -n 4", + "hmm_enum.py -m 2 -t 3 -d 4 --num-warmup 1 -n 4", + "hmm_enum.py -m 3 -t 3 -d 3 --num-warmup 1 -n 4", + "hmm_enum.py -m 3 -t 3 -d 4 --num-warmup 1 -n 4", + "hmm_enum.py -m 4 -t 3 -d 4 --num-warmup 1 -n 4", + "hmm_enum.py -m 6 -t 4 -d 3 --num-warmup 1 -n 4", + "minipyro.py", + "neutra.py --num-samples 100 --num-warmup 100", + "ode.py --num-samples 100 --num-warmup 100 --num-chains 1", + "sparse_regression.py --num-samples 10 --num-warmup 10 --num-data 10 --num-dimensions 10", + "stochastic_volatility.py --num-samples 100 --num-warmup 100", + "ucbadmit.py --num-chains 2", + "vae.py -n 1", ] -@pytest.mark.parametrize('example', EXAMPLES) +@pytest.mark.parametrize("example", EXAMPLES) @pytest.mark.filterwarnings("ignore:There are not enough devices:UserWarning") @pytest.mark.filterwarnings("ignore:Higgs is a 2.6 GB dataset:UserWarning") def test_cpu(example): - print('Running:\npython examples/{}'.format(example)) + print("Running:\npython examples/{}".format(example)) example = example.split() filename, args = example[0], example[1:] filename = os.path.join(EXAMPLES_DIR, filename) diff --git a/test/test_flows.py b/test/test_flows.py index 752bc8a88..769644fc3 100644 --- a/test/test_flows.py +++ b/test/test_flows.py @@ -10,7 +10,10 @@ from jax import jacfwd, random from jax.experimental import stax -from numpyro.distributions.flows import BlockNeuralAutoregressiveTransform, InverseAutoregressiveTransform +from numpyro.distributions.flows import ( + BlockNeuralAutoregressiveTransform, + InverseAutoregressiveTransform, +) from numpyro.distributions.util import matrix_to_tril_vec from numpyro.nn import AutoregressiveNN, BlockNeuralAutoregressiveNN @@ -20,26 +23,38 @@ def _make_iaf_args(input_dim, hidden_dims): perm = random.permutation(rng_perm, np.arange(input_dim)) # we use Elu nonlinearity because the default one, Relu, masks out negative hidden values, # which in turn create some zero entries in the lower triangular part of Jacobian. - arn_init, arn = AutoregressiveNN(input_dim, hidden_dims, param_dims=[1, 1], - permutation=perm, nonlinearity=stax.Elu) + arn_init, arn = AutoregressiveNN( + input_dim, + hidden_dims, + param_dims=[1, 1], + permutation=perm, + nonlinearity=stax.Elu, + ) _, init_params = arn_init(random.PRNGKey(0), (input_dim,)) - return partial(arn, init_params), + return (partial(arn, init_params),) def _make_bnaf_args(input_dim, hidden_factors): arn_init, arn = BlockNeuralAutoregressiveNN(input_dim, hidden_factors) _, rng_key_perm = random.split(random.PRNGKey(0)) _, init_params = arn_init(random.PRNGKey(0), (input_dim,)) - return partial(arn, init_params), - - -@pytest.mark.parametrize('flow_class, flow_args, input_dim', [ - (InverseAutoregressiveTransform, _make_iaf_args(5, hidden_dims=[10]), 5), - (InverseAutoregressiveTransform, _make_iaf_args(7, hidden_dims=[8, 9]), 7), - (BlockNeuralAutoregressiveTransform, _make_bnaf_args(7, hidden_factors=[4]), 7), - (BlockNeuralAutoregressiveTransform, _make_bnaf_args(7, hidden_factors=[2, 3]), 7), -]) -@pytest.mark.parametrize('batch_shape', [(), (1,), (4,), (2, 3)]) + return (partial(arn, init_params),) + + +@pytest.mark.parametrize( + "flow_class, flow_args, input_dim", + [ + (InverseAutoregressiveTransform, _make_iaf_args(5, hidden_dims=[10]), 5), + (InverseAutoregressiveTransform, _make_iaf_args(7, hidden_dims=[8, 9]), 7), + (BlockNeuralAutoregressiveTransform, _make_bnaf_args(7, hidden_factors=[4]), 7), + ( + BlockNeuralAutoregressiveTransform, + _make_bnaf_args(7, hidden_factors=[2, 3]), + 7, + ), + ], +) +@pytest.mark.parametrize("batch_shape", [(), (1,), (4,), (2, 3)]) def test_flows(flow_class, flow_args, input_dim, batch_shape): transform = flow_class(*flow_args) x = random.normal(random.PRNGKey(0), batch_shape + (input_dim,)) diff --git a/test/test_handlers.py b/test/test_handlers.py index d868792c0..ccdfe9c66 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -18,65 +18,59 @@ from numpyro.util import not_jax_tracer, optional -@pytest.mark.parametrize('mask_last', [1, 5, 10]) -@pytest.mark.parametrize('use_jit', [False, True]) +@pytest.mark.parametrize("mask_last", [1, 5, 10]) +@pytest.mark.parametrize("use_jit", [False, True]) def test_mask(mask_last, use_jit): N = 10 mask = np.ones(N, dtype=np.bool) mask[-mask_last] = 0 def model(data, mask): - with numpyro.plate('N', N): - x = numpyro.sample('x', dist.Normal(0, 1)) + with numpyro.plate("N", N): + x = numpyro.sample("x", dist.Normal(0, 1)) with handlers.mask(mask=mask): - numpyro.sample('y', dist.Delta(x, log_density=1.)) + numpyro.sample("y", dist.Delta(x, log_density=1.0)) with handlers.scale(scale=2): - numpyro.sample('obs', dist.Normal(x, 1), obs=data) + numpyro.sample("obs", dist.Normal(x, 1), obs=data) data = random.normal(random.PRNGKey(0), (N,)) x = random.normal(random.PRNGKey(1), (N,)) if use_jit: log_joint = jit(lambda *args: log_density(*args)[0], static_argnums=(0,))( - model, (data, mask), {}, {'x': x, 'y': x}) + model, (data, mask), {}, {"x": x, "y": x} + ) else: - log_joint = log_density(model, (data, mask), {}, {'x': x, 'y': x})[0] + log_joint = log_density(model, (data, mask), {}, {"x": x, "y": x})[0] log_prob_x = dist.Normal(0, 1).log_prob(x) log_prob_y = mask log_prob_z = dist.Normal(x, 1).log_prob(data) - expected = (log_prob_x + jnp.where(mask, log_prob_y + 2 * log_prob_z, 0.)).sum() + expected = (log_prob_x + jnp.where(mask, log_prob_y + 2 * log_prob_z, 0.0)).sum() assert_allclose(log_joint, expected, atol=1e-4) @pytest.mark.parametrize("num_particles", [1, 2]) -@pytest.mark.parametrize("mask", [ - True, - False, - np.array([True]), - np.array([False]), - np.array([False, True, False]), -]) -@pytest.mark.parametrize("Elbo", [ - Trace_ELBO, -]) +@pytest.mark.parametrize( + "mask", + [True, False, np.array([True]), np.array([False]), np.array([False, True, False])], +) +@pytest.mark.parametrize("Elbo", [Trace_ELBO]) def test_obs_mask_ok(Elbo, mask, num_particles): - data = np.array([7., 7., 7.]) + data = np.array([7.0, 7.0, 7.0]) def model(): - x = numpyro.sample("x", dist.Normal(0., 1.)) + x = numpyro.sample("x", dist.Normal(0.0, 1.0)) with numpyro.plate("plate", len(data)): - y = numpyro.sample("y", dist.Normal(x, 1.), - obs=data, obs_mask=mask) + y = numpyro.sample("y", dist.Normal(x, 1.0), obs=data, obs_mask=mask) if not_jax_tracer(y): assert ((y == data) == mask).all() def guide(): loc = numpyro.param("loc", np.zeros(())) - scale = numpyro.param("scale", np.ones(()), - constraint=constraints.positive) + scale = numpyro.param("scale", np.ones(()), constraint=constraints.positive) x = numpyro.sample("x", dist.Normal(loc, scale)) with numpyro.plate("plate", len(data)): with handlers.mask(mask=np.invert(mask)): - numpyro.sample("y_unobserved", dist.Normal(x, 1.)) + numpyro.sample("y_unobserved", dist.Normal(x, 1.0)) elbo = Elbo(num_particles=num_particles) svi = SVI(model, guide, numpyro.optim.Adam(1), elbo) @@ -85,31 +79,32 @@ def guide(): @pytest.mark.parametrize("num_particles", [1, 2]) -@pytest.mark.parametrize("mask", [ - True, - False, - np.array([True]), - np.array([False]), - np.array([False, True, True, False]), -]) -@pytest.mark.parametrize("Elbo", [ - Trace_ELBO, -]) +@pytest.mark.parametrize( + "mask", + [ + True, + False, + np.array([True]), + np.array([False]), + np.array([False, True, True, False]), + ], +) +@pytest.mark.parametrize("Elbo", [Trace_ELBO]) def test_obs_mask_multivariate_ok(Elbo, mask, num_particles): data = np.full((4, 3), 7.0) def model(): x = numpyro.sample("x", dist.MultivariateNormal(np.zeros(3), np.eye(3))) with numpyro.plate("plate", len(data)): - y = numpyro.sample("y", dist.MultivariateNormal(x, np.eye(3)), - obs=data, obs_mask=mask) + y = numpyro.sample( + "y", dist.MultivariateNormal(x, np.eye(3)), obs=data, obs_mask=mask + ) if not_jax_tracer(y): assert ((y == data).all(-1) == mask).all() def guide(): loc = numpyro.param("loc", np.zeros(3)) - cov = numpyro.param("cov", np.eye(3), - constraint=constraints.positive_definite) + cov = numpyro.param("cov", np.eye(3), constraint=constraints.positive_definite) x = numpyro.sample("x", dist.MultivariateNormal(loc, cov)) with numpyro.plate("plate", len(data)): with handlers.mask(mask=np.invert(mask)): @@ -124,41 +119,50 @@ def guide(): def test_mask_inf(): def model(): with handlers.mask(mask=jnp.zeros(10, dtype=bool)): - numpyro.factor('inf', -jnp.inf) + numpyro.factor("inf", -jnp.inf) log_joint = log_density(model, (), {}, {})[0] - assert_allclose(log_joint, 0.) + assert_allclose(log_joint, 0.0) -@pytest.mark.parametrize('use_context_manager', [True, False]) +@pytest.mark.parametrize("use_context_manager", [True, False]) def test_scale(use_context_manager): def model(data): - x = numpyro.sample('x', dist.Normal(0, 1)) + x = numpyro.sample("x", dist.Normal(0, 1)) with optional(use_context_manager, handlers.scale(scale=10)): - numpyro.sample('obs', dist.Normal(x, 1), obs=data) + numpyro.sample("obs", dist.Normal(x, 1), obs=data) - model = model if use_context_manager else handlers.scale(model, 10.) + model = model if use_context_manager else handlers.scale(model, 10.0) data = random.normal(random.PRNGKey(0), (3,)) x = random.normal(random.PRNGKey(1)) - log_joint = log_density(model, (data,), {}, {'x': x})[0] - log_prob1, log_prob2 = dist.Normal(0, 1).log_prob(x), dist.Normal(x, 1).log_prob(data).sum() - expected = log_prob1 + 10 * log_prob2 if use_context_manager else 10 * (log_prob1 + log_prob2) + log_joint = log_density(model, (data,), {}, {"x": x})[0] + log_prob1, log_prob2 = ( + dist.Normal(0, 1).log_prob(x), + dist.Normal(x, 1).log_prob(data).sum(), + ) + expected = ( + log_prob1 + 10 * log_prob2 + if use_context_manager + else 10 * (log_prob1 + log_prob2) + ) assert_allclose(log_joint, expected) def test_substitute(): def model(): - x = numpyro.param('x', None) - y = handlers.substitute(lambda: numpyro.param('y', None) * numpyro.param('x', None), {'y': x})() + x = numpyro.param("x", None) + y = handlers.substitute( + lambda: numpyro.param("y", None) * numpyro.param("x", None), {"y": x} + )() return x + y - assert handlers.substitute(model, {'x': 3.})() == 12. + assert handlers.substitute(model, {"x": 3.0})() == 12.0 def test_seed(): def _sample(): - x = numpyro.sample('x', dist.Normal(0., 1.)) - y = numpyro.sample('y', dist.Normal(1., 2.)) + x = numpyro.sample("x", dist.Normal(0.0, 1.0)) + y = numpyro.sample("y", dist.Normal(1.0, 2.0)) return jnp.stack([x, y]) xs = [] @@ -167,7 +171,9 @@ def _sample(): xs.append(_sample()) xs = jnp.stack(xs) - ys = vmap(lambda rng_key: handlers.seed(lambda: _sample(), rng_key)())(jnp.arange(100)) + ys = vmap(lambda rng_key: handlers.seed(lambda: _sample(), rng_key)())( + jnp.arange(100) + ) assert_allclose(xs, ys, atol=1e-6) @@ -176,9 +182,9 @@ def fn(rng_key_1, rng_key_2, rng_key_3): xs = [] with handlers.seed(rng_seed=rng_key_1): with handlers.seed(rng_seed=rng_key_2): - xs.append(numpyro.sample('x', dist.Normal(0., 1.))) + xs.append(numpyro.sample("x", dist.Normal(0.0, 1.0))) with handlers.seed(rng_seed=rng_key_3): - xs.append(numpyro.sample('y', dist.Normal(0., 1.))) + xs.append(numpyro.sample("y", dist.Normal(0.0, 1.0))) return jnp.stack(xs) s1, s2 = fn(0, 1, 2), fn(3, 1, 2) @@ -190,150 +196,153 @@ def fn(rng_key_1, rng_key_2, rng_key_3): def test_condition(): def model(): - x = numpyro.sample('x', dist.Delta(0.)) - y = numpyro.sample('y', dist.Normal(0., 1.)) + x = numpyro.sample("x", dist.Delta(0.0)) + y = numpyro.sample("y", dist.Normal(0.0, 1.0)) return x + y - model = handlers.condition(handlers.seed(model, random.PRNGKey(1)), {'y': 2.}) + model = handlers.condition(handlers.seed(model, random.PRNGKey(1)), {"y": 2.0}) model_trace = handlers.trace(model).get_trace() - assert model_trace['y']['value'] == 2. - assert model_trace['y']['is_observed'] - assert handlers.condition(model, {'y': 3.})() == 3. + assert model_trace["y"]["value"] == 2.0 + assert model_trace["y"]["is_observed"] + assert handlers.condition(model, {"y": 3.0})() == 3.0 def test_no_split_deterministic(): def model(): - x = numpyro.sample('x', dist.Normal(0., 1.)) - y = numpyro.sample('y', dist.Normal(0., 1.)) + x = numpyro.sample("x", dist.Normal(0.0, 1.0)) + y = numpyro.sample("y", dist.Normal(0.0, 1.0)) return x + y - model = handlers.condition(model, {'x': 1., 'y': 2.}) - assert model() == 3. + model = handlers.condition(model, {"x": 1.0, "y": 2.0}) + assert model() == 3.0 def model_nested_plates_0(): - with numpyro.plate('outer', 10): - x = numpyro.sample('y', dist.Normal(0., 1.)) + with numpyro.plate("outer", 10): + x = numpyro.sample("y", dist.Normal(0.0, 1.0)) assert x.shape == (10,) - with numpyro.plate('inner', 5): - y = numpyro.sample('x', dist.Normal(0., 1.)) + with numpyro.plate("inner", 5): + y = numpyro.sample("x", dist.Normal(0.0, 1.0)) assert y.shape == (5, 10) - z = numpyro.deterministic('z', x ** 2) + z = numpyro.deterministic("z", x ** 2) assert z.shape == (10,) def model_nested_plates_1(): - with numpyro.plate('outer', 10, dim=-2): - x = numpyro.sample('y', dist.Normal(0., 1.)) + with numpyro.plate("outer", 10, dim=-2): + x = numpyro.sample("y", dist.Normal(0.0, 1.0)) assert x.shape == (10, 1) - with numpyro.plate('inner', 5): - y = numpyro.sample('x', dist.Normal(0., 1.)) + with numpyro.plate("inner", 5): + y = numpyro.sample("x", dist.Normal(0.0, 1.0)) assert y.shape == (10, 5) - z = numpyro.deterministic('z', x ** 2) + z = numpyro.deterministic("z", x ** 2) assert z.shape == (10, 1) def model_nested_plates_2(): - outer = numpyro.plate('outer', 10) - inner = numpyro.plate('inner', 5, dim=-3) + outer = numpyro.plate("outer", 10) + inner = numpyro.plate("inner", 5, dim=-3) with outer: - x = numpyro.sample('x', dist.Normal(0., 1.)) + x = numpyro.sample("x", dist.Normal(0.0, 1.0)) assert x.shape == (10,) with inner: - y = numpyro.sample('y', dist.Normal(0., 1.)) + y = numpyro.sample("y", dist.Normal(0.0, 1.0)) assert y.shape == (5, 1, 1) - z = numpyro.deterministic('z', x ** 2) + z = numpyro.deterministic("z", x ** 2) assert z.shape == (10,) with outer, inner: - xy = numpyro.sample('xy', dist.Normal(0., 1.), sample_shape=(10,)) + xy = numpyro.sample("xy", dist.Normal(0.0, 1.0), sample_shape=(10,)) assert xy.shape == (5, 1, 10) def model_nested_plates_3(): - outer = numpyro.plate('outer', 10, dim=-1) - inner = numpyro.plate('inner', 5, dim=-2) - numpyro.deterministic('z', 1.) + outer = numpyro.plate("outer", 10, dim=-1) + inner = numpyro.plate("inner", 5, dim=-2) + numpyro.deterministic("z", 1.0) with inner, outer: - xy = numpyro.sample('xy', dist.Normal(jnp.zeros((5, 10)), 1.)) + xy = numpyro.sample("xy", dist.Normal(jnp.zeros((5, 10)), 1.0)) assert xy.shape == (5, 10) def model_dist_batch_shape(): - outer = numpyro.plate('outer', 10) - inner = numpyro.plate('inner', 5, dim=-3) + outer = numpyro.plate("outer", 10) + inner = numpyro.plate("inner", 5, dim=-3) with outer: - x = numpyro.sample('x', dist.Normal(jnp.zeros(10), 1.)) + x = numpyro.sample("x", dist.Normal(jnp.zeros(10), 1.0)) assert x.shape == (10,) with inner: - y = numpyro.sample('y', dist.Normal(0., jnp.ones(10))) + y = numpyro.sample("y", dist.Normal(0.0, jnp.ones(10))) assert y.shape == (5, 1, 10) - z = numpyro.deterministic('z', x ** 2) + z = numpyro.deterministic("z", x ** 2) assert z.shape == (10,) with outer, inner: - xy = numpyro.sample('xy', dist.Normal(0., jnp.ones(10)), sample_shape=(10,)) + xy = numpyro.sample("xy", dist.Normal(0.0, jnp.ones(10)), sample_shape=(10,)) assert xy.shape == (5, 10, 10) def model_subsample_1(): - outer = numpyro.plate('outer', 20, subsample_size=10) - inner = numpyro.plate('inner', 10, subsample_size=5, dim=-3) + outer = numpyro.plate("outer", 20, subsample_size=10) + inner = numpyro.plate("inner", 10, subsample_size=5, dim=-3) with outer: - x = numpyro.sample('x', dist.Normal(0., 1.)) + x = numpyro.sample("x", dist.Normal(0.0, 1.0)) assert x.shape == (10,) with inner: - y = numpyro.sample('y', dist.Normal(0., 1.)) + y = numpyro.sample("y", dist.Normal(0.0, 1.0)) assert y.shape == (5, 1, 1) - z = numpyro.deterministic('z', x ** 2) + z = numpyro.deterministic("z", x ** 2) assert z.shape == (10,) with outer, inner: - xy = numpyro.sample('xy', dist.Normal(0., 1.)) + xy = numpyro.sample("xy", dist.Normal(0.0, 1.0)) assert xy.shape == (5, 1, 10) def model_subsample_2(): data = jnp.ones((10, 1, 20)) - outer = numpyro.plate('outer', data.shape[-1], subsample_size=10) - inner = numpyro.plate('inner', data.shape[-3], subsample_size=5, dim=-3) + outer = numpyro.plate("outer", data.shape[-1], subsample_size=10) + inner = numpyro.plate("inner", data.shape[-3], subsample_size=5, dim=-3) with outer: - x = numpyro.sample('x', dist.Normal(0., 1.)) + x = numpyro.sample("x", dist.Normal(0.0, 1.0)) assert x.shape == (10,) with inner: - y = numpyro.sample('y', dist.Normal(0., 1.)) + y = numpyro.sample("y", dist.Normal(0.0, 1.0)) assert y.shape == (5, 1, 1) - z = numpyro.deterministic('z', x ** 2) + z = numpyro.deterministic("z", x ** 2) assert z.shape == (10,) with outer, inner: - xy = numpyro.sample('xy', dist.Normal(0., 1.)) + xy = numpyro.sample("xy", dist.Normal(0.0, 1.0)) assert xy.shape == (5, 1, 10) subsample_data = numpyro.subsample(data, event_dim=0) assert subsample_data.shape == (5, 1, 10) -@pytest.mark.parametrize('model', [ - model_nested_plates_0, - model_nested_plates_1, - model_nested_plates_2, - model_nested_plates_3, - model_dist_batch_shape, - model_subsample_1, - model_subsample_2, -]) +@pytest.mark.parametrize( + "model", + [ + model_nested_plates_0, + model_nested_plates_1, + model_nested_plates_2, + model_nested_plates_3, + model_dist_batch_shape, + model_subsample_1, + model_subsample_2, + ], +) def test_plate(model): trace = handlers.trace(handlers.seed(model, random.PRNGKey(1))).get_trace() jit_trace = handlers.trace(jit(handlers.seed(model, random.PRNGKey(1)))).get_trace() - assert 'z' in trace + assert "z" in trace for name, site in trace.items(): - if site['type'] == 'sample': - assert_allclose(jit_trace[name]['value'].shape, site['value'].shape) + if site["type"] == "sample": + assert_allclose(jit_trace[name]["value"].shape, site["value"].shape) def test_subsample_data(): - data = jnp.arange(100.) + data = jnp.arange(100.0) subsample_size = 7 with handlers.seed(rng_seed=0): with numpyro.plate("a", len(data), subsample_size=subsample_size) as idx: @@ -343,21 +352,23 @@ def test_subsample_data(): def test_subsample_param(): - data = jnp.arange(100.) + data = jnp.arange(100.0) subsample_size = 7 with handlers.seed(rng_seed=0): with numpyro.plate("a", len(data), subsample_size=subsample_size): - p0 = numpyro.param("p0", 0., event_dim=0) + p0 = numpyro.param("p0", 0.0, event_dim=0) assert jnp.shape(p0) == () p = numpyro.param("p", 0.5 * jnp.ones(len(data)), event_dim=0) assert len(p) == subsample_size def test_subsample_substitute(): - data = jnp.arange(100.) + data = jnp.arange(100.0) subsample_size = 7 subsample = jnp.array([13, 3, 30, 4, 1, 68, 5]) - with handlers.trace() as tr, handlers.seed(rng_seed=0), handlers.substitute(data={"a": subsample}): + with handlers.trace() as tr, handlers.seed(rng_seed=0), handlers.substitute( + data={"a": subsample} + ): with numpyro.plate("a", len(data), subsample_size=subsample_size) as idx: assert data[idx].shape == (subsample_size,) assert_allclose(idx, subsample) @@ -365,7 +376,7 @@ def test_subsample_substitute(): def test_subsample_replay(): - data = jnp.arange(100.) + data = jnp.arange(100.0) subsample_size = 7 with handlers.trace() as guide_trace, handlers.seed(rng_seed=0): @@ -378,7 +389,7 @@ def test_subsample_replay(): assert subsample_data.shape == (subsample_size,) -@pytest.mark.parametrize("scale", [1., 2.], ids=["unscaled", "scaled"]) +@pytest.mark.parametrize("scale", [1.0, 2.0], ids=["unscaled", "scaled"]) @pytest.mark.parametrize("subsample", [False, True], ids=["full", "subsample"]) def test_subsample_gradient(scale, subsample): data = jnp.array([-0.5, 2.0]) @@ -393,13 +404,13 @@ def model(subsample): numpyro.sample("x", dist.Normal(z, 1), obs=x) def guide(subsample): - scale = numpyro.param("scale", 1.) + scale = numpyro.param("scale", 1.0) with handlers.substitute(data={"data": subsample}): with numpyro.plate("data", len(data), subsample_size): loc = numpyro.param("loc", jnp.zeros(len(data)), event_dim=0) numpyro.sample("z", dist.Normal(loc, scale)) - if scale != 1.: + if scale != 1.0: model = handlers.scale(model, scale=scale) guide = handlers.scale(guide, scale=scale) @@ -412,28 +423,45 @@ def guide(subsample): normalizer = 2 if subsample else 1 if subsample_size == 1: subsample = jnp.array([0]) - loss1, grads1 = value_and_grad(lambda x: svi.loss.loss( - svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, subsample))(params) + loss1, grads1 = value_and_grad( + lambda x: svi.loss.loss( + svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, subsample + ) + )(params) subsample = jnp.array([1]) - loss2, grads2 = value_and_grad(lambda x: svi.loss.loss( - svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, subsample))(params) + loss2, grads2 = value_and_grad( + lambda x: svi.loss.loss( + svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, subsample + ) + )(params) grads = tree_multimap(lambda *vals: vals[0] + vals[1], grads1, grads2) loss = loss1 + loss2 else: subsample = jnp.array([0, 1]) - loss, grads = value_and_grad(lambda x: svi.loss.loss( - svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, subsample))(params) + loss, grads = value_and_grad( + lambda x: svi.loss.loss( + svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, subsample + ) + )(params) actual_loss = loss / normalizer - expected_loss, _ = value_and_grad(lambda x: svi.loss.loss( - svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, None))(params) + expected_loss, _ = value_and_grad( + lambda x: svi.loss.loss( + svi_state.rng_key, svi.constrain_fn(x), svi.model, svi.guide, None + ) + )(params) assert_allclose(actual_loss, expected_loss, rtol=precision, atol=precision) actual_grads = {name: grad / normalizer for name, grad in grads.items()} - expected_grads = {'loc': scale * jnp.array([0.5, -2.0]), 'scale': scale * jnp.array([2.0])} + expected_grads = { + "loc": scale * jnp.array([0.5, -2.0]), + "scale": scale * jnp.array([2.0]), + } assert actual_grads.keys() == expected_grads.keys() for name in expected_grads: - assert_allclose(actual_grads[name], expected_grads[name], rtol=precision, atol=precision) + assert_allclose( + actual_grads[name], expected_grads[name], rtol=precision, atol=precision + ) def test_messenger_fn_invalid(): @@ -442,7 +470,7 @@ def test_messenger_fn_invalid(): pass -@pytest.mark.parametrize('shape', [(), (5,), (2, 3)]) +@pytest.mark.parametrize("shape", [(), (5,), (2, 3)]) def test_plate_stack(shape): def guide(): with numpyro.plate_stack("plates", shape): @@ -452,18 +480,21 @@ def guide(): assert x.shape == shape -@pytest.mark.parametrize('intervene,observe,flip', [ - (True, False, False), - (False, True, False), - (True, True, False), - (True, True, True), -]) +@pytest.mark.parametrize( + "intervene,observe,flip", + [ + (True, False, False), + (False, True, False), + (True, True, False), + (True, True, True), + ], +) def test_counterfactual_query(intervene, observe, flip): # x -> y -> z -> w sites = ["x", "y", "z", "w"] - observations = {"x": 1., "y": None, "z": 1., "w": 1.} - interventions = {"x": None, "y": 0., "z": 2., "w": 1.} + observations = {"x": 1.0, "y": None, "z": 1.0, "w": 1.0} + interventions = {"x": None, "y": 0.0, "z": 2.0, "w": 1.0} def model(): with handlers.seed(rng_seed=0): @@ -480,8 +511,8 @@ def model(): model = handlers.condition(model, data=observations) elif flip and intervene and observe: model = handlers.do( - handlers.condition(model, data=observations), - data=interventions) + handlers.condition(model, data=observations), data=interventions + ) with handlers.trace() as tr: actual_values = model() @@ -489,65 +520,85 @@ def model(): # case 1: purely observational query like handlers.condition if not intervene and observe: if observations[name] is not None: - assert tr[name]['is_observed'] + assert tr[name]["is_observed"] assert_allclose(observations[name], actual_values[name]) - assert_allclose(observations[name], tr[name]['value']) + assert_allclose(observations[name], tr[name]["value"]) if interventions[name] != observations[name]: if interventions[name] is not None: - assert_raises(AssertionError, assert_allclose, interventions[name], actual_values[name]) + assert_raises( + AssertionError, + assert_allclose, + interventions[name], + actual_values[name], + ) # case 2: purely interventional query like old handlers.do elif intervene and not observe: - assert not tr[name]['is_observed'] + assert not tr[name]["is_observed"] if interventions[name] is not None: assert_allclose(interventions[name], actual_values[name]) if observations[name] is not None: - assert_raises(AssertionError, assert_allclose, observations[name], tr[name]['value']) + assert_raises( + AssertionError, + assert_allclose, + observations[name], + tr[name]["value"], + ) if interventions[name] is not None: - assert_raises(AssertionError, assert_allclose, interventions[name], tr[name]['value']) + assert_raises( + AssertionError, + assert_allclose, + interventions[name], + tr[name]["value"], + ) # case 3: counterfactual query mixing intervention and observation elif intervene and observe: if observations[name] is not None: - assert tr[name]['is_observed'] - assert_allclose(observations[name], tr[name]['value']) + assert tr[name]["is_observed"] + assert_allclose(observations[name], tr[name]["value"]) if interventions[name] is not None: assert_allclose(interventions[name], actual_values[name]) if interventions[name] != observations[name]: if interventions[name] is not None: - assert_raises(AssertionError, assert_allclose, interventions[name], tr[name]['value']) + assert_raises( + AssertionError, + assert_allclose, + interventions[name], + tr[name]["value"], + ) def test_block(): with handlers.trace() as trace: - with handlers.block(hide=['x']): + with handlers.block(hide=["x"]): with handlers.seed(rng_seed=0): - numpyro.sample('x', dist.Normal()) - assert 'x' not in trace + numpyro.sample("x", dist.Normal()) + assert "x" not in trace def test_scope(): def fn(): - return numpyro.sample('x', dist.Normal()) + return numpyro.sample("x", dist.Normal()) with handlers.trace() as trace: with handlers.seed(rng_seed=1): - with handlers.scope(prefix='a'): + with handlers.scope(prefix="a"): fn() - with handlers.scope(prefix='b'): - with handlers.scope(prefix='a'): + with handlers.scope(prefix="b"): + with handlers.scope(prefix="a"): fn() - assert 'a/x' in trace - assert 'b/a/x' in trace + assert "a/x" in trace + assert "b/a/x" in trace def test_lift(): def model(): - loc1 = numpyro.param("loc1", 0.) - scale1 = numpyro.param("scale1", 1., constraint=constraints.positive) + loc1 = numpyro.param("loc1", 0.0) + scale1 = numpyro.param("scale1", 1.0, constraint=constraints.positive) numpyro.sample("latent1", dist.Normal(loc1, scale1)) - loc2 = numpyro.param("loc2", 1.) - scale2 = numpyro.param("scale2", 2., constraint=constraints.positive) + loc2 = numpyro.param("loc2", 1.0) + scale2 = numpyro.param("scale2", 2.0, constraint=constraints.positive) latent2 = numpyro.sample("latent2", dist.Normal(loc2, scale2)) return latent2 @@ -567,11 +618,11 @@ def model(): for name in tr.keys(): assert name in lifted_tr if name in prior: - assert lifted_tr[name]['fn'] is prior[name] - assert lifted_tr[name]['type'] == 'sample' - assert lifted_tr[name]['value'] not in (0., 1.) - elif name in ('loc2', 'scale2'): - assert lifted_tr[name]['type'] == 'param' + assert lifted_tr[name]["fn"] is prior[name] + assert lifted_tr[name]["type"] == "sample" + assert lifted_tr[name]["value"] not in (0.0, 1.0) + elif name in ("loc2", "scale2"): + assert lifted_tr[name]["type"] == "param" def test_lift_memoize(): @@ -587,7 +638,7 @@ def model(): def test_collapse_beta_binomial(): total_count = 10 - data = 3. + data = 3.0 def model1(): c1 = numpyro.param("c1", 0.5, constraint=dist.constraints.positive) @@ -599,8 +650,7 @@ def model1(): def model2(): c1 = numpyro.param("c1", 0.5, constraint=dist.constraints.positive) c0 = numpyro.param("c0", 1.5, constraint=dist.constraints.positive) - numpyro.sample("obs", dist.BetaBinomial(c1, c0, total_count), - obs=data) + numpyro.sample("obs", dist.BetaBinomial(c1, c0, total_count), obs=data) trace1 = handlers.trace(model1).get_trace() trace2 = handlers.trace(model2).get_trace() @@ -625,7 +675,7 @@ def model2(): def test_collapse_beta_bernoulli(): - data = 0. + data = 0.0 def model(): c = numpyro.sample("c", dist.Gamma(1, 1)) @@ -634,8 +684,8 @@ def model(): numpyro.sample("obs", dist.Bernoulli(probs), obs=data) def guide(): - a = numpyro.param("a", 1., constraint=constraints.positive) - b = numpyro.param("b", 1., constraint=constraints.positive) + a = numpyro.param("a", 1.0, constraint=constraints.positive) + b = numpyro.param("b", 1.0, constraint=constraints.positive) numpyro.sample("c", dist.Gamma(a, b)) svi = SVI(model, guide, numpyro.optim.Adam(1), Trace_ELBO()) @@ -645,19 +695,18 @@ def guide(): @pytest.mark.xfail(reason="missing pattern in Funsor") def test_collapse_beta_binomial_plate(): - data = np.array([0., 1., 5., 5.]) + data = np.array([0.0, 1.0, 5.0, 5.0]) def model(): c = numpyro.sample("c", dist.Gamma(1, 1)) with handlers.collapse(): probs = numpyro.sample("probs", dist.Beta(c, 2)) with numpyro.plate("plate", len(data)): - numpyro.sample("obs", dist.Binomial(10, probs), - obs=data) + numpyro.sample("obs", dist.Binomial(10, probs), obs=data) def guide(): - a = numpyro.param("a", 1., constraint=constraints.positive) - b = numpyro.param("b", 1., constraint=constraints.positive) + a = numpyro.param("a", 1.0, constraint=constraints.positive) + b = numpyro.param("b", 1.0, constraint=constraints.positive) numpyro.sample("c", dist.Gamma(a, b)) svi = SVI(model, guide, numpyro.optim.Adam(1), Trace_ELBO()) @@ -701,7 +750,11 @@ def subsample_fn(rng_key): subsamples = vmap(subsample_fn)(rng_keys) for k in range(1, 11): i = random.randint(random.PRNGKey(k), (), 0, size) - assert_allclose(jnp.mean(subsamples == i, axis=0), jnp.full(subsample_size, 1 / size), atol=1e-3) + assert_allclose( + jnp.mean(subsamples == i, axis=0), + jnp.full(subsample_size, 1 / size), + atol=1e-3, + ) # test that values are not duplicated assert len(set(subsamples[k])) == subsample_size diff --git a/test/test_model_rendering.py b/test/test_model_rendering.py index edbcc9a40..c9dbb97ff 100644 --- a/test/test_model_rendering.py +++ b/test/test_model_rendering.py @@ -11,79 +11,101 @@ def simple(data): - x = numpyro.sample('x', dist.Normal(0, 1)) - sd = numpyro.sample('sd', dist.LogNormal(x, 1)) - with numpyro.plate('N', len(data)): - numpyro.sample('obs', dist.Normal(x, sd), obs=data) + x = numpyro.sample("x", dist.Normal(0, 1)) + sd = numpyro.sample("sd", dist.LogNormal(x, 1)) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Normal(x, sd), obs=data) def plate_improper_subsets(): - with numpyro.plate('N', 10): - with numpyro.plate('M', 10): - numpyro.sample('x', dist.Normal(0, 1)) + with numpyro.plate("N", 10): + with numpyro.plate("M", 10): + numpyro.sample("x", dist.Normal(0, 1)) def nested_plates(): - N_plate = numpyro.plate('N', 10, dim=-2) - M_plate = numpyro.plate('M', 5, dim=-1) + N_plate = numpyro.plate("N", 10, dim=-2) + M_plate = numpyro.plate("M", 5, dim=-1) with N_plate: - numpyro.sample('x', dist.Normal(0, 1)) + numpyro.sample("x", dist.Normal(0, 1)) with M_plate: - numpyro.sample('y', dist.Normal(0, 1)) + numpyro.sample("y", dist.Normal(0, 1)) with M_plate: - numpyro.sample('z', dist.Normal(0, 1)) + numpyro.sample("z", dist.Normal(0, 1)) def discrete_to_continuous(probs, locs): - c = numpyro.sample('c', dist.Categorical(probs)) - numpyro.sample('x', dist.Normal(locs[c], 0.5)) + c = numpyro.sample("c", dist.Categorical(probs)) + numpyro.sample("x", dist.Normal(locs[c], 0.5)) -@pytest.mark.parametrize('test_model,model_kwargs,expected_graph_spec', [ - (simple, dict(data=jnp.ones(10)), { - 'plate_groups': {'N': ['obs'], None: ['x', 'sd']}, - 'plate_data': {'N': {'parent': None}}, - 'node_data': { - 'x': {'is_observed': False, 'distribution': 'Normal'}, - 'sd': {'is_observed': False, 'distribution': 'LogNormal'}, - 'obs': {'is_observed': True, 'distribution': 'Normal'}, - }, - 'edge_list': [('x', 'sd'), ('x', 'obs'), ('sd', 'obs')], - }), - (plate_improper_subsets, dict(), { - 'plate_groups': {'N': ['x'], 'M': ['x'], None: []}, - 'plate_data': {'N': {'parent': None}, 'M': {'parent': 'N'}}, - 'node_data': {'x': {'is_observed': False, 'distribution': 'Normal'}}, - 'edge_list': [], - }), - (nested_plates, dict(), { - 'plate_groups': {'N': ['x', 'y'], 'M': ['y'], 'M__CLONE': ['z'], None: []}, - 'plate_data': { - 'N': {'parent': None}, - 'M': {'parent': 'N'}, - 'M__CLONE': {'parent': None}, - }, - 'node_data': { - 'x': {'is_observed': False, 'distribution': 'Normal'}, - 'y': {'is_observed': False, 'distribution': 'Normal'}, - 'z': {'is_observed': False, 'distribution': 'Normal'}, - }, - 'edge_list': [], - }), - ( - discrete_to_continuous, - dict(probs=jnp.array([0.15, 0.3, 0.3, 0.25]), locs=jnp.array([-2, 0, 2, 4])), - { - 'plate_groups': {None: ['c', 'x']}, - 'plate_data': {}, - 'node_data': { - 'c': {'is_observed': False, 'distribution': 'CategoricalProbs'}, - 'x': {'is_observed': False, 'distribution': 'Normal'}, +@pytest.mark.parametrize( + "test_model,model_kwargs,expected_graph_spec", + [ + ( + simple, + dict(data=jnp.ones(10)), + { + "plate_groups": {"N": ["obs"], None: ["x", "sd"]}, + "plate_data": {"N": {"parent": None}}, + "node_data": { + "x": {"is_observed": False, "distribution": "Normal"}, + "sd": {"is_observed": False, "distribution": "LogNormal"}, + "obs": {"is_observed": True, "distribution": "Normal"}, + }, + "edge_list": [("x", "sd"), ("x", "obs"), ("sd", "obs")], }, - 'edge_list': [('c', 'x')], - } - ), -]) + ), + ( + plate_improper_subsets, + dict(), + { + "plate_groups": {"N": ["x"], "M": ["x"], None: []}, + "plate_data": {"N": {"parent": None}, "M": {"parent": "N"}}, + "node_data": {"x": {"is_observed": False, "distribution": "Normal"}}, + "edge_list": [], + }, + ), + ( + nested_plates, + dict(), + { + "plate_groups": { + "N": ["x", "y"], + "M": ["y"], + "M__CLONE": ["z"], + None: [], + }, + "plate_data": { + "N": {"parent": None}, + "M": {"parent": "N"}, + "M__CLONE": {"parent": None}, + }, + "node_data": { + "x": {"is_observed": False, "distribution": "Normal"}, + "y": {"is_observed": False, "distribution": "Normal"}, + "z": {"is_observed": False, "distribution": "Normal"}, + }, + "edge_list": [], + }, + ), + ( + discrete_to_continuous, + dict( + probs=jnp.array([0.15, 0.3, 0.3, 0.25]), locs=jnp.array([-2, 0, 2, 4]) + ), + { + "plate_groups": {None: ["c", "x"]}, + "plate_data": {}, + "node_data": { + "c": {"is_observed": False, "distribution": "CategoricalProbs"}, + "x": {"is_observed": False, "distribution": "Normal"}, + }, + "edge_list": [("c", "x")], + }, + ), + ], +) def test_model_transformation(test_model, model_kwargs, expected_graph_spec): relations = get_model_relations(test_model, model_kwargs=model_kwargs) graph_spec = generate_graph_specification(relations) diff --git a/test/test_nn.py b/test/test_nn.py index bf07a42d6..97b45a7ed 100644 --- a/test/test_nn.py +++ b/test/test_nn.py @@ -17,15 +17,20 @@ from numpyro.nn.block_neural_arn import BlockNeuralAutoregressiveNN -@pytest.mark.parametrize('input_dim', [5]) -@pytest.mark.parametrize('param_dims', [[1], [1, 1], [2], [2, 3]]) -@pytest.mark.parametrize('hidden_dims', [[8], [6, 7]]) -@pytest.mark.parametrize('skip_connections', [True, False]) +@pytest.mark.parametrize("input_dim", [5]) +@pytest.mark.parametrize("param_dims", [[1], [1, 1], [2], [2, 3]]) +@pytest.mark.parametrize("hidden_dims", [[8], [6, 7]]) +@pytest.mark.parametrize("skip_connections", [True, False]) def test_auto_reg_nn(input_dim, hidden_dims, param_dims, skip_connections): rng_key, rng_key_perm = random.split(random.PRNGKey(0)) perm = random.permutation(rng_key_perm, np.arange(input_dim)) - arn_init, arn = AutoregressiveNN(input_dim, hidden_dims, param_dims=param_dims, - skip_connections=skip_connections, permutation=perm) + arn_init, arn = AutoregressiveNN( + input_dim, + hidden_dims, + param_dims=param_dims, + skip_connections=skip_connections, + permutation=perm, + ) batch_size = 4 input_shape = (batch_size, input_dim) @@ -59,14 +64,16 @@ def test_auto_reg_nn(input_dim, hidden_dims, param_dims, skip_connections): assert np.sum(np.abs(np.triu(permuted_jac))) == 0.0 -@pytest.mark.parametrize('input_dim', [2, 6]) -@pytest.mark.parametrize('n_layers', [1, 2]) -@pytest.mark.parametrize('output_dim_multiplier', [1, 2]) +@pytest.mark.parametrize("input_dim", [2, 6]) +@pytest.mark.parametrize("n_layers", [1, 2]) +@pytest.mark.parametrize("output_dim_multiplier", [1, 2]) def test_masks(input_dim, n_layers, output_dim_multiplier): hidden_dim = input_dim * 3 hidden_dims = [hidden_dim] * n_layers permutation = np.random.permutation(input_dim) - masks, mask_skip = create_mask(input_dim, hidden_dims, permutation, output_dim_multiplier) + masks, mask_skip = create_mask( + input_dim, hidden_dims, permutation, output_dim_multiplier + ) masks = [np.transpose(m) for m in masks] mask_skip = np.transpose(mask_skip) @@ -78,7 +85,7 @@ def test_masks(input_dim, n_layers, output_dim_multiplier): # Loop over variables for idx in range(input_dim): # Calculate correct answer - correct = np.array(sorted(_permutation[0:np.where(permutation == idx)[0][0]])) + correct = np.array(sorted(_permutation[0 : np.where(permutation == idx)[0][0]])) # Loop over parameters for each variable for jdx in range(output_dim_multiplier): @@ -107,11 +114,13 @@ def test_masks(input_dim, n_layers, output_dim_multiplier): assert_array_equal(list(sorted(skip_connections)), correct) -@pytest.mark.parametrize('input_dim', [5, 7]) +@pytest.mark.parametrize("input_dim", [5, 7]) def test_masked_dense(input_dim): hidden_dim = input_dim * 3 output_dim_multiplier = input_dim - 4 - mask, _ = create_mask(input_dim, [hidden_dim], np.random.permutation(input_dim), output_dim_multiplier) + mask, _ = create_mask( + input_dim, [hidden_dim], np.random.permutation(input_dim), output_dim_multiplier + ) init_random_params, masked_dense = serial(MaskedDense(mask[0])) rng_key = random.PRNGKey(0) @@ -122,10 +131,10 @@ def test_masked_dense(input_dim): assert output.shape == (batch_size, hidden_dim) -@pytest.mark.parametrize('input_dim', [5]) -@pytest.mark.parametrize('hidden_factors', [[4], [2, 3]]) -@pytest.mark.parametrize('residual', [None, "normal", "gated"]) -@pytest.mark.parametrize('batch_shape', [(3,), ()]) +@pytest.mark.parametrize("input_dim", [5]) +@pytest.mark.parametrize("hidden_factors", [[4], [2, 3]]) +@pytest.mark.parametrize("residual", [None, "normal", "gated"]) +@pytest.mark.parametrize("batch_shape", [(3,), ()]) def test_block_neural_arn(input_dim, hidden_factors, residual, batch_shape): arn_init, arn = BlockNeuralAutoregressiveNN(input_dim, hidden_factors, residual) diff --git a/test/test_optimizers.py b/test/test_optimizers.py index ffaa1fc06..9d7a30f8a 100644 --- a/test/test_optimizers.py +++ b/test/test_optimizers.py @@ -10,7 +10,7 @@ def loss(params): - return jnp.sum(params['x'] ** 2 + params['y'] ** 2) + return jnp.sum(params["x"] ** 2 + params["y"] ** 2) @partial(jit, static_argnums=(1,)) @@ -20,17 +20,20 @@ def step(opt_state, optim): return optim.update(g, opt_state) -@pytest.mark.parametrize('optim_class, args', [ - (optim.Adam, (1e-2,)), - (optim.ClippedAdam, (1e-2,)), - (optim.Adagrad, (1e-1,)), - (optim.Momentum, (1e-2, 0.5,)), - (optim.RMSProp, (1e-2, 0.95)), - (optim.RMSPropMomentum, (1e-4,)), - (optim.SGD, (1e-2,)) -]) +@pytest.mark.parametrize( + "optim_class, args", + [ + (optim.Adam, (1e-2,)), + (optim.ClippedAdam, (1e-2,)), + (optim.Adagrad, (1e-1,)), + (optim.Momentum, (1e-2, 0.5)), + (optim.RMSProp, (1e-2, 0.95)), + (optim.RMSPropMomentum, (1e-4,)), + (optim.SGD, (1e-2,)), + ], +) def test_optim_multi_params(optim_class, args): - params = {'x': jnp.array([1., 1., 1.]), 'y': jnp.array([-1, -1., -1.])} + params = {"x": jnp.array([1.0, 1.0, 1.0]), "y": jnp.array([-1, -1.0, -1.0])} opt = optim_class(*args) opt_state = opt.init(params) for i in range(2000): @@ -41,15 +44,18 @@ def test_optim_multi_params(optim_class, args): # note: this is somewhat of a bruteforce test. testing directly from # _NumpyroOptim would probably be better -@pytest.mark.parametrize('optim_class, args', [ - (optim.Adam, (1e-2,)), - (optim.ClippedAdam, (1e-2,)), - (optim.Adagrad, (1e-1,)), - (optim.Momentum, (1e-2, 0.5,)), - (optim.RMSProp, (1e-2, 0.95)), - (optim.RMSPropMomentum, (1e-4,)), - (optim.SGD, (1e-2,)) -]) +@pytest.mark.parametrize( + "optim_class, args", + [ + (optim.Adam, (1e-2,)), + (optim.ClippedAdam, (1e-2,)), + (optim.Adagrad, (1e-1,)), + (optim.Momentum, (1e-2, 0.5)), + (optim.RMSProp, (1e-2, 0.95)), + (optim.RMSPropMomentum, (1e-4,)), + (optim.SGD, (1e-2,)), + ], +) def test_numpyrooptim_no_double_jit(optim_class, args): opt = optim_class(*args) @@ -65,8 +71,8 @@ def my_fn(state, g): state = opt.update(g, state) return state - state = my_fn(state, jnp.ones(10)*1.) - state = my_fn(state, jnp.ones(10)*2.) - state = my_fn(state, jnp.ones(10)*3.) + state = my_fn(state, jnp.ones(10) * 1.0) + state = my_fn(state, jnp.ones(10) * 2.0) + state = my_fn(state, jnp.ones(10) * 3.0) assert my_fn_calls == 1 diff --git a/test/test_util.py b/test/test_util.py index 2d2bf75d2..02d7737aa 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -34,60 +34,69 @@ def f(x): def test_fori_collect(): def f(x): - return {'i': x['i'] + x['j'], 'j': x['i'] - x['j']} + return {"i": x["i"] + x["j"], "j": x["i"] - x["j"]} - a = {'i': jnp.array([0.]), 'j': jnp.array([1.])} - expected_tree = {'i': jnp.array([[0.], [2.]])} - actual_tree = fori_collect(1, 3, f, a, transform=lambda a: {'i': a['i']}) + a = {"i": jnp.array([0.0]), "j": jnp.array([1.0])} + expected_tree = {"i": jnp.array([[0.0], [2.0]])} + actual_tree = fori_collect(1, 3, f, a, transform=lambda a: {"i": a["i"]}) check_eq(actual_tree, expected_tree) -@pytest.mark.parametrize('progbar', [False, True]) +@pytest.mark.parametrize("progbar", [False, True]) def test_fori_collect_return_last(progbar): def f(x): - x['i'] = x['i'] + 1 + x["i"] = x["i"] + 1 return x - tree, init_state = fori_collect(2, 4, f, {'i': 0}, - transform=lambda a: {'i': a['i']}, - return_last_val=True, - progbar=progbar) - expected_tree = {'i': jnp.array([3, 4])} - expected_last_state = {'i': jnp.array(4)} + tree, init_state = fori_collect( + 2, + 4, + f, + {"i": 0}, + transform=lambda a: {"i": a["i"]}, + return_last_val=True, + progbar=progbar, + ) + expected_tree = {"i": jnp.array([3, 4])} + expected_last_state = {"i": jnp.array(4)} check_eq(init_state, expected_last_state) check_eq(tree, expected_tree) -@pytest.mark.parametrize('pytree', [ - {'a': jnp.array(0.), 'b': jnp.array([[1., 2.], [3., 4.]])}, - {'a': jnp.array(0), 'b': jnp.array([[1, 2], [3, 4]])}, - {'a': jnp.array(0), 'b': jnp.array([[1., 2.], [3., 4.]])}, - {'a': 0., 'b': jnp.array([[1., 2.], [3., 4.]])}, - {'a': False, 'b': jnp.array([[1., 2.], [3., 4.]])}, - [False, True, 0., jnp.array([[1., 2.], [3., 4.]])], -]) +@pytest.mark.parametrize( + "pytree", + [ + {"a": jnp.array(0.0), "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, + {"a": jnp.array(0), "b": jnp.array([[1, 2], [3, 4]])}, + {"a": jnp.array(0), "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, + {"a": 0.0, "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, + {"a": False, "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, + [False, True, 0.0, jnp.array([[1.0, 2.0], [3.0, 4.0]])], + ], +) def test_ravel_pytree(pytree): flat, unravel_fn = ravel_pytree(pytree) unravel = unravel_fn(flat) tree_flatten(tree_multimap(lambda x, y: assert_allclose(x, y), unravel, pytree)) - assert all(tree_flatten(tree_multimap(lambda x, y: - jnp.result_type(x) == jnp.result_type(y), - unravel, pytree))[0]) + assert all( + tree_flatten( + tree_multimap( + lambda x, y: jnp.result_type(x) == jnp.result_type(y), unravel, pytree + ) + )[0] + ) -@pytest.mark.parametrize('batch_shape', [ - (), (1,), (10,), (3, 4) -]) -@pytest.mark.parametrize('chunk_size', [ - None, 1, 5, 16 -]) +@pytest.mark.parametrize("batch_shape", [(), (1,), (10,), (3, 4)]) +@pytest.mark.parametrize("chunk_size", [None, 1, 5, 16]) def test_soft_vmap(batch_shape, chunk_size): - def f(x): - return {k: ((v[..., None] * jnp.ones(4)) if k == 'a' else ~v) for k, v in x.items()} + return { + k: ((v[..., None] * jnp.ones(4)) if k == "a" else ~v) for k, v in x.items() + } - xs = {'a': jnp.ones(batch_shape + (4,)), 'b': jnp.zeros(batch_shape).astype(bool)} + xs = {"a": jnp.ones(batch_shape + (4,)), "b": jnp.zeros(batch_shape).astype(bool)} ys = soft_vmap(f, xs, len(batch_shape), chunk_size) - assert set(ys.keys()) == {'a', 'b'} - assert_allclose(ys['a'], xs['a'][..., None] * jnp.ones(4)) - assert_allclose(ys['b'], ~xs['b']) + assert set(ys.keys()) == {"a", "b"} + assert_allclose(ys["a"], xs["a"][..., None] * jnp.ones(4)) + assert_allclose(ys["b"], ~xs["b"]) From bd93d45ee6a273d42e77426445ce695fa8c43135 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 31 Mar 2021 22:38:09 -0500 Subject: [PATCH 089/222] Allow setting max tree depth during warmup phase (#984) * support max tree depth warmup * fix docs and args of max three depth * make it clear that max tree depth is not trajectory length --- numpyro/infer/hmc.py | 26 ++++++++++++++++++++------ numpyro/infer/hmc_util.py | 10 +++++++++- test/infer/test_mcmc.py | 5 +++-- 3 files changed, 32 insertions(+), 9 deletions(-) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 4f5ae2f65..a771d5059 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -247,7 +247,9 @@ def init_kernel( :param float trajectory_length: Length of a MCMC trajectory for HMC. Default value is :math:`2\\pi`. :param int max_tree_depth: Max depth of the binary tree created during the doubling - scheme of NUTS sampler. Defaults to 10. + scheme of NUTS sampler. Defaults to 10. This argument also accepts a tuple of + integers `(d1, d2)`, where `d1` is the max tree depth during warmup phase and + `d2` is the max tree depth during post warmup phase. :param bool find_heuristic_step_size: whether to a heuristic function to adjust the step size at the beginning of each adaptation window. Defaults to False. :param tuple model_args: Model arguments if `potential_fn_gen` is specified. @@ -263,7 +265,11 @@ def init_kernel( nonlocal wa_update, max_treedepth, vv_update, wa_steps, forward_mode_ad forward_mode_ad = forward_mode_differentiation wa_steps = num_warmup - max_treedepth = max_tree_depth + max_treedepth = ( + max_tree_depth + if isinstance(max_tree_depth, tuple) + else (max_tree_depth, max_tree_depth) + ) if isinstance(init_params, ParamInfo): z, pe, z_grad = init_params else: @@ -376,7 +382,7 @@ def _nuts_next( model_args, model_kwargs, rng_key, - trajectory_length, + max_treedepth_current, ): if potential_fn_gen: nonlocal vv_update, forward_mode_ad @@ -391,7 +397,7 @@ def _nuts_next( step_size, rng_key, max_delta_energy=max_delta_energy, - max_tree_depth=max_treedepth, + max_tree_depth=(max_treedepth_current, max(max_treedepth)), ) accept_prob = binary_tree.sum_accept_probs / binary_tree.num_proposals num_steps = binary_tree.num_proposals @@ -437,6 +443,12 @@ def sample_kernel(hmc_state, model_args=(), model_kwargs=None): vv_state = IntegratorState( hmc_state.z, r, hmc_state.potential_energy, hmc_state.z_grad ) + if algo == "HMC": + hmc_length_args = (hmc_state.trajectory_length,) + else: + hmc_length_args = ( + jnp.where(hmc_state.i < wa_steps, max_treedepth[0], max_treedepth[1]), + ) vv_state, energy, num_steps, accept_prob, diverging = _next( hmc_state.adapt_state.step_size, hmc_state.adapt_state.inverse_mass_matrix, @@ -444,7 +456,7 @@ def sample_kernel(hmc_state, model_args=(), model_kwargs=None): model_args, model_kwargs, rng_key_transition, - hmc_state.trajectory_length, + *hmc_length_args, ) # not update adapt_state after warmup phase adapt_state = cond( @@ -800,7 +812,9 @@ class NUTS(HMC): :param float trajectory_length: Length of a MCMC trajectory for HMC. This arg has no effect in NUTS sampler. :param int max_tree_depth: Max depth of the binary tree created during the doubling - scheme of NUTS sampler. Defaults to 10. + scheme of NUTS sampler. Defaults to 10. This argument also accepts a tuple of + integers `(d1, d2)`, where `d1` is the max tree depth during warmup phase and + `d2` is the max tree depth during post warmup phase. :param callable init_strategy: a per-site initialization function. See :ref:`init_strategy` section for available functions. :param bool find_heuristic_step_size: whether to a heuristic function to adjust the diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 86f9f9764..c2ddaaa4b 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -1116,9 +1116,17 @@ def build_tree( randomness. :param float max_delta_energy: A threshold to decide if the new state diverges (based on the energy difference) too much from the initial integrator state. + :param int max_tree_depth: Max depth of the binary tree created during the doubling + scheme of NUTS sampler. Defaults to 10. This argument also accepts a tuple of + integers `(d1, d2)`, where `d1` is the max tree depth at the current MCMC + step and `d2` is the global max tree depth for all MCMC steps. :return: information of the tree. :rtype: :data:`TreeInfo` """ + if isinstance(max_tree_depth, tuple): + max_tree_depth_current, max_tree_depth = max_tree_depth + else: + max_tree_depth_current = max_tree_depth z, r, potential_energy, z_grad = verlet_state energy_current = potential_energy + kinetic_fn(inverse_mass_matrix, r) latent_size = jnp.size(ravel_pytree(r)[0]) @@ -1147,7 +1155,7 @@ def build_tree( def _cond_fn(state): tree, _ = state - return (tree.depth < max_tree_depth) & ~tree.turning & ~tree.diverging + return (tree.depth < max_tree_depth_current) & ~tree.turning & ~tree.diverging def _body_fn(state): tree, key = state diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index f7f59ce23..2abdabf90 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -156,7 +156,8 @@ def model(data): assert_allclose(jnp.mean(samples["loc"], 0), true_coef, atol=0.05) -def test_improper_normal(): +@pytest.mark.parametrize("max_tree_depth", [10, (5, 10)]) +def test_improper_normal(max_tree_depth): true_coef = 0.9 def model(data): @@ -171,7 +172,7 @@ def model(data): numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) data = true_coef + random.normal(random.PRNGKey(0), (1000,)) - kernel = NUTS(model=model) + kernel = NUTS(model=model, max_tree_depth=max_tree_depth) mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000) mcmc.run(random.PRNGKey(0), data) samples = mcmc.get_samples() From fa93f0871bba86d6f2bd801be84d1bb9fc03696a Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 1 Apr 2021 07:01:08 -0500 Subject: [PATCH 090/222] [breaking change] not setting platform to CPU by default (#986) --- README.md | 2 +- numpyro/__init__.py | 10 ++++++++- numpyro/infer/hmc.py | 7 +++--- numpyro/infer/hmc_gibbs.py | 3 ++- numpyro/infer/mixed_hmc.py | 3 ++- numpyro/util.py | 43 +++--------------------------------- setup.py | 6 ++--- test/infer/test_autoguide.py | 2 +- test/test_util.py | 3 ++- 9 files changed, 26 insertions(+), 53 deletions(-) diff --git a/README.md b/README.md index c62cb0b61..8b9285252 100644 --- a/README.md +++ b/README.md @@ -194,7 +194,7 @@ To use NumPyro on the GPU, you will need to first [install](https://github.com/g To run NumPyro on Cloud TPUs, you can use pip to install NumPyro as above and setup the TPU backend as detailed [here](https://github.com/google/jax/tree/master/cloud_tpu_colabs). -> **Default Platform:** In contrast to JAX, which uses GPU as the default platform, we use CPU as the default platform. You can use [set_platform](http://num.pyro.ai/en/stable/utilities.html#set-platform) utility to switch to other platforms such as GPU or TPU at the beginning of your program. +> **Default Platform:** JAX will use GPU by default if CUDA-supported `jaxlib` package is installed. You can use [set_platform](http://num.pyro.ai/en/stable/utilities.html#set-platform) utility `numpyro.set_platform("cpu")` to switch to CPU at the beginning of your program. You can also install NumPyro from source: diff --git a/numpyro/__init__.py b/numpyro/__init__.py index 81c1461b3..4fc884250 100644 --- a/numpyro/__init__.py +++ b/numpyro/__init__.py @@ -1,6 +1,8 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +import logging + from numpyro import compat, diagnostics, distributions, handlers, infer, optim from numpyro.contrib.render import render_model from numpyro.distributions.distribution import enable_validation, validation_enabled @@ -20,7 +22,13 @@ from numpyro.util import enable_x64, set_host_device_count, set_platform from numpyro.version import __version__ -set_platform("cpu") + +# filter out this annoying warning, which raises even when we install CPU-only jaxlib +def _filter_absl_cpu_warning(record): + return not record.getMessage().startswith("No GPU/TPU found, falling back to CPU.") + + +logging.getLogger("absl").addFilter(_filter_absl_cpu_warning) __all__ = [ diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index a771d5059..8273ddb24 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -259,9 +259,10 @@ def init_kernel( """ step_size = lax.convert_element_type(step_size, jnp.result_type(float)) - trajectory_length = lax.convert_element_type( - trajectory_length, jnp.result_type(float) - ) + if trajectory_length is not None: + trajectory_length = lax.convert_element_type( + trajectory_length, jnp.result_type(float) + ) nonlocal wa_update, max_treedepth, vv_update, wa_steps, forward_mode_ad forward_mode_ad = forward_mode_differentiation wa_steps = num_warmup diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 1c03edc23..9773fb67d 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -19,6 +19,7 @@ random, value_and_grad, ) +from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.scipy.special import expit @@ -28,7 +29,7 @@ from numpyro.infer.hmc import HMC from numpyro.infer.mcmc import MCMCKernel from numpyro.infer.util import _unconstrain_reparam -from numpyro.util import cond, fori_loop, identity, ravel_pytree +from numpyro.util import cond, fori_loop, identity HMCGibbsState = namedtuple("HMCGibbsState", "z, hmc_state, rng_key") """ diff --git a/numpyro/infer/mixed_hmc.py b/numpyro/infer/mixed_hmc.py index f0df47e47..eea01e011 100644 --- a/numpyro/infer/mixed_hmc.py +++ b/numpyro/infer/mixed_hmc.py @@ -5,12 +5,13 @@ from functools import partial from jax import grad, jacfwd, lax, ops, random +from jax.flatten_util import ravel_pytree import jax.numpy as jnp from numpyro.infer.hmc import momentum_generator from numpyro.infer.hmc_gibbs import DiscreteHMCGibbs from numpyro.infer.hmc_util import euclidean_kinetic_energy, warmup_adapter -from numpyro.util import cond, fori_loop, identity, ravel_pytree +from numpyro.util import cond, fori_loop, identity MixedHMCState = namedtuple("MixedHMCState", "z, hmc_state, rng_key, accept_prob") diff --git a/numpyro/util.py b/numpyro/util.py index 14963c5c2..4123154ed 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -1,7 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -from collections import OrderedDict, namedtuple +from collections import OrderedDict from contextlib import contextmanager import os import random @@ -15,8 +15,9 @@ from jax import device_put, jit, lax, ops, vmap from jax.core import Tracer from jax.experimental import host_callback +from jax.flatten_util import ravel_pytree import jax.numpy as jnp -from jax.tree_util import tree_flatten, tree_map, tree_unflatten +from jax.tree_util import tree_flatten, tree_map _DISABLE_CONTROL_FLOW_PRIM = False @@ -347,44 +348,6 @@ def _body_fn(i, vals): return (unravel_collection, last_val) if return_last_val else unravel_collection -pytree_metadata = namedtuple("pytree_metadata", ["flat", "shape", "size", "dtype"]) - - -def _ravel_list(*leaves): - leaves_metadata = tree_map( - lambda l: pytree_metadata( - jnp.ravel(l), jnp.shape(l), jnp.size(l), jnp.result_type(l) - ), - leaves, - ) - leaves_idx = jnp.cumsum(jnp.array((0,) + tuple(d.size for d in leaves_metadata))) - - def unravel_list(arr): - return [ - jnp.reshape( - lax.dynamic_slice_in_dim(arr, leaves_idx[i], m.size), m.shape - ).astype(m.dtype) - for i, m in enumerate(leaves_metadata) - ] - - flat = ( - jnp.concatenate([m.flat for m in leaves_metadata]) - if leaves_metadata - else jnp.array([]) - ) - return flat, unravel_list - - -def ravel_pytree(pytree): - leaves, treedef = tree_flatten(pytree) - flat, unravel_list = _ravel_list(*leaves) - - def unravel_pytree(arr): - return tree_unflatten(treedef, unravel_list(arr)) - - return flat, unravel_pytree - - def soft_vmap(fn, xs, batch_ndims=1, chunk_size=None): """ Vectorizing map that maps a function `fn` over `batch_ndims` leading axes diff --git a/setup.py b/setup.py index 511893df0..a70090752 100644 --- a/setup.py +++ b/setup.py @@ -32,10 +32,8 @@ url="https://github.com/pyro-ppl/numpyro", author="Uber AI Labs", install_requires=[ - # TODO: pin to a specific version for the release (until JAX's API becomes stable) - "jax==0.2.10", - # check min version here: https://github.com/google/jax/blob/master/jax/lib/__init__.py#L26 - "jaxlib==0.1.62", + "jax>=0.2.11", + "jaxlib>=0.1.62", "tqdm", ], extras_require={ diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 9146cb879..a902602c6 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -244,7 +244,7 @@ def model(): class _AutoGuide(AutoDiagonalNormal): def __call__(self, *args, **kwargs): return substitute( - super(_AutoGuide, self).__call__, {"_auto_latent": x_init} + super(_AutoGuide, self).__call__, {"_auto_latent": x_init[None]} )(*args, **kwargs) adam = optim.Adam(0.01) diff --git a/test/test_util.py b/test/test_util.py index 02d7737aa..7ee8ae9aa 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -4,11 +4,12 @@ from numpy.testing import assert_allclose import pytest +from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.test_util import check_eq from jax.tree_util import tree_flatten, tree_multimap -from numpyro.util import fori_collect, ravel_pytree, soft_vmap +from numpyro.util import fori_collect, soft_vmap def test_fori_collect_thinning(): From b93d10afd77d217348c16cbf4189c7b068e65c1d Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 1 Apr 2021 17:36:36 -0500 Subject: [PATCH 091/222] Add pip install for tutorials (#987) --- docs/requirements.txt | 2 +- ...esian_hierarchical_linear_regression.ipynb | 9 +++++ notebooks/source/bayesian_imputation.ipynb | 9 +++++ notebooks/source/bayesian_regression.ipynb | 2 +- notebooks/source/discrete_imputation.ipynb | 9 +++++ notebooks/source/logistic_regression.ipynb | 9 +++++ notebooks/source/model_rendering.ipynb | 38 ++++++++++++------- notebooks/source/ordinal_regression.ipynb | 9 +++++ .../source/time_series_forecasting.ipynb | 9 +++++ setup.py | 5 ++- 10 files changed, 84 insertions(+), 17 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index fecea923c..9f3d81d87 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -5,5 +5,5 @@ jax>=0.1.65 jaxlib>=0.1.45 nbsphinx==0.8.1 sphinx-gallery -tensorflow-probability +tfp-nightly # TODO: change this to tensorflow-probability when it is stable tqdm diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index 7f05fe207..fbcede836 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -19,6 +19,15 @@ "Let's explore the data and see what's that all about:" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro arviz" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index da6bc5e9a..ae795ad48 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -19,6 +19,15 @@ "+ and consider missing values as unobserved latent variables." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index d73afefec..69531d1c4 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -36,7 +36,7 @@ "metadata": {}, "outputs": [], "source": [ - "%reset -s -f" + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" ] }, { diff --git a/notebooks/source/discrete_imputation.ipynb b/notebooks/source/discrete_imputation.ipynb index f761091e8..96f43560b 100644 --- a/notebooks/source/discrete_imputation.ipynb +++ b/notebooks/source/discrete_imputation.ipynb @@ -13,6 +13,15 @@ "Inference by automatic enumeration of discrete variables is implemented in numpyro and allows for a very convenient way of dealing with missing discrete data.\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro funsor" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index a3902514c..f0f9db37d 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -14,6 +14,15 @@ "This notebook uses `numpyro` and replicates experiments in references [1] which evaluates the performance of NUTS on various frameworks. The benchmark is run with CUDA 10.1 on a NVIDIA RTX 2070." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index e04816698..c7e8eac33 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "renewable-moment", + "id": "planned-pharmacy", "metadata": {}, "source": [ "# Automatic rendering of NumPyro models\n", @@ -10,10 +10,20 @@ "In this tutorial we will demonstrate how to create beautiful visualizations of your probabilistic graphical models." ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "informal-anniversary", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ] + }, { "cell_type": "code", "execution_count": 1, - "id": "structured-foster", + "id": "nearby-beach", "metadata": {}, "outputs": [], "source": [ @@ -28,7 +38,7 @@ }, { "cell_type": "markdown", - "id": "civil-template", + "id": "pleasant-alias", "metadata": {}, "source": [ "## A Simple Example\n", @@ -39,7 +49,7 @@ { "cell_type": "code", "execution_count": 2, - "id": "designing-listening", + "id": "fresh-throw", "metadata": {}, "outputs": [], "source": [ @@ -53,7 +63,7 @@ { "cell_type": "code", "execution_count": 3, - "id": "disturbed-vocabulary", + "id": "capital-ferry", "metadata": {}, "outputs": [ { @@ -129,7 +139,7 @@ }, { "cell_type": "markdown", - "id": "suited-millennium", + "id": "preceding-moisture", "metadata": {}, "source": [ "The visualization can be saved to a file by providing `filename='path'` to `numpyro.render_model`. You can use different formats such as PDF or PNG by changing the filename's suffix.\n", @@ -139,7 +149,7 @@ { "cell_type": "code", "execution_count": 4, - "id": "olive-cooler", + "id": "extreme-bacteria", "metadata": {}, "outputs": [], "source": [ @@ -148,7 +158,7 @@ }, { "cell_type": "markdown", - "id": "unexpected-definition", + "id": "naughty-intent", "metadata": {}, "source": [ "## Tweaking the visualization\n", @@ -160,7 +170,7 @@ { "cell_type": "code", "execution_count": 5, - "id": "developmental-florence", + "id": "coordinate-valve", "metadata": {}, "outputs": [], "source": [ @@ -221,7 +231,7 @@ { "cell_type": "code", "execution_count": 6, - "id": "bottom-enlargement", + "id": "loose-spotlight", "metadata": {}, "outputs": [ { @@ -326,7 +336,7 @@ { "cell_type": "code", "execution_count": 7, - "id": "filled-cardiff", + "id": "thrown-filling", "metadata": {}, "outputs": [ { @@ -430,7 +440,7 @@ }, { "cell_type": "markdown", - "id": "mighty-prospect", + "id": "balanced-command", "metadata": {}, "source": [ "## Distribution annotations\n", @@ -441,7 +451,7 @@ { "cell_type": "code", "execution_count": 8, - "id": "palestinian-motion", + "id": "proprietary-baseball", "metadata": {}, "outputs": [], "source": [ @@ -455,7 +465,7 @@ { "cell_type": "code", "execution_count": 9, - "id": "international-ethnic", + "id": "sonic-confidentiality", "metadata": {}, "outputs": [ { diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 14ff1a699..666891b3b 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -16,6 +16,15 @@ "This poses a challenge for statistical modeling as the data do not fit the most well known modelling approaches (e.g. linear regression). Modeling the data as [categorical](https://en.wikipedia.org/wiki/Categorical_distribution) is one possibility, but it disregards the inherent ordering in the data, and may be less statistically efficient. There are multiple appoaches for modeling ordered data. Here we will show how to use the OrderedLogistic distribution using cutpoints that are sampled from a Normal distribution with as additional constrain that the cutpoints they are ordered. For a more in-depth discussion of Bayesian modeling of ordinal data, see e.g. [Michael Betancour's blog](https://betanalpha.github.io/assets/case_studies/ordinal_regression.html)" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/notebooks/source/time_series_forecasting.ipynb b/notebooks/source/time_series_forecasting.ipynb index 5fd18d541..b4bac7937 100644 --- a/notebooks/source/time_series_forecasting.ipynb +++ b/notebooks/source/time_series_forecasting.ipynb @@ -14,6 +14,15 @@ "In this tutorial, we will demonstrate how to build a model for time series forecasting in NumPyro. Specifically, we will replicate the **Seasonal, Global Trend (SGT)** model from the [Rlgt: Bayesian Exponential Smoothing Models with Trend Modifications](https://cran.r-project.org/web/packages/Rlgt/index.html) package. The time series data that we will use for this tutorial is the **lynx** dataset, which contains annual numbers of lynx trappings from 1821 to 1934 in Canada." ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ] + }, { "cell_type": "code", "execution_count": 1, diff --git a/setup.py b/setup.py index a70090752..93c6e1f1e 100644 --- a/setup.py +++ b/setup.py @@ -55,9 +55,12 @@ "dev": [ "dm-haiku", "flax", + # TODO: bump funsor version before the release "funsor @ git+https://github.com/pyro-ppl/funsor.git@d5574988665dd822ec64e41f2b54b9dc929959dc", "graphviz", - "tensorflow_probability", + # TODO: change this to tensorflow_probability>0.12.1 when the next version + # of tfp is released. The current release is not compatible with jax>=0.2.12. + "tfp-nightly", ], "examples": ["arviz", "jupyter", "matplotlib", "pandas", "seaborn"], }, From 8bb94f170de3f6c276fe61e4c92cd4e21de70a4b Mon Sep 17 00:00:00 2001 From: AndrewCSQ Date: Tue, 6 Apr 2021 22:43:59 -0400 Subject: [PATCH 092/222] Experimental Dockerfiles (#996) * initial draft of dockerfiles * draft of README * changes according to @fehiepsi comments * changes according to @fehiepsi comments_edits * changes according to @fehiepsi comments r2 Co-authored-by: Andrew Chia Co-authored-by: Andrew Chia --- docker/README.md | 38 ++++++++++++++++++++++++++++++++++++++ docker/dev/Dockerfile | 34 ++++++++++++++++++++++++++++++++++ docker/release/Dockerfile | 33 +++++++++++++++++++++++++++++++++ 3 files changed, 105 insertions(+) create mode 100644 docker/README.md create mode 100644 docker/dev/Dockerfile create mode 100644 docker/release/Dockerfile diff --git a/docker/README.md b/docker/README.md new file mode 100644 index 000000000..da3cd7ff6 --- /dev/null +++ b/docker/README.md @@ -0,0 +1,38 @@ +Docker Images for NumPyro +========================= + +Experimental Dockerfiles for CUDA-accelerated NumPyro. There are two Dockerfiles included: + +- `release`: intended for users of NumPyro. Includes the jax and jaxlib versions needed to run NumPyro only. (Right now, that is 0.2.10, 0.1.62, and 0.6.0 respectively). +- `dev`: intended for NumPyro developers. It includes the jax and jaxlib versions needed to run the latest release of NumPyro (same as above, for now), plus an installation of NumPyro from source. + +## Pre-Requisites + +The Docker host that the image is being deployed on will need to have the proprietary Nvidia driver as well as [the Nvidia Container Toolkit](https://github.com/NVIDIA/nvidia-docker) installed. OS support is constrained by what Nvidia supports on their toolkit. Right now, that means Linux only, although there is [experimental WSL2 support](https://docs.nvidia.com/cuda/wsl-user-guide/index.html#installing-wip), with an estimated ~30% hit to performance. + +## Using the Dockerfiles + +At the moment, these images are not distributed on Dockerhub or any similar Docker registry. Users must build the Docker images themselves. This can be done (from the root of the git repository) with the command + +``` +docker build -t docker/[dev or release]/. +``` + +The Docker image will then be available locally. For example, to open a shell in the Docker image, one would run + +``` +docker run -ti +``` + +## Current State & Future Work + +Design Choices: + +- The Docker images do not include any users other than root, and do not include any other packages (such as Tensorflow or PyTorch). Users of the Docker image should layer their own requirements on top of these images. +- To avoid long build-times, the images use Google's provided CUDA wheels rather than building jaxlib from source. + +Future Work: + +- Right now the jax, jaxlib, and numpyro versions are manually specified, so they have to be updated every NumPyro release. There are two ways forward for this: + 1. If there is a CI/CD in place to build and push images to a repository like Dockerhub, then the jax, jaxlib, and numpyro versions can be passed in as environment variables (for example, if something like [Drone CI](http://plugins.drone.io/drone-plugins/drone-docker/) is used). If implemented this way, the jax/jaxlib/numpyro versions will be ephemereal (not stored in source code). + 2. Alternative, one can create a Python script that will modify the Dockerfiles upon release accordingly (using a hook of some sort). diff --git a/docker/dev/Dockerfile b/docker/dev/Dockerfile new file mode 100644 index 000000000..2cf3c62a1 --- /dev/null +++ b/docker/dev/Dockerfile @@ -0,0 +1,34 @@ +# Experimental Dockerfile for CUDA-enabled numpyro +# This image should be suitable for numpyro developers +# it installs the latest version of numpyro from git +# and includes [dev] for libraries needed for development +# Author/Maintainer: AndrewCSQ (web_enquiry at andrewchia dot tech) + +FROM nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04 + +# declare the image name +# note that this image uses Python 3.8 +ENV IMG_NAME=11.2.2-cudnn8-devel-ubuntu20.04 \ + # declare the cuda version for pulling appropriate jaxlib wheel + JAXLIB_CUDA=112 + +# install python3 and pip on top of the base Ubuntu image +# unlike for release, we need to install git and setuptools too +# one would probably want build-essential (gcc and friends) as well +RUN apt update && \ + apt install python3-dev python3-pip git build-essential -y + +# add .local/bin to PATH for tqdm and f2py +ENV PATH=/root/.local/bin:$PATH + +# install python packages via pip +# install pip-versions to detect the latest version of jax and jaxlib +RUN pip3 install pip-versions +# this uses latest version of jax and jaxlib available from pypi +RUN pip-versions latest jaxlib | xargs -I{} pip3 install jaxlib=={}+cuda${JAXLIB_CUDA} -f https://storage.googleapis.com/jax-releases/jax_releases.html \ + jax + +# clone the numpyro git repository and run pip install +RUN git clone https://github.com/pyro-ppl/numpyro.git && \ + cd numpyro && \ + pip3 install -e .[dev, test] # contains additional dependencies for NumPyro development diff --git a/docker/release/Dockerfile b/docker/release/Dockerfile new file mode 100644 index 000000000..14fa65023 --- /dev/null +++ b/docker/release/Dockerfile @@ -0,0 +1,33 @@ +# Experimental Dockerfile for CUDA-enabled numpyro +# This image should be suitable for developers on top of numpyro, or for end-users +# who wish to hit the ground running with CUDA+numpyro. +# Author/Maintainer: AndrewCSQ (web_enquiry at andrewchia dot tech) + +FROM nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04 + +# declare the image name +# note that this image uses Python 3.8 +ENV IMG_NAME=11.2.2-cudnn8-devel-ubuntu20.04 \ + # declare what jaxlib, jax, and numpyro versions to use + # right now this is a manual process - in the future it should be automated + # if a CI/CD system is expected to pass in these arguments + # the dockerfile should be modified accordingly + JAXLIB_CUDA=112 \ + JAXLIB_VERSION=0.1.62 \ + JAX_VERSION=0.2.10 \ + NUMPYRO_VERSION=0.6.0 + +# install python3 and pip on top of the base Ubuntu image +RUN apt update && \ + apt install python3-dev python3-pip -y + +# add .local/bin to PATH for tqdm and f2py +ENV PATH=/root/.local/bin:$PATH + +# install python packages via pip +RUN pip3 install --user \ + numpyro==${NUMPYRO_VERSION} \ + jax==${JAX_VERSION} \ + # we pull wheels from google's api as per https://github.com/google/jax#installation + # the pre-compiled wheels that google provides work for now. This may change in the future (and necessitate building from source) + jaxlib==${JAXLIB_VERSION}+cuda${JAXLIB_CUDA} -f https://storage.googleapis.com/jax-releases/jax_releases.html \ No newline at end of file From b73e85fe8b6e87d72968451cd40d4e095d9f5267 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 8 Apr 2021 07:30:43 -0500 Subject: [PATCH 093/222] support total_count=0 in multinomial (#1000) --- numpyro/distributions/util.py | 7 ++++++- test/test_distributions_util.py | 12 ++++++++++++ 2 files changed, 18 insertions(+), 1 deletion(-) diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index 991b3f327..3917b407f 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -215,6 +215,8 @@ def _multinomial(key, p, n, n_max, shape=()): n = jnp.broadcast_to(n, broadcast_shape) p = jnp.broadcast_to(p, broadcast_shape + jnp.shape(p)[-1:]) shape = shape or p.shape[:-1] + if n_max == 0: + return jnp.zeros(shape + p.shape[-1:], dtype=jnp.result_type(int)) # get indices from categorical distribution then gather the result indices = categorical(key, p, (n_max,) + shape) # mask out values when counts is heterogeneous @@ -244,7 +246,10 @@ def _multinomial(key, p, n, n_max, shape=()): def multinomial(key, p, n, shape=()): - n_max = int(jnp.max(n)) + assert not isinstance( + n, jax.core.Tracer + ), "The total count parameter `n` should not be a jax abstract array." + n_max = int(np.max(jax.device_get(n))) return _multinomial(key, p, n, n_max, shape) diff --git a/test/test_distributions_util.py b/test/test_distributions_util.py index 2be645056..830725e5e 100644 --- a/test/test_distributions_util.py +++ b/test/test_distributions_util.py @@ -91,6 +91,18 @@ def test_multinomial_shape(p, shape): assert jnp.shape(multinomial(rng_key, p, n, shape)) == expected_shape +@pytest.mark.parametrize("n", [0, 1, np.array([0, 0]), np.array([2, 1, 0])]) +@pytest.mark.parametrize("device_array", [True, False]) +def test_multinomial_inhomogeneous(n, device_array): + if device_array: + n = jnp.asarray(n) + + p = jnp.array([0.5, 0.5]) + x = multinomial(random.PRNGKey(0), p, n) + assert x.shape == jnp.shape(n) + jnp.shape(p) + assert_allclose(x.sum(-1), n) + + @pytest.mark.parametrize("p", [np.array([0.2, 0.3, 0.5]), np.array([0.8, 0.1, 0.1])]) @pytest.mark.parametrize("n", [10000, np.array([10000, 20000])]) def test_multinomial_stats(p, n): From 30dcc9ff758dee23a4d09e2ba4d6afda8cffa220 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Fri, 9 Apr 2021 13:20:10 -0400 Subject: [PATCH 094/222] Implement SoftLaplace distribution (#1002) * Implement SoftLaplace distribution * Address review comments --- docs/source/distributions.rst | 8 ++++ numpyro/distributions/__init__.py | 2 + numpyro/distributions/continuous.py | 62 +++++++++++++++++++++++++++-- test/test_distributions.py | 2 + 4 files changed, 71 insertions(+), 3 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 83bf83e63..640777984 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -245,6 +245,14 @@ RightTruncatedDistribution :show-inheritance: :member-order: bysource +SoftLaplace +----------- +.. autoclass:: numpyro.distributions.continuous.SoftLaplace + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + StudentT -------- .. autoclass:: numpyro.distributions.continuous.StudentT diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 9a2d73f60..ad093b3e2 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -29,6 +29,7 @@ Normal, Pareto, RightTruncatedDistribution, + SoftLaplace, StudentT, TruncatedCauchy, TruncatedDistribution, @@ -129,6 +130,7 @@ "ProjectedNormal", "PRNGIdentity", "RightTruncatedDistribution", + "SoftLaplace", "StudentT", "TransformedDistribution", "TruncatedCauchy", diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index d14e3b12b..a15add90d 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -1252,6 +1252,62 @@ def tree_flatten(self): return super(TransformedDistribution, self).tree_flatten() +class SoftLaplace(Distribution): + """ + Smooth distribution with Laplace-like tail behavior. + + This distribution corresponds to the log-convex density:: + + z = (value - loc) / scale + log_prob = log(2 / pi) - log(scale) - logaddexp(z, -z) + + Like the Laplace density, this density has the heaviest possible tails + (asymptotically) while still being log-convex. Unlike the Laplace + distribution, this distribution is infinitely differentiable everywhere, + and is thus suitable for HMC and Laplace approximation. + + :param loc: Location parameter. + :param scale: Scale parameter. + """ + + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} + support = constraints.real + reparametrized_params = ["loc", "scale"] + + def __init__(self, loc, scale, *, validate_args=None): + self.loc, self.scale = promote_shapes(loc, scale) + batch_shape = lax.broadcast_shapes(jnp.shape(loc), jnp.shape(scale)) + super().__init__(batch_shape=batch_shape, validate_args=validate_args) + + @validate_sample + def log_prob(self, value): + z = (value - self.loc) / self.scale + return jnp.log(2 / jnp.pi) - jnp.log(self.scale) - jnp.logaddexp(z, -z) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + u = random.uniform( + key, shape=sample_shape + self.batch_shape + self.event_shape + ) + return self.icdf(u) + + @validate_sample + def cdf(self, value): + z = (value - self.loc) / self.scale + return jnp.arctan(jnp.exp(z)) * (2 / jnp.pi) + + def icdf(self, value): + return jnp.log(jnp.tan(value * (jnp.pi / 2))) * self.scale + self.loc + + @property + def mean(self): + return self.loc + + @property + def variance(self): + return (jnp.pi / 2 * self.scale) ** 2 + + class StudentT(Distribution): arg_constraints = { "df": constraints.positive, @@ -1331,7 +1387,7 @@ def icdf(self, q): class LeftTruncatedDistribution(Distribution): arg_constraints = {"low": constraints.real} reparametrized_params = ["low"] - supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) + supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) def __init__(self, base_dist, low=0.0, validate_args=None): assert isinstance(base_dist, self.supported_types) @@ -1404,7 +1460,7 @@ def tree_unflatten(cls, aux_data, params): class RightTruncatedDistribution(Distribution): arg_constraints = {"high": constraints.real} reparametrized_params = ["high"] - supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) + supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) def __init__(self, base_dist, high=0.0, validate_args=None): assert isinstance(base_dist, self.supported_types) @@ -1462,7 +1518,7 @@ def tree_unflatten(cls, aux_data, params): class TwoSidedTruncatedDistribution(Distribution): arg_constraints = {"low": constraints.dependent, "high": constraints.dependent} reparametrized_params = ["low", "high"] - supported_types = (Cauchy, Laplace, Logistic, Normal, StudentT) + supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) def __init__(self, base_dist, low=0.0, high=1.0, validate_args=None): assert isinstance(base_dist, self.supported_types) diff --git a/test/test_distributions.py b/test/test_distributions.py index ea88e16fa..2ca49ca44 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -246,6 +246,8 @@ def sample(self, key, sample_shape=()): T(dist.Pareto, 1.0, 2.0), T(dist.Pareto, jnp.array([1.0, 0.5]), jnp.array([0.3, 2.0])), T(dist.Pareto, jnp.array([[1.0], [3.0]]), jnp.array([1.0, 0.5])), + T(dist.SoftLaplace, 1.0, 1.0), + T(dist.SoftLaplace, jnp.array([-1.0, 50.0]), jnp.array([4.0, 100.0])), T(dist.StudentT, 1.0, 1.0, 0.5), T(dist.StudentT, 2.0, jnp.array([1.0, 2.0]), 2.0), T(dist.StudentT, jnp.array([3.0, 5.0]), jnp.array([[1.0], [2.0]]), 2.0), From 5d08f6d1b591520879674428dc6b88627271d1d0 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 13 Apr 2021 10:14:49 -0500 Subject: [PATCH 095/222] Refactor truncated distributions into a separate file (#1005) --- docs/source/distributions.rst | 108 ++++---- numpyro/distributions/__init__.py | 16 +- numpyro/distributions/continuous.py | 391 +-------------------------- numpyro/distributions/truncated.py | 404 ++++++++++++++++++++++++++++ test/test_distributions.py | 4 +- 5 files changed, 472 insertions(+), 451 deletions(-) create mode 100644 numpyro/distributions/truncated.py diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 640777984..68493233f 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -205,14 +205,6 @@ MultivariateNormal :show-inheritance: :member-order: bysource -LeftTruncatedDistribution -------------------------- -.. autoclass:: numpyro.distributions.continuous.LeftTruncatedDistribution - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - LowRankMultivariateNormal ------------------------- .. autoclass:: numpyro.distributions.continuous.LowRankMultivariateNormal @@ -237,14 +229,6 @@ Pareto :show-inheritance: :member-order: bysource -RightTruncatedDistribution --------------------------- -.. autoclass:: numpyro.distributions.continuous.RightTruncatedDistribution - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - SoftLaplace ----------- .. autoclass:: numpyro.distributions.continuous.SoftLaplace @@ -261,42 +245,6 @@ StudentT :show-inheritance: :member-order: bysource -TruncatedCauchy ---------------- -.. autoclass:: numpyro.distributions.continuous.TruncatedCauchy - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - -TruncatedDistribution ---------------------- -.. autofunction:: numpyro.distributions.continuous.TruncatedDistribution - -TruncatedNormal ---------------- -.. autoclass:: numpyro.distributions.continuous.TruncatedNormal - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - -TruncatedPolyaGamma -------------------- -.. autoclass:: numpyro.distributions.continuous.TruncatedPolyaGamma - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - -TwoSidedTruncatedDistribution ------------------------------ -.. autoclass:: numpyro.distributions.continuous.TwoSidedTruncatedDistribution - :members: - :undoc-members: - :show-inheritance: - :member-order: bysource - Uniform ------- .. autoclass:: numpyro.distributions.continuous.Uniform @@ -486,6 +434,62 @@ VonMises :member-order: bysource +Truncated Distributions +======================= + +LeftTruncatedDistribution +------------------------- +.. autoclass:: numpyro.distributions.truncated.LeftTruncatedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +RightTruncatedDistribution +-------------------------- +.. autoclass:: numpyro.distributions.truncated.RightTruncatedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +TruncatedCauchy +--------------- +.. autoclass:: numpyro.distributions.truncated.TruncatedCauchy + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +TruncatedDistribution +--------------------- +.. autofunction:: numpyro.distributions.truncated.TruncatedDistribution + +TruncatedNormal +--------------- +.. autoclass:: numpyro.distributions.truncated.TruncatedNormal + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +TruncatedPolyaGamma +------------------- +.. autoclass:: numpyro.distributions.truncated.TruncatedPolyaGamma + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +TwoSidedTruncatedDistribution +----------------------------- +.. autoclass:: numpyro.distributions.truncated.TwoSidedTruncatedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + + TensorFlow Distributions ======================== diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index ad093b3e2..1c31f67fc 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -20,7 +20,6 @@ HalfNormal, InverseGamma, Laplace, - LeftTruncatedDistribution, LKJCholesky, Logistic, LogNormal, @@ -28,14 +27,8 @@ MultivariateNormal, Normal, Pareto, - RightTruncatedDistribution, SoftLaplace, StudentT, - TruncatedCauchy, - TruncatedDistribution, - TruncatedNormal, - TruncatedPolyaGamma, - TwoSidedTruncatedDistribution, Uniform, ) from numpyro.distributions.directional import ProjectedNormal, VonMises @@ -72,6 +65,15 @@ ) from numpyro.distributions.kl import kl_divergence from numpyro.distributions.transforms import biject_to +from numpyro.distributions.truncated import ( + LeftTruncatedDistribution, + RightTruncatedDistribution, + TruncatedCauchy, + TruncatedDistribution, + TruncatedNormal, + TruncatedPolyaGamma, + TwoSidedTruncatedDistribution, +) from . import constraints, transforms diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index a15add90d..469c2748e 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -31,17 +31,7 @@ import jax.numpy as jnp import jax.random as random from jax.scipy.linalg import cho_solve, solve_triangular -from jax.scipy.special import ( - betainc, - expit, - gammaln, - logit, - logsumexp, - multigammaln, - ndtr, - ndtri, -) -from jax.tree_util import tree_map +from jax.scipy.special import betainc, expit, gammaln, logit, multigammaln, ndtr, ndtri from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution, TransformedDistribution @@ -1384,338 +1374,6 @@ def icdf(self, q): raise NotImplementedError -class LeftTruncatedDistribution(Distribution): - arg_constraints = {"low": constraints.real} - reparametrized_params = ["low"] - supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) - - def __init__(self, base_dist, low=0.0, validate_args=None): - assert isinstance(base_dist, self.supported_types) - assert ( - base_dist.support is constraints.real - ), "The base distribution should be univariate and have real support." - batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(low)) - self.base_dist = tree_map( - lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist - ) - (self.low,) = promote_shapes(low, shape=batch_shape) - self._support = constraints.greater_than(low) - super().__init__(batch_shape, validate_args=validate_args) - - @constraints.dependent_property(is_discrete=False, event_dim=0) - def support(self): - return self._support - - @lazy_property - def _tail_prob_at_low(self): - # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) - loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1.0, -1.0) - return self.base_dist.cdf(loc - sign * (loc - self.low)) - - @lazy_property - def _tail_prob_at_high(self): - # if low < loc, returns cdf(high) = 1; otherwise returns 1 - cdf(high) = 0 - return jnp.where(self.low <= self.base_dist.loc, 1.0, 0.0) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - u = random.uniform(key, sample_shape + self.batch_shape) - loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1.0, -1.0) - return (1 - sign) * loc + sign * self.base_dist.icdf( - (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high - ) - - @validate_sample - def log_prob(self, value): - sign = jnp.where(self.base_dist.loc >= self.low, 1.0, -1.0) - return self.base_dist.log_prob(value) - jnp.log( - sign * (self._tail_prob_at_high - self._tail_prob_at_low) - ) - - def tree_flatten(self): - base_flatten, base_aux = self.base_dist.tree_flatten() - if isinstance(self._support.lower_bound, (int, float)): - return base_flatten, ( - type(self.base_dist), - base_aux, - self._support.lower_bound, - ) - else: - return (base_flatten, self.low), (type(self.base_dist), base_aux) - - @classmethod - def tree_unflatten(cls, aux_data, params): - if len(aux_data) == 2: - base_flatten, low = params - base_cls, base_aux = aux_data - else: - base_flatten = params - base_cls, base_aux, low = aux_data - base_dist = base_cls.tree_unflatten(base_aux, base_flatten) - return cls(base_dist, low=low) - - -class RightTruncatedDistribution(Distribution): - arg_constraints = {"high": constraints.real} - reparametrized_params = ["high"] - supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) - - def __init__(self, base_dist, high=0.0, validate_args=None): - assert isinstance(base_dist, self.supported_types) - assert ( - base_dist.support is constraints.real - ), "The base distribution should be univariate and have real support." - batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(high)) - self.base_dist = tree_map( - lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist - ) - (self.high,) = promote_shapes(high, shape=batch_shape) - self._support = constraints.less_than(high) - super().__init__(batch_shape, validate_args=validate_args) - - @constraints.dependent_property(is_discrete=False, event_dim=0) - def support(self): - return self._support - - @lazy_property - def _cdf_at_high(self): - return self.base_dist.cdf(self.high) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - u = random.uniform(key, sample_shape + self.batch_shape) - return self.base_dist.icdf(u * self._cdf_at_high) - - @validate_sample - def log_prob(self, value): - return self.base_dist.log_prob(value) - jnp.log(self._cdf_at_high) - - def tree_flatten(self): - base_flatten, base_aux = self.base_dist.tree_flatten() - if isinstance(self._support.upper_bound, (int, float)): - return base_flatten, ( - type(self.base_dist), - base_aux, - self._support.upper_bound, - ) - else: - return (base_flatten, self.high), (type(self.base_dist), base_aux) - - @classmethod - def tree_unflatten(cls, aux_data, params): - if len(aux_data) == 2: - base_flatten, high = params - base_cls, base_aux = aux_data - else: - base_flatten = params - base_cls, base_aux, high = aux_data - base_dist = base_cls.tree_unflatten(base_aux, base_flatten) - return cls(base_dist, high=high) - - -class TwoSidedTruncatedDistribution(Distribution): - arg_constraints = {"low": constraints.dependent, "high": constraints.dependent} - reparametrized_params = ["low", "high"] - supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) - - def __init__(self, base_dist, low=0.0, high=1.0, validate_args=None): - assert isinstance(base_dist, self.supported_types) - assert ( - base_dist.support is constraints.real - ), "The base distribution should be univariate and have real support." - batch_shape = lax.broadcast_shapes( - base_dist.batch_shape, jnp.shape(low), jnp.shape(high) - ) - self.base_dist = tree_map( - lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist - ) - (self.low,) = promote_shapes(low, shape=batch_shape) - (self.high,) = promote_shapes(high, shape=batch_shape) - self._support = constraints.interval(low, high) - super().__init__(batch_shape, validate_args=validate_args) - - @constraints.dependent_property(is_discrete=False, event_dim=0) - def support(self): - return self._support - - @lazy_property - def _tail_prob_at_low(self): - # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) - loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1.0, -1.0) - return self.base_dist.cdf(loc - sign * (loc - self.low)) - - @lazy_property - def _tail_prob_at_high(self): - # if low < loc, returns cdf(high); otherwise returns 1 - cdf(high) - loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1.0, -1.0) - return self.base_dist.cdf(loc - sign * (loc - self.high)) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - u = random.uniform(key, sample_shape + self.batch_shape) - - # NB: we use a more numerically stable formula for a symmetric base distribution - # A = icdf(cdf(low) + (cdf(high) - cdf(low)) * u) = icdf[(1 - u) * cdf(low) + u * cdf(high)] - # will suffer by precision issues when low is large; - # If low < loc: - # A = icdf[(1 - u) * cdf(low) + u * cdf(high)] - # Else - # A = 2 * loc - icdf[(1 - u) * cdf(2*loc-low)) + u * cdf(2*loc - high)] - loc = self.base_dist.loc - sign = jnp.where(loc >= self.low, 1.0, -1.0) - return (1 - sign) * loc + sign * self.base_dist.icdf( - (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high - ) - - @validate_sample - def log_prob(self, value): - # NB: we use a more numerically stable formula for a symmetric base distribution - # if low < loc - # cdf(high) - cdf(low) = as-is - # if low > loc - # cdf(high) - cdf(low) = cdf(2 * loc - low) - cdf(2 * loc - high) - sign = jnp.where(self.base_dist.loc >= self.low, 1.0, -1.0) - return self.base_dist.log_prob(value) - jnp.log( - sign * (self._tail_prob_at_high - self._tail_prob_at_low) - ) - - def tree_flatten(self): - base_flatten, base_aux = self.base_dist.tree_flatten() - if isinstance(self._support.lower_bound, (int, float)) and isinstance( - self._support.upper_bound, (int, float) - ): - return base_flatten, ( - type(self.base_dist), - base_aux, - self._support.lower_bound, - self._support.upper_bound, - ) - else: - return (base_flatten, self.low, self.high), (type(self.base_dist), base_aux) - - @classmethod - def tree_unflatten(cls, aux_data, params): - if len(aux_data) == 2: - base_flatten, low, high = params - base_cls, base_aux = aux_data - else: - base_flatten = params - base_cls, base_aux, low, high = aux_data - base_dist = base_cls.tree_unflatten(base_aux, base_flatten) - return cls(base_dist, low=low, high=high) - - -def TruncatedDistribution(base_dist, low=None, high=None, validate_args=None): - """ - A function to generate a truncated distribution. - - :param base_dist: The base distribution to be truncated. This should be a univariate - distribution. Currently, only the following distributions are supported: - Cauchy, Laplace, Logistic, Normal, and StudentT. - :param low: the value which is used to truncate the base distribution from below. - Setting this parameter to None to not truncate from below. - :param high: the value which is used to truncate the base distribution from above. - Setting this parameter to None to not truncate from above. - """ - if high is None: - if low is None: - return base_dist - else: - return LeftTruncatedDistribution( - base_dist, low=low, validate_args=validate_args - ) - elif low is None: - return RightTruncatedDistribution( - base_dist, high=high, validate_args=validate_args - ) - else: - return TwoSidedTruncatedDistribution( - base_dist, low=low, high=high, validate_args=validate_args - ) - - -class TruncatedCauchy(LeftTruncatedDistribution): - arg_constraints = { - "low": constraints.real, - "loc": constraints.real, - "scale": constraints.positive, - } - reparametrized_params = ["low", "loc", "scale"] - - def __init__(self, low=0.0, loc=0.0, scale=1.0, validate_args=None): - self.low, self.loc, self.scale = promote_shapes(low, loc, scale) - super().__init__( - Cauchy(self.loc, self.scale), low=self.low, validate_args=validate_args - ) - - @property - def mean(self): - return jnp.full(self.batch_shape, jnp.nan) - - @property - def variance(self): - return jnp.full(self.batch_shape, jnp.nan) - - def tree_flatten(self): - if isinstance(self._support.lower_bound, (int, float)): - aux_data = self._support.lower_bound - else: - aux_data = None - return (self.low, self.loc, self.scale), aux_data - - @classmethod - def tree_unflatten(cls, aux_data, params): - d = cls(*params) - if aux_data is not None: - d._support = constraints.greater_than(aux_data) - return d - - -class TruncatedNormal(LeftTruncatedDistribution): - arg_constraints = { - "low": constraints.real, - "loc": constraints.real, - "scale": constraints.positive, - } - reparametrized_params = ["low", "loc", "scale"] - - def __init__(self, low=0.0, loc=0.0, scale=1.0, validate_args=None): - self.low, self.loc, self.scale = promote_shapes(low, loc, scale) - super().__init__( - Normal(self.loc, self.scale), low=self.low, validate_args=validate_args - ) - - @property - def mean(self): - low_prob = jnp.exp(self.log_prob(self.low)) - return self.loc + low_prob * self.scale ** 2 - - @property - def variance(self): - low_prob = jnp.exp(self.log_prob(self.low)) - return (self.scale ** 2) * ( - 1 + (self.low - self.loc) * low_prob - (low_prob * self.scale) ** 2 - ) - - def tree_flatten(self): - if isinstance(self._support.lower_bound, (int, float)): - aux_data = self._support.lower_bound - else: - aux_data = None - return (self.low, self.loc, self.scale), aux_data - - @classmethod - def tree_unflatten(cls, aux_data, params): - d = cls(*params) - if aux_data is not None: - d._support = constraints.greater_than(aux_data) - return d - - class Uniform(Distribution): arg_constraints = {"low": constraints.dependent, "high": constraints.dependent} reparametrized_params = ["low", "high"] @@ -1768,50 +1426,3 @@ def infer_shapes(low=(), high=()): batch_shape = lax.broadcast_shapes(low, high) event_shape = () return batch_shape, event_shape - - -class TruncatedPolyaGamma(Distribution): - truncation_point = 2.5 - num_log_prob_terms = 7 - num_gamma_variates = 8 - assert num_log_prob_terms % 2 == 1 - - arg_constraints = {} - support = constraints.interval(0.0, truncation_point) - - def __init__(self, batch_shape=(), validate_args=None): - super(TruncatedPolyaGamma, self).__init__( - batch_shape, validate_args=validate_args - ) - - def sample(self, key, sample_shape=()): - assert is_prng_key(key) - denom = jnp.square(jnp.arange(0.5, self.num_gamma_variates)) - x = random.gamma( - key, jnp.ones(self.batch_shape + sample_shape + (self.num_gamma_variates,)) - ) - x = jnp.sum(x / denom, axis=-1) - return jnp.clip(x * (0.5 / jnp.pi ** 2), a_max=self.truncation_point) - - @validate_sample - def log_prob(self, value): - value = value[..., None] - all_indices = jnp.arange(0, self.num_log_prob_terms) - two_n_plus_one = 2.0 * all_indices + 1.0 - log_terms = ( - jnp.log(two_n_plus_one) - - 1.5 * jnp.log(value) - - 0.125 * jnp.square(two_n_plus_one) / value - ) - even_terms = jnp.take(log_terms, all_indices[::2], axis=-1) - odd_terms = jnp.take(log_terms, all_indices[1::2], axis=-1) - sum_even = jnp.exp(logsumexp(even_terms, axis=-1)) - sum_odd = jnp.exp(logsumexp(odd_terms, axis=-1)) - return jnp.log(sum_even - sum_odd) - 0.5 * jnp.log(2.0 * jnp.pi) - - def tree_flatten(self): - return (), self.batch_shape - - @classmethod - def tree_unflatten(cls, aux_data, params): - return cls(batch_shape=aux_data) diff --git a/numpyro/distributions/truncated.py b/numpyro/distributions/truncated.py new file mode 100644 index 000000000..1717b155a --- /dev/null +++ b/numpyro/distributions/truncated.py @@ -0,0 +1,404 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from jax import lax +import jax.numpy as jnp +import jax.random as random +from jax.scipy.special import logsumexp +from jax.tree_util import tree_map + +from numpyro.distributions import constraints +from numpyro.distributions.continuous import ( + Cauchy, + Laplace, + Logistic, + Normal, + SoftLaplace, + StudentT, +) +from numpyro.distributions.distribution import Distribution +from numpyro.distributions.util import ( + is_prng_key, + lazy_property, + promote_shapes, + validate_sample, +) + + +class LeftTruncatedDistribution(Distribution): + arg_constraints = {"low": constraints.real} + reparametrized_params = ["low"] + supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) + + def __init__(self, base_dist, low=0.0, validate_args=None): + assert isinstance(base_dist, self.supported_types) + assert ( + base_dist.support is constraints.real + ), "The base distribution should be univariate and have real support." + batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(low)) + self.base_dist = tree_map( + lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist + ) + (self.low,) = promote_shapes(low, shape=batch_shape) + self._support = constraints.greater_than(low) + super().__init__(batch_shape, validate_args=validate_args) + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return self._support + + @lazy_property + def _tail_prob_at_low(self): + # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1.0, -1.0) + return self.base_dist.cdf(loc - sign * (loc - self.low)) + + @lazy_property + def _tail_prob_at_high(self): + # if low < loc, returns cdf(high) = 1; otherwise returns 1 - cdf(high) = 0 + return jnp.where(self.low <= self.base_dist.loc, 1.0, 0.0) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + u = random.uniform(key, sample_shape + self.batch_shape) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1.0, -1.0) + return (1 - sign) * loc + sign * self.base_dist.icdf( + (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high + ) + + @validate_sample + def log_prob(self, value): + sign = jnp.where(self.base_dist.loc >= self.low, 1.0, -1.0) + return self.base_dist.log_prob(value) - jnp.log( + sign * (self._tail_prob_at_high - self._tail_prob_at_low) + ) + + def tree_flatten(self): + base_flatten, base_aux = self.base_dist.tree_flatten() + if isinstance(self._support.lower_bound, (int, float)): + return base_flatten, ( + type(self.base_dist), + base_aux, + self._support.lower_bound, + ) + else: + return (base_flatten, self.low), (type(self.base_dist), base_aux) + + @classmethod + def tree_unflatten(cls, aux_data, params): + if len(aux_data) == 2: + base_flatten, low = params + base_cls, base_aux = aux_data + else: + base_flatten = params + base_cls, base_aux, low = aux_data + base_dist = base_cls.tree_unflatten(base_aux, base_flatten) + return cls(base_dist, low=low) + + +class RightTruncatedDistribution(Distribution): + arg_constraints = {"high": constraints.real} + reparametrized_params = ["high"] + supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) + + def __init__(self, base_dist, high=0.0, validate_args=None): + assert isinstance(base_dist, self.supported_types) + assert ( + base_dist.support is constraints.real + ), "The base distribution should be univariate and have real support." + batch_shape = lax.broadcast_shapes(base_dist.batch_shape, jnp.shape(high)) + self.base_dist = tree_map( + lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist + ) + (self.high,) = promote_shapes(high, shape=batch_shape) + self._support = constraints.less_than(high) + super().__init__(batch_shape, validate_args=validate_args) + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return self._support + + @lazy_property + def _cdf_at_high(self): + return self.base_dist.cdf(self.high) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + u = random.uniform(key, sample_shape + self.batch_shape) + return self.base_dist.icdf(u * self._cdf_at_high) + + @validate_sample + def log_prob(self, value): + return self.base_dist.log_prob(value) - jnp.log(self._cdf_at_high) + + def tree_flatten(self): + base_flatten, base_aux = self.base_dist.tree_flatten() + if isinstance(self._support.upper_bound, (int, float)): + return base_flatten, ( + type(self.base_dist), + base_aux, + self._support.upper_bound, + ) + else: + return (base_flatten, self.high), (type(self.base_dist), base_aux) + + @classmethod + def tree_unflatten(cls, aux_data, params): + if len(aux_data) == 2: + base_flatten, high = params + base_cls, base_aux = aux_data + else: + base_flatten = params + base_cls, base_aux, high = aux_data + base_dist = base_cls.tree_unflatten(base_aux, base_flatten) + return cls(base_dist, high=high) + + +class TwoSidedTruncatedDistribution(Distribution): + arg_constraints = {"low": constraints.dependent, "high": constraints.dependent} + reparametrized_params = ["low", "high"] + supported_types = (Cauchy, Laplace, Logistic, Normal, SoftLaplace, StudentT) + + def __init__(self, base_dist, low=0.0, high=1.0, validate_args=None): + assert isinstance(base_dist, self.supported_types) + assert ( + base_dist.support is constraints.real + ), "The base distribution should be univariate and have real support." + batch_shape = lax.broadcast_shapes( + base_dist.batch_shape, jnp.shape(low), jnp.shape(high) + ) + self.base_dist = tree_map( + lambda p: promote_shapes(p, shape=batch_shape)[0], base_dist + ) + (self.low,) = promote_shapes(low, shape=batch_shape) + (self.high,) = promote_shapes(high, shape=batch_shape) + self._support = constraints.interval(low, high) + super().__init__(batch_shape, validate_args=validate_args) + + @constraints.dependent_property(is_discrete=False, event_dim=0) + def support(self): + return self._support + + @lazy_property + def _tail_prob_at_low(self): + # if low < loc, returns cdf(low); otherwise returns 1 - cdf(low) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1.0, -1.0) + return self.base_dist.cdf(loc - sign * (loc - self.low)) + + @lazy_property + def _tail_prob_at_high(self): + # if low < loc, returns cdf(high); otherwise returns 1 - cdf(high) + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1.0, -1.0) + return self.base_dist.cdf(loc - sign * (loc - self.high)) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + u = random.uniform(key, sample_shape + self.batch_shape) + + # NB: we use a more numerically stable formula for a symmetric base distribution + # A = icdf(cdf(low) + (cdf(high) - cdf(low)) * u) = icdf[(1 - u) * cdf(low) + u * cdf(high)] + # will suffer by precision issues when low is large; + # If low < loc: + # A = icdf[(1 - u) * cdf(low) + u * cdf(high)] + # Else + # A = 2 * loc - icdf[(1 - u) * cdf(2*loc-low)) + u * cdf(2*loc - high)] + loc = self.base_dist.loc + sign = jnp.where(loc >= self.low, 1.0, -1.0) + return (1 - sign) * loc + sign * self.base_dist.icdf( + (1 - u) * self._tail_prob_at_low + u * self._tail_prob_at_high + ) + + @validate_sample + def log_prob(self, value): + # NB: we use a more numerically stable formula for a symmetric base distribution + # if low < loc + # cdf(high) - cdf(low) = as-is + # if low > loc + # cdf(high) - cdf(low) = cdf(2 * loc - low) - cdf(2 * loc - high) + sign = jnp.where(self.base_dist.loc >= self.low, 1.0, -1.0) + return self.base_dist.log_prob(value) - jnp.log( + sign * (self._tail_prob_at_high - self._tail_prob_at_low) + ) + + def tree_flatten(self): + base_flatten, base_aux = self.base_dist.tree_flatten() + if isinstance(self._support.lower_bound, (int, float)) and isinstance( + self._support.upper_bound, (int, float) + ): + return base_flatten, ( + type(self.base_dist), + base_aux, + self._support.lower_bound, + self._support.upper_bound, + ) + else: + return (base_flatten, self.low, self.high), (type(self.base_dist), base_aux) + + @classmethod + def tree_unflatten(cls, aux_data, params): + if len(aux_data) == 2: + base_flatten, low, high = params + base_cls, base_aux = aux_data + else: + base_flatten = params + base_cls, base_aux, low, high = aux_data + base_dist = base_cls.tree_unflatten(base_aux, base_flatten) + return cls(base_dist, low=low, high=high) + + +def TruncatedDistribution(base_dist, low=None, high=None, validate_args=None): + """ + A function to generate a truncated distribution. + + :param base_dist: The base distribution to be truncated. This should be a univariate + distribution. Currently, only the following distributions are supported: + Cauchy, Laplace, Logistic, Normal, and StudentT. + :param low: the value which is used to truncate the base distribution from below. + Setting this parameter to None to not truncate from below. + :param high: the value which is used to truncate the base distribution from above. + Setting this parameter to None to not truncate from above. + """ + if high is None: + if low is None: + return base_dist + else: + return LeftTruncatedDistribution( + base_dist, low=low, validate_args=validate_args + ) + elif low is None: + return RightTruncatedDistribution( + base_dist, high=high, validate_args=validate_args + ) + else: + return TwoSidedTruncatedDistribution( + base_dist, low=low, high=high, validate_args=validate_args + ) + + +class TruncatedCauchy(LeftTruncatedDistribution): + arg_constraints = { + "low": constraints.real, + "loc": constraints.real, + "scale": constraints.positive, + } + reparametrized_params = ["low", "loc", "scale"] + + def __init__(self, low=0.0, loc=0.0, scale=1.0, validate_args=None): + self.low, self.loc, self.scale = promote_shapes(low, loc, scale) + super().__init__( + Cauchy(self.loc, self.scale), low=self.low, validate_args=validate_args + ) + + @property + def mean(self): + return jnp.full(self.batch_shape, jnp.nan) + + @property + def variance(self): + return jnp.full(self.batch_shape, jnp.nan) + + def tree_flatten(self): + if isinstance(self._support.lower_bound, (int, float)): + aux_data = self._support.lower_bound + else: + aux_data = None + return (self.low, self.loc, self.scale), aux_data + + @classmethod + def tree_unflatten(cls, aux_data, params): + d = cls(*params) + if aux_data is not None: + d._support = constraints.greater_than(aux_data) + return d + + +class TruncatedNormal(LeftTruncatedDistribution): + arg_constraints = { + "low": constraints.real, + "loc": constraints.real, + "scale": constraints.positive, + } + reparametrized_params = ["low", "loc", "scale"] + + def __init__(self, low=0.0, loc=0.0, scale=1.0, validate_args=None): + self.low, self.loc, self.scale = promote_shapes(low, loc, scale) + super().__init__( + Normal(self.loc, self.scale), low=self.low, validate_args=validate_args + ) + + @property + def mean(self): + low_prob = jnp.exp(self.log_prob(self.low)) + return self.loc + low_prob * self.scale ** 2 + + @property + def variance(self): + low_prob = jnp.exp(self.log_prob(self.low)) + return (self.scale ** 2) * ( + 1 + (self.low - self.loc) * low_prob - (low_prob * self.scale) ** 2 + ) + + def tree_flatten(self): + if isinstance(self._support.lower_bound, (int, float)): + aux_data = self._support.lower_bound + else: + aux_data = None + return (self.low, self.loc, self.scale), aux_data + + @classmethod + def tree_unflatten(cls, aux_data, params): + d = cls(*params) + if aux_data is not None: + d._support = constraints.greater_than(aux_data) + return d + + +class TruncatedPolyaGamma(Distribution): + truncation_point = 2.5 + num_log_prob_terms = 7 + num_gamma_variates = 8 + assert num_log_prob_terms % 2 == 1 + + arg_constraints = {} + support = constraints.interval(0.0, truncation_point) + + def __init__(self, batch_shape=(), validate_args=None): + super(TruncatedPolyaGamma, self).__init__( + batch_shape, validate_args=validate_args + ) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + denom = jnp.square(jnp.arange(0.5, self.num_gamma_variates)) + x = random.gamma( + key, jnp.ones(self.batch_shape + sample_shape + (self.num_gamma_variates,)) + ) + x = jnp.sum(x / denom, axis=-1) + return jnp.clip(x * (0.5 / jnp.pi ** 2), a_max=self.truncation_point) + + @validate_sample + def log_prob(self, value): + value = value[..., None] + all_indices = jnp.arange(0, self.num_log_prob_terms) + two_n_plus_one = 2.0 * all_indices + 1.0 + log_terms = ( + jnp.log(two_n_plus_one) + - 1.5 * jnp.log(value) + - 0.125 * jnp.square(two_n_plus_one) / value + ) + even_terms = jnp.take(log_terms, all_indices[::2], axis=-1) + odd_terms = jnp.take(log_terms, all_indices[1::2], axis=-1) + sum_even = jnp.exp(logsumexp(even_terms, axis=-1)) + sum_odd = jnp.exp(logsumexp(odd_terms, axis=-1)) + return jnp.log(sum_even - sum_odd) - 0.5 * jnp.log(2.0 * jnp.pi) + + def tree_flatten(self): + return (), self.batch_shape + + @classmethod + def tree_unflatten(cls, aux_data, params): + return cls(batch_shape=aux_data) diff --git a/test/test_distributions.py b/test/test_distributions.py index 2ca49ca44..500d62d9e 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -278,7 +278,7 @@ def sample(self, key, sample_shape=()): None, jnp.array([-2.0, 2.0]), ), - T(dist.continuous.TwoSidedTruncatedDistribution, dist.Laplace(0.0, 1.0), -2.0, 3.0), + T(dist.TwoSidedTruncatedDistribution, dist.Laplace(0.0, 1.0), -2.0, 3.0), T(dist.Uniform, 0.0, 2.0), T(dist.Uniform, 1.0, jnp.array([2.0, 3.0])), T(dist.Uniform, jnp.array([0.0, 0.0]), jnp.array([[2.0], [3.0]])), @@ -1107,7 +1107,7 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): ): continue if ( - jax_dist is dist.continuous.TwoSidedTruncatedDistribution + jax_dist is dist.TwoSidedTruncatedDistribution and dist_args[i] == "base_dist" ): continue From 3080edbf3aa9b962dfe599beb4939039ae3f0d96 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Tue, 13 Apr 2021 11:55:06 -0400 Subject: [PATCH 096/222] Implement sparse Poisson.log_prob() (#1003) * Add is_sparse flag to Poisson distribution * Add failing tests * lint * Attempt to fix errors * Fix bugs, add a jit log likelihood test * Address review comments --- numpyro/distributions/discrete.py | 22 +++++++++++++++- test/test_distributions.py | 44 ++++++++++++++++++++++++++++--- 2 files changed, 61 insertions(+), 5 deletions(-) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index a41702a29..bce6c692f 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -29,9 +29,11 @@ import numpy as np +import jax from jax import lax from jax.nn import softmax, softplus import jax.numpy as jnp +from jax.ops import index_add import jax.random as random from jax.scipy.special import expit, gammaln, logsumexp, xlog1py, xlogy @@ -608,8 +610,9 @@ class Poisson(Distribution): support = constraints.nonnegative_integer is_discrete = True - def __init__(self, rate, validate_args=None): + def __init__(self, rate, *, is_sparse=False, validate_args=None): self.rate = rate + self.is_sparse = is_sparse super(Poisson, self).__init__(jnp.shape(rate), validate_args=validate_args) def sample(self, key, sample_shape=()): @@ -620,6 +623,23 @@ def sample(self, key, sample_shape=()): def log_prob(self, value): if self._validate_args: self._validate_sample(value) + value = jax.device_get(value) + if ( + self.is_sparse + and not isinstance(value, jax.core.Tracer) + and jnp.size(value) > 1 + ): + shape = lax.broadcast_shapes(self.batch_shape, jnp.shape(value)) + rate = jnp.broadcast_to(self.rate, shape).reshape(-1) + value = jnp.broadcast_to(value, shape).reshape(-1) + nonzero = value > 0 + sparse_value = value[nonzero] + sparse_rate = rate[nonzero] + return index_add( + -rate, + nonzero, + jnp.log(sparse_rate) * sparse_value - gammaln(sparse_value + 1), + ).reshape(shape) return (jnp.log(self.rate) * value) - gammaln(value + 1) - self.rate @property diff --git a/test/test_distributions.py b/test/test_distributions.py index 500d62d9e..7e791c0a4 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -47,9 +47,7 @@ def _identity(x): class T(namedtuple("TestCase", ["jax_dist", "sp_dist", "params"])): def __new__(cls, jax_dist, *params): - sp_dist = None - if jax_dist in _DIST_MAP: - sp_dist = _DIST_MAP[jax_dist] + sp_dist = get_sp_dist(jax_dist) return super(cls, T).__new__(cls, jax_dist, sp_dist, params) @@ -98,6 +96,11 @@ def sample(self, key, sample_shape=()): return transform(unconstrained_samples) +class SparsePoisson(dist.Poisson): + def __init__(self, rate, *, validate_args=None): + super().__init__(rate, is_sparse=True, validate_args=validate_args) + + _DIST_MAP = { dist.BernoulliProbs: lambda probs: osp.bernoulli(p=probs), dist.BernoulliLogits: lambda logits: osp.bernoulli(p=_to_probs_bernoulli(logits)), @@ -141,6 +144,14 @@ def sample(self, key, sample_shape=()): _TruncatedNormal: _truncnorm_to_scipy, } + +def get_sp_dist(jax_dist): + classes = jax_dist.mro() if isinstance(jax_dist, type) else [jax_dist] + for cls in classes: + if cls in _DIST_MAP: + return _DIST_MAP[cls] + + CONTINUOUS = [ T(dist.Beta, 0.2, 1.1), T(dist.Beta, 1.0, jnp.array([2.0, 2.0])), @@ -331,6 +342,8 @@ def sample(self, key, sample_shape=()): T(dist.OrderedLogistic, jnp.array([-4, 3, 4, 5]), jnp.array([-1.5])), T(dist.Poisson, 2.0), T(dist.Poisson, jnp.array([2.0, 3.0, 5.0])), + T(SparsePoisson, 2.0), + T(SparsePoisson, jnp.array([2.0, 3.0, 5.0])), T(dist.ZeroInflatedPoisson, 0.6, 2.0), T(dist.ZeroInflatedPoisson, jnp.array([0.2, 0.7, 0.3]), jnp.array([2.0, 3.0, 5.0])), ] @@ -652,6 +665,29 @@ def test_pathwise_gradient(jax_dist, sp_dist, params): assert_allclose(actual_grad[i], expected_grad, rtol=0.005) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL +) +def test_jit_log_likelihood(jax_dist, sp_dist, params): + if jax_dist.__name__ in ( + "GaussianRandomWalk", + "_ImproperWrapper", + "LKJ", + "LKJCholesky", + ): + pytest.xfail(reason="non-jittable params") + + rng_key = random.PRNGKey(0) + samples = jax_dist(*params).sample(key=rng_key, sample_shape=(2, 3)) + + def log_likelihood(*params): + return jax_dist(*params).log_prob(samples) + + expected = log_likelihood(*params) + actual = jax.jit(log_likelihood)(*params) + assert_allclose(actual, expected, atol=1e-5) + + @pytest.mark.parametrize( "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL ) @@ -688,7 +724,7 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): # old api low, loc, scale = params high = jnp.inf - sp_dist = _DIST_MAP[type(jax_dist.base_dist)](loc, scale) + sp_dist = get_sp_dist(type(jax_dist.base_dist))(loc, scale) expected = sp_dist.logpdf(samples) - jnp.log( sp_dist.cdf(high) - sp_dist.cdf(low) ) From eb545d231367216f31b542fd1179def9d023e0ec Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 13 Apr 2021 11:31:09 -0500 Subject: [PATCH 097/222] Add a flag to control regularize mass matrix behavior (#998) * add regularize_mass_matrix flag * make barkermh picklable * make SA gradient_free * make format * default to -> defaults to; separating positional arguments * better match for xla_flags * typo --- numpyro/handlers.py | 20 ++++++++++---------- numpyro/infer/barker.py | 6 ++++++ numpyro/infer/hmc.py | 30 +++++++++++++++++++++++------- numpyro/infer/hmc_util.py | 3 ++- numpyro/infer/sa.py | 1 + numpyro/infer/util.py | 30 ++++++++++++++++++++++++------ numpyro/util.py | 4 ++-- test/infer/test_mcmc.py | 17 +++++++++++++++-- test/test_pickle.py | 13 +++++++++++-- 9 files changed, 94 insertions(+), 30 deletions(-) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index cb1ead7ae..fd4ce4c6d 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -597,16 +597,16 @@ class scope(Messenger): .. doctest:: - >>> import numpyro - >>> import numpyro.distributions as dist - >>> from numpyro.handlers import scope, seed, trace - >>> - >>> def model(): - ... with scope(prefix="a"): - ... with scope(prefix="b", divider="."): - ... return numpyro.sample("x", dist.Bernoulli(0.5)) - ... - >>> assert "a/b.x" in trace(seed(model, 0)).get_trace() + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.handlers import scope, seed, trace + >>> + >>> def model(): + ... with scope(prefix="a"): + ... with scope(prefix="b", divider="."): + ... return numpyro.sample("x", dist.Bernoulli(0.5)) + ... + >>> assert "a/b.x" in trace(seed(model, 0)).get_trace() :param fn: Python callable with NumPyro primitives. :param str prefix: a string to prepend to sample names diff --git a/numpyro/infer/barker.py b/numpyro/infer/barker.py index 2649184a3..147f72b40 100644 --- a/numpyro/infer/barker.py +++ b/numpyro/infer/barker.py @@ -285,3 +285,9 @@ def sample(self, state, model_args, model_kwargs): return BarkerMHState( itr, x, pe, x_grad, accept_prob, mean_accept_prob, adapt_state, rng_key ) + + def __getstate__(self): + state = self.__dict__.copy() + state["_postprocess_fn"] = None + state["_wa_update"] = None + return state diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 8273ddb24..aff4493f5 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -184,6 +184,7 @@ def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo="NUTS"): def init_kernel( init_params, num_warmup, + *, step_size=1.0, inverse_mass_matrix=None, adapt_step_size=True, @@ -194,6 +195,7 @@ def init_kernel( max_tree_depth=10, find_heuristic_step_size=False, forward_mode_differentiation=False, + regularize_mass_matrix=True, model_args=(), model_kwargs=None, rng_key=random.PRNGKey(0), @@ -243,7 +245,7 @@ def init_kernel( :type dense_mass: bool or list :param float target_accept_prob: Target acceptance probability for step size adaptation using Dual Averaging. Increasing this value will lead to a smaller - step size, hence the sampling will be slower but more robust. Default to 0.8. + step size, hence the sampling will be slower but more robust. Defaults to 0.8. :param float trajectory_length: Length of a MCMC trajectory for HMC. Default value is :math:`2\\pi`. :param int max_tree_depth: Max depth of the binary tree created during the doubling @@ -252,6 +254,9 @@ def init_kernel( `d2` is the max tree depth during post warmup phase. :param bool find_heuristic_step_size: whether to a heuristic function to adjust the step size at the beginning of each adaptation window. Defaults to False. + :param bool regularize_mass_matrix: whether or not to regularize the estimated mass + matrix for numerical stability during warmup phase. Defaults to True. This flag + does not take effect if ``adapt_mass_matrix == False``. :param tuple model_args: Model arguments if `potential_fn_gen` is specified. :param dict model_kwargs: Model keyword arguments if `potential_fn_gen` is specified. :param jax.random.PRNGKey rng_key: random key to be used as the source of @@ -298,6 +303,7 @@ def init_kernel( dense_mass=dense_mass, target_accept_prob=target_accept_prob, find_reasonable_step_size=find_reasonable_ss, + regularize_mass_matrix=regularize_mass_matrix, ) rng_key_hmc, rng_key_wa, rng_key_momentum = random.split(rng_key, 3) @@ -557,13 +563,14 @@ class HMC(MCMCKernel): :type dense_mass: bool or list :param float target_accept_prob: Target acceptance probability for step size adaptation using Dual Averaging. Increasing this value will lead to a smaller - step size, hence the sampling will be slower but more robust. Default to 0.8. + step size, hence the sampling will be slower but more robust. Defaults to 0.8. :param float trajectory_length: Length of a MCMC trajectory for HMC. Default value is :math:`2\\pi`. :param callable init_strategy: a per-site initialization function. See :ref:`init_strategy` section for available functions. - :param bool find_heuristic_step_size: whether to a heuristic function to adjust the - step size at the beginning of each adaptation window. Defaults to False. + :param bool find_heuristic_step_size: whether or not to use a heuristic function + to adjust the step size at the beginning of each adaptation window. Defaults + to False. :param bool forward_mode_differentiation: whether to use forward-mode differentiation or reverse-mode differentiation. By default, we use reverse mode but the forward mode can be useful in some cases to improve the performance. In addition, some @@ -571,6 +578,9 @@ class HMC(MCMCKernel): only supports forward-mode differentiation. See `JAX's The Autodiff Cookbook `_ for more information. + :param bool regularize_mass_matrix: whether or not to regularize the estimated mass + matrix for numerical stability during warmup phase. Defaults to True. This flag + does not take effect if ``adapt_mass_matrix == False``. """ def __init__( @@ -588,6 +598,7 @@ def __init__( init_strategy=init_to_uniform, find_heuristic_step_size=False, forward_mode_differentiation=False, + regularize_mass_matrix=True, ): if not (model is None) ^ (potential_fn is None): raise ValueError("Only one of `model` or `potential_fn` must be specified.") @@ -612,6 +623,7 @@ def __init__( self._init_strategy = init_strategy self._find_heuristic_step_size = find_heuristic_step_size self._forward_mode_differentiation = forward_mode_differentiation + self._regularize_mass_matrix = regularize_mass_matrix # Set on first call to init self._init_fn = None self._potential_fn_gen = None @@ -707,6 +719,7 @@ def init( max_tree_depth=self._max_tree_depth, find_heuristic_step_size=self._find_heuristic_step_size, forward_mode_differentiation=self._forward_mode_differentiation, + regularize_mass_matrix=self._regularize_mass_matrix, model_args=model_args, model_kwargs=model_kwargs, rng_key=rng_key, @@ -809,7 +822,7 @@ class NUTS(HMC): :type dense_mass: bool or list :param float target_accept_prob: Target acceptance probability for step size adaptation using Dual Averaging. Increasing this value will lead to a smaller - step size, hence the sampling will be slower but more robust. Default to 0.8. + step size, hence the sampling will be slower but more robust. Defaults to 0.8. :param float trajectory_length: Length of a MCMC trajectory for HMC. This arg has no effect in NUTS sampler. :param int max_tree_depth: Max depth of the binary tree created during the doubling @@ -818,8 +831,9 @@ class NUTS(HMC): `d2` is the max tree depth during post warmup phase. :param callable init_strategy: a per-site initialization function. See :ref:`init_strategy` section for available functions. - :param bool find_heuristic_step_size: whether to a heuristic function to adjust the - step size at the beginning of each adaptation window. Defaults to False. + :param bool find_heuristic_step_size: whether or not to use a heuristic function + to adjust the step size at the beginning of each adaptation window. Defaults + to False. :param bool forward_mode_differentiation: whether to use forward-mode differentiation or reverse-mode differentiation. By default, we use reverse mode but the forward mode can be useful in some cases to improve the performance. In addition, some @@ -845,6 +859,7 @@ def __init__( init_strategy=init_to_uniform, find_heuristic_step_size=False, forward_mode_differentiation=False, + regularize_mass_matrix=True, ): super(NUTS, self).__init__( potential_fn=potential_fn, @@ -860,6 +875,7 @@ def __init__( init_strategy=init_strategy, find_heuristic_step_size=find_heuristic_step_size, forward_mode_differentiation=forward_mode_differentiation, + regularize_mass_matrix=regularize_mass_matrix, ) self._max_tree_depth = max_tree_depth self._algo = "NUTS" diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index c2ddaaa4b..53495715a 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -517,6 +517,7 @@ def warmup_adapter( adapt_mass_matrix=True, dense_mass=False, target_accept_prob=0.8, + regularize_mass_matrix=True, ): """ A scheme to adapt tunable parameters, namely step size and mass matrix, during @@ -601,7 +602,7 @@ def _update_at_window_end(z_info, rng_key_ss, state): if adapt_mass_matrix: inverse_mass_matrix, mass_matrix_sqrt, mass_matrix_sqrt_inv = mm_final( - mm_state, regularize=True + mm_state, regularize=regularize_mass_matrix ) if isinstance(inverse_mass_matrix, dict): size = {k: v.shape for k, v in inverse_mass_matrix.items()} diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index 31bb8db7a..a64aef9ec 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -311,6 +311,7 @@ def _init_state(self, rng_key, model_args, model_kwargs, init_params): init_strategy=self._init_strategy, model_args=model_args, model_kwargs=model_kwargs, + validate_grad=False, ) init_params = init_params[0] # NB: init args is different from HMC diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 505558c8b..05f0a5853 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -182,12 +182,14 @@ def _init_to_unconstrained_value(site=None, values={}): def find_valid_initial_params( rng_key, model, + *, init_strategy=init_to_uniform, enum=False, model_args=(), model_kwargs=None, prototype_params=None, forward_mode_differentiation=False, + validate_grad=True, ): """ (EXPERIMENTAL INTERFACE) Given a model with Pyro primitives, returns an initial @@ -207,6 +209,10 @@ def find_valid_initial_params( :param dict model_kwargs: kwargs provided to the model. :param dict prototype_params: an optional prototype parameters, which is used to define the shape for initial parameters. + :param bool forward_mode_differentiation: whether to use forward-mode differentiation + or reverse-mode differentiation. Defaults to False. + :param bool validate_grad: whether to validate gradient of the initial params. + Defaults to True. :return: tuple of `init_params_info` and `is_valid`, where `init_params_info` is the tuple containing the initial params, their potential energy, and their gradients. """ @@ -264,13 +270,19 @@ def body_fn(state): potential_fn = partial( potential_energy, model, model_args, model_kwargs, enum=enum ) - if forward_mode_differentiation: - pe = potential_fn(params) - z_grad = jacfwd(potential_fn)(params) + if validate_grad: + if forward_mode_differentiation: + pe = potential_fn(params) + z_grad = jacfwd(potential_fn)(params) + else: + pe, z_grad = value_and_grad(potential_fn)(params) + z_grad_flat = ravel_pytree(z_grad)[0] + is_valid = jnp.isfinite(pe) & jnp.all(jnp.isfinite(z_grad_flat)) else: - pe, z_grad = value_and_grad(potential_fn)(params) - z_grad_flat = ravel_pytree(z_grad)[0] - is_valid = jnp.isfinite(pe) & jnp.all(jnp.isfinite(z_grad_flat)) + pe = potential_fn(params) + is_valid = jnp.isfinite(pe) + z_grad = None + return i + 1, key, (params, pe, z_grad), is_valid def _find_valid_params(rng_key, exit_early=False): @@ -336,6 +348,7 @@ def _get_model_transforms(model, model_args=(), model_kwargs=None): def get_potential_fn( model, inv_transforms, + *, enum=False, replay_model=False, dynamic_args=False, @@ -438,11 +451,13 @@ def _validate_model(model_trace): def initialize_model( rng_key, model, + *, init_strategy=init_to_uniform, dynamic_args=False, model_args=(), model_kwargs=None, forward_mode_differentiation=False, + validate_grad=True, ): """ (EXPERIMENTAL INTERFACE) Helper function that calls :func:`~numpyro.infer.util.get_potential_fn` @@ -468,6 +483,8 @@ def initialize_model( only supports forward-mode differentiation. See `JAX's The Autodiff Cookbook `_ for more information. + :param bool validate_grad: whether to validate gradient of the initial params. + Defaults to True. :return: a namedtupe `ModelInfo` which contains the fields (`param_info`, `potential_fn`, `postprocess_fn`, `model_trace`), where `param_info` is a namedtuple `ParamInfo` containing values from the prior @@ -546,6 +563,7 @@ def initialize_model( model_kwargs=model_kwargs, prototype_params=prototype_params, forward_mode_differentiation=forward_mode_differentiation, + validate_grad=validate_grad, ) if not_jax_tracer(is_valid): diff --git a/numpyro/util.py b/numpyro/util.py index 4123154ed..1a2d090d0 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -75,9 +75,9 @@ def set_host_device_count(n): :param int n: number of CPU devices to use. """ - xla_flags = os.getenv("XLA_FLAGS", "").lstrip("--") + xla_flags = os.getenv("XLA_FLAGS", "") xla_flags = re.sub( - r"xla_force_host_platform_device_count=.+\s", "", xla_flags + r"--xla_force_host_platform_device_count=\S+", "", xla_flags ).split() os.environ["XLA_FLAGS"] = " ".join( ["--xla_force_host_platform_device_count={}".format(n)] + xla_flags diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index 2abdabf90..3a20eb148 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -53,7 +53,8 @@ def potential_fn(z): assert hmc_states.dtype == jnp.float64 -def test_correlated_mvn(): +@pytest.mark.parametrize("regularize", [True, False]) +def test_correlated_mvn(regularize): # This requires dense mass matrix estimation. D = 5 @@ -71,7 +72,9 @@ def potential_fn(z): return 0.5 * jnp.dot(z.T, jnp.dot(true_prec, z)) init_params = jnp.zeros(D) - kernel = NUTS(potential_fn=potential_fn, dense_mass=True) + kernel = NUTS( + potential_fn=potential_fn, dense_mass=True, regularize_mass_matrix=regularize + ) mcmc = MCMC(kernel, warmup_steps, num_samples) mcmc.run(random.PRNGKey(0), init_params=init_params) samples = mcmc.get_samples() @@ -897,6 +900,16 @@ def model(): mcmc.run(random.PRNGKey(0)) +def test_SA_gradient_free(): + def model(): + x = numpyro.sample("x", dist.Normal(0, 1)) + y = lax.while_loop(lambda x: x < 10, lambda x: x + 1, x) + numpyro.sample("obs", dist.Normal(y, 1), obs=1.0) + + mcmc = MCMC(SA(model), 10, 10) + mcmc.run(random.PRNGKey(0)) + + def test_model_with_lift_handler(): def model(data): c = numpyro.param("c", jnp.array(1.0), constraint=dist.constraints.positive) diff --git a/test/test_pickle.py b/test/test_pickle.py index fbfcdd3c7..1a74b7f18 100644 --- a/test/test_pickle.py +++ b/test/test_pickle.py @@ -10,7 +10,16 @@ import numpyro import numpyro.distributions as dist -from numpyro.infer import HMC, HMCECS, MCMC, NUTS, SA, DiscreteHMCGibbs, MixedHMC +from numpyro.infer import ( + HMC, + HMCECS, + MCMC, + NUTS, + SA, + BarkerMH, + DiscreteHMCGibbs, + MixedHMC, +) def normal_model(): @@ -29,7 +38,7 @@ def logistic_regression(): numpyro.sample("obs", dist.Bernoulli(logits=x), obs=batch) -@pytest.mark.parametrize("kernel", [HMC, NUTS, SA]) +@pytest.mark.parametrize("kernel", [BarkerMH, HMC, NUTS, SA]) def test_pickle_hmc(kernel): mcmc = MCMC(kernel(normal_model), 10, 10) mcmc.run(random.PRNGKey(0)) From 6823c495f62774172936fb437bb17210fd0179e0 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Tue, 13 Apr 2021 23:24:36 -0400 Subject: [PATCH 098/222] Support decorator syntax for handlers (#1009) --- numpyro/primitives.py | 5 ++++ test/infer/test_reparam.py | 54 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 59 insertions(+) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 94253ee89..8c998702c 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -78,6 +78,11 @@ def postprocess_message(self, msg): pass def __call__(self, *args, **kwargs): + if self.fn is None: + # Assume self is being used as a decorator. + assert len(args) == 1 and not kwargs + self.fn = args[0] + return self with self: return self.fn(*args, **kwargs) diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index e025885cc..98e992a86 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -37,6 +37,60 @@ def get_moments(x): return jnp.stack([m1, m2, m3, m4]) +def test_syntax(): + loc = np.random.uniform(-1.0, 1.0, ()) + scale = np.random.uniform(0.5, 1.5, ()) + data = np.random.uniform(-1.0, 1.0, ()) + config = {"x": LocScaleReparam(), "y": LocScaleReparam()} + + def model(): + x = numpyro.sample("x", dist.Normal(loc, scale)) + y = numpyro.sample("y", dist.Normal(x, scale)) + numpyro.sample("z", dist.Normal(y, scale), obs=data) + + # Context manager syntax. + seed = numpyro.handlers.seed(rng_seed=0) + trace = numpyro.handlers.trace() + reparam = numpyro.handlers.reparam(config=config) + with reparam, trace, seed: + model() + tr1 = trace.trace + + # Eager function syntax. + seed = numpyro.handlers.seed(model, rng_seed=0) + trace = numpyro.handlers.trace(seed) + reparam = numpyro.handlers.reparam(trace, config=config) + reparam() + tr2 = trace.trace + + # Partial function syntax. + seed = numpyro.handlers.seed(rng_seed=0) + trace = numpyro.handlers.trace() + reparam = numpyro.handlers.reparam(config=config) + m = model + m = seed(m) + m = trace(m) + m = reparam(m) + m() + tr3 = trace.trace + + # Decorator syntax. + seed = numpyro.handlers.seed(rng_seed=0) + trace = numpyro.handlers.trace() + reparam = numpyro.handlers.reparam(config=config) + + @reparam + @trace + @seed + def m(): + return model() + + m() + tr4 = trace.trace + + assert tr1.keys() == tr2.keys() == tr3.keys() == tr4.keys() + + @pytest.mark.parametrize( "batch_shape,base_batch_shape", [((), ()), ((4,), (4,)), ((2, 3), (2, 3)), ((2, 3), ())], From 048d2c80d9f4087aa9614225568bb88e1f74d669 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Mon, 19 Apr 2021 20:01:58 +0100 Subject: [PATCH 099/222] Fix AutoGuide event_ndim issue (#1013) * Fix AutoGuide event_ndim issue * Add Predictive to autoguide tests --- numpyro/infer/autoguide.py | 2 +- test/infer/test_autoguide.py | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 246dd9642..fa306bb8b 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -482,13 +482,13 @@ def __call__(self, *args, **kwargs): site = self.prototype_trace[name] transform = biject_to(site["fn"].support) value = transform(unconstrained_value) + event_ndim = site["fn"].event_dim if numpyro.get_mask() is False: log_density = 0.0 else: log_density = -transform.log_abs_det_jacobian( unconstrained_value, value ) - event_ndim = site["fn"].event_dim log_density = sum_rightmost( log_density, jnp.ndim(log_density) - jnp.ndim(value) + event_ndim ) diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index a902602c6..926aa13db 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -31,6 +31,7 @@ ) from numpyro.infer.initialization import init_to_median from numpyro.infer.reparam import TransformReparam +from numpyro.infer.util import Predictive from numpyro.nn.auto_reg_nn import AutoregressiveNN from numpyro.util import fori_loop @@ -75,6 +76,16 @@ def body_fn(i, val): ) assert_allclose(jnp.mean(posterior_samples["beta"], 0), true_coefs, atol=0.05) + # Predictive can be instantiated from posterior samples... + predictive = Predictive(model, posterior_samples=posterior_samples) + predictive_samples = predictive(random.PRNGKey(1), None) + assert predictive_samples["obs"].shape == (1000, 2) + + # ... or from the guide + params + predictive = Predictive(model, guide=guide, params=params, num_samples=1000) + predictive_samples = predictive(random.PRNGKey(1), None) + assert predictive_samples["obs"].shape == (1000, 2) + @pytest.mark.parametrize( "auto_class", From bfedef93e64d560d586caf00b4dbd556d1636f08 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 22 Apr 2021 14:26:36 -0500 Subject: [PATCH 100/222] Raise error for SVI if model/guide has discrete latent values (#1017) * fix is_discrete issues and raise error for SVI with discrete latent * run make format * fix lint issues * catch SVI warnings * try to split test/infer into 2 tests to avoid memory errors --- .github/workflows/ci.yml | 3 ++- numpyro/distributions/conjugate.py | 3 --- numpyro/distributions/constraints.py | 8 ++++++++ numpyro/distributions/discrete.py | 14 -------------- numpyro/distributions/distribution.py | 20 +++++--------------- numpyro/infer/svi.py | 9 +++++++++ test/infer/test_svi.py | 13 +++++++++++++ test/pyroapi/test_pyroapi.py | 3 ++- test/test_distributions.py | 3 +++ 9 files changed, 42 insertions(+), 34 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 2fa9ec0f7..4aac638a8 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -100,7 +100,8 @@ jobs: pip freeze - name: Test with pytest run: | - pytest -vs --durations=100 test/infer + pytest -vs --durations=20 test/infer/test_mcmc.py + pytest -vs --durations=20 test/infer --ignore=test/infer/test_mcmc.py - name: Test x64 run: | JAX_ENABLE_X64=1 pytest -vs test/infer/test_mcmc.py -k x64 diff --git a/numpyro/distributions/conjugate.py b/numpyro/distributions/conjugate.py index b671cedf6..c47d09647 100644 --- a/numpyro/distributions/conjugate.py +++ b/numpyro/distributions/conjugate.py @@ -36,7 +36,6 @@ class BetaBinomial(Distribution): "total_count": constraints.nonnegative_integer, } has_enumerate_support = True - is_discrete = True enumerate_support = BinomialProbs.enumerate_support def __init__( @@ -105,7 +104,6 @@ class DirichletMultinomial(Distribution): "concentration": constraints.independent(constraints.positive, 1), "total_count": constraints.nonnegative_integer, } - is_discrete = True def __init__(self, concentration, total_count=1, validate_args=None): if jnp.ndim(concentration) < 1: @@ -180,7 +178,6 @@ class GammaPoisson(Distribution): "rate": constraints.positive, } support = constraints.nonnegative_integer - is_discrete = True def __init__(self, concentration, rate=1.0, validate_args=None): self.concentration, self.rate = promote_shapes(concentration, rate) diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 56734b127..34a7727b0 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -66,6 +66,7 @@ class Constraint(object): e.g. within which a variable can be optimized. """ + is_discrete = False event_dim = 0 def __call__(self, x): @@ -86,6 +87,8 @@ def feasible_like(self, prototype): class _Boolean(Constraint): + is_discrete = True + def __call__(self, x): return (x == 0) | (x == 1) @@ -271,6 +274,8 @@ def feasible_like(self, prototype): class _IntegerInterval(Constraint): + is_discrete = True + def __init__(self, lower_bound, upper_bound): self.lower_bound = lower_bound self.upper_bound = upper_bound @@ -283,6 +288,8 @@ def feasible_like(self, prototype): class _IntegerGreaterThan(Constraint): + is_discrete = True + def __init__(self, lower_bound): self.lower_bound = lower_bound @@ -326,6 +333,7 @@ def feasible_like(self, prototype): class _Multinomial(Constraint): + is_discrete = True event_dim = 1 def __init__(self, upper_bound): diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index bce6c692f..52645494e 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -75,7 +75,6 @@ class BernoulliProbs(Distribution): arg_constraints = {"probs": constraints.unit_interval} support = constraints.boolean has_enumerate_support = True - is_discrete = True def __init__(self, probs, validate_args=None): self.probs = probs @@ -117,7 +116,6 @@ class BernoulliLogits(Distribution): arg_constraints = {"logits": constraints.real} support = constraints.boolean has_enumerate_support = True - is_discrete = True def __init__(self, logits=None, validate_args=None): self.logits = logits @@ -170,7 +168,6 @@ class BinomialProbs(Distribution): "total_count": constraints.nonnegative_integer, } has_enumerate_support = True - is_discrete = True def __init__(self, probs, total_count=1, validate_args=None): self.probs, self.total_count = promote_shapes(probs, total_count) @@ -240,7 +237,6 @@ class BinomialLogits(Distribution): "total_count": constraints.nonnegative_integer, } has_enumerate_support = True - is_discrete = True enumerate_support = BinomialProbs.enumerate_support def __init__(self, logits, total_count=1, validate_args=None): @@ -301,7 +297,6 @@ def Binomial(total_count=1, probs=None, logits=None, validate_args=None): class CategoricalProbs(Distribution): arg_constraints = {"probs": constraints.simplex} has_enumerate_support = True - is_discrete = True def __init__(self, probs, validate_args=None): if jnp.ndim(probs) < 1: @@ -352,7 +347,6 @@ def enumerate_support(self, expand=True): class CategoricalLogits(Distribution): arg_constraints = {"logits": constraints.real_vector} has_enumerate_support = True - is_discrete = True def __init__(self, logits, validate_args=None): if jnp.ndim(logits) < 1: @@ -458,8 +452,6 @@ class PRNGIdentity(Distribution): handler. Only `sample` method is supported. """ - is_discrete = True - def __init__(self): warnings.warn( "PRNGIdentity distribution is deprecated. To get a random " @@ -480,7 +472,6 @@ class MultinomialProbs(Distribution): "probs": constraints.simplex, "total_count": constraints.nonnegative_integer, } - is_discrete = True def __init__(self, probs, total_count=1, validate_args=None): if jnp.ndim(probs) < 1: @@ -538,7 +529,6 @@ class MultinomialLogits(Distribution): "logits": constraints.real_vector, "total_count": constraints.nonnegative_integer, } - is_discrete = True def __init__(self, logits, total_count=1, validate_args=None): if jnp.ndim(logits) < 1: @@ -608,7 +598,6 @@ def Multinomial(total_count=1, probs=None, logits=None, validate_args=None): class Poisson(Distribution): arg_constraints = {"rate": constraints.positive} support = constraints.nonnegative_integer - is_discrete = True def __init__(self, rate, *, is_sparse=False, validate_args=None): self.rate = rate @@ -661,7 +650,6 @@ class ZeroInflatedPoisson(Distribution): arg_constraints = {"gate": constraints.unit_interval, "rate": constraints.positive} support = constraints.nonnegative_integer - is_discrete = True def __init__(self, gate, rate=1.0, validate_args=None): batch_shape = lax.broadcast_shapes(jnp.shape(gate), jnp.shape(rate)) @@ -701,7 +689,6 @@ def variance(self): class GeometricProbs(Distribution): arg_constraints = {"probs": constraints.unit_interval} support = constraints.nonnegative_integer - is_discrete = True def __init__(self, probs, validate_args=None): self.probs = probs @@ -738,7 +725,6 @@ def variance(self): class GeometricLogits(Distribution): arg_constraints = {"logits": constraints.real} support = constraints.nonnegative_integer - is_discrete = True def __init__(self, logits, validate_args=None): self.logits = logits diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index 31ea62ed6..ce71e40c4 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -129,7 +129,6 @@ class Distribution(metaclass=DistributionMeta): arg_constraints = {} support = None has_enumerate_support = False - is_discrete = False reparametrized_params = [] _validate_args = False @@ -461,6 +460,10 @@ def icdf(self, q): """ raise NotImplementedError + @property + def is_discrete(self): + return self.support.is_discrete + class ExpandedDistribution(Distribution): arg_constraints = {} @@ -518,10 +521,6 @@ def _broadcast_shape(existing_shape, new_shape): def has_enumerate_support(self): return self.base_dist.has_enumerate_support - @property - def is_discrete(self): - return self.base_dist.is_discrete - @property def has_rsample(self): return self.base_dist.has_rsample @@ -760,10 +759,6 @@ def support(self): def has_enumerate_support(self): return self.base_dist.has_enumerate_support - @property - def is_discrete(self): - return self.base_dist.is_discrete - @property def reparameterized_params(self): return self.base_dist.reparameterized_params @@ -845,10 +840,6 @@ def __init__(self, base_dist, mask): def has_enumerate_support(self): return self.base_dist.has_enumerate_support - @property - def is_discrete(self): - return self.base_dist.is_discrete - @property def has_rsample(self): return self.base_dist.has_rsample @@ -1066,7 +1057,6 @@ class Delta(Distribution): "log_density": constraints.real, } reparameterized_params = ["v", "log_density"] - is_discrete = True def __init__(self, v=0.0, log_density=0.0, event_dim=0, validate_args=None): if event_dim > jnp.ndim(v): @@ -1085,7 +1075,7 @@ def __init__(self, v=0.0, log_density=0.0, event_dim=0, validate_args=None): batch_shape, event_shape, validate_args=validate_args ) - @constraints.dependent_property(is_discrete=True) + @constraints.dependent_property def support(self): return constraints.independent(constraints.real, self.event_dim) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 25961b06a..38dca4999 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 from functools import namedtuple, partial +import warnings import tqdm @@ -121,6 +122,14 @@ def init(self, rng_key, *args, **kwargs): transform = biject_to(constraint) inv_transforms[site["name"]] = transform params[site["name"]] = transform.inv(site["value"]) + elif ( + site["type"] == "sample" + and (not site["is_observed"]) + and site["fn"].support.is_discrete + ): + warnings.warn( + "Currently, SVI does not support models with discrete latent variables" + ) self.constrain_fn = partial(transform_fn, inv_transforms) # we convert weak types like float to float32/float64 diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index efd484012..6580d6f48 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -216,3 +216,16 @@ def guide(): svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) svi_result = svi.run(random.PRNGKey(0), 1000, stable_update=stable_run) assert jnp.isfinite(svi_result.params["loc"]) == stable_run + + +def test_svi_discrete_latent(): + def model(): + numpyro.sample("x", dist.Bernoulli(0.5)) + + def guide(): + probs = numpyro.param("probs", 0.2) + numpyro.sample("x", dist.Bernoulli(probs)) + + svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) + with pytest.warns(UserWarning, match="SVI does not support models with discrete"): + svi.run(random.PRNGKey(0), 10) diff --git a/test/pyroapi/test_pyroapi.py b/test/pyroapi/test_pyroapi.py index d8e89e764..2ce443d63 100644 --- a/test/pyroapi/test_pyroapi.py +++ b/test/pyroapi/test_pyroapi.py @@ -6,7 +6,8 @@ import pytest pytestmark = pytest.mark.filterwarnings( - "ignore::numpyro.compat.util.UnsupportedAPIWarning" + "ignore::numpyro.compat.util.UnsupportedAPIWarning", + "ignore:Currently, SVI does not support models with discrete", ) diff --git a/test/test_distributions.py b/test/test_distributions.py index 7e791c0a4..ff5578b9e 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1376,6 +1376,9 @@ def g(x): ], ) def test_constraints(constraint, x, expected): + v = constraint.feasible_like(x) + if jnp.result_type(v) == "float32" or jnp.result_type(v) == "float64": + assert not constraint.is_discrete assert_array_equal(constraint(x), expected) feasible_value = constraint.feasible_like(x) From fb2601398d35229ecee11060f2ffd0f44a0a3160 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 22 Apr 2021 14:26:58 -0500 Subject: [PATCH 101/222] Fix initial params affected by enumeration with init_to_median strategy (#1019) * fix issue when using init to median strategy with enum * add test for init_to_median with enum * split ci test/infer into 2 phases --- numpyro/infer/util.py | 12 +++++++++++- test/contrib/test_funsor.py | 4 ++-- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 05f0a5853..cf52779f3 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -239,8 +239,18 @@ def body_fn(state): key, subkey = random.split(key) if radius is None or prototype_params is None: + # XXX: we don't want to apply enum to draw latent samples + model_ = model + if enum: + from numpyro.contrib.funsor import enum as enum_handler + + if isinstance(model, substitute) and isinstance(model.fn, enum_handler): + model_ = substitute(model.fn.fn, data=model.data) + elif isinstance(model, enum_handler): + model_ = model.fn + # Wrap model in a `substitute` handler to initialize from `init_loc_fn`. - seeded_model = substitute(seed(model, subkey), substitute_fn=init_strategy) + seeded_model = substitute(seed(model_, subkey), substitute_fn=init_strategy) model_trace = trace(seeded_model).get_trace(*model_args, **model_kwargs) constrained_values, inv_transforms = {}, {} for k, v in model_trace.items(): diff --git a/test/contrib/test_funsor.py b/test/contrib/test_funsor.py index 915a2b963..85520bafb 100644 --- a/test/contrib/test_funsor.py +++ b/test/contrib/test_funsor.py @@ -19,7 +19,7 @@ from numpyro.contrib.funsor.infer_util import log_density from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist -from numpyro.infer import MCMC, NUTS +from numpyro.infer import MCMC, NUTS, init_to_median from numpyro.primitives import _PYRO_STACK @@ -49,7 +49,7 @@ def gmm(data): random.PRNGKey(1) ) - nuts_kernel = NUTS(gmm) + nuts_kernel = NUTS(gmm, init_strategy=init_to_median) mcmc = MCMC(nuts_kernel, num_warmup=500, num_samples=500) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() From c25659c7eb4b5774458807e33c3131b55db39206 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Fri, 23 Apr 2021 16:50:03 +0100 Subject: [PATCH 102/222] Fix for `AutoContinuous` guides with deterministic sites (#1022) * Add test for SVI with autoguide + deterministic sites * Fix AutoContinuous.sample_posterior when model has deterministic site --- numpyro/infer/util.py | 5 +++- test/infer/test_autoguide.py | 48 ++++++++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index cf52779f3..6d8a2a349 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -106,7 +106,10 @@ def constrain_fn(model, model_args, model_kwargs, params, return_deterministic=F def substitute_fn(site): if site["name"] in params: - return biject_to(site["fn"].support)(params[site["name"]]) + if site["type"] == "sample": + return biject_to(site["fn"].support)(params[site["name"]]) + else: + return params[site["name"]] substituted_model = substitute(model, substitute_fn=substitute_fn) model_trace = trace(substituted_model).get_trace(*model_args, **model_kwargs) diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 926aa13db..86c340107 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -434,3 +434,51 @@ def create_plates(batch, subsample, full_size): batch = data[:, beg:end] beg = end svi_state, loss = update_fn(svi_state, batch, subsample, full_size) + + +@pytest.mark.parametrize( + "auto_class", + [ + AutoDiagonalNormal, + AutoMultivariateNormal, + AutoLaplaceApproximation, + AutoLowRankMultivariateNormal, + AutoNormal, + AutoDelta, + ], +) +def test_autoguide_deterministic(auto_class): + def model(y=None): + n = y.size if y is not None else 1 + + mu = numpyro.sample("mu", dist.Normal(0, 5)) + sigma = numpyro.param("sigma", 1, constraint=constraints.positive) + + y = numpyro.sample("y", dist.Normal(mu, sigma).expand((n,)), obs=y) + numpyro.deterministic("z", (y - mu) / sigma) + + mu, sigma = 2, 3 + y = mu + sigma * random.normal(random.PRNGKey(0), shape=(300,)) + y_train = y[:200] + y_test = y[200:] + + guide = auto_class(model) + optimiser = numpyro.optim.Adam(step_size=0.01) + svi = SVI(model, guide, optimiser, Trace_ELBO()) + + params, losses = svi.run(random.PRNGKey(0), num_steps=500, y=y_train) + posterior_samples = guide.sample_posterior( + random.PRNGKey(0), params, sample_shape=(1000,) + ) + + predictive = Predictive(model, posterior_samples, params=params) + predictive_samples = predictive(random.PRNGKey(0), y_test) + + assert predictive_samples["y"].shape == (1000, 100) + assert predictive_samples["z"].shape == (1000, 100) + assert_allclose( + (predictive_samples["y"] - posterior_samples["mu"][..., None]) + / params["sigma"], + predictive_samples["z"], + atol=0.05, + ) From 2d7dd49c24cd4a02df8a58d9c781f0ec921e8656 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Mon, 26 Apr 2021 11:20:02 -0400 Subject: [PATCH 103/222] Document get_model_relations() (#1025) * Document get_model_relations() * Apply updated black --- docs/source/utilities.rst | 4 ++++ numpyro/contrib/einstein/utils.py | 4 ++-- numpyro/contrib/render.py | 36 +++++++++++++++++++++++++--- numpyro/distributions/directional.py | 4 ++-- numpyro/distributions/util.py | 2 +- 5 files changed, 42 insertions(+), 8 deletions(-) diff --git a/docs/source/utilities.rst b/docs/source/utilities.rst index bdf92f145..b40a04fc2 100644 --- a/docs/source/utilities.rst +++ b/docs/source/utilities.rst @@ -94,6 +94,10 @@ Tensor Indexing :show-inheritance: :member-order: bysource +Model inspection +---------------- +.. autofunction:: numpyro.contrib.render.get_model_relations + Visualization Utilities ======================= diff --git a/numpyro/contrib/einstein/utils.py b/numpyro/contrib/einstein/utils.py index fd5b0b01b..14f23bf75 100644 --- a/numpyro/contrib/einstein/utils.py +++ b/numpyro/contrib/einstein/utils.py @@ -6,7 +6,7 @@ def posdef(m): - """ Map a matrix to a positive definite matrix, where all eigenvalues are >= 1e-5. """ + """Map a matrix to a positive definite matrix, where all eigenvalues are >= 1e-5.""" mlambda, mvec = jnp.linalg.eigh(m) if jnp.ndim(mlambda) >= 2: mlambda = jax.vmap( @@ -19,7 +19,7 @@ def posdef(m): def sqrth(m): - """ Map a matrix to a positive definite matrix and square root it. """ + """Map a matrix to a positive definite matrix and square root it.""" mlambda, mvec = jnp.linalg.eigh(m) if jnp.ndim(mlambda) >= 2: mlambdasqrt = jax.vmap( diff --git a/numpyro/contrib/render.py b/numpyro/contrib/render.py index bb877f7ae..91d422504 100644 --- a/numpyro/contrib/render.py +++ b/numpyro/contrib/render.py @@ -13,9 +13,39 @@ def get_model_relations(model, model_args=None, model_kwargs=None, num_tries=10): """ Infer relations of RVs and plates from given model and optionally data. - See issue #949 on pyro-ppl/numpyro for more details. - - :param int num_tries: times to trace model to detect discrete -> continuous dependency. + See https://github.com/pyro-ppl/numpyro/issues/949 for more details. + + This returns a dictionary with keys: + + - "sample_sample" map each downstream sample site to a list of the upstream + sample sites on which it depend; + - "sample_dist" maps each sample site to the name of the distribution at + that site; + - "plate_sample" maps each plate name to a lists of the sample sites + within that plate; and + - "observe" is a list of observed sample sites. + + For example for the model:: + + def model(data): + m = numpyro.sample('m', dist.Normal(0, 1)) + sd = numpyro.sample('sd', dist.LogNormal(m, 1)) + with numpyro.plate('N', len(data)): + numpyro.sample('obs', dist.Normal(m, sd), obs=data) + + the relation is:: + + {'sample_sample': {'m': [], 'sd': ['m'], 'obs': ['m', 'sd']}, + 'sample_dist': {'m': 'Normal', 'sd': 'LogNormal', 'obs': 'Normal'}, + 'plate_sample': {'N': ['obs']}, + 'observed': ['obs']} + + :param callable model: A model to inspect. + :param model_args: Optional tuple of model args. + :param model_kwargs: Optional dict of model kwargs. + :param int num_tries: Optional number times to trace model to detect + discrete -> continuous dependency. + :rtype: dict """ model_args = model_args or () model_kwargs = model_kwargs or {} diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index eca7f8de2..50e60cdb8 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -62,14 +62,14 @@ def log_prob(self, value): @property def mean(self): - """ Computes circular mean of distribution. NOTE: same as location when mapped to support [-pi, pi] """ + """Computes circular mean of distribution. NOTE: same as location when mapped to support [-pi, pi]""" return jnp.broadcast_to( (self.loc + jnp.pi) % (2.0 * jnp.pi) - jnp.pi, self.batch_shape ) @property def variance(self): - """ Computes circular variance of distribution """ + """Computes circular variance of distribution""" return jnp.broadcast_to( 1.0 - i1e(self.concentration) / i0e(self.concentration), self.batch_shape ) diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index 3917b407f..c66b0b2d8 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -462,7 +462,7 @@ def _von_mises_centered(key, concentration, shape, dtype): s = jnp.where(concentration > s_cutoff, s_exact, s_approximate) def cond_fn(*args): - """ check if all are done or reached max number of iterations """ + """check if all are done or reached max number of iterations""" i, _, done, _, _ = args[0] return jnp.bitwise_and(i < 100, jnp.logical_not(jnp.all(done))) From 637c2d3576c31780886a1fa4e88cc04667c4b3d8 Mon Sep 17 00:00:00 2001 From: Dominik Straub Date: Mon, 26 Apr 2021 18:07:10 +0200 Subject: [PATCH 104/222] Example: Thompson sampling for Bayesian Optimization with GPs (#1014) * Working version of Thompson sampling for GP * Adhere to style guid * Improve plots * Reformat with black * Make license * Add docstring * Changes due to review * Run black again * Use cholesky factorization for GP * Improve plot and add docs * Replace title * Fix title underline --- .../img/examples/thompson_sampling.png | Bin 0 -> 159302 bytes docs/source/index.rst | 1 + examples/thompson_sampling.py | 321 ++++++++++++++++++ 3 files changed, 322 insertions(+) create mode 100644 docs/source/_static/img/examples/thompson_sampling.png create mode 100644 examples/thompson_sampling.py diff --git a/docs/source/_static/img/examples/thompson_sampling.png b/docs/source/_static/img/examples/thompson_sampling.png new file mode 100644 index 0000000000000000000000000000000000000000..03eb94fd312bfb5de67dcaf8528fe7f92a70cf30 GIT binary patch literal 159302 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ⅆ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 bTgP0fN%Y@oTvtyJ@J~TjRi;$REa-m$XZ@9> literal 0 HcmV?d00001 diff --git a/docs/source/index.rst b/docs/source/index.rst index 9ed708736..0a24a2a84 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -57,6 +57,7 @@ NumPyro documentation examples/ode examples/neutra examples/covtype + examples/thompson_sampling Indices and tables diff --git a/examples/thompson_sampling.py b/examples/thompson_sampling.py new file mode 100644 index 000000000..19782a72b --- /dev/null +++ b/examples/thompson_sampling.py @@ -0,0 +1,321 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +""" +Example: Thompson sampling for Bayesian Optimization with GPs +============================================================= + +In this example we show how to implement Thompson sampling for Bayesian optimization with Gaussian processes. +The implementation is based on this tutorial: https://gdmarmerola.github.io/ts-for-bayesian-optim/ + +.. image:: ../_static/img/examples/thompson_sampling.png + :align: center + +""" + +import argparse + +import matplotlib.pyplot as plt +import numpy as np + +import jax +import jax.numpy as jnp +import jax.random as random +from jax.scipy import linalg + +import numpyro +import numpyro.distributions as dist +from numpyro.infer import SVI, Trace_ELBO +from numpyro.infer.autoguide import AutoDelta + +numpyro.enable_x64() + + +# the function to be minimized. At y=0 to get a 1D cut at the origin +def ackley_1d(x, y=0): + out = ( + -20 * jnp.exp(-0.2 * jnp.sqrt(0.5 * (x ** 2 + y ** 2))) + - jnp.exp(0.5 * (jnp.cos(2 * jnp.pi * x) + jnp.cos(2 * jnp.pi * y))) + + jnp.e + + 20 + ) + return out + + +# matern kernel with nu = 5/2 +def matern52_kernel(X, Z, var=1.0, length=0.5, jitter=1.0e-6): + d = jnp.sqrt(0.5) * jnp.sqrt(jnp.power((X[:, None] - Z), 2.0)) / length + k = var * (1 + d + (d ** 2) / 3) * jnp.exp(-d) + if jitter: + # we are assuming a noise free process, but add a small jitter for numerical stability + k += jitter * jnp.eye(X.shape[0]) + return k + + +def model(X, Y, kernel=matern52_kernel): + # set uninformative log-normal priors on our kernel hyperparameters + var = numpyro.sample("var", dist.LogNormal(0.0, 1.0)) + length = numpyro.sample("length", dist.LogNormal(0.0, 1.0)) + + # compute kernel + k = kernel(X, X, var, length) + + # sample Y according to the standard gaussian process formula + numpyro.sample( + "Y", + dist.MultivariateNormal(loc=jnp.zeros(X.shape[0]), covariance_matrix=k), + obs=Y, + ) + + +class GP: + def __init__(self, kernel=matern52_kernel): + self.kernel = kernel + self.kernel_params = None + + def fit(self, X, Y, rng_key, n_step): + self.X_train = X + + # store moments of training y (to normalize) + self.y_mean = jnp.mean(Y) + self.y_std = jnp.std(Y) + + # normalize y + Y = (Y - self.y_mean) / self.y_std + + # setup optimizer and SVI + optim = numpyro.optim.Adam(step_size=0.005, b1=0.5) + + svi = SVI( + model, + guide=AutoDelta(model), + optim=optim, + loss=Trace_ELBO(), + X=X, + Y=Y, + ) + + params, _ = svi.run(rng_key, n_step) + + # get kernel parameters from guide with proper names + self.kernel_params = svi.guide.median(params) + + # store cholesky factor of prior covariance + self.L = linalg.cho_factor(self.kernel(X, X, **self.kernel_params)) + + # store inverted prior covariance multiplied by y + self.alpha = linalg.cho_solve(self.L, Y) + + return self.kernel_params + + # do GP prediction for a given set of hyperparameters. this makes use of the well-known + # formula for gaussian process predictions + def predict(self, X, return_std=False): + # compute kernels between train and test data, etc. + k_pp = self.kernel(X, X, **self.kernel_params) + k_pX = self.kernel(X, self.X_train, **self.kernel_params, jitter=0.0) + + # compute posterior covariance + K = k_pp - k_pX @ linalg.cho_solve(self.L, k_pX.T) + + # compute posterior mean + mean = k_pX @ self.alpha + + # we return both the mean function and the standard deviation + if return_std: + return ( + (mean * self.y_std) + self.y_mean, + jnp.sqrt(jnp.diag(K * self.y_std ** 2)), + ) + else: + return (mean * self.y_std) + self.y_mean, K * self.y_std ** 2 + + def sample_y(self, rng_key, X): + # get posterior mean and covariance + y_mean, y_cov = self.predict(X) + # draw one sample + return jax.random.multivariate_normal(rng_key, mean=y_mean, cov=y_cov) + + +# our TS-GP optimizer +class ThompsonSamplingGP: + """ Adapted to numpyro from https://gdmarmerola.github.io/ts-for-bayesian-optim/ """ + + # initialization + def __init__( + self, gp, n_random_draws, objective, x_bounds, grid_resolution=1000, seed=123 + ): + # Gaussian Process + self.gp = gp + + # number of random samples before starting the optimization + self.n_random_draws = n_random_draws + + # the objective is the function we're trying to optimize + self.objective = objective + + # the bounds tell us the interval of x we can work + self.bounds = x_bounds + + # interval resolution is defined as how many points we will use to + # represent the posterior sample + # we also define the x grid + self.grid_resolution = grid_resolution + self.X_grid = np.linspace(self.bounds[0], self.bounds[1], self.grid_resolution) + + # also initializing our design matrix and target variable + self.X = np.array([]) + self.y = np.array([]) + + self.rng_key = random.PRNGKey(seed) + + # fitting process + def fit(self, X, y, n_step): + self.rng_key, subkey = random.split(self.rng_key) + # fitting the GP + self.gp.fit(X, y, rng_key=subkey, n_step=n_step) + + # return the fitted model + return self.gp + + # choose the next Thompson sample + def choose_next_sample(self, n_step=2_000): + + # if we do not have enough samples, sample randomly from bounds + if self.X.shape[0] < self.n_random_draws: + self.rng_key, subkey = random.split(self.rng_key) + next_sample = random.uniform( + subkey, minval=self.bounds[0], maxval=self.bounds[1], shape=(1,) + ) + + # define dummy values for sample, mean and std to avoid errors when returning them + posterior_sample = np.array([np.mean(self.y)] * self.grid_resolution) + posterior_mean = np.array([np.mean(self.y)] * self.grid_resolution) + posterior_std = np.array([0] * self.grid_resolution) + + # if we do, we fit the GP and choose the next point based on the posterior draw minimum + else: + + # 1. Fit the GP to the observations we have + self.gp = self.fit(self.X, self.y, n_step=n_step) + + # 2. Draw one sample (a function) from the posterior + self.rng_key, subkey = random.split(self.rng_key) + posterior_sample = self.gp.sample_y(subkey, self.X_grid) + + # 3. Choose next point as the optimum of the sample + which_min = np.argmin(posterior_sample) + next_sample = self.X_grid[which_min] + + # let us also get the std from the posterior, for visualization purposes + posterior_mean, posterior_std = self.gp.predict( + self.X_grid, return_std=True + ) + + # let us observe the objective and append this new data to our X and y + next_observation = self.objective(next_sample) + self.X = np.append(self.X, next_sample) + self.y = np.append(self.y, next_observation) + + # returning values of interest + return ( + self.X, + self.y, + self.X_grid, + posterior_sample, + posterior_mean, + posterior_std, + ) + + +def main(args): + gp = GP(kernel=matern52_kernel) + # do inference + thompson = ThompsonSamplingGP( + gp, n_random_draws=args.num_random, objective=ackley_1d, x_bounds=(-4, 4) + ) + + fig, axes = plt.subplots( + args.num_samples - args.num_random, 1, figsize=(6, 12), sharex=True, sharey=True + ) + for i in range(args.num_samples): + ( + X, + y, + X_grid, + posterior_sample, + posterior_mean, + posterior_std, + ) = thompson.choose_next_sample( + n_step=args.num_step, + ) + + if i >= args.num_random: + ax = axes[i - args.num_random] + # plot training data + ax.scatter(X, y, color="blue", marker="o", label="samples") + ax.axvline( + X_grid[posterior_sample.argmin()], + color="blue", + linestyle="--", + label="next sample", + ) + ax.plot(X_grid, ackley_1d(X_grid), color="black", linestyle="--") + ax.plot( + X_grid, + posterior_sample, + color="red", + linestyle="-", + label="posterior sample", + ) + # plot 90% confidence level of predictions + ax.fill_between( + X_grid, + posterior_mean - posterior_std, + posterior_mean + posterior_std, + color="red", + alpha=0.5, + ) + ax.set_ylabel("Y") + if i == args.num_samples - 1: + ax.set_xlabel("X") + + plt.legend( + loc="upper center", + bbox_to_anchor=(0.5, -0.15), + fancybox=True, + shadow=True, + ncol=3, + ) + + fig.suptitle("Thompson sampling") + fig.tight_layout() + plt.show() + + +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser(description="Thompson sampling example") + parser.add_argument( + "--num-random", nargs="?", default=2, type=int, help="number of random draws" + ) + parser.add_argument( + "--num-samples", + nargs="?", + default=10, + type=int, + help="number of Thompson samples", + ) + parser.add_argument( + "--num-step", + nargs="?", + default=2_000, + type=int, + help="number of steps for optimization", + ) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') + args = parser.parse_args() + + numpyro.set_platform(args.device) + + main(args) From 87e6e8ff531f22b2f1e0363f90611e618ab9546d Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 26 Apr 2021 15:37:55 -0500 Subject: [PATCH 105/222] update black (#1027) --- examples/thompson_sampling.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/thompson_sampling.py b/examples/thompson_sampling.py index 19782a72b..0c15f6bf4 100644 --- a/examples/thompson_sampling.py +++ b/examples/thompson_sampling.py @@ -139,7 +139,7 @@ def sample_y(self, rng_key, X): # our TS-GP optimizer class ThompsonSamplingGP: - """ Adapted to numpyro from https://gdmarmerola.github.io/ts-for-bayesian-optim/ """ + """Adapted to numpyro from https://gdmarmerola.github.io/ts-for-bayesian-optim/""" # initialization def __init__( From f7109f70d2959e337c28b192bec96bb6e0744d66 Mon Sep 17 00:00:00 2001 From: "Justin R. Porter" Date: Tue, 27 Apr 2021 13:00:18 -0500 Subject: [PATCH 106/222] Fix issue where scan would error out if _PYRO_STACK is empty. (#1026) * Fix issue where scan would error out if _PYRO_STACK is empty. * Add test ensuring scan can be used with empty _PYRO_STACK. * newline for flake8 * format test with black * remove additional dimension of test matrix for scan without PYRO_STACK --- numpyro/contrib/control_flow/scan.py | 1 + test/contrib/test_control_flow.py | 20 ++++++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/numpyro/contrib/control_flow/scan.py b/numpyro/contrib/control_flow/scan.py index 35ffb1dd7..c2a9e26ac 100644 --- a/numpyro/contrib/control_flow/scan.py +++ b/numpyro/contrib/control_flow/scan.py @@ -451,6 +451,7 @@ def g(*args, **kwargs): (length, rng_key, carry), (pytree_trace, ys) = scan_wrapper( f, init, xs, length=length, reverse=reverse ) + return carry, ys else: # Otherwise, we initialize a message... initial_msg = { diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 09d40afa1..944be7b1d 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -112,3 +112,23 @@ def transition(state, i): actual_log_joint = potential_energy(fun_model, (T,), {}, fun_params) expected_log_joint = potential_energy(model, (T,), {}, params) assert_allclose(actual_log_joint, expected_log_joint) + + +def test_scan_without_stack(): + def multiply_and_add_repeatedly(K, c_in): + def iteration(c_prev, c_in): + c_next = jnp.dot(c_prev, K) + c_in + return c_next, (c_next,) + + _, (ys,) = scan(iteration, init=jnp.asarray([1.0, 0.0]), xs=c_in) + + return ys + + result = multiply_and_add_repeatedly( + K=jnp.asarray([[0.7, 0.3], [0.3, 0.7]]), c_in=jnp.asarray([[1.0, 0.0]]) + ) + + assert_allclose( + result, + [[1.7, 0.3]], + ) From aa409945a425a57312e3d93d2480f5427cfcf65b Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 30 Apr 2021 11:15:50 -0500 Subject: [PATCH 107/222] Add Poisson cdf method (#1006) * add Poisson cdf method * make it clearer that we can't use grad test for cdf of discrete * address comment by phylyc --- numpyro/distributions/continuous.py | 2 +- numpyro/distributions/discrete.py | 6 +++++- test/test_distributions.py | 8 ++++++-- 3 files changed, 12 insertions(+), 4 deletions(-) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 469c2748e..413af7369 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -1281,7 +1281,7 @@ def sample(self, key, sample_shape=()): ) return self.icdf(u) - @validate_sample + # TODO: refactor validate_sample to only does validation check and use it here def cdf(self, value): z = (value - self.loc) / self.scale return jnp.arctan(jnp.exp(z)) * (2 / jnp.pi) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 52645494e..309ed043c 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -35,7 +35,7 @@ import jax.numpy as jnp from jax.ops import index_add import jax.random as random -from jax.scipy.special import expit, gammaln, logsumexp, xlog1py, xlogy +from jax.scipy.special import expit, gammaincc, gammaln, logsumexp, xlog1py, xlogy from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution @@ -639,6 +639,10 @@ def mean(self): def variance(self): return self.rate + def cdf(self, value): + k = jnp.floor(value) + 1 + return gammaincc(k, self.rate) + class ZeroInflatedPoisson(Distribution): """ diff --git a/test/test_distributions.py b/test/test_distributions.py index ff5578b9e..24c2a56d7 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -755,7 +755,11 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): assert_allclose(jit_fn(jax_dist.log_prob)(samples), expected, atol=1e-5) -@pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS) +@pytest.mark.parametrize( + "jax_dist, sp_dist, params", + # TODO: add more complete pattern for Discrete.cdf + CONTINUOUS + [T(dist.Poisson, 2.0), T(dist.Poisson, jnp.array([2.0, 3.0, 5.0]))], +) def test_cdf_and_icdf(jax_dist, sp_dist, params): d = jax_dist(*params) if d.event_dim > 0: @@ -763,7 +767,7 @@ def test_cdf_and_icdf(jax_dist, sp_dist, params): samples = d.sample(key=random.PRNGKey(0), sample_shape=(100,)) quantiles = random.uniform(random.PRNGKey(1), (100,) + d.shape()) try: - if d.shape() == (): + if d.shape() == () and not d.is_discrete: rtol = 1e-3 if jax_dist is dist.StudentT else 1e-5 assert_allclose( jax.vmap(jax.grad(d.cdf))(samples), From 7d24d432c9b6de08802e9ace3711674adde7363e Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 1 May 2021 18:37:08 -0500 Subject: [PATCH 108/222] Add ZeroInflatedDistribution (#1007) * start ZeroInflatedDistribution * add zero inflated distribution * add zero inflated to docs * test for agreement of zero inflated probs and logits --- docs/source/distributions.rst | 4 ++ numpyro/distributions/__init__.py | 2 + numpyro/distributions/discrete.py | 112 +++++++++++++++++++++++------- test/test_distributions.py | 39 ++++++++++- 4 files changed, 127 insertions(+), 30 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 68493233f..60d34b636 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -405,6 +405,10 @@ PRNGIdentity :show-inheritance: :member-order: bysource +ZeroInflatedDistribution +------------------------ +.. autofunction:: numpyro.distributions.discrete.ZeroInflatedDistribution + ZeroInflatedPoisson ------------------- .. autoclass:: numpyro.distributions.discrete.ZeroInflatedPoisson diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 1c31f67fc..a1fc58769 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -51,6 +51,7 @@ OrderedLogistic, Poisson, PRNGIdentity, + ZeroInflatedDistribution, ZeroInflatedPoisson, ) from numpyro.distributions.distribution import ( @@ -143,5 +144,6 @@ "Uniform", "Unit", "VonMises", + "ZeroInflatedDistribution", "ZeroInflatedPoisson", ] diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 309ed043c..8596f71b9 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -644,50 +644,108 @@ def cdf(self, value): return gammaincc(k, self.rate) -class ZeroInflatedPoisson(Distribution): - """ - A Zero Inflated Poisson distribution. - - :param numpy.ndarray gate: probability of extra zeros. - :param numpy.ndarray rate: rate of Poisson distribution. - """ - - arg_constraints = {"gate": constraints.unit_interval, "rate": constraints.positive} - support = constraints.nonnegative_integer - - def __init__(self, gate, rate=1.0, validate_args=None): - batch_shape = lax.broadcast_shapes(jnp.shape(gate), jnp.shape(rate)) - self.gate, self.rate = promote_shapes(gate, rate) - super(ZeroInflatedPoisson, self).__init__( +class ZeroInflatedProbs(Distribution): + arg_constraints = {"gate": constraints.unit_interval} + + def __init__(self, base_dist, gate, *, validate_args=None): + batch_shape = lax.broadcast_shapes(jnp.shape(gate), base_dist.batch_shape) + (self.gate,) = promote_shapes(gate, shape=batch_shape) + assert base_dist.is_discrete + if base_dist.event_shape: + raise ValueError( + "ZeroInflatedProbs expected empty base_dist.event_shape but got {}".format( + base_dist.event_shape + ) + ) + # XXX: we might need to promote parameters of base_dist but let's keep + # this simplified for now + self.base_dist = base_dist.expand(batch_shape) + super(ZeroInflatedProbs, self).__init__( batch_shape, validate_args=validate_args ) def sample(self, key, sample_shape=()): assert is_prng_key(key) - key_bern, key_poisson = random.split(key) + key_bern, key_base = random.split(key) shape = sample_shape + self.batch_shape mask = random.bernoulli(key_bern, self.gate, shape) - samples = random.poisson(key_poisson, self.rate, shape) + samples = self.base_dist(rng_key=key_base, sample_shape=sample_shape) return jnp.where(mask, 0, samples) @validate_sample def log_prob(self, value): - log_prob = ( - jnp.log(self.rate) * value - - gammaln(value + 1) - + (jnp.log1p(-self.gate) - self.rate) - ) - return jnp.where( - value == 0, jnp.logaddexp(jnp.log(self.gate), log_prob), log_prob - ) + log_prob = jnp.log1p(-self.gate) + self.base_dist.log_prob(value) + return jnp.where(value == 0, jnp.log(self.gate + jnp.exp(log_prob)), log_prob) + + @constraints.dependent_property(is_discrete=True, event_dim=0) + def support(self): + return self.base_dist.support @lazy_property def mean(self): - return (1 - self.gate) * self.rate + return (1 - self.gate) * self.base_dist.mean @lazy_property def variance(self): - return (1 - self.gate) * self.rate * (1 + self.rate * self.gate) + return (1 - self.gate) * ( + self.base_dist.mean ** 2 + self.base_dist.variance + ) - self.mean ** 2 + + +class ZeroInflatedLogits(ZeroInflatedProbs): + arg_constraints = {"gate_logits": constraints.real} + + def __init__(self, base_dist, gate_logits, *, validate_args=None): + gate = _to_probs_bernoulli(gate_logits) + batch_shape = lax.broadcast_shapes(jnp.shape(gate), base_dist.batch_shape) + (self.gate_logits,) = promote_shapes(gate_logits, shape=batch_shape) + super().__init__(base_dist, gate, validate_args=validate_args) + + @validate_sample + def log_prob(self, value): + log_prob_minus_log_gate = -self.gate_logits + self.base_dist.log_prob(value) + log_gate = -softplus(-self.gate_logits) + log_prob = log_prob_minus_log_gate + log_gate + zero_log_prob = softplus(log_prob_minus_log_gate) + log_gate + return jnp.where(value == 0, zero_log_prob, log_prob) + + +def ZeroInflatedDistribution( + base_dist, *, gate=None, gate_logits=None, validate_args=None +): + """ + Generic Zero Inflated distribution. + + :param Distribution base_dist: the base distribution. + :param numpy.ndarray gate: probability of extra zeros given via a Bernoulli distribution. + :param numpy.ndarray gate_logits: logits of extra zeros given via a Bernoulli distribution. + """ + if (gate is None) == (gate_logits is None): + raise ValueError( + "Either `gate` or `gate_logits` must be specified, but not both." + ) + if gate is not None: + return ZeroInflatedProbs(base_dist, gate, validate_args=validate_args) + else: + return ZeroInflatedLogits(base_dist, gate_logits, validate_args=validate_args) + + +class ZeroInflatedPoisson(ZeroInflatedProbs): + """ + A Zero Inflated Poisson distribution. + + :param numpy.ndarray gate: probability of extra zeros. + :param numpy.ndarray rate: rate of Poisson distribution. + """ + + arg_constraints = {"gate": constraints.unit_interval, "rate": constraints.positive} + support = constraints.nonnegative_integer + + # TODO: resolve inconsistent parameter order w.r.t. Pyro + # and support `gate_logits` argument + def __init__(self, gate, rate=1.0, validate_args=None): + _, self.rate = promote_shapes(gate, rate) + super().__init__(Poisson(self.rate), gate, validate_args=validate_args) class GeometricProbs(Distribution): diff --git a/test/test_distributions.py b/test/test_distributions.py index 24c2a56d7..c6e058022 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -15,7 +15,7 @@ from jax import grad, jacfwd, lax, vmap import jax.numpy as jnp import jax.random as random -from jax.scipy.special import logsumexp +from jax.scipy.special import expit, logsumexp import numpyro.distributions as dist from numpyro.distributions import constraints, kl_divergence, transforms @@ -96,6 +96,14 @@ def sample(self, key, sample_shape=()): return transform(unconstrained_samples) +class ZeroInflatedPoissonLogits(dist.discrete.ZeroInflatedLogits): + arg_constraints = {"rate": constraints.positive, "gate_logits": constraints.real} + + def __init__(self, rate, gate_logits, *, validate_args=None): + self.rate = rate + super().__init__(dist.Poisson(rate), gate_logits, validate_args=validate_args) + + class SparsePoisson(dist.Poisson): def __init__(self, rate, *, validate_args=None): super().__init__(rate, is_sparse=True, validate_args=validate_args) @@ -346,6 +354,12 @@ def get_sp_dist(jax_dist): T(SparsePoisson, jnp.array([2.0, 3.0, 5.0])), T(dist.ZeroInflatedPoisson, 0.6, 2.0), T(dist.ZeroInflatedPoisson, jnp.array([0.2, 0.7, 0.3]), jnp.array([2.0, 3.0, 5.0])), + T(ZeroInflatedPoissonLogits, 2.0, 3.0), + T( + ZeroInflatedPoissonLogits, + jnp.array([0.2, 4.0, 0.3]), + jnp.array([2.0, -3.0, 5.0]), + ), ] @@ -921,6 +935,25 @@ def test_log_prob_LKJCholesky(dimension, concentration): assert_allclose(jax.jit(d.log_prob)(sample), d.log_prob(sample), atol=2e-6) +def test_zero_inflated_logits_probs_agree(): + concentration = np.exp(np.random.normal(100)) + rate = np.exp(np.random.normal(100)) + d = dist.GammaPoisson(concentration, rate) + gate_logits = np.random.normal(100) + gate_probs = expit(gate_logits) + zi_logits = dist.ZeroInflatedDistribution(d, gate_logits=gate_logits) + zi_probs = dist.ZeroInflatedDistribution(d, gate=gate_probs) + sample = np.random.randint( + 0, + 20, + ( + 1000, + 100, + ), + ) + assert_allclose(zi_probs.log_prob(sample), zi_logits.log_prob(sample)) + + @pytest.mark.parametrize("rate", [0.1, 0.5, 0.9, 1.0, 1.1, 2.0, 10.0]) def test_ZIP_log_prob(rate): # if gate is 0 ZIP is Poisson @@ -929,7 +962,7 @@ def test_ZIP_log_prob(rate): s = zip_.sample(random.PRNGKey(0), (20,)) zip_prob = zip_.log_prob(s) pois_prob = pois.log_prob(s) - assert_allclose(zip_prob, pois_prob) + assert_allclose(zip_prob, pois_prob, rtol=1e-6) # if gate is 1 ZIP is Delta(0) zip_ = dist.ZeroInflatedPoisson(1.0, rate) @@ -937,7 +970,7 @@ def test_ZIP_log_prob(rate): s = jnp.array([0.0, 1.0]) zip_prob = zip_.log_prob(s) delta_prob = delta.log_prob(s) - assert_allclose(zip_prob, delta_prob) + assert_allclose(zip_prob, delta_prob, rtol=1e-6) @pytest.mark.parametrize("total_count", [1, 2, 3, 10]) From 1ca72ffc3ddd34ebeaa4f6b4389ff33b20219535 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Tue, 4 May 2021 14:53:31 +0100 Subject: [PATCH 109/222] Add `cond` primitive (#1028) * Add `cond` control flow primitive * Add test for cond * Make cond usage example more readable * Docstring fixes * Test NUTS with cond * Add return statements to example * Fix markup in docstring * Fix failing doctest * Add enumeration warning * Make MCMC + cond test more robust * Test full mean and std of mixture in cond test * Adjust mode separation in cond test * Typo in test >_< --- docs/source/primitives.rst | 4 + numpyro/contrib/control_flow/__init__.py | 5 +- numpyro/contrib/control_flow/cond.py | 162 +++++++++++++++++++++++ numpyro/contrib/control_flow/scan.py | 34 +---- numpyro/contrib/control_flow/util.py | 45 +++++++ test/contrib/test_control_flow.py | 73 +++++++++- 6 files changed, 285 insertions(+), 38 deletions(-) create mode 100644 numpyro/contrib/control_flow/cond.py create mode 100644 numpyro/contrib/control_flow/util.py diff --git a/docs/source/primitives.rst b/docs/source/primitives.rst index 1505d2e66..1b3d0fea4 100644 --- a/docs/source/primitives.rst +++ b/docs/source/primitives.rst @@ -62,3 +62,7 @@ random_haiku_module scan ---- .. autofunction:: numpyro.contrib.control_flow.scan + +cond +---- +.. autofunction:: numpyro.contrib.control_flow.cond diff --git a/numpyro/contrib/control_flow/__init__.py b/numpyro/contrib/control_flow/__init__.py index 6fde52c57..ad8ca00da 100644 --- a/numpyro/contrib/control_flow/__init__.py +++ b/numpyro/contrib/control_flow/__init__.py @@ -1,8 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +from numpyro.contrib.control_flow.cond import cond from numpyro.contrib.control_flow.scan import scan -__all__ = [ - "scan", -] +__all__ = ["cond", "scan"] diff --git a/numpyro/contrib/control_flow/cond.py b/numpyro/contrib/control_flow/cond.py new file mode 100644 index 000000000..54c0b20d1 --- /dev/null +++ b/numpyro/contrib/control_flow/cond.py @@ -0,0 +1,162 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from functools import partial + +from jax import device_put, lax + +from numpyro import handlers +from numpyro.contrib.control_flow.util import PytreeTrace +from numpyro.primitives import _PYRO_STACK, apply_stack + + +def _subs_wrapper(subs_map, site): + if isinstance(subs_map, dict) and site["name"] in subs_map: + return subs_map[site["name"]] + elif callable(subs_map): + rng_key = site["kwargs"].get("rng_key") + subs_map = ( + handlers.seed(subs_map, rng_seed=rng_key) + if rng_key is not None + else subs_map + ) + return subs_map(site) + return None + + +def wrap_fn(fn, substitute_stack): + def wrapper(wrapped_operand): + rng_key, operand = wrapped_operand + + with handlers.block(): + seeded_fn = handlers.seed(fn, rng_key) if rng_key is not None else fn + for subs_type, subs_map in substitute_stack: + subs_fn = partial(_subs_wrapper, subs_map) + if subs_type == "condition": + seeded_fn = handlers.condition(seeded_fn, condition_fn=subs_fn) + elif subs_type == "substitute": + seeded_fn = handlers.substitute(seeded_fn, substitute_fn=subs_fn) + + with handlers.trace() as trace: + value = seeded_fn(operand) + + return value, PytreeTrace(trace) + + return wrapper + + +def cond_wrapper( + pred, + true_fun, + false_fun, + operand, + rng_key=None, + substitute_stack=None, + enum=False, + first_available_dim=None, +): + if enum: + # TODO: support enumeration. note that pred passed to lax.cond must be scalar + # which means that even simple conditions like `x == 0` can get complicated if + # x is an enumerated discrete random variable + raise RuntimeError("The cond primitive does not currently support enumeration") + + if substitute_stack is None: + substitute_stack = [] + + wrapped_true_fun = wrap_fn(true_fun, substitute_stack) + wrapped_false_fun = wrap_fn(false_fun, substitute_stack) + wrapped_operand = device_put((rng_key, operand)) + return lax.cond(pred, wrapped_true_fun, wrapped_false_fun, wrapped_operand) + + +def cond(pred, true_fun, false_fun, operand): + """ + This primitive conditionally applies ``true_fun`` or ``false_fun``. See + :func:`jax.lax.cond` for more information. + + **Usage**: + + .. doctest:: + + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from jax import random + >>> from numpyro.contrib.control_flow import cond + >>> from numpyro.infer import SVI, Trace_ELBO + >>> + >>> def model(): + ... def true_fun(_): + ... return numpyro.sample("x", dist.Normal(20.0)) + ... + ... def false_fun(_): + ... return numpyro.sample("x", dist.Normal(0.0)) + ... + ... cluster = numpyro.sample("cluster", dist.Normal()) + ... return cond(cluster > 0, true_fun, false_fun, None) + >>> + >>> def guide(): + ... m1 = numpyro.param("m1", 10.0) + ... s1 = numpyro.param("s1", 0.1, constraint=dist.constraints.positive) + ... m2 = numpyro.param("m2", 10.0) + ... s2 = numpyro.param("s2", 0.1, constraint=dist.constraints.positive) + ... + ... def true_fun(_): + ... return numpyro.sample("x", dist.Normal(m1, s1)) + ... + ... def false_fun(_): + ... return numpyro.sample("x", dist.Normal(m2, s2)) + ... + ... cluster = numpyro.sample("cluster", dist.Normal()) + ... return cond(cluster > 0, true_fun, false_fun, None) + >>> + >>> svi = SVI(model, guide, numpyro.optim.Adam(1e-2), Trace_ELBO(num_particles=100)) + >>> params, losses = svi.run(random.PRNGKey(0), num_steps=2500) + + .. warning:: This is an experimental utility function that allows users to use + JAX control flow with NumPyro's effect handlers. Currently, `sample` and + `deterministic` sites within `true_fun` and `false_fun` are supported. If you + notice that any effect handlers or distributions are unsupported, please file + an issue. + + .. warning:: The ``cond`` primitive does not currently support enumeration and can + not be used inside a ``numpyro.plate`` context. + + .. note:: All ``sample`` sites must belong to the same distribution class. For + example the following is not supported + + .. code-block:: python + + cond( + True, + lambda _: numpyro.sample("x", dist.Normal()), + lambda _: numpyro.sample("x", dist.Laplace()), + None, + ) + + :param bool pred: Boolean scalar type indicating which branch function to apply + :param callable true_fun: A function to be applied if ``pred`` is true. + :param callable false_fun: A function to be applied if ``pred`` is false. + :param operand: Operand input to either branch depending on ``pred``. This can + be any JAX PyTree (e.g. list / dict of arrays). + :return: Output of the applied branch function. + """ + if not _PYRO_STACK: + value, _ = cond_wrapper(pred, true_fun, false_fun, operand) + return value + + initial_msg = { + "type": "control_flow", + "fn": cond_wrapper, + "args": (pred, true_fun, false_fun, operand), + "kwargs": {"rng_key": None, "substitute_stack": []}, + "value": None, + } + + msg = apply_stack(initial_msg) + value, pytree_trace = msg["value"] + + for msg in pytree_trace.trace.values(): + apply_stack(msg) + + return value diff --git a/numpyro/contrib/control_flow/scan.py b/numpyro/contrib/control_flow/scan.py index c2a9e26ac..57165b834 100644 --- a/numpyro/contrib/control_flow/scan.py +++ b/numpyro/contrib/control_flow/scan.py @@ -14,45 +14,13 @@ tree_unflatten, ) import jax.numpy as jnp -from jax.tree_util import register_pytree_node_class from numpyro import handlers +from numpyro.contrib.control_flow.util import PytreeTrace from numpyro.primitives import _PYRO_STACK, Messenger, apply_stack from numpyro.util import not_jax_tracer -@register_pytree_node_class -class PytreeTrace: - def __init__(self, trace): - self.trace = trace - - def tree_flatten(self): - trace, aux_trace = {}, {} - for name, site in self.trace.items(): - if site["type"] in ["sample", "deterministic"]: - trace[name], aux_trace[name] = {}, {"_control_flow_done": True} - for key in site: - if key in ["fn", "args", "value", "intermediates"]: - trace[name][key] = site[key] - # scanned sites have stop field because we trace them inside a block handler - elif key != "stop": - aux_trace[name][key] = site[key] - # keep the site order information because in JAX, flatten and unflatten do not preserve - # the order of keys in a dict - site_names = list(trace.keys()) - return (trace,), (aux_trace, site_names) - - @classmethod - def tree_unflatten(cls, aux_data, children): - aux_trace, site_names = aux_data - (trace,) = children - trace_with_aux = {} - for name in site_names: - trace[name].update(aux_trace[name]) - trace_with_aux[name] = trace[name] - return cls(trace_with_aux) - - def _subs_wrapper(subs_map, i, length, site): value = None if isinstance(subs_map, dict) and site["name"] in subs_map: diff --git a/numpyro/contrib/control_flow/util.py b/numpyro/contrib/control_flow/util.py new file mode 100644 index 000000000..4c8f0590f --- /dev/null +++ b/numpyro/contrib/control_flow/util.py @@ -0,0 +1,45 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from jax.tree_util import register_pytree_node_class + + +@register_pytree_node_class +class PytreeTrace: + def __init__(self, trace): + self.trace = trace + + def tree_flatten(self): + trace, aux_trace = {}, {} + for name, site in self.trace.items(): + if site["type"] in ["sample", "deterministic"]: + trace[name], aux_trace[name] = {}, {"_control_flow_done": True} + for key in site: + if key in ["fn", "args", "value", "intermediates"]: + trace[name][key] = site[key] + # scanned sites have stop field because we trace them inside a block handler + elif key != "stop": + if key == "kwargs": + kwargs = site["kwargs"].copy() + if "rng_key" in kwargs: + # rng_key is not traced else it is collected by the + # scan primitive which doesn't make sense + # set to None to avoid leaks during tracing by JAX + kwargs["rng_key"] = None + aux_trace[name][key] = kwargs + else: + aux_trace[name][key] = site[key] + # keep the site order information because in JAX, flatten and unflatten do not preserve + # the order of keys in a dict + site_names = list(trace.keys()) + return (trace,), (aux_trace, site_names) + + @classmethod + def tree_unflatten(cls, aux_data, children): + aux_trace, site_names = aux_data + (trace,) = children + trace_with_aux = {} + for name in site_names: + trace[name].update(aux_trace[name]) + trace_with_aux[name] = trace[name] + return cls(trace_with_aux) diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 944be7b1d..1e3f0d764 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -8,10 +8,10 @@ import jax.numpy as jnp import numpyro -from numpyro.contrib.control_flow.scan import scan +from numpyro.contrib.control_flow import cond, scan import numpyro.distributions as dist from numpyro.handlers import seed, substitute, trace -from numpyro.infer import MCMC, NUTS, Predictive +from numpyro.infer import MCMC, NUTS, SVI, Predictive, Trace_ELBO from numpyro.infer.util import potential_energy @@ -132,3 +132,72 @@ def iteration(c_prev, c_in): result, [[1.7, 0.3]], ) + + +def test_cond(): + def model(): + def true_fun(_): + x = numpyro.sample("x", dist.Normal(4.0)) + numpyro.deterministic("z", x - 4.0) + + def false_fun(_): + x = numpyro.sample("x", dist.Normal(0.0)) + numpyro.deterministic("z", x) + + cluster = numpyro.sample("cluster", dist.Normal()) + cond(cluster > 0, true_fun, false_fun, None) + + def guide(): + m1 = numpyro.param("m1", 2.0) + s1 = numpyro.param("s1", 0.1, constraint=dist.constraints.positive) + m2 = numpyro.param("m2", 2.0) + s2 = numpyro.param("s2", 0.1, constraint=dist.constraints.positive) + + def true_fun(_): + numpyro.sample("x", dist.Normal(m1, s1)) + + def false_fun(_): + numpyro.sample("x", dist.Normal(m2, s2)) + + cluster = numpyro.sample("cluster", dist.Normal()) + cond(cluster > 0, true_fun, false_fun, None) + + svi = SVI(model, guide, numpyro.optim.Adam(1e-2), Trace_ELBO(num_particles=100)) + params, losses = svi.run(random.PRNGKey(0), num_steps=2500) + + predictive = Predictive( + model, + guide=guide, + params=params, + num_samples=1000, + return_sites=["cluster", "x", "z"], + ) + result = predictive(random.PRNGKey(0)) + + assert result["cluster"].shape == (1000,) + assert result["x"].shape == (1000,) + assert result["z"].shape == (1000,) + + mcmc = MCMC( + NUTS(model), + num_warmup=500, + num_samples=2500, + num_chains=4, + chain_method="sequential", + ) + mcmc.run(random.PRNGKey(0)) + + x = mcmc.get_samples()["x"] + assert x.shape == (10_000,) + assert_allclose( + [ + x.mean(), + x.std(), + x[x > 2.0].mean(), + x[x > 2.0].std(), + x[x < 2.0].mean(), + x[x < 2.0].std(), + ], + [2.0, jnp.sqrt(5.0), 4.0, 1.0, 0.0, 1.0], + atol=0.1, + ) From 673880c8c2c50f1bc291af9115fe46e8876554d5 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Tue, 4 May 2021 23:37:07 +0100 Subject: [PATCH 110/222] Make cond test more robust (#1029) --- test/contrib/test_control_flow.py | 12 +++--------- 1 file changed, 3 insertions(+), 9 deletions(-) diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 1e3f0d764..7818cffb1 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -190,14 +190,8 @@ def false_fun(_): x = mcmc.get_samples()["x"] assert x.shape == (10_000,) assert_allclose( - [ - x.mean(), - x.std(), - x[x > 2.0].mean(), - x[x > 2.0].std(), - x[x < 2.0].mean(), - x[x < 2.0].std(), - ], - [2.0, jnp.sqrt(5.0), 4.0, 1.0, 0.0, 1.0], + [x[x > 2.0].mean(), x[x > 2.0].std(), x[x < 2.0].mean(), x[x < 2.0].std()], + [4.01, 0.965, -0.01, 0.965], atol=0.1, ) + assert_allclose([x.mean(), x.std()], [2.0, jnp.sqrt(5.0)], atol=0.5) From b895042d5c67d8a95896a99a72a74c2cbd8f77b4 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Wed, 12 May 2021 05:57:23 +0100 Subject: [PATCH 111/222] Add support for Optax optimizers (#1034) * Add support for Optax optimizers * Test Optax * Fix isort linter * Add optax to docs requirements * Simplify optax wrapper * Better handling of import error * Pin Sphinx version * Address comments * Add optax_to_numpyro to docs * isort * Edit optax snippet in SVI docstring * Update docs * Use optax.OptState for type hints * Allow jax.experimental.optimizers.Optimizer instances to be used directly in SVI * Rerun CI * Pin Jinja2 version --- docs/requirements.txt | 3 +- docs/source/optimizers.rst | 6 +- numpyro/contrib/optim.py | 46 +++++++++++++++ numpyro/infer/svi.py | 39 ++++++++++++- setup.cfg | 2 +- setup.py | 4 +- test/contrib/test_optim.py | 114 +++++++++++++++++++++++++++++++++++++ test/infer/test_svi.py | 11 ++-- 8 files changed, 215 insertions(+), 10 deletions(-) create mode 100644 numpyro/contrib/optim.py create mode 100644 test/contrib/test_optim.py diff --git a/docs/requirements.txt b/docs/requirements.txt index 9f3d81d87..85463b00f 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -3,7 +3,8 @@ flax funsor jax>=0.1.65 jaxlib>=0.1.45 -nbsphinx==0.8.1 +optax==0.0.6 +nbsphinx>=0.8.4 sphinx-gallery tfp-nightly # TODO: change this to tensorflow-probability when it is stable tqdm diff --git a/docs/source/optimizers.rst b/docs/source/optimizers.rst index 5268dc7bc..68e2bb0ab 100644 --- a/docs/source/optimizers.rst +++ b/docs/source/optimizers.rst @@ -64,4 +64,8 @@ SM3 .. autoclass:: numpyro.optim.SM3 :members: :undoc-members: - :inherited-members: \ No newline at end of file + :inherited-members: + +Optax support +------------- +.. autofunction:: numpyro.contrib.optim.optax_to_numpyro diff --git a/numpyro/contrib/optim.py b/numpyro/contrib/optim.py new file mode 100644 index 000000000..5f759dcdc --- /dev/null +++ b/numpyro/contrib/optim.py @@ -0,0 +1,46 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +""" +This module provides a wrapper for Optax optimizers so that they can be used with +NumPyro inference algorithms. +""" + +from typing import Tuple, TypeVar + +import optax + +from numpyro.optim import _NumPyroOptim + +_Params = TypeVar("_Params") +_State = Tuple[_Params, optax.OptState] + + +def optax_to_numpyro(transformation: optax.GradientTransformation) -> _NumPyroOptim: + """ + This function produces a ``numpyro.optim._NumPyroOptim`` instance from an + ``optax.GradientTransformation`` so that it can be used with + ``numpyro.infer.svi.SVI``. It is a lightweight wrapper that recreates the + ``(init_fn, update_fn, get_params_fn)`` interface defined by + :mod:`jax.experimental.optimizers`. + + :param transformation: An ``optax.GradientTransformation`` instance to wrap. + :return: An instance of ``numpyro.optim._NumPyroOptim`` wrapping the supplied + Optax optimizer. + """ + + def init_fn(params: _Params) -> _State: + opt_state = transformation.init(params) + return params, opt_state + + def update_fn(step, grads: _Params, state: _State) -> _State: + params, opt_state = state + updates, opt_state = transformation.update(grads, opt_state, params) + updated_params = optax.apply_updates(params, updates) + return updated_params, opt_state + + def get_params_fn(state: _State) -> _Params: + params, _ = state + return params + + return _NumPyroOptim(lambda x, y, z: (x, y, z), init_fn, update_fn, get_params_fn) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 38dca4999..5cbf15d85 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -6,6 +6,7 @@ import tqdm +import jax from jax import jit, lax, random import jax.numpy as jnp from jax.tree_util import tree_map @@ -14,6 +15,7 @@ from numpyro.distributions.transforms import biject_to from numpyro.handlers import replay, seed, trace from numpyro.infer.util import transform_fn +from numpyro.optim import _NumPyroOptim SVIState = namedtuple("SVIState", ["optim_state", "rng_key"]) """ @@ -80,7 +82,14 @@ class SVI(object): :param model: Python callable with Pyro primitives for the model. :param guide: Python callable with Pyro primitives for the guide (recognition network). - :param optim: an instance of :class:`~numpyro.optim._NumpyroOptim`. + :param optim: An instance of :class:`~numpyro.optim._NumpyroOptim`, a + ``jax.experimental.optimizers.Optimizer`` or an Optax + ``GradientTransformation``. If you pass an Optax optimizer it will + automatically be wrapped using :func:`numpyro.contrib.optim.optax_to_numpyro`. + + >>> from optax import adam, chain, clip + >>> svi = SVI(model, guide, chain(clip(10.0), adam(1e-3)), loss=Trace_ELBO()) + :param loss: ELBO loss, i.e. negative Evidence Lower Bound, to minimize. :param static_kwargs: static arguments for the model / guide, i.e. arguments that remain constant during fitting. @@ -91,10 +100,36 @@ def __init__(self, model, guide, optim, loss, **static_kwargs): self.model = model self.guide = guide self.loss = loss - self.optim = optim self.static_kwargs = static_kwargs self.constrain_fn = None + if isinstance(optim, _NumPyroOptim): + self.optim = optim + elif isinstance(optim, jax.experimental.optimizers.Optimizer): + self.optim = _NumPyroOptim(lambda *args: args, *optim) + else: + try: + import optax + + from numpyro.contrib.optim import optax_to_numpyro + except ImportError: + raise ImportError( + "It looks like you tried to use an optimizer that isn't an " + "instance of numpyro.optim._NumPyroOptim or " + "jax.experimental.optimizers.Optimizer. There is experimental " + "support for Optax optimizers, but you need to install Optax. " + "It can be installed with `pip install optax`." + ) + + if not isinstance(optim, optax.GradientTransformation): + raise TypeError( + "Expected either an instance of numpyro.optim._NumPyroOptim, " + "jax.experimental.optimizers.Optimizer or " + "optax.GradientTransformation. Got {}".format(type(optim)) + ) + + self.optim = optax_to_numpyro(optim) + def init(self, rng_key, *args, **kwargs): """ Gets the initial SVI state. diff --git a/setup.cfg b/setup.cfg index edc653778..2a47de391 100644 --- a/setup.cfg +++ b/setup.cfg @@ -8,7 +8,7 @@ profile = black skip_glob = .ipynb_checkpoints known_first_party = funsor, numpyro, test known_third_party = opt_einsum -known_jax = flax, haiku, jax, tensorflow_probability +known_jax = flax, haiku, jax, optax, tensorflow_probability sections = FUTURE, STDLIB, THIRDPARTY, JAX, FIRSTPARTY, LOCALFOLDER force_sort_within_sections = true combine_as_imports = true diff --git a/setup.py b/setup.py index 93c6e1f1e..b727365e3 100644 --- a/setup.py +++ b/setup.py @@ -39,8 +39,9 @@ extras_require={ "doc": [ "ipython", # sphinx needs this to render codes + "jinja2<3.0.0", "nbsphinx", - "sphinx", + "sphinx<4.0.0", "sphinx_rtd_theme", "sphinx-gallery", ], @@ -58,6 +59,7 @@ # TODO: bump funsor version before the release "funsor @ git+https://github.com/pyro-ppl/funsor.git@d5574988665dd822ec64e41f2b54b9dc929959dc", "graphviz", + "optax==0.0.6", # TODO: change this to tensorflow_probability>0.12.1 when the next version # of tfp is released. The current release is not compatible with jax>=0.2.12. "tfp-nightly", diff --git a/test/contrib/test_optim.py b/test/contrib/test_optim.py new file mode 100644 index 000000000..361c8f5ae --- /dev/null +++ b/test/contrib/test_optim.py @@ -0,0 +1,114 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from numpy.testing import assert_allclose +import pytest + +from jax import grad, jit, partial, random +from jax.lax import fori_loop +import jax.numpy as jnp +from jax.test_util import check_close + +import numpyro +import numpyro.distributions as dist +from numpyro.distributions import constraints +from numpyro.infer import SVI, RenyiELBO, Trace_ELBO + +try: + import optax + + from numpyro.contrib.optim import optax_to_numpyro + + # the optimizer test is parameterized by different optax optimizers, but we have + # to define them here to ensure that `optax` is defined. pytest.mark.parameterize + # decorators are run even if tests are skipped at the top of the file. + optimizers = [ + (optax.adam, (1e-2,), {}), + # clipped adam + (optax.chain, (optax.clip(10.0), optax.adam(1e-2)), {}), + (optax.adagrad, (1e-1,), {}), + # SGD with momentum + (optax.sgd, (1e-2,), {"momentum": 0.9}), + (optax.rmsprop, (1e-2,), {"decay": 0.95}), + # RMSProp with momentum + (optax.rmsprop, (1e-4,), {"decay": 0.9, "momentum": 0.9}), + (optax.sgd, (1e-2,), {}), + ] +except ImportError: + pytestmark = pytest.mark.skip(reason="optax is not installed") + optimizers = [] + + +def loss(params): + return jnp.sum(params["x"] ** 2 + params["y"] ** 2) + + +@partial(jit, static_argnums=(1,)) +def step(opt_state, optim): + params = optim.get_params(opt_state) + g = grad(loss)(params) + return optim.update(g, opt_state) + + +@pytest.mark.parametrize("optim_class, args, kwargs", optimizers) +def test_optim_multi_params(optim_class, args, kwargs): + params = {"x": jnp.array([1.0, 1.0, 1.0]), "y": jnp.array([-1, -1.0, -1.0])} + opt = optax_to_numpyro(optim_class(*args, **kwargs)) + opt_state = opt.init(params) + for i in range(2000): + opt_state = step(opt_state, opt) + for _, param in opt.get_params(opt_state).items(): + assert jnp.allclose(param, jnp.zeros(3)) + + +@pytest.mark.parametrize("elbo", [Trace_ELBO(), RenyiELBO(num_particles=10)]) +def test_beta_bernoulli(elbo): + data = jnp.array([1.0] * 8 + [0.0] * 2) + + def model(data): + f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) + numpyro.sample("obs", dist.Bernoulli(f), obs=data) + + def guide(data): + alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) + beta_q = numpyro.param("beta_q", 1.0, constraint=constraints.positive) + numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) + + adam = optax.adam(0.05) + svi = SVI(model, guide, adam, elbo) + svi_state = svi.init(random.PRNGKey(1), data) + assert_allclose(svi.optim.get_params(svi_state.optim_state)["alpha_q"], 0.0) + + def body_fn(i, val): + svi_state, _ = svi.update(val, data) + return svi_state + + svi_state = fori_loop(0, 2000, body_fn, svi_state) + params = svi.get_params(svi_state) + assert_allclose( + params["alpha_q"] / (params["alpha_q"] + params["beta_q"]), + 0.8, + atol=0.05, + rtol=0.05, + ) + + +def test_jitted_update_fn(): + data = jnp.array([1.0] * 8 + [0.0] * 2) + + def model(data): + f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) + numpyro.sample("obs", dist.Bernoulli(f), obs=data) + + def guide(data): + alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) + beta_q = numpyro.param("beta_q", 1.0, constraint=constraints.positive) + numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) + + adam = optax.adam(0.05) + svi = SVI(model, guide, adam, Trace_ELBO()) + svi_state = svi.init(random.PRNGKey(1), data) + expected = svi.get_params(svi.update(svi_state, data)[0]) + + actual = svi.get_params(jit(svi.update)(svi_state, data=data)[0]) + check_close(actual, expected, atol=1e-5) diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index 6580d6f48..d0e7a0a6c 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -4,6 +4,7 @@ from numpy.testing import assert_allclose import pytest +import jax from jax import jit, random, value_and_grad import jax.numpy as jnp from jax.test_util import check_close @@ -41,7 +42,10 @@ def renyi_loss_fn(x): @pytest.mark.parametrize("elbo", [Trace_ELBO(), RenyiELBO(num_particles=10)]) -def test_beta_bernoulli(elbo): +@pytest.mark.parametrize( + "optimizer", [optim.Adam(0.05), jax.experimental.optimizers.adam(0.05)] +) +def test_beta_bernoulli(elbo, optimizer): data = jnp.array([1.0] * 8 + [0.0] * 2) def model(data): @@ -53,10 +57,9 @@ def guide(data): beta_q = numpyro.param("beta_q", 1.0, constraint=constraints.positive) numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) - adam = optim.Adam(0.05) - svi = SVI(model, guide, adam, elbo) + svi = SVI(model, guide, optimizer, elbo) svi_state = svi.init(random.PRNGKey(1), data) - assert_allclose(adam.get_params(svi_state.optim_state)["alpha_q"], 0.0) + assert_allclose(svi.optim.get_params(svi_state.optim_state)["alpha_q"], 0.0) def body_fn(i, val): svi_state, _ = svi.update(val, data) From 155524a6219971fe4d4a0e6437d574d11e053c3e Mon Sep 17 00:00:00 2001 From: Freddy Boulton Date: Wed, 12 May 2021 17:20:47 -0400 Subject: [PATCH 112/222] Adding conda install instructions. (#784) --- README.md | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/README.md b/README.md index 8b9285252..3f982eae5 100644 --- a/README.md +++ b/README.md @@ -204,6 +204,11 @@ git clone https://github.com/pyro-ppl/numpyro.git pip install -e .[dev] # contains additional dependencies for NumPyro development ``` +You can also install NumPyro with conda: +``` +conda install -c conda-forge numpyro +``` + ## Frequently Asked Questions 1. Unlike in Pyro, `numpyro.sample('x', dist.Normal(0, 1))` does not work. Why? From 94040410a0e63de49fdbab1f0a48f7f8d15073b2 Mon Sep 17 00:00:00 2001 From: Simon Dirmeier Date: Fri, 21 May 2021 05:44:35 +0200 Subject: [PATCH 113/222] More distributions (#1039) * Add Weibull and Betaproportion * Add NegativeBinomials * Add ZeroInflatedNegativeBinomial * Fix some unit tests and bugs * Reviews * Simplify Weibull * Fix Weibull constraint * Improve computation of log_prob for NBLogits * Add dispatch method for NegativeBinomial; fix unit tests * Add distributions to doc --- docs/source/distributions.rst | 49 ++++++++++++++++ numpyro/distributions/__init__.py | 12 ++++ numpyro/distributions/conjugate.py | 87 ++++++++++++++++++++++++++++- numpyro/distributions/continuous.py | 74 ++++++++++++++++++++++++ test/test_distributions.py | 36 +++++++++++- 5 files changed, 253 insertions(+), 5 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 60d34b636..b2bdc5708 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -77,6 +77,15 @@ Beta :show-inheritance: :member-order: bysource +BetaProportion +-------------- +.. autoclass:: numpyro.distributions.continuous.BetaProportion + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + + Cauchy ------ .. autoclass:: numpyro.distributions.continuous.Cauchy @@ -253,6 +262,14 @@ Uniform :show-inheritance: :member-order: bysource +Weibull +------- +.. autoclass:: numpyro.distributions.continuous.Weibull + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + Discrete Distributions ====================== @@ -389,6 +406,34 @@ OrderedLogistic :show-inheritance: :member-order: bysource +NegativeBinomial +---------------- +.. autofunction:: numpyro.distributions.conjugate.NegativeBinomial + +NegativeBinomialLogits +---------------------- +.. autoclass:: numpyro.distributions.conjugate.NegativeBinomialLogits + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +NegativeBinomialProbs +--------------------- +.. autoclass:: numpyro.distributions.conjugate.NegativeBinomialProbs + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + +NegativeBinomial2 +----------------- +.. autoclass:: numpyro.distributions.conjugate.NegativeBinomial2 + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + Poisson ------- .. autoclass:: numpyro.distributions.discrete.Poisson @@ -417,6 +462,10 @@ ZeroInflatedPoisson :show-inheritance: :member-order: bysource +ZeroInflatedNegativeBinomial2 +----------------------------- +.. autofunction:: numpyro.distributions.conjugate.ZeroInflatedNegativeBinomial2 + Directional Distributions ========================= diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index a1fc58769..b629093a9 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -5,10 +5,15 @@ BetaBinomial, DirichletMultinomial, GammaPoisson, + NegativeBinomial2, + NegativeBinomialLogits, + NegativeBinomialProbs, + ZeroInflatedNegativeBinomial2, ) from numpyro.distributions.continuous import ( LKJ, Beta, + BetaProportion, Cauchy, Chi2, Dirichlet, @@ -30,6 +35,7 @@ SoftLaplace, StudentT, Uniform, + Weibull, ) from numpyro.distributions.directional import ProjectedNormal, VonMises from numpyro.distributions.discrete import ( @@ -88,6 +94,7 @@ "BernoulliProbs", "Beta", "BetaBinomial", + "BetaProportion", "Binomial", "BinomialLogits", "BinomialProbs", @@ -127,6 +134,9 @@ "MultivariateNormal", "LowRankMultivariateNormal", "Normal", + "NegativeBinomialProbs", + "NegativeBinomialLogits", + "NegativeBinomial2", "OrderedLogistic", "Pareto", "Poisson", @@ -144,6 +154,8 @@ "Uniform", "Unit", "VonMises", + "Weibull", "ZeroInflatedDistribution", "ZeroInflatedPoisson", + "ZeroInflatedNegativeBinomial2", ] diff --git a/numpyro/distributions/conjugate.py b/numpyro/distributions/conjugate.py index c47d09647..58f6351c8 100644 --- a/numpyro/distributions/conjugate.py +++ b/numpyro/distributions/conjugate.py @@ -1,13 +1,18 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -from jax import lax, random +from jax import lax, nn, random import jax.numpy as jnp -from jax.scipy.special import betaln, gammaln +from jax.scipy.special import betainc, betaln, gammaln from numpyro.distributions import constraints from numpyro.distributions.continuous import Beta, Dirichlet, Gamma -from numpyro.distributions.discrete import BinomialProbs, MultinomialProbs, Poisson +from numpyro.distributions.discrete import ( + BinomialProbs, + MultinomialProbs, + Poisson, + ZeroInflatedDistribution, +) from numpyro.distributions.distribution import Distribution from numpyro.distributions.util import is_prng_key, promote_shapes, validate_sample @@ -209,3 +214,79 @@ def mean(self): @property def variance(self): return self.concentration / jnp.square(self.rate) * (1 + self.rate) + + def cdf(self, value): + bt = betainc(self.concentration, value + 1.0, self.rate / (self.rate + 1.0)) + return bt + + +def NegativeBinomial(total_count, probs=None, logits=None, validate_args=None): + if probs is not None: + return NegativeBinomialProbs(total_count, probs, validate_args=validate_args) + elif logits is not None: + return NegativeBinomialLogits(total_count, logits, validate_args=validate_args) + else: + raise ValueError("One of `probs` or `logits` must be specified.") + + +class NegativeBinomialProbs(GammaPoisson): + arg_constraints = { + "total_count": constraints.positive, + "probs": constraints.unit_interval, + } + support = constraints.nonnegative_integer + + def __init__(self, total_count, probs, validate_args=None): + self.total_count, self.probs = promote_shapes(total_count, probs) + concentration = total_count + rate = 1.0 / probs - 1.0 + super().__init__(concentration, rate, validate_args=validate_args) + + +class NegativeBinomialLogits(GammaPoisson): + arg_constraints = { + "total_count": constraints.positive, + "logits": constraints.real, + } + support = constraints.nonnegative_integer + + def __init__(self, total_count, logits, validate_args=None): + self.total_count, self.logits = promote_shapes(total_count, logits) + concentration = total_count + rate = jnp.exp(-logits) + super().__init__(concentration, rate, validate_args=validate_args) + + @validate_sample + def log_prob(self, value): + return -( + self.total_count * nn.softplus(self.logits) + + value * nn.softplus(-self.logits) + + _log_beta_1(self.total_count, value) + ) + + +class NegativeBinomial2(GammaPoisson): + """ + Another parameterization of GammaPoisson with `rate` is replaced by `mean`. + """ + + arg_constraints = { + "mean": constraints.positive, + "concentration": constraints.positive, + } + support = constraints.nonnegative_integer + + def __init__(self, mean, concentration, validate_args=None): + rate = concentration / mean + super().__init__(concentration, rate, validate_args=validate_args) + + +def ZeroInflatedNegativeBinomial2( + mean, concentration, *, gate=None, gate_logits=None, validate_args=None +): + return ZeroInflatedDistribution( + NegativeBinomial2(mean, concentration, validate_args=validate_args), + gate=gate, + gate_logits=gate_logits, + validate_args=validate_args, + ) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 413af7369..95797595e 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -1426,3 +1426,77 @@ def infer_shapes(low=(), high=()): batch_shape = lax.broadcast_shapes(low, high) event_shape = () return batch_shape, event_shape + + +class Weibull(Distribution): + arg_constraints = { + "scale": constraints.positive, + "concentration": constraints.positive, + } + support = constraints.positive + reparametrized_params = ["scale", "concentration"] + + def __init__(self, scale, concentration, validate_args=None): + self.concentration, self.scale = promote_shapes(concentration, scale) + batch_shape = lax.broadcast_shapes(jnp.shape(concentration), jnp.shape(scale)) + super().__init__(batch_shape=batch_shape, validate_args=validate_args) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + return random.weibull_min( + key, + scale=self.scale, + concentration=self.concentration, + shape=sample_shape + self.batch_shape, + ) + + @validate_sample + def log_prob(self, value): + ll = -jnp.power(value / self.scale, self.concentration) + ll += jnp.log(self.concentration) + ll += (self.concentration - 1.0) * jnp.log(value) + ll -= self.concentration * jnp.log(self.scale) + return ll + + def cdf(self, value): + return 1 - jnp.exp(-((value / self.scale) ** self.concentration)) + + @property + def mean(self): + return self.scale * jnp.exp(gammaln(1.0 + 1.0 / self.concentration)) + + @property + def variance(self): + return self.scale ** 2 * ( + jnp.exp(gammaln(1.0 + 2.0 / self.concentration)) + - jnp.exp(gammaln(1.0 + 1.0 / self.concentration)) ** 2 + ) + + +class BetaProportion(Beta): + """ + The BetaProportion distribution is a reparameterization of the conventional + Beta distribution in terms of a the variate mean and a + precision parameter. + + **Reference:** + `Beta regression for modelling rates and proportion`, Ferrari Silvia, and + Francisco Cribari-Neto. Journal of Applied Statistics 31.7 (2004): 799-815. + """ + + arg_constraints = { + "mean": constraints.unit_interval, + "concentration": constraints.positive, + } + reparametrized_params = ["mean", "concentration"] + support = constraints.unit_interval + + def __init__(self, mean, concentration, validate_args=None): + self.concentration = jnp.broadcast_to( + concentration, lax.broadcast_shapes(jnp.shape(concentration)) + ) + super().__init__( + mean * concentration, + (1.0 - mean) * concentration, + validate_args=validate_args, + ) diff --git a/test/test_distributions.py b/test/test_distributions.py index c6e058022..ca73a9861 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -113,6 +113,7 @@ def __init__(self, rate, *, validate_args=None): dist.BernoulliProbs: lambda probs: osp.bernoulli(p=probs), dist.BernoulliLogits: lambda logits: osp.bernoulli(p=_to_probs_bernoulli(logits)), dist.Beta: lambda con1, con0: osp.beta(con1, con0), + dist.BetaProportion: lambda mu, kappa: osp.beta(mu * kappa, (1 - mu) * kappa), dist.BinomialProbs: lambda probs, total_count: osp.binom(n=total_count, p=probs), dist.BinomialLogits: lambda logits, total_count: osp.binom( n=total_count, p=_to_probs_bernoulli(logits) @@ -149,6 +150,10 @@ def __init__(self, rate, *, validate_args=None): dist.VonMises: lambda loc, conc: osp.vonmises( loc=np.array(loc, dtype=np.float64), kappa=np.array(conc, dtype=np.float64) ), + dist.Weibull: lambda scale, conc: osp.weibull_min( + c=conc, + scale=scale, + ), _TruncatedNormal: _truncnorm_to_scipy, } @@ -164,6 +169,9 @@ def get_sp_dist(jax_dist): T(dist.Beta, 0.2, 1.1), T(dist.Beta, 1.0, jnp.array([2.0, 2.0])), T(dist.Beta, 1.0, jnp.array([[1.0, 1.0], [2.0, 2.0]])), + T(dist.BetaProportion, 0.2, 10.0), + T(dist.BetaProportion, 0.51, jnp.array([2.0, 1.0])), + T(dist.BetaProportion, 0.5, jnp.array([[4.0, 4.0], [2.0, 2.0]])), T(dist.Chi2, 2.0), T(dist.Chi2, jnp.array([0.3, 1.3])), T(dist.Cauchy, 0.0, 1.0), @@ -301,6 +309,9 @@ def get_sp_dist(jax_dist): T(dist.Uniform, 0.0, 2.0), T(dist.Uniform, 1.0, jnp.array([2.0, 3.0])), T(dist.Uniform, jnp.array([0.0, 0.0]), jnp.array([[2.0], [3.0]])), + T(dist.Weibull, 0.2, 1.1), + T(dist.Weibull, 2.8, jnp.array([2.0, 2.0])), + T(dist.Weibull, 1.8, jnp.array([[1.0, 1.0], [2.0, 2.0]])), ] DIRECTIONAL = [ @@ -346,6 +357,25 @@ def get_sp_dist(jax_dist): T(dist.MultinomialProbs, jnp.array([0.2, 0.7, 0.1]), 10), T(dist.MultinomialProbs, jnp.array([0.2, 0.7, 0.1]), jnp.array([5, 8])), T(dist.MultinomialLogits, jnp.array([-1.0, 3.0]), jnp.array([[5], [8]])), + T(dist.NegativeBinomialProbs, 10, 0.2), + T(dist.NegativeBinomialProbs, 10, jnp.array([0.2, 0.6])), + T(dist.NegativeBinomialProbs, jnp.array([4.2, 10.7, 2.1]), 0.2), + T( + dist.NegativeBinomialProbs, + jnp.array([4.2, 10.7, 2.1]), + jnp.array([0.2, 0.6, 0.5]), + ), + T(dist.NegativeBinomialLogits, 10, -2.1), + T(dist.NegativeBinomialLogits, 10, jnp.array([-5.2, 2.1])), + T(dist.NegativeBinomialLogits, jnp.array([4.2, 10.7, 2.1]), -5.2), + T( + dist.NegativeBinomialLogits, + jnp.array([4.2, 7.7, 2.1]), + jnp.array([4.2, 0.7, 2.1]), + ), + T(dist.NegativeBinomial2, 0.3, 10), + T(dist.NegativeBinomial2, jnp.array([10.2, 7, 31]), 10), + T(dist.NegativeBinomial2, jnp.array([10.2, 7, 31]), jnp.array([10.2, 20.7, 2.1])), T(dist.OrderedLogistic, -2, jnp.array([-10.0, 4.0, 9.0])), T(dist.OrderedLogistic, jnp.array([-4, 3, 4, 5]), jnp.array([-1.5])), T(dist.Poisson, 2.0), @@ -631,7 +661,7 @@ def fn(args): # finite diff approximation expected_grad = (fn_rhs - fn_lhs) / (2.0 * eps) assert jnp.shape(actual_grad[i]) == jnp.shape(repara_params[i]) - assert_allclose(jnp.sum(actual_grad[i]), expected_grad, rtol=0.02) + assert_allclose(jnp.sum(actual_grad[i]), expected_grad, rtol=0.02, atol=0.03) @pytest.mark.parametrize( @@ -699,7 +729,7 @@ def log_likelihood(*params): expected = log_likelihood(*params) actual = jax.jit(log_likelihood)(*params) - assert_allclose(actual, expected, atol=1e-5) + assert_allclose(actual, expected, atol=2e-5) @pytest.mark.parametrize( @@ -823,6 +853,8 @@ def test_gof(jax_dist, sp_dist, params): pytest.xfail("incorrect submanifold scaling") num_samples = 10000 + if "BetaProportion" in jax_dist.__name__: + num_samples = 20000 rng_key = random.PRNGKey(0) d = jax_dist(*params) samples = d.sample(key=rng_key, sample_shape=(num_samples,)) From d735523972ae6644423f2cc0e7ec50c1877201d7 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 26 May 2021 12:21:55 -0500 Subject: [PATCH 114/222] explicit num_warmup, num_samples arguments for MCMC (#1040) * request for explicit num_warmup, num_samples * force num_warmup num_samples in all tests * ping nbsphinx version * fix remaining bugs * run make format * revert docs requirement * fix wrong changes --- examples/annotation.py | 4 +- examples/baseball.py | 4 +- examples/bnn.py | 4 +- examples/capture_recapture.py | 4 +- examples/covtype.py | 2 +- examples/funnel.py | 4 +- examples/gp.py | 4 +- examples/hmm.py | 4 +- examples/hmm_enum.py | 6 +- examples/neutra.py | 8 +- examples/ode.py | 4 +- examples/proportion_test.py | 6 +- examples/sparse_regression.py | 4 +- examples/ucbadmit.py | 6 +- ...esian_hierarchical_linear_regression.ipynb | 2 +- notebooks/source/bayesian_imputation.ipynb | 4 +- notebooks/source/bayesian_regression.ipynb | 6 +- notebooks/source/discrete_imputation.ipynb | 2 +- notebooks/source/logistic_regression.ipynb | 2 +- notebooks/source/model_rendering.ipynb | 2 +- notebooks/source/ordinal_regression.ipynb | 2 +- .../source/time_series_forecasting.ipynb | 2 +- numpyro/compat/infer.py | 8 +- numpyro/handlers.py | 2 +- numpyro/infer/hmc_gibbs.py | 6 +- numpyro/infer/mcmc.py | 5 +- numpyro/infer/mixed_hmc.py | 2 +- test/contrib/test_control_flow.py | 2 +- test/contrib/test_infer_discrete.py | 2 +- test/contrib/test_module.py | 6 +- test/contrib/test_tfp.py | 14 ++- test/infer/test_hmc_gibbs.py | 38 +++--- test/infer/test_mcmc.py | 108 +++++++++++------- test/test_compile.py | 6 +- test/test_pickle.py | 6 +- 35 files changed, 165 insertions(+), 126 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index e4691c1b1..da35e89ed 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -304,8 +304,8 @@ def main(args): mcmc = MCMC( NUTS(model), - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/baseball.py b/examples/baseball.py index 5372ab452..463c54203 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -145,8 +145,8 @@ def run_inference(model, at_bats, hits, rng_key, args): kernel = SA(model) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if ("NUMPYRO_SPHINXBUILD" in os.environ or args.disable_progbar) diff --git a/examples/bnn.py b/examples/bnn.py index 4aa48bb49..333ef1c6c 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -76,8 +76,8 @@ def run_inference(model, args, rng_key, X, Y, D_H): kernel = NUTS(model) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/capture_recapture.py b/examples/capture_recapture.py index e13a515c7..6d4382500 100644 --- a/examples/capture_recapture.py +++ b/examples/capture_recapture.py @@ -288,8 +288,8 @@ def run_inference(model, capture_history, sex, rng_key, args): kernel = HMC(model) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/covtype.py b/examples/covtype.py index 2393cef6c..f00c1b0b1 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -192,7 +192,7 @@ def benchmark_hmc(args, features, labels): ) else: raise ValueError("Invalid algorithm, either 'HMC', 'NUTS', or 'HMCECS'.") - mcmc = MCMC(kernel, args.num_warmup, args.num_samples) + mcmc = MCMC(kernel, num_warmup=args.num_warmup, num_samples=args.num_samples) mcmc.run(rng_key, features, labels, subsample_size, extra_fields=("accept_prob",)) print("Mean accept prob:", jnp.mean(mcmc.get_extra_fields()["accept_prob"])) mcmc.print_summary(exclude_deterministic=False) diff --git a/examples/funnel.py b/examples/funnel.py index e0346e427..16897f06f 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -53,8 +53,8 @@ def run_inference(model, args, rng_key): kernel = NUTS(model) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/gp.py b/examples/gp.py index 0c4eed324..11b7a4d3a 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -85,8 +85,8 @@ def run_inference(model, args, rng_key, X, Y): kernel = NUTS(model, init_strategy=init_strategy) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, thinning=args.thinning, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, diff --git a/examples/hmm.py b/examples/hmm.py index 95f3c94c8..f57e6dffd 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -221,8 +221,8 @@ def main(args): kernel = NUTS(semi_supervised_hmm) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/hmm_enum.py b/examples/hmm_enum.py index 636aa0b86..cf924d2fa 100644 --- a/examples/hmm_enum.py +++ b/examples/hmm_enum.py @@ -326,9 +326,9 @@ def main(args): kernel = {"nuts": NUTS, "hmc": HMC}[args.kernel](model) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, - args.num_chains, + num_warmup=args.num_warmup, + num_samples=args.num_samples, + num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) mcmc.run(rng_key, sequences, lengths, args=args) diff --git a/examples/neutra.py b/examples/neutra.py index 6a2536e01..4a30c87ab 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -64,8 +64,8 @@ def main(args): nuts_kernel = NUTS(dual_moon_model) mcmc = MCMC( nuts_kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) @@ -91,8 +91,8 @@ def main(args): nuts_kernel = NUTS(neutra_model) mcmc = MCMC( nuts_kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/ode.py b/examples/ode.py index a453a38de..6b9f241df 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -90,8 +90,8 @@ def main(args): # use dense_mass for better mixing rate mcmc = MCMC( NUTS(model, dense_mass=True), - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index 64affcd7e..b02e9aeb5 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -131,9 +131,9 @@ def run_inference( kernel = NUTS(model) mcmc = MCMC( kernel, - num_warmup, - num_samples, - num_chains, + num_warmup=num_warmup, + num_samples=num_samples, + num_chains=num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) mcmc.run(rng_key, design_matrix, outcome) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index 26ac7d0e8..f94cfac48 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -230,8 +230,8 @@ def run_inference(model, args, rng_key, X, Y, hypers): kernel = NUTS(model) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, + num_warmup=args.num_warmup, + num_samples=args.num_samples, num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index 55f080d0a..a7523a787 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -92,9 +92,9 @@ def run_inference(dept, male, applications, admit, rng_key, args): kernel = NUTS(glmm) mcmc = MCMC( kernel, - args.num_warmup, - args.num_samples, - args.num_chains, + num_warmup=args.num_warmup, + num_samples=args.num_samples, + num_chains=args.num_chains, progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, ) mcmc.run(rng_key, dept, male, applications, admit) diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index fbcede836..49670aef3 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -678,7 +678,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index ae795ad48..e7a03197e 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -780,7 +780,7 @@ } ], "source": [ - "mcmc = MCMC(NUTS(model), 1000, 1000)\n", + "mcmc = MCMC(NUTS(model), num_warmup=1000, num_samples=1000)\n", "mcmc.run(random.PRNGKey(0), **data, survived=survived)\n", "mcmc.print_summary()" ] @@ -1103,7 +1103,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 69531d1c4..39c6a0aa7 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -1269,11 +1269,9 @@ "rng_key = random.PRNGKey(0)\n", "rng_key, rng_key_ = random.split(rng_key)\n", "\n", - "num_warmup, num_samples = 1000, 2000\n", - "\n", "# Run NUTS.\n", "kernel = NUTS(model)\n", - "mcmc = MCMC(kernel, num_warmup, num_samples)\n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=2000)\n", "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values, divorce=dset.DivorceScaled.values)\n", "mcmc.print_summary()\n", "samples_1 = mcmc.get_samples()" @@ -2205,7 +2203,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/discrete_imputation.ipynb b/notebooks/source/discrete_imputation.ipynb index 96f43560b..3b1a564b6 100644 --- a/notebooks/source/discrete_imputation.ipynb +++ b/notebooks/source/discrete_imputation.ipynb @@ -802,7 +802,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index f0f9db37d..bea5eecbd 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -373,7 +373,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index c7e8eac33..17d46747a 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -563,7 +563,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 666891b3b..1787786fe 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -281,7 +281,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/time_series_forecasting.ipynb b/notebooks/source/time_series_forecasting.ipynb index b4bac7937..4ecb36510 100644 --- a/notebooks/source/time_series_forecasting.ipynb +++ b/notebooks/source/time_series_forecasting.ipynb @@ -512,7 +512,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/numpyro/compat/infer.py b/numpyro/compat/infer.py index 2182a9c97..6b40719ff 100644 --- a/numpyro/compat/infer.py +++ b/numpyro/compat/infer.py @@ -82,7 +82,7 @@ def __init__( self, kernel, num_samples, - warmup_steps=None, + num_warmup=None, initial_params=None, num_chains=1, hook_fn=None, @@ -91,12 +91,12 @@ def __init__( disable_validation=True, transforms=None, ): - if warmup_steps is None: - warmup_steps = num_samples + if num_warmup is None: + num_warmup = num_samples self._initial_params = initial_params self._mcmc = mcmc.MCMC( kernel, - warmup_steps, + num_warmup, num_samples, num_chains=num_chains, progress_bar=(not disable_progbar), diff --git a/numpyro/handlers.py b/numpyro/handlers.py index fd4ce4c6d..e4d736a27 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -47,7 +47,7 @@ >>> labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) >>> num_warmup, num_samples = 1000, 1000 - >>> mcmc = MCMC(NUTS(model=logistic_regression), num_warmup, num_samples) + >>> mcmc = MCMC(NUTS(model=logistic_regression), num_warmup=num_warmup, num_samples=num_samples) >>> mcmc.run(random.PRNGKey(2), data, labels) # doctest: +SKIP sample: 100%|██████████| 1000/1000 [00:00<00:00, 1252.39it/s, 1 steps of size 5.83e-01. acc. prob=0.85] >>> mcmc.print_summary() # doctest: +SKIP diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 9773fb67d..1c1fab8a0 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -86,7 +86,7 @@ class HMCGibbs(MCMCKernel): ... >>> hmc_kernel = NUTS(model) >>> kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['x']) - >>> mcmc = MCMC(kernel, 100, 100, progress_bar=False) + >>> mcmc = MCMC(kernel, num_warmup=100, num_samples=100, progress_bar=False) >>> mcmc.run(random.PRNGKey(0)) >>> mcmc.print_summary() # doctest: +SKIP @@ -386,7 +386,7 @@ class DiscreteHMCGibbs(HMCGibbs): >>> probs = jnp.array([0.15, 0.3, 0.3, 0.25]) >>> locs = jnp.array([-2, 0, 2, 4]) >>> kernel = DiscreteHMCGibbs(NUTS(model), modified=True) - >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) + >>> mcmc = MCMC(kernel, num_warmup=1000, num_samples=100000, progress_bar=False) >>> mcmc.run(random.PRNGKey(0), probs, locs) >>> mcmc.print_summary() # doctest: +SKIP >>> samples = mcmc.get_samples()["x"] @@ -587,7 +587,7 @@ class HMCECS(HMCGibbs): ... >>> data = random.normal(random.PRNGKey(0), (10000,)) + 1 >>> kernel = HMCECS(NUTS(model), num_blocks=10) - >>> mcmc = MCMC(kernel, 1000, 1000) + >>> mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000) >>> mcmc.run(random.PRNGKey(0), data) >>> samples = mcmc.get_samples()["x"] >>> assert abs(jnp.mean(samples) - 1.) < 0.1 diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 3af9da5a6..58d5eaf39 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -234,6 +234,7 @@ class MCMC(object): def __init__( self, sampler, + *, num_warmup, num_samples, num_chains=1, @@ -439,7 +440,7 @@ def post_warmup_state(self): .. code-block:: python - mcmc = MCMC(NUTS(model), 100, 100) + mcmc = MCMC(NUTS(model), num_warmup=100, num_samples=100) mcmc.run(random.PRNGKey(0)) first_100_samples = mcmc.get_samples() mcmc.post_warmup_state = mcmc.last_state @@ -466,7 +467,7 @@ def warmup( extra_fields=(), collect_warmup=False, init_params=None, - **kwargs + **kwargs, ): """ Run the MCMC warmup adaptation phase. After this call, `self.warmup_state` will be set diff --git a/numpyro/infer/mixed_hmc.py b/numpyro/infer/mixed_hmc.py index eea01e011..ee4b7defd 100644 --- a/numpyro/infer/mixed_hmc.py +++ b/numpyro/infer/mixed_hmc.py @@ -59,7 +59,7 @@ class MixedHMC(DiscreteHMCGibbs): >>> probs = jnp.array([0.15, 0.3, 0.3, 0.25]) >>> locs = jnp.array([-2, 0, 2, 4]) >>> kernel = MixedHMC(HMC(model, trajectory_length=1.2), num_discrete_updates=20) - >>> mcmc = MCMC(kernel, 1000, 100000, progress_bar=False) + >>> mcmc = MCMC(kernel, num_warmup=1000, num_samples=100000, progress_bar=False) >>> mcmc.run(random.PRNGKey(0), probs, locs) >>> mcmc.print_summary() # doctest: +SKIP >>> samples = mcmc.get_samples() diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 7818cffb1..1a4392273 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -36,7 +36,7 @@ def transition(state, i): T = 10 num_samples = 100 kernel = NUTS(model) - mcmc = MCMC(kernel, 100, num_samples) + mcmc = MCMC(kernel, num_warmup=100, num_samples=num_samples) mcmc.run(random.PRNGKey(0), T=T) assert set(mcmc.get_samples()) == {"x", "y", "y2", "x_0", "y_0"} mcmc.print_summary() diff --git a/test/contrib/test_infer_discrete.py b/test/contrib/test_infer_discrete.py index 78b24d15b..2de58ad77 100644 --- a/test/contrib/test_infer_discrete.py +++ b/test/contrib/test_infer_discrete.py @@ -360,7 +360,7 @@ def model2(): @pytest.mark.parametrize("model", [model_zzxx, model2]) @pytest.mark.parametrize("temperature", [0, 1]) def test_mcmc_model_side_enumeration(model, temperature): - mcmc = infer.MCMC(infer.NUTS(model), 0, 1) + mcmc = infer.MCMC(infer.NUTS(model), num_warmup=0, num_samples=1) mcmc.run(random.PRNGKey(0)) mcmc_data = { k: v[0] for k, v in mcmc.get_samples().items() if k in ["loc", "scale"] diff --git a/test/contrib/test_module.py b/test/contrib/test_module.py index ef34ca3d9..2e411f62d 100644 --- a/test/contrib/test_module.py +++ b/test/contrib/test_module.py @@ -169,7 +169,7 @@ def test_random_module__mcmc(backend, init): kwargs_name = "x" N, dim = 3000, 3 - warmup_steps, num_samples = (1000, 1000) + num_warmup, num_samples = (1000, 1000) data = random.normal(random.PRNGKey(0), (N, dim)) true_coefs = np.arange(1.0, dim + 1.0) logits = np.sum(true_coefs * data, axis=-1) @@ -191,7 +191,9 @@ def model(data, labels): numpyro.sample("y", dist.Bernoulli(logits=logits), obs=labels) kernel = NUTS(model=model) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(2), data, labels) mcmc.print_summary() samples = mcmc.get_samples() diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index 1e47e859d..eeb3ea1e2 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -88,7 +88,7 @@ def model(labels): return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) kernel = NUTS(model) - mcmc = MCMC(kernel, num_warmup, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(2), labels) mcmc.print_summary() samples = mcmc.get_samples() @@ -103,7 +103,7 @@ def model(labels): def test_beta_bernoulli(): from numpyro.contrib.tfp import distributions as dist - warmup_steps, num_samples = (500, 2000) + num_warmup, num_samples = (500, 2000) def model(data): alpha = jnp.array([1.1, 1.1]) @@ -115,7 +115,7 @@ def model(data): true_probs = jnp.array([0.9, 0.1]) data = dist.Bernoulli(true_probs)(rng_key=random.PRNGKey(1), sample_shape=(1000, 2)) kernel = NUTS(model=model, trajectory_length=0.1) - mcmc = MCMC(kernel, num_warmup=warmup_steps, num_samples=num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(2), data) mcmc.print_summary() samples = mcmc.get_samples() @@ -215,7 +215,7 @@ def test_unnormalized_normal_chain(kernel, kwargs, num_chains): kernel_class = getattr(mcmc, kernel) true_mean, true_std = 1.0, 0.5 - warmup_steps, num_samples = (1000, 8000) + num_warmup, num_samples = (1000, 8000) def potential_fn(z): return 0.5 * ((z - true_mean) / true_std) ** 2 @@ -223,7 +223,11 @@ def potential_fn(z): init_params = jnp.array(0.0) if num_chains == 1 else jnp.array([0.0, 2.0]) tfp_kernel = kernel_class(potential_fn=potential_fn, **kwargs) mcmc = MCMC( - tfp_kernel, warmup_steps, num_samples, num_chains=num_chains, progress_bar=False + tfp_kernel, + num_warmup=num_warmup, + num_samples=num_samples, + num_chains=num_chains, + progress_bar=False, ) mcmc.run(random.PRNGKey(0), init_params=init_params) mcmc.print_summary() diff --git a/test/infer/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py index b51fed2d6..3ab0e8663 100644 --- a/test/infer/test_hmc_gibbs.py +++ b/test/infer/test_hmc_gibbs.py @@ -40,7 +40,7 @@ def _linear_regression_gibbs_fn(X, XX, XY, Y, rng_key, gibbs_sites, hmc_sites): @pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) def test_linear_model_log_sigma( - kernel_cls, N=100, P=50, sigma=0.11, warmup_steps=500, num_samples=500 + kernel_cls, N=100, P=50, sigma=0.11, num_warmup=500, num_samples=500 ): np.random.seed(0) X = np.random.randn(N * P).reshape((N, P)) @@ -63,7 +63,9 @@ def model(X, Y): hmc_kernel = kernel_cls(model) kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=["beta"]) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(0), X, Y) @@ -76,7 +78,7 @@ def model(X, Y): @pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) def test_linear_model_sigma( - kernel_cls, N=90, P=40, sigma=0.07, warmup_steps=500, num_samples=500 + kernel_cls, N=90, P=40, sigma=0.07, num_warmup=500, num_samples=500 ): np.random.seed(1) X = np.random.randn(N * P).reshape((N, P)) @@ -97,7 +99,9 @@ def model(X, Y): hmc_kernel = kernel_cls(model) kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=["beta"]) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(0), X, Y) @@ -109,7 +113,7 @@ def model(X, Y): @pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) -def test_gaussian_model(kernel_cls, D=2, warmup_steps=5000, num_samples=5000): +def test_gaussian_model(kernel_cls, D=2, num_warmup=5000, num_samples=5000): np.random.seed(0) cov = np.random.randn(4 * D * D).reshape((2 * D, 2 * D)) cov = jnp.matmul(jnp.transpose(cov), cov) + 0.25 * jnp.eye(2 * D) @@ -149,7 +153,9 @@ def model(): hmc_kernel = kernel_cls(model, dense_mass=True) kernel = HMCGibbs(hmc_kernel, gibbs_fn=gaussian_gibbs_fn, gibbs_sites=["x0"]) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(0)) @@ -178,7 +184,13 @@ def model(): numpyro.sample("y", dist.Binomial(10, 0.3)) sampler = kernel(inner_kernel(model), **kwargs) - mcmc = MCMC(sampler, 1000, 10000, num_chains=num_chains, progress_bar=False) + mcmc = MCMC( + sampler, + num_warmup=1000, + num_samples=10000, + num_chains=num_chains, + progress_bar=False, + ) mcmc.run(random.PRNGKey(0)) mcmc.print_summary() samples = mcmc.get_samples() @@ -197,7 +209,7 @@ def model(): numpyro.deterministic("y2", y ** 2) sampler = kernel(inner_kernel(model), **kwargs) - mcmc = MCMC(sampler, 1000, 10000, progress_bar=False) + mcmc = MCMC(sampler, num_warmup=1000, num_samples=10000, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["y"], 0), 0.3 * 10, atol=0.1) @@ -217,7 +229,7 @@ def model(): numpyro.sample("c", dist.Bernoulli(0.8)) sampler = kernel(inner_kernel(model), random_walk=random_walk, **kwargs) - mcmc = MCMC(sampler, 1000, 10000, progress_bar=False) + mcmc = MCMC(sampler, num_warmup=1000, num_samples=10000, progress_bar=False) mcmc.run(random.PRNGKey(0)) samples = mcmc.get_samples()["c"] assert_allclose(jnp.mean(samples), 0.8, atol=0.05) @@ -238,7 +250,7 @@ def model(probs, locs): sampler = kernel( inner_kernel(model, trajectory_length=1.2), modified=modified, **kwargs ) - mcmc = MCMC(sampler, 1000, 200000, progress_bar=False) + mcmc = MCMC(sampler, num_warmup=1000, num_samples=200000, progress_bar=False) mcmc.run(random.PRNGKey(0), probs, locs) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["x"]), 1.3, atol=0.1) @@ -276,7 +288,7 @@ def model(data): data = random.normal(random.PRNGKey(0), (10000,)) + 1 kernel = HMCECS(NUTS(model), num_blocks=10) - mcmc = MCMC(kernel, 10, 10) + mcmc = MCMC(kernel, num_warmup=10, num_samples=10) mcmc.run(random.PRNGKey(0), data) @@ -304,7 +316,7 @@ def model(data, subsample_size): proxy_fn = HMCECS.taylor_proxy(ref_params) kernel = HMCECS(kernel_cls(model), proxy=proxy_fn) - mcmc = MCMC(kernel, num_warmup, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(0), data, subsample_size) samples = mcmc.get_samples() @@ -407,7 +419,7 @@ def model(data): proxy_fn = HMCECS.taylor_proxy({"mean": ref_params}) kernel = HMCECS(kernel_cls(model), proxy=proxy_fn, num_blocks=num_blocks) - mcmc = MCMC(kernel, num_warmup, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(0), data, extra_fields=["hmc_state.potential_energy"]) diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index 3a20eb148..6ce06c39c 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -28,7 +28,7 @@ @pytest.mark.parametrize("dense_mass", [False, True]) def test_unnormalized_normal_x64(kernel_cls, dense_mass): true_mean, true_std = 1.0, 0.5 - warmup_steps, num_samples = (100000, 100000) if kernel_cls is SA else (1000, 8000) + num_warmup, num_samples = (100000, 100000) if kernel_cls is SA else (1000, 8000) def potential_fn(z): return 0.5 * jnp.sum(((z - true_mean) / true_std) ** 2) @@ -42,7 +42,9 @@ def potential_fn(z): kernel = kernel_cls( potential_fn=potential_fn, trajectory_length=8, dense_mass=dense_mass ) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(0), init_params=init_params) mcmc.print_summary() hmc_states = mcmc.get_samples() @@ -58,7 +60,7 @@ def test_correlated_mvn(regularize): # This requires dense mass matrix estimation. D = 5 - warmup_steps, num_samples = 5000, 8000 + num_warmup, num_samples = 5000, 8000 true_mean = 0.0 a = jnp.tril( @@ -75,7 +77,7 @@ def potential_fn(z): kernel = NUTS( potential_fn=potential_fn, dense_mass=True, regularize_mass_matrix=regularize ) - mcmc = MCMC(kernel, warmup_steps, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(0), init_params=init_params) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples), true_mean, atol=0.02) @@ -86,11 +88,11 @@ def potential_fn(z): def test_logistic_regression_x64(kernel_cls): N, dim = 3000, 3 if kernel_cls is SA: - warmup_steps, num_samples = (100000, 100000) + num_warmup, num_samples = (100000, 100000) elif kernel_cls is BarkerMH: - warmup_steps, num_samples = (2000, 12000) + num_warmup, num_samples = (2000, 12000) else: - warmup_steps, num_samples = (1000, 8000) + num_warmup, num_samples = (1000, 8000) data = random.normal(random.PRNGKey(0), (N, dim)) true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) @@ -109,7 +111,9 @@ def model(labels): kernel = kernel_cls( model=model, trajectory_length=8, find_heuristic_step_size=True ) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(2), labels) mcmc.print_summary() samples = mcmc.get_samples() @@ -184,7 +188,7 @@ def model(data): @pytest.mark.parametrize("kernel_cls", [HMC, NUTS, SA, BarkerMH]) def test_beta_bernoulli_x64(kernel_cls): - warmup_steps, num_samples = (100000, 100000) if kernel_cls is SA else (500, 20000) + num_warmup, num_samples = (100000, 100000) if kernel_cls is SA else (500, 20000) def model(data): alpha = jnp.array([1.1, 1.1]) @@ -202,7 +206,7 @@ def model(data): else: kernel = kernel_cls(model=model, trajectory_length=0.1) mcmc = MCMC( - kernel, num_warmup=warmup_steps, num_samples=num_samples, progress_bar=False + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False ) mcmc.run(random.PRNGKey(2), data) mcmc.print_summary() @@ -216,7 +220,7 @@ def model(data): @pytest.mark.parametrize("kernel_cls", [HMC, NUTS, BarkerMH]) @pytest.mark.parametrize("dense_mass", [False, True]) def test_dirichlet_categorical_x64(kernel_cls, dense_mass): - warmup_steps, num_samples = 100, 20000 + num_warmup, num_samples = 100, 20000 def model(data): concentration = jnp.array([1.0, 1.0, 1.0]) @@ -230,7 +234,9 @@ def model(data): kernel = BarkerMH(model=model, dense_mass=dense_mass) else: kernel = kernel_cls(model, trajectory_length=1.0, dense_mass=dense_mass) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["p_latent"], 0), true_probs, atol=0.02) @@ -242,7 +248,7 @@ def model(data): @pytest.mark.parametrize("kernel_cls", [HMC, NUTS, BarkerMH]) @pytest.mark.parametrize("rho", [-0.7, 0.8]) def test_dense_mass(kernel_cls, rho): - warmup_steps, num_samples = 20000, 10000 + num_warmup, num_samples = 20000, 10000 true_cov = jnp.array([[10.0, rho], [rho, 0.1]]) @@ -256,7 +262,9 @@ def model(): elif kernel_cls is BarkerMH: kernel = BarkerMH(model, dense_mass=True) - mcmc = MCMC(kernel, warmup_steps, num_samples, progress_bar=False) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc.run(random.PRNGKey(0)) mass_matrix_sqrt = mcmc.last_state.adapt_state.mass_matrix_sqrt @@ -275,7 +283,7 @@ def model(): def test_change_point_x64(): # Ref: https://forum.pyro.ai/t/i-dont-understand-why-nuts-code-is-not-working-bayesian-hackers-mail/696 - warmup_steps, num_samples = 500, 3000 + num_warmup, num_samples = 500, 3000 def model(data): alpha = 1 / jnp.mean(data.astype(np.float32)) @@ -364,7 +372,7 @@ def model(data): ] ) kernel = NUTS(model=model) - mcmc = MCMC(kernel, warmup_steps, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(4), count_data) samples = mcmc.get_samples() tau_posterior = (samples["tau"] * len(count_data)).astype(jnp.int32) @@ -382,7 +390,7 @@ def model(data): @pytest.mark.parametrize("with_logits", ["True", "False"]) def test_binomial_stable_x64(with_logits): # Ref: https://github.com/pyro-ppl/pyro/issues/1706 - warmup_steps, num_samples = 200, 200 + num_warmup, num_samples = 200, 200 def model(data): p = numpyro.sample("p", dist.Beta(1.0, 1.0)) @@ -396,7 +404,7 @@ def model(data): data = {"n": 5000000, "x": 3849} kernel = NUTS(model=model) - mcmc = MCMC(kernel, warmup_steps, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() assert_allclose(jnp.mean(samples["p"], 0), data["x"] / data["n"], rtol=0.05) @@ -418,7 +426,7 @@ def model(data): data = dist.Normal(true_mean, true_std).sample(random.PRNGKey(1), (2000,)) kernel = NUTS(model=model) - mcmc = MCMC(kernel, num_warmup, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.warmup(random.PRNGKey(2), data) mcmc.run(random.PRNGKey(2), data) samples = mcmc.get_samples() @@ -437,10 +445,12 @@ def model(data): data = dist.Normal(true_mean, true_std).sample(random.PRNGKey(1), (2000,)) kernel = NUTS(model=model) - mcmc = MCMC(kernel, num_warmup, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.warmup(random.PRNGKey(2), data) mcmc.run(random.PRNGKey(3), data) - mcmc1 = MCMC(kernel, num_warmup, num_samples, progress_bar=False) + mcmc1 = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, progress_bar=False + ) mcmc1.run(random.PRNGKey(2), data) with pytest.raises(AssertionError): @@ -464,7 +474,7 @@ def model(data): model, step_size=10.0, adapt_step_size=adapt_step_size, adapt_mass_matrix=False ) num_warmup = num_samples = 1000 - mcmc = MCMC(kernel, num_warmup, num_samples) + mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.warmup( random.PRNGKey(1), data, extra_fields=["diverging"], collect_warmup=True ) @@ -538,7 +548,9 @@ def model(labels): return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) kernel = NUTS(model=model) - mcmc = MCMC(kernel, num_warmup, num_samples, num_chains=num_chains) + mcmc = MCMC( + kernel, num_warmup=num_warmup, num_samples=num_samples, num_chains=num_chains + ) mcmc.chain_method = chain_method init_params = ( None @@ -576,7 +588,7 @@ def test_chain_inside_jit(kernel_cls, chain_method): # Caution: compiling time will be slow (~ 90s) if chain_method == "parallel" and xla_bridge.device_count() == 1: pytest.skip("parallel method requires device_count greater than 1.") - warmup_steps, num_samples = 100, 2000 + num_warmup, num_samples = 100, 2000 # Here are settings which is currently supported. rng_key = random.PRNGKey(2) step_size = 1.0 @@ -605,8 +617,8 @@ def get_samples(rng_key, data, step_size, trajectory_length, target_accept_prob) ) mcmc = MCMC( kernel, - warmup_steps, - num_samples, + num_warmup=num_warmup, + num_samples=num_samples, num_chains=2, chain_method=chain_method, progress_bar=False, @@ -643,8 +655,8 @@ def model(data): kernel = NUTS(model) mcmc = MCMC( kernel, - 2, - 5, + num_warmup=2, + num_samples=5, num_chains=2, chain_method=chain_method, jit_model_args=compile_args, @@ -659,7 +671,7 @@ def test_extra_fields(): def model(): numpyro.sample("x", dist.Normal(0, 1), sample_shape=(5,)) - mcmc = MCMC(NUTS(model), 1000, 1000) + mcmc = MCMC(NUTS(model), num_warmup=1000, num_samples=1000) mcmc.run(random.PRNGKey(0), extra_fields=("num_steps", "adapt_state.step_size")) samples = mcmc.get_samples(group_by_chain=True) assert samples["x"].shape == (1, 1000, 5) @@ -672,7 +684,7 @@ def model(): @pytest.mark.parametrize("algo", ["HMC", "NUTS"]) def test_functional_beta_bernoulli_x64(algo): - warmup_steps, num_samples = 410, 100 + num_warmup, num_samples = 410, 100 def model(data): alpha = jnp.array([1.1, 1.1]) @@ -687,7 +699,7 @@ def model(data): random.PRNGKey(2), model, model_args=(data,) ) init_kernel, sample_kernel = hmc(potential_fn, algo=algo) - hmc_state = init_kernel(init_params, trajectory_length=1.0, num_warmup=warmup_steps) + hmc_state = init_kernel(init_params, trajectory_length=1.0, num_warmup=num_warmup) samples = fori_collect( 0, num_samples, sample_kernel, hmc_state, transform=lambda x: constrain_fn(x.z) ) @@ -708,7 +720,7 @@ def test_functional_map(algo, map_fn): pytest.skip("pmap test requires device_count greater than 1.") true_mean, true_std = 1.0, 2.0 - warmup_steps, num_samples = 1000, 8000 + num_warmup, num_samples = 1000, 8000 def potential_fn(z): return 0.5 * jnp.sum(((z - true_mean) / true_std) ** 2) @@ -719,7 +731,7 @@ def potential_fn(z): init_kernel_map = map_fn( lambda init_param, rng_key: init_kernel( - init_param, trajectory_length=9, num_warmup=warmup_steps, rng_key=rng_key + init_param, trajectory_length=9, num_warmup=num_warmup, rng_key=rng_key ) ) init_states = init_kernel_map(init_params, rng_keys) @@ -755,7 +767,7 @@ def model(y_obs): # Run MCMC on zero observations. kernel = NUTS(model) - mcmc = MCMC(kernel, 300, 500, jit_model_args=jit_args) + mcmc = MCMC(kernel, num_warmup=300, num_samples=500, jit_model_args=jit_args) mcmc.run(random.PRNGKey(32), y1) # Re-run on new data - should be much faster. @@ -784,7 +796,7 @@ def model(a=None, b=None, z=None): # Run MCMC on zero observations. kernel = NUTS(model) - mcmc = MCMC(kernel, 20, 10, jit_model_args=jit_args) + mcmc = MCMC(kernel, num_warmup=20, num_samples=10, jit_model_args=jit_args) mcmc.run(random.PRNGKey(1), a, b=None, z=z) assert set(mcmc.get_samples()) == {"a", "x", "sigma"} mcmc.run(random.PRNGKey(2), a=None, b=b, z=z) @@ -809,9 +821,9 @@ def model(): num_samples = 10 mcmc = MCMC( NUTS(model), - 10, - num_samples, - num_chains, + num_warmup=10, + num_samples=num_samples, + num_chains=num_chains, chain_method=chain_method, progress_bar=progress_bar, ) @@ -829,7 +841,13 @@ def model(): # test for reproducible if num_chains > 1: - mcmc = MCMC(NUTS(model), 10, num_samples, 1, progress_bar=progress_bar) + mcmc = MCMC( + NUTS(model), + num_warmup=10, + num_samples=num_samples, + num_chains=1, + progress_bar=progress_bar, + ) rng_key = random.split(rng_key)[0] mcmc.run(rng_key) first_chain_samples = mcmc.get_samples()["x"] @@ -881,7 +899,7 @@ def model(): return numpyro.sample("y", dist.Normal(x, 1), obs=2) num_samples = 10 - mcmc = MCMC(NUTS(model), 10, num_samples) + mcmc = MCMC(NUTS(model), num_warmup=10, num_samples=num_samples) mcmc.run(random.PRNGKey(0)) # because event_shape of x is (1,), x should only take value 1 assert_allclose( @@ -896,7 +914,9 @@ def model(): numpyro.sample("obs", dist.Normal(y, 1), obs=1.0) # this fails in reverse mode - mcmc = MCMC(NUTS(model, forward_mode_differentiation=True), 10, 10) + mcmc = MCMC( + NUTS(model, forward_mode_differentiation=True), num_warmup=10, num_samples=10 + ) mcmc.run(random.PRNGKey(0)) @@ -906,7 +926,7 @@ def model(): y = lax.while_loop(lambda x: x < 10, lambda x: x + 1, x) numpyro.sample("obs", dist.Normal(y, 1), obs=1.0) - mcmc = MCMC(SA(model), 10, 10) + mcmc = MCMC(SA(model), num_warmup=10, num_samples=10) mcmc.run(random.PRNGKey(0)) @@ -1001,7 +1021,7 @@ def model(): inverse_mass_matrix={("x",): expected_mm}, adapt_mass_matrix=False, ) - mcmc = MCMC(kernel, 1, 1) + mcmc = MCMC(kernel, num_warmup=1, num_samples=1) mcmc.run(random.PRNGKey(0)) inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix assert set(inverse_mass_matrix.keys()) == {("x",), ("z",)} @@ -1023,7 +1043,7 @@ def model(): inverse_mass_matrix=expected_mm, adapt_mass_matrix=False, ) - mcmc = MCMC(kernel, 1, 1) + mcmc = MCMC(kernel, num_warmup=1, num_samples=1) mcmc.run(random.PRNGKey(0)) inverse_mass_matrix = mcmc.last_state.adapt_state.inverse_mass_matrix assert set(inverse_mass_matrix.keys()) == {("x", "z")} diff --git a/test/test_compile.py b/test/test_compile.py index bc606c34a..99dec7058 100644 --- a/test/test_compile.py +++ b/test/test_compile.py @@ -27,7 +27,9 @@ def model(deterministic=True): def test_mcmc_one_chain(deterministic, find_heuristic_step_size): GLOBAL["count"] = 0 mcmc = MCMC( - NUTS(model, find_heuristic_step_size=find_heuristic_step_size), 100, 100 + NUTS(model, find_heuristic_step_size=find_heuristic_step_size), + num_warmup=100, + num_samples=100, ) mcmc.run(random.PRNGKey(0), deterministic=deterministic) mcmc.get_samples() @@ -45,7 +47,7 @@ def test_mcmc_one_chain(deterministic, find_heuristic_step_size): ) def test_mcmc_parallel_chain(deterministic): GLOBAL["count"] = 0 - mcmc = MCMC(NUTS(model), 100, 100, num_chains=2) + mcmc = MCMC(NUTS(model), num_warmup=100, num_samples=100, num_chains=2) mcmc.run(random.PRNGKey(0), deterministic=deterministic) mcmc.get_samples() diff --git a/test/test_pickle.py b/test/test_pickle.py index 1a74b7f18..bf0d79793 100644 --- a/test/test_pickle.py +++ b/test/test_pickle.py @@ -40,7 +40,7 @@ def logistic_regression(): @pytest.mark.parametrize("kernel", [BarkerMH, HMC, NUTS, SA]) def test_pickle_hmc(kernel): - mcmc = MCMC(kernel(normal_model), 10, 10) + mcmc = MCMC(kernel(normal_model), num_warmup=10, num_samples=10) mcmc.run(random.PRNGKey(0)) pickled_mcmc = pickle.loads(pickle.dumps(mcmc)) test_util.check_close(mcmc.get_samples(), pickled_mcmc.get_samples()) @@ -48,14 +48,14 @@ def test_pickle_hmc(kernel): @pytest.mark.parametrize("kernel", [DiscreteHMCGibbs, MixedHMC]) def test_pickle_discrete_hmc(kernel): - mcmc = MCMC(kernel(HMC(bernoulli_model)), 10, 10) + mcmc = MCMC(kernel(HMC(bernoulli_model)), num_warmup=10, num_samples=10) mcmc.run(random.PRNGKey(0)) pickled_mcmc = pickle.loads(pickle.dumps(mcmc)) test_util.check_close(mcmc.get_samples(), pickled_mcmc.get_samples()) def test_pickle_hmcecs(): - mcmc = MCMC(HMCECS(NUTS(logistic_regression)), 10, 10) + mcmc = MCMC(HMCECS(NUTS(logistic_regression)), num_warmup=10, num_samples=10) mcmc.run(random.PRNGKey(0)) pickled_mcmc = pickle.loads(pickle.dumps(mcmc)) test_util.check_close(mcmc.get_samples(), pickled_mcmc.get_samples()) From 36769fdd3778de6ba9308b5c68c1ae86cf28a7d2 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 27 May 2021 15:28:24 -0500 Subject: [PATCH 115/222] add some png images (#1042) --- docs/source/_static/img/examples/annotation.png | Bin 0 -> 25224 bytes docs/source/_static/img/examples/baseball.png | Bin 0 -> 10097 bytes .../_static/img/examples/capture_recapture.png | Bin 0 -> 9493 bytes docs/source/_static/img/examples/covtype.png | Bin 0 -> 27638 bytes docs/source/_static/img/examples/hmm_enum.png | Bin 0 -> 13929 bytes .../_static/img/examples/proportion_test.png | Bin 0 -> 16665 bytes .../_static/img/examples/sparse_regression.png | Bin 0 -> 27666 bytes docs/source/_static/img/examples/vae.png | Bin 0 -> 99511 bytes .../img/tutorials/bayesian_imputation.png | Bin 0 -> 70944 bytes .../_static/img/tutorials/model_rendering.png | Bin 0 -> 15275 bytes 10 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/source/_static/img/examples/annotation.png create mode 100644 docs/source/_static/img/examples/baseball.png create mode 100644 docs/source/_static/img/examples/capture_recapture.png create mode 100644 docs/source/_static/img/examples/covtype.png create mode 100644 docs/source/_static/img/examples/hmm_enum.png create mode 100644 docs/source/_static/img/examples/proportion_test.png create mode 100644 docs/source/_static/img/examples/sparse_regression.png create mode 100644 docs/source/_static/img/examples/vae.png create mode 100644 docs/source/_static/img/tutorials/bayesian_imputation.png create mode 100644 docs/source/_static/img/tutorials/model_rendering.png diff --git a/docs/source/_static/img/examples/annotation.png b/docs/source/_static/img/examples/annotation.png new file mode 100644 index 0000000000000000000000000000000000000000..556facf9006bc7e21847a318c1a916625d2717ef GIT binary patch literal 25224 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 XD!f*delRI(bLAyds|)4lJ?{N4Zmn70 literal 0 HcmV?d00001 diff --git a/docs/source/_static/img/examples/covtype.png b/docs/source/_static/img/examples/covtype.png new file mode 100644 index 0000000000000000000000000000000000000000..b852dfd4ad20f25bb56b60503006e6f35e0927f3 GIT binary patch literal 27638 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
    #9hKA~%D&}UlCMxV}&%9{#NXD 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 TLQ(%6LsOR5kSlv_@%}#nrcswG literal 0 HcmV?d00001 diff --git a/docs/source/_static/img/examples/proportion_test.png b/docs/source/_static/img/examples/proportion_test.png new file mode 100644 index 0000000000000000000000000000000000000000..5faa5efed1bcdc5837ba9a6e3bce3730b0b76fac GIT binary patch literal 16665 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

    xbEqIPb}o_Tz@lv;H(Kg|xZl+^A7Q_O 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 ZlTm1xwcEk0x&aJ$$xEw9eUUJR{vVKF`R)J! literal 0 HcmV?d00001 diff --git a/docs/source/_static/img/tutorials/bayesian_imputation.png b/docs/source/_static/img/tutorials/bayesian_imputation.png new file mode 100644 index 0000000000000000000000000000000000000000..c689414b5b7bc3735acdce459460c5df722063b0 GIT binary patch literal 70944 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 MNkj3CyovAs0YV_IuK)l5 literal 0 HcmV?d00001 From 9ca63dad442d6b84f846b24b60fdd00552f7456d Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 27 May 2021 15:28:51 -0500 Subject: [PATCH 116/222] bump nbsphinx version (#1041) --- docs/requirements.txt | 2 +- setup.py | 5 ++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 85463b00f..afe85da6b 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -4,7 +4,7 @@ funsor jax>=0.1.65 jaxlib>=0.1.45 optax==0.0.6 -nbsphinx>=0.8.4 +nbsphinx>=0.8.5 sphinx-gallery tfp-nightly # TODO: change this to tensorflow-probability when it is stable tqdm diff --git a/setup.py b/setup.py index b727365e3..ca45c3977 100644 --- a/setup.py +++ b/setup.py @@ -39,9 +39,8 @@ extras_require={ "doc": [ "ipython", # sphinx needs this to render codes - "jinja2<3.0.0", - "nbsphinx", - "sphinx<4.0.0", + "nbsphinx>=0.8.5", + "sphinx", "sphinx_rtd_theme", "sphinx-gallery", ], From 4876f8714554f7d7cdc4991d81f9c0c2842ee0c0 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 31 May 2021 19:02:05 -0500 Subject: [PATCH 117/222] Disable progbar for multi-GPU platform (#1048) * disable progbar for multi-GPU platform * add a warning for progress bar on GPU * add missing import --- numpyro/util.py | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/numpyro/util.py b/numpyro/util.py index 1a2d090d0..9405caa86 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -6,6 +6,7 @@ import os import random import re +import warnings import numpy as np import tqdm @@ -300,6 +301,13 @@ def fori_collect( init_val_flat, unravel_fn = ravel_pytree(transform(init_val)) start_idx = lower + (upper - lower) % thinning num_chains = progbar_opts.pop("num_chains", 1) + # host_callback does not work yet with multi-GPU platforms + # See: https://github.com/google/jax/issues/6447 + if num_chains > 1 and jax.default_backend() == "gpu": + warnings.warn( + "We will disable progress bar because it does not work yet on multi-GPUs platforms." + ) + progbar = False @cached_by(fori_collect, body_fun, transform) def _body_fn(i, vals): From 05d37d6650d95713acdc918d0b4114cf64d31969 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 31 May 2021 19:03:23 -0500 Subject: [PATCH 118/222] Check plate consistent in auto guide (#1049) * check plate consistent and add regression test * make format --- numpyro/infer/autoguide.py | 7 ++++++- test/infer/test_autoguide.py | 14 ++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index fa306bb8b..e7a8dc1cb 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -148,7 +148,12 @@ def _setup_prototype(self, *args, **kwargs): for name, site in self.prototype_trace.items(): if site["type"] == "sample": for frame in site["cond_indep_stack"]: - self._prototype_frames[frame.name] = frame + if frame.name in self._prototype_frames: + assert ( + frame == self._prototype_frames[frame.name] + ), f"The plate {frame.name} has inconsistent dim or size. Please check your model again." + else: + self._prototype_frames[frame.name] = frame elif site["type"] == "plate": self._prototype_frame_full_sizes[name] = site["args"][0] diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 86c340107..bb16cd166 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -482,3 +482,17 @@ def model(y=None): predictive_samples["z"], atol=0.05, ) + + +@pytest.mark.parametrize("size,dim", [(10, -2), (5, -1)]) +def test_plate_inconsistent(size, dim): + def model(): + with numpyro.plate("a", 10, dim=-1): + numpyro.sample("x", dist.Normal(0, 1)) + with numpyro.plate("a", size, dim=dim): + numpyro.sample("y", dist.Normal(0, 1)) + + guide = AutoDelta(model) + svi = SVI(model, guide, numpyro.optim.Adam(step_size=0.1), Trace_ELBO()) + with pytest.raises(AssertionError, match="has inconsistent dim or size"): + svi.run(random.PRNGKey(0), 10) From ad35577e4021d2cee1209976af41ae6575ea44ca Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 1 Jun 2021 11:02:28 -0500 Subject: [PATCH 119/222] Add folded distribution (#1050) --- docs/source/distributions.rst | 8 ++++++ numpyro/distributions/__init__.py | 2 ++ numpyro/distributions/distribution.py | 35 ++++++++++++++++++++++++++- test/test_distributions.py | 17 +++++++++++++ 4 files changed, 61 insertions(+), 1 deletion(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index b2bdc5708..845d22282 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -17,6 +17,14 @@ ExpandedDistribution :show-inheritance: :member-order: bysource +FoldedDistribution +------------------ +.. autoclass:: numpyro.distributions.distribution.FoldedDistribution + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + ImproperUniform --------------- .. autoclass:: numpyro.distributions.distribution.ImproperUniform diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index b629093a9..65e9d7bb9 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -64,6 +64,7 @@ Delta, Distribution, ExpandedDistribution, + FoldedDistribution, ImproperUniform, Independent, MaskedDistribution, @@ -109,6 +110,7 @@ "Distribution", "Exponential", "ExpandedDistribution", + "FoldedDistribution", "Gamma", "GammaPoisson", "GaussianRandomWalk", diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index ce71e40c4..f65751d55 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -35,8 +35,9 @@ from jax import lax, tree_util import jax.numpy as jnp +from jax.scipy.special import logsumexp -from numpyro.distributions.transforms import ComposeTransform, Transform +from numpyro.distributions.transforms import AbsTransform, ComposeTransform, Transform from numpyro.distributions.util import ( lazy_property, promote_shapes, @@ -1051,6 +1052,38 @@ def tree_flatten(self): ) +class FoldedDistribution(TransformedDistribution): + """ + Equivalent to ``TransformedDistribution(base_dist, AbsTransform())``, + but additionally supports :meth:`log_prob` . + + :param Distribution base_dist: A univariate distribution to reflect. + """ + + support = constraints.positive + + def __init__(self, base_dist, validate_args=None): + if base_dist.event_shape: + raise ValueError("Only univariate distributions can be folded.") + super().__init__(base_dist, AbsTransform(), validate_args=validate_args) + + @validate_sample + def log_prob(self, value): + dim = max(len(self.batch_shape), jnp.ndim(value)) + plus_minus = jnp.array([1.0, -1.0]).reshape((2,) + (1,) * dim) + return logsumexp(self.base_dist.log_prob(plus_minus * value), axis=0) + + def tree_flatten(self): + base_flatten, base_aux = self.base_dist.tree_flatten() + return base_flatten, (type(self.base_dist), base_aux) + + @classmethod + def tree_unflatten(cls, aux_data, params): + base_cls, base_aux = aux_data + base_dist = base_cls.tree_unflatten(base_aux, params) + return cls(base_dist) + + class Delta(Distribution): arg_constraints = { "v": constraints.dependent(is_discrete=False), diff --git a/test/test_distributions.py b/test/test_distributions.py index ca73a9861..7c063aafe 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -109,6 +109,19 @@ def __init__(self, rate, *, validate_args=None): super().__init__(rate, is_sparse=True, validate_args=validate_args) +class FoldedNormal(dist.FoldedDistribution): + arg_constraints = {"loc": constraints.real, "scale": constraints.positive} + + def __init__(self, loc, scale, validate_args=None): + self.loc = loc + self.scale = scale + super().__init__(dist.Normal(loc, scale), validate_args=validate_args) + + @classmethod + def tree_unflatten(cls, aux_data, params): + return dist.FoldedDistribution.tree_unflatten(aux_data, params) + + _DIST_MAP = { dist.BernoulliProbs: lambda probs: osp.bernoulli(p=probs), dist.BernoulliLogits: lambda logits: osp.bernoulli(p=_to_probs_bernoulli(logits)), @@ -189,6 +202,8 @@ def get_sp_dist(jax_dist): T(dist.Gumbel, 0.0, 1.0), T(dist.Gumbel, 0.5, 2.0), T(dist.Gumbel, jnp.array([0.0, 0.5]), jnp.array([1.0, 2.0])), + T(FoldedNormal, 2.0, 4.0), + T(FoldedNormal, jnp.array([2.0, 50.0]), jnp.array([4.0, 100.0])), T(dist.HalfCauchy, 1.0), T(dist.HalfCauchy, jnp.array([1.0, 2.0])), T(dist.HalfNormal, 1.0), @@ -1102,6 +1117,8 @@ def fn(*args): def test_mean_var(jax_dist, sp_dist, params): if jax_dist is _ImproperWrapper: pytest.skip("Improper distribution does not has mean/var implemented") + if jax_dist is FoldedNormal: + pytest.skip("Folded distribution does not has mean/var implemented") if jax_dist in ( _TruncatedNormal, dist.LeftTruncatedDistribution, From 1c44b1e6269632f6e99e93f7b11363f479c120de Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 1 Jun 2021 12:32:33 -0500 Subject: [PATCH 120/222] Add tests for pathwise derivative (#1051) --- test/test_distributions.py | 63 +++++++++++++++----------------------- 1 file changed, 24 insertions(+), 39 deletions(-) diff --git a/test/test_distributions.py b/test/test_distributions.py index 7c063aafe..bbaa0c6ac 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -12,7 +12,7 @@ import scipy.stats as osp import jax -from jax import grad, jacfwd, lax, vmap +from jax import grad, lax, vmap import jax.numpy as jnp import jax.random as random from jax.scipy.special import expit, logsumexp @@ -680,48 +680,33 @@ def fn(args): @pytest.mark.parametrize( - "jax_dist, sp_dist, params", + "jax_dist, params", [ - (dist.Gamma, osp.gamma, (1.0,)), - (dist.Gamma, osp.gamma, (0.1,)), - (dist.Gamma, osp.gamma, (10.0,)), - (dist.Chi2, osp.chi2, (1.0,)), - (dist.Chi2, osp.chi2, (0.1,)), - (dist.Chi2, osp.chi2, (10.0,)), - # TODO: add more test cases for Beta/StudentT (and Dirichlet too) when - # their pathwise grad (independent of standard_gamma grad) is implemented. - pytest.param( - dist.Beta, - osp.beta, - (1.0, 1.0), - marks=pytest.mark.xfail( - reason="currently, variance of grad of beta sampler is large" - ), - ), - pytest.param( - dist.StudentT, - osp.t, - (1.0,), - marks=pytest.mark.xfail( - reason="currently, variance of grad of t sampler is large" - ), - ), + (dist.Gamma, (1.0,)), + (dist.Gamma, (0.1,)), + (dist.Gamma, (10.0,)), + (dist.Chi2, (1.0,)), + (dist.Chi2, (0.1,)), + (dist.Chi2, (10.0,)), + (dist.Beta, (1.0, 1.0)), + (dist.StudentT, (5.0, 2.0, 4.0)), ], ) -def test_pathwise_gradient(jax_dist, sp_dist, params): +def test_pathwise_gradient(jax_dist, params): rng_key = random.PRNGKey(0) - N = 100 - z = jax_dist(*params).sample(key=rng_key, sample_shape=(N,)) - actual_grad = jacfwd(lambda x: jax_dist(*x).sample(key=rng_key, sample_shape=(N,)))( - params - ) - eps = 1e-3 - for i in range(len(params)): - args_lhs = [p if j != i else p - eps for j, p in enumerate(params)] - args_rhs = [p if j != i else p + eps for j, p in enumerate(params)] - cdf_dot = (sp_dist(*args_rhs).cdf(z) - sp_dist(*args_lhs).cdf(z)) / (2 * eps) - expected_grad = -cdf_dot / sp_dist(*params).pdf(z) - assert_allclose(actual_grad[i], expected_grad, rtol=0.005) + N = 1000000 + + def f(params): + z = jax_dist(*params).sample(key=rng_key, sample_shape=(N,)) + return (z + z ** 2).mean(0) + + def g(params): + d = jax_dist(*params) + return d.mean + d.variance + d.mean ** 2 + + actual_grad = grad(f)(params) + expected_grad = grad(g)(params) + assert_allclose(actual_grad, expected_grad, rtol=0.005) @pytest.mark.parametrize( From 4ad6b98ae3127e0d509ca7ff425cbf07185fbdad Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 4 Jun 2021 11:59:35 -0500 Subject: [PATCH 121/222] Illustrate the usage of infer_discrete in the annotation example (#1043) * first try to make infer_discrete work for scan * fix substituting errors * add todo infer_discrete for annotation example * add infer discrete to annotation * print history in annotation example * mark xfail for nontrivial scan history * make lint * simplify infer discrete code * fix failing test --- examples/annotation.py | 31 +++++++- numpyro/contrib/funsor/discrete.py | 106 ++++++++++----------------- numpyro/contrib/funsor/infer_util.py | 69 ++++++++++------- numpyro/handlers.py | 17 +++-- test/contrib/test_infer_discrete.py | 45 ++++++++++++ test/test_handlers.py | 2 +- 6 files changed, 170 insertions(+), 100 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index da35e89ed..6b7ada33e 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -37,11 +37,12 @@ import numpy as np -from jax import nn, random +from jax import nn, random, vmap import jax.numpy as jnp import numpyro from numpyro import handlers +from numpyro.contrib.funsor import config_enumerate, infer_discrete from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist from numpyro.infer import MCMC, NUTS @@ -312,6 +313,34 @@ def main(args): mcmc.run(random.PRNGKey(0), *data) mcmc.print_summary() + def infer_discrete_model(rng_key, samples): + conditioned_model = handlers.condition(model, data=samples) + infer_discrete_model = infer_discrete( + config_enumerate(conditioned_model), rng_key=rng_key + ) + with handlers.trace() as tr: + infer_discrete_model(*data) + + return { + name: site["value"] + for name, site in tr.items() + if site["type"] == "sample" and site["infer"].get("enumerate") == "parallel" + } + + posterior_samples = mcmc.get_samples() + discrete_samples = vmap(infer_discrete_model)( + random.split(random.PRNGKey(1), args.num_samples), posterior_samples + ) + + item_class = vmap(lambda x: jnp.bincount(x, length=4), in_axes=1)( + discrete_samples["c"].squeeze(-1) + ) + print("Histogram of the predicted class of each item:") + row_format = "{:>10}" * 5 + print(row_format.format("", *["c={}".format(i) for i in range(4)])) + for i, row in enumerate(item_class): + print(row_format.format(f"item[{i}]", *row)) + if __name__ == "__main__": assert numpyro.__version__.startswith("0.6.0") diff --git a/numpyro/contrib/funsor/discrete.py b/numpyro/contrib/funsor/discrete.py index 59ed4513a..72767ff84 100644 --- a/numpyro/contrib/funsor/discrete.py +++ b/numpyro/contrib/funsor/discrete.py @@ -1,16 +1,16 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -from collections import OrderedDict +from collections import OrderedDict, defaultdict import functools from jax import random +import jax.numpy as jnp import funsor -from numpyro.contrib.funsor.enum_messenger import enum, trace as packed_trace -from numpyro.contrib.funsor.infer_util import plate_to_enum_plate -from numpyro.distributions.util import is_identically_one -from numpyro.handlers import block, replay, seed, trace +from numpyro.contrib.funsor.enum_messenger import enum +from numpyro.contrib.funsor.infer_util import _enum_log_density, _get_shift, _shift_name +from numpyro.handlers import block, seed, substitute, trace from numpyro.infer.util import _guess_max_plate_nesting @@ -38,46 +38,6 @@ def _get_support_value_delta(funsor_dist, name, **kwargs): return OrderedDict(funsor_dist.terms)[name][0] -def terms_from_trace(tr): - """Helper function to extract elbo components from execution traces.""" - log_factors = {} - log_measures = {} - sum_vars, prod_vars = frozenset(), frozenset() - for site in tr.values(): - if site["type"] == "sample": - value = site["value"] - intermediates = site["intermediates"] - scale = site["scale"] - if intermediates: - log_prob = site["fn"].log_prob(value, intermediates) - else: - log_prob = site["fn"].log_prob(value) - - if (scale is not None) and (not is_identically_one(scale)): - log_prob = scale * log_prob - - dim_to_name = site["infer"]["dim_to_name"] - log_prob_factor = funsor.to_funsor( - log_prob, output=funsor.Real, dim_to_name=dim_to_name - ) - - if site["is_observed"]: - log_factors[site["name"]] = log_prob_factor - else: - log_measures[site["name"]] = log_prob_factor - sum_vars |= frozenset({site["name"]}) - prod_vars |= frozenset( - f.name for f in site["cond_indep_stack"] if f.dim is not None - ) - - return { - "log_factors": log_factors, - "log_measures": log_measures, - "measure_vars": sum_vars, - "plate_vars": prod_vars, - } - - def _sample_posterior( model, first_available_dim, temperature, rng_key, *args, **kwargs ): @@ -97,27 +57,14 @@ def _sample_posterior( model_trace = trace(seed(model, rng_key)).get_trace(*args, **kwargs) first_available_dim = -_guess_max_plate_nesting(model_trace) - 1 - with block(), enum(first_available_dim=first_available_dim): - with plate_to_enum_plate(): - model_tr = packed_trace(model).get_trace(*args, **kwargs) - - terms = terms_from_trace(model_tr) - # terms["log_factors"] = [log p(x) for each observed or latent sample site x] - # terms["log_measures"] = [log p(z) or other Dice factor - # for each latent sample site z] - - with funsor.interpretations.lazy: - log_prob = funsor.sum_product.sum_product( - sum_op, - prod_op, - list(terms["log_factors"].values()) + list(terms["log_measures"].values()), - eliminate=terms["measure_vars"] | terms["plate_vars"], - plates=terms["plate_vars"], - ) - log_prob = funsor.optimizer.apply_optimizer(log_prob) + with funsor.adjoint.AdjointTape() as tape: + with block(), enum(first_available_dim=first_available_dim): + log_prob, model_tr, log_measures = _enum_log_density( + model, args, kwargs, {}, sum_op, prod_op + ) with approx: - approx_factors = funsor.adjoint.adjoint(sum_op, prod_op, log_prob) + approx_factors = tape.adjoint(sum_op, prod_op, log_prob) # construct a result trace to replay against the model sample_tr = model_tr.copy() @@ -138,13 +85,40 @@ def _sample_posterior( value, name_to_dim=node["infer"]["name_to_dim"] ) else: - log_measure = approx_factors[terms["log_measures"][name]] + log_measure = approx_factors[log_measures[name]] sample_subs[name] = _get_support_value(log_measure, name) node["value"] = funsor.to_data( sample_subs[name], name_to_dim=node["infer"]["name_to_dim"] ) - with replay(guide_trace=sample_tr): + data = { + name: site["value"] + for name, site in sample_tr.items() + if site["type"] == "sample" + } + + # concatenate _PREV_foo to foo + time_vars = defaultdict(list) + for name in data: + if name.startswith("_PREV_"): + root_name = _shift_name(name, -_get_shift(name)) + time_vars[root_name].append(name) + for name in time_vars: + if name in data: + time_vars[name].append(name) + time_vars[name] = sorted(time_vars[name], key=len, reverse=True) + + for root_name, vars in time_vars.items(): + prototype_shape = model_trace[root_name]["value"].shape + values = [data.pop(name) for name in vars] + if len(values) == 1: + data[root_name] = values[0].reshape(prototype_shape) + else: + assert len(prototype_shape) >= 1 + values = [v.reshape((-1,) + prototype_shape[1:]) for v in values] + data[root_name] = jnp.concatenate(values) + + with substitute(data=data): return model(*args, **kwargs) diff --git a/numpyro/contrib/funsor/infer_util.py b/numpyro/contrib/funsor/infer_util.py index 09d94b88f..5a65a2db5 100644 --- a/numpyro/contrib/funsor/infer_util.py +++ b/numpyro/contrib/funsor/infer_util.py @@ -100,6 +100,8 @@ def compute_markov_factors( sum_vars, prod_vars, history, + sum_op, + prod_op, ): """ :param dict time_to_factors: a map from time variable to the log prob factors. @@ -119,8 +121,8 @@ def compute_markov_factors( eliminate_vars = (sum_vars | prod_vars) - time_to_markov_dims[time_var] with funsor.interpretations.lazy: lazy_result = funsor.sum_product.sum_product( - funsor.ops.logaddexp, - funsor.ops.add, + sum_op, + prod_op, log_factors, eliminate=eliminate_vars, plates=prod_vars, @@ -136,7 +138,7 @@ def compute_markov_factors( ) markov_factors.append( funsor.sum_product.sarkka_bilmes_product( - funsor.ops.logaddexp, funsor.ops.add, trans, time_var, global_vars + sum_op, prod_op, trans, time_var, global_vars ) ) else: @@ -144,33 +146,14 @@ def compute_markov_factors( prev_to_curr = {k: _shift_name(k, -_get_shift(k)) for k in prev_vars} markov_factors.append( funsor.sum_product.sequential_sum_product( - funsor.ops.logaddexp, funsor.ops.add, trans, time_var, prev_to_curr + sum_op, prod_op, trans, time_var, prev_to_curr ) ) return markov_factors -def log_density(model, model_args, model_kwargs, params): - """ - Similar to :func:`numpyro.infer.util.log_density` but works for models - with discrete latent variables. Internally, this uses :mod:`funsor` - to marginalize discrete latent sites and evaluate the joint log probability. - - :param model: Python callable containing NumPyro primitives. Typically, - the model has been enumerated by using - :class:`~numpyro.contrib.funsor.enum_messenger.enum` handler:: - - def model(*args, **kwargs): - ... - - log_joint = log_density(enum(config_enumerate(model)), args, kwargs, params) - - :param tuple model_args: args provided to the model. - :param dict model_kwargs: kwargs provided to the model. - :param dict params: dictionary of current parameter values keyed by site - name. - :return: log of joint density and a corresponding model trace - """ +def _enum_log_density(model, model_args, model_kwargs, params, sum_op, prod_op): + """Helper function to compute elbo and extract its components from execution traces.""" model = substitute(model, data=params) with plate_to_enum_plate(): model_trace = packed_trace(model).get_trace(*model_args, **model_kwargs) @@ -180,6 +163,7 @@ def model(*args, **kwargs): time_to_markov_dims = defaultdict(frozenset) # dimensions at markov sites sum_vars, prod_vars = frozenset(), frozenset() history = 1 + log_measures = {} for site in model_trace.values(): if site["type"] == "sample": value = site["value"] @@ -214,7 +198,9 @@ def model(*args, **kwargs): log_factors.append(log_prob_factor) if not site["is_observed"]: + log_measures[site["name"]] = log_prob_factor sum_vars |= frozenset({site["name"]}) + prod_vars |= frozenset( f.name for f in site["cond_indep_stack"] if f.dim is not None ) @@ -236,13 +222,15 @@ def model(*args, **kwargs): sum_vars, prod_vars, history, + sum_op, + prod_op, ) log_factors = log_factors + markov_factors with funsor.interpretations.lazy: lazy_result = funsor.sum_product.sum_product( - funsor.ops.logaddexp, - funsor.ops.add, + sum_op, + prod_op, log_factors, eliminate=sum_vars | prod_vars, plates=prod_vars, @@ -255,4 +243,31 @@ def model(*args, **kwargs): result.data.shape, {k.split("__BOUND")[0] for k in result.inputs} ) ) + return result, model_trace, log_measures + + +def log_density(model, model_args, model_kwargs, params): + """ + Similar to :func:`numpyro.infer.util.log_density` but works for models + with discrete latent variables. Internally, this uses :mod:`funsor` + to marginalize discrete latent sites and evaluate the joint log probability. + + :param model: Python callable containing NumPyro primitives. Typically, + the model has been enumerated by using + :class:`~numpyro.contrib.funsor.enum_messenger.enum` handler:: + + def model(*args, **kwargs): + ... + + log_joint = log_density(enum(config_enumerate(model)), args, kwargs, params) + + :param tuple model_args: args provided to the model. + :param dict model_kwargs: kwargs provided to the model. + :param dict params: dictionary of current parameter values keyed by site + name. + :return: log of joint density and a corresponding model trace + """ + result, model_trace, _ = _enum_log_density( + model, model_args, model_kwargs, params, funsor.ops.logaddexp, funsor.ops.add + ) return result.data, model_trace diff --git a/numpyro/handlers.py b/numpyro/handlers.py index e4d736a27..53be5116d 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -196,14 +196,21 @@ class replay(Messenger): >>> assert replayed_trace['a']['value'] == exec_trace['a']['value'] """ - def __init__(self, fn=None, guide_trace=None): - assert guide_trace is not None - self.guide_trace = guide_trace + def __init__(self, fn=None, trace=None, guide_trace=None): + if guide_trace is not None: + warnings.warn( + "`guide_trace` argument is deprecated. Please replace it by `trace`.", + FutureWarning, + ) + if guide_trace is not None: + trace = guide_trace + assert trace is not None + self.trace = trace super(replay, self).__init__(fn) def process_message(self, msg): - if msg["type"] in ("sample", "plate") and msg["name"] in self.guide_trace: - msg["value"] = self.guide_trace[msg["name"]]["value"] + if msg["type"] in ("sample", "plate") and msg["name"] in self.trace: + msg["value"] = self.trace[msg["name"]]["value"] class block(Messenger): diff --git a/test/contrib/test_infer_discrete.py b/test/contrib/test_infer_discrete.py index 2de58ad77..dd364531e 100644 --- a/test/contrib/test_infer_discrete.py +++ b/test/contrib/test_infer_discrete.py @@ -12,6 +12,7 @@ import numpyro from numpyro import handlers, infer +from numpyro.contrib.control_flow import scan import numpyro.distributions as dist from numpyro.distributions.util import is_identically_one @@ -81,6 +82,50 @@ def hmm(data, hidden_dim=10): logger.info("inferred states: {}".format(list(map(int, inferred_states)))) +@pytest.mark.parametrize( + "length", + [ + 1, + 2, + pytest.param( + 10, + marks=pytest.mark.xfail( + reason="adjoint does not work with markov sum product yet." + ), + ), + ], +) +@pytest.mark.parametrize("temperature", [0, 1]) +def test_scan_hmm_smoke(length, temperature): + + # This should match the example in the infer_discrete docstring. + def hmm(data, hidden_dim=10): + transition = 0.3 / hidden_dim + 0.7 * jnp.eye(hidden_dim) + means = jnp.arange(float(hidden_dim)) + + def transition_fn(state, y): + state = numpyro.sample("states", dist.Categorical(transition[state])) + y = numpyro.sample("obs", dist.Normal(means[state], 1.0), obs=y) + return state, (state, y) + + _, (states, data) = scan(transition_fn, 0, data, length=length) + + return [0] + [s for s in states], data + + true_states, data = handlers.seed(hmm, 0)(None) + assert len(data) == length + assert len(true_states) == 1 + len(data) + + decoder = infer_discrete( + config_enumerate(hmm), temperature=temperature, rng_key=random.PRNGKey(1) + ) + inferred_states, _ = decoder(data) + assert len(inferred_states) == len(true_states) + + logger.info("true states: {}".format(list(map(int, true_states)))) + logger.info("inferred states: {}".format(list(map(int, inferred_states)))) + + def vectorize_model(model, size, dim): def fn(*args, **kwargs): with numpyro.plate("particles", size=size, dim=dim): diff --git a/test/test_handlers.py b/test/test_handlers.py index ccdfe9c66..a58926278 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -383,7 +383,7 @@ def test_subsample_replay(): with numpyro.plate("a", len(data), subsample_size=subsample_size): pass - with handlers.seed(rng_seed=1), handlers.replay(guide_trace=guide_trace): + with handlers.seed(rng_seed=1), handlers.replay(trace=guide_trace): with numpyro.plate("a", len(data)): subsample_data = numpyro.subsample(data, event_dim=0) assert subsample_data.shape == (subsample_size,) From f212f32cee5fbe8005fe41d506e5bc17135ccf56 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 8 Jun 2021 09:08:47 -0500 Subject: [PATCH 122/222] fix loc scale reparam with center=1 (#1059) --- numpyro/infer/reparam.py | 2 +- test/infer/test_reparam.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index e7363a3c4..54bdb729d 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -89,7 +89,7 @@ def __call__(self, name, fn, obs): assert obs is None, "LocScaleReparam does not support observe statements" centered = self.centered if is_identically_one(centered): - return name, fn, obs + return fn, obs event_shape = fn.event_shape fn, expand_shape, event_dim = self._unwrap(fn) diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index 98e992a86..2f335bdfb 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -217,9 +217,9 @@ def get_expected_probe(loc, scale): return get_moments(trace["x"]["value"]) if "dist_type" == "Normal": - reparam = LocScaleReparam() + reparam = LocScaleReparam(centered) else: - reparam = LocScaleReparam(shape_params=["df"]) + reparam = LocScaleReparam(centered, shape_params=["df"]) def get_actual_probe(loc, scale): with numpyro.handlers.trace() as trace: From 63b4b67006add23b6b03148c1eb2f64c18ab7f4d Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 20 Jun 2021 16:17:54 -0500 Subject: [PATCH 123/222] Raise helpful support errors (#1069) --- docs/requirements.txt | 2 +- numpyro/infer/autoguide.py | 14 +++++-- numpyro/infer/initialization.py | 6 ++- numpyro/infer/svi.py | 5 ++- numpyro/infer/util.py | 35 ++++++++++++++-- setup.py | 3 +- test/infer/test_autoguide.py | 71 ++++++++++++++++++++++++++++++++- 7 files changed, 122 insertions(+), 14 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index afe85da6b..d7f878f7c 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -6,5 +6,5 @@ jaxlib>=0.1.45 optax==0.0.6 nbsphinx>=0.8.5 sphinx-gallery -tfp-nightly # TODO: change this to tensorflow-probability when it is stable +tfp-nightly<=0.14.0.dev20210608 # TODO: change this to tensorflow-probability when it is stable tqdm diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index e7a8dc1cb..8a2274dba 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -36,8 +36,8 @@ sum_rightmost, ) from numpyro.infer.elbo import Trace_ELBO -from numpyro.infer.initialization import init_to_median -from numpyro.infer.util import init_to_uniform, initialize_model +from numpyro.infer.initialization import init_to_median, init_to_uniform +from numpyro.infer.util import helpful_support_errors, initialize_model from numpyro.nn.auto_reg_nn import AutoregressiveNN from numpyro.nn.block_neural_arn import BlockNeuralAutoregressiveNN from numpyro.util import not_jax_tracer @@ -147,6 +147,10 @@ def _setup_prototype(self, *args, **kwargs): self._prototype_plate_sizes = {} for name, site in self.prototype_trace.items(): if site["type"] == "sample": + if not site["is_observed"] and site["fn"].is_discrete: + # raise support errors early for discrete sites + with helpful_support_errors(site): + biject_to(site["fn"].support) for frame in site["cond_indep_stack"]: if frame.name in self._prototype_frames: assert ( @@ -266,7 +270,8 @@ def __call__(self, *args, **kwargs): ): result[name] = numpyro.sample(name, site_fn) else: - transform = biject_to(site["fn"].support) + with helpful_support_errors(site): + transform = biject_to(site["fn"].support) guide_dist = dist.TransformedDistribution(site_fn, transform) result[name] = numpyro.sample(name, guide_dist) @@ -485,7 +490,8 @@ def __call__(self, *args, **kwargs): for name, unconstrained_value in self._unpack_latent(latent).items(): site = self.prototype_trace[name] - transform = biject_to(site["fn"].support) + with helpful_support_errors(site): + transform = biject_to(site["fn"].support) value = transform(unconstrained_value) event_ndim = site["fn"].event_dim if numpyro.get_mask() is False: diff --git a/numpyro/infer/initialization.py b/numpyro/infer/initialization.py index d1a2d1912..8aacef780 100644 --- a/numpyro/infer/initialization.py +++ b/numpyro/infer/initialization.py @@ -58,11 +58,15 @@ def init_to_uniform(site=None, radius=2): and not site["is_observed"] and not site["fn"].is_discrete ): + # XXX: we import here to avoid circular import + from numpyro.infer.util import helpful_support_errors + rng_key = site["kwargs"].get("rng_key") sample_shape = site["kwargs"].get("sample_shape") rng_key, subkey = random.split(rng_key) - transform = biject_to(site["fn"].support) + with helpful_support_errors(site): + transform = biject_to(site["fn"].support) unconstrained_shape = transform.inverse_shape(site["fn"].shape()) unconstrained_samples = dist.Uniform(-radius, radius)( rng_key=rng_key, sample_shape=sample_shape + unconstrained_shape diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 5cbf15d85..ddf120644 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -14,7 +14,7 @@ from numpyro.distributions import constraints from numpyro.distributions.transforms import biject_to from numpyro.handlers import replay, seed, trace -from numpyro.infer.util import transform_fn +from numpyro.infer.util import helpful_support_errors, transform_fn from numpyro.optim import _NumPyroOptim SVIState = namedtuple("SVIState", ["optim_state", "rng_key"]) @@ -154,7 +154,8 @@ def init(self, rng_key, *args, **kwargs): for site in list(model_trace.values()) + list(guide_trace.values()): if site["type"] == "param": constraint = site["kwargs"].pop("constraint", constraints.real) - transform = biject_to(constraint) + with helpful_support_errors(site): + transform = biject_to(constraint) inv_transforms[site["name"]] = transform params[site["name"]] = transform.inv(site["value"]) elif ( diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 6d8a2a349..d24f730dc 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 from collections import namedtuple +from contextlib import contextmanager from functools import partial import warnings @@ -107,7 +108,8 @@ def constrain_fn(model, model_args, model_kwargs, params, return_deterministic=F def substitute_fn(site): if site["name"] in params: if site["type"] == "sample": - return biject_to(site["fn"].support)(params[site["name"]]) + with helpful_support_errors(site): + return biject_to(site["fn"].support)(params[site["name"]]) else: return params[site["name"]] @@ -125,7 +127,8 @@ def _unconstrain_reparam(params, site): if name in params: p = params[name] support = site["fn"].support - t = biject_to(support) + with helpful_support_errors(site): + t = biject_to(support) # in scan, we might only want to substitute an item at index i, rather than the whole sequence i = site["infer"].get("_scan_current_index", None) if i is not None: @@ -263,7 +266,8 @@ def body_fn(state): and not v["fn"].is_discrete ): constrained_values[k] = v["value"] - inv_transforms[k] = biject_to(v["fn"].support) + with helpful_support_errors(v): + inv_transforms[k] = biject_to(v["fn"].support) params = transform_fn( inv_transforms, {k: v for k, v in constrained_values.items()}, @@ -343,7 +347,8 @@ def _get_model_transforms(model, model_args=(), model_kwargs=None): ) else: support = v["fn"].support - inv_transforms[k] = biject_to(support) + with helpful_support_errors(v): + inv_transforms[k] = biject_to(support) # XXX: the following code filters out most situations with dynamic supports args = () if isinstance(support, constraints._GreaterThan): @@ -844,3 +849,25 @@ def single_loglik(samples): batch_size = int(np.prod(batch_shape)) chunk_size = batch_size if parallel else 1 return soft_vmap(single_loglik, posterior_samples, len(batch_shape), chunk_size) + + +@contextmanager +def helpful_support_errors(site): + try: + yield + except NotImplementedError as e: + name = site["name"] + support_name = repr(site["fn"].support).lower() + if "integer" in support_name or "boolean" in support_name: + # TODO: mention enumeration when it is supported in SVI + raise ValueError( + f"Continuous inference cannot handle discrete sample site '{name}'." + ) + if "sphere" in support_name: + raise ValueError( + f"Continuous inference cannot handle spherical sample site '{name}'. " + "Consider using ProjectedNormal distribution together with " + "a reparameterizer, e.g. " + f"numpyro.handlers.reparam(config={{'{name}': ProjectedNormalReparam()}})." + ) + raise e from None diff --git a/setup.py b/setup.py index ca45c3977..b43b3913a 100644 --- a/setup.py +++ b/setup.py @@ -61,7 +61,8 @@ "optax==0.0.6", # TODO: change this to tensorflow_probability>0.12.1 when the next version # of tfp is released. The current release is not compatible with jax>=0.2.12. - "tfp-nightly", + # TODO: relax this restriction when we revise tfp wrapper + "tfp-nightly<=0.14.0.dev20210608", ], "examples": ["arviz", "jupyter", "matplotlib", "pandas", "seaborn"], }, diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index bb16cd166..606f2f08d 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -29,7 +29,12 @@ AutoMultivariateNormal, AutoNormal, ) -from numpyro.infer.initialization import init_to_median +from numpyro.infer.initialization import ( + init_to_feasible, + init_to_median, + init_to_sample, + init_to_uniform, +) from numpyro.infer.reparam import TransformReparam from numpyro.infer.util import Predictive from numpyro.nn.auto_reg_nn import AutoregressiveNN @@ -496,3 +501,67 @@ def model(): svi = SVI(model, guide, numpyro.optim.Adam(step_size=0.1), Trace_ELBO()) with pytest.raises(AssertionError, match="has inconsistent dim or size"): svi.run(random.PRNGKey(0), 10) + + +@pytest.mark.parametrize( + "auto_class", + [ + AutoDelta, + AutoDiagonalNormal, + AutoMultivariateNormal, + AutoNormal, + AutoLowRankMultivariateNormal, + AutoLaplaceApproximation, + ], +) +@pytest.mark.parametrize( + "init_loc_fn", + [ + init_to_feasible, + init_to_median, + init_to_sample, + init_to_uniform, + ], +) +def test_discrete_helpful_error(auto_class, init_loc_fn): + def model(): + p = numpyro.sample("p", dist.Beta(2.0, 2.0)) + x = numpyro.sample("x", dist.Bernoulli(p)) + numpyro.sample( + "obs", dist.Bernoulli(p * x + (1 - p) * (1 - x)), obs=jnp.array([1.0, 0.0]) + ) + + guide = auto_class(model, init_loc_fn=init_loc_fn) + with pytest.raises(ValueError, match=".*handle discrete.*"): + handlers.seed(guide, 0)() + + +@pytest.mark.parametrize( + "auto_class", + [ + AutoDelta, + AutoDiagonalNormal, + AutoMultivariateNormal, + AutoNormal, + AutoLowRankMultivariateNormal, + AutoLaplaceApproximation, + ], +) +@pytest.mark.parametrize( + "init_loc_fn", + [ + init_to_feasible, + init_to_median, + init_to_sample, + init_to_uniform, + ], +) +def test_sphere_helpful_error(auto_class, init_loc_fn): + def model(): + x = numpyro.sample("x", dist.Normal(0.0, 1.0).expand([2]).to_event(1)) + y = numpyro.sample("y", dist.ProjectedNormal(x)) + numpyro.sample("obs", dist.Normal(y, 1), obs=jnp.array([1.0, 0.0])) + + guide = auto_class(model, init_loc_fn=init_loc_fn) + with pytest.raises(ValueError, match=".*ProjectedNormalReparam.*"): + handlers.seed(guide, 0)() From ca6811bfc7f4fae9d93f012e13b252acacb1213b Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 22 Jun 2021 10:08:59 -0500 Subject: [PATCH 124/222] Add TraceGraph_ELBO (#1044) * temp save * update elbo * fix some isseus * add TraceGraph_ELBO * add tests for TraceGraph * add docs for TraceGraph_ELBO * fix sign bug and disable gradient for no rsample distribution * make format * fix lint * fix typo at Delta distribution * reduce the scope of has_rsample effect * make format * mark EXPERIMENTAL and add note * addresses comments and add more tests * add gaussian chain test * fix typos catched by reviewer * clear cached values --- docs/source/svi.rst | 11 + numpyro/distributions/distribution.py | 2 +- numpyro/infer/__init__.py | 9 +- numpyro/infer/elbo.py | 265 +++++++++++++- numpyro/infer/util.py | 51 ++- test/infer/test_compute_downstream_costs.py | 369 ++++++++++++++++++++ test/infer/test_svi.py | 267 +++++++++++++- 7 files changed, 969 insertions(+), 5 deletions(-) create mode 100644 test/infer/test_compute_downstream_costs.py diff --git a/docs/source/svi.rst b/docs/source/svi.rst index 7281ef62e..ed71d4c2a 100644 --- a/docs/source/svi.rst +++ b/docs/source/svi.rst @@ -25,6 +25,17 @@ Trace_ELBO :show-inheritance: :member-order: bysource + +TraceGraph_ELBO +--------------- + +.. autoclass:: numpyro.infer.elbo.TraceGraph_ELBO + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + + TraceMeanField_ELBO ------------------- diff --git a/numpyro/distributions/distribution.py b/numpyro/distributions/distribution.py index f65751d55..97fe10d60 100644 --- a/numpyro/distributions/distribution.py +++ b/numpyro/distributions/distribution.py @@ -1089,7 +1089,7 @@ class Delta(Distribution): "v": constraints.dependent(is_discrete=False), "log_density": constraints.real, } - reparameterized_params = ["v", "log_density"] + reparametrized_params = ["v", "log_density"] def __init__(self, v=0.0, log_density=0.0, event_dim=0, validate_args=None): if event_dim > jnp.ndim(v): diff --git a/numpyro/infer/__init__.py b/numpyro/infer/__init__.py index 11fa0a553..b26ec5f92 100644 --- a/numpyro/infer/__init__.py +++ b/numpyro/infer/__init__.py @@ -2,7 +2,13 @@ # SPDX-License-Identifier: Apache-2.0 from numpyro.infer.barker import BarkerMH -from numpyro.infer.elbo import ELBO, RenyiELBO, Trace_ELBO, TraceMeanField_ELBO +from numpyro.infer.elbo import ( + ELBO, + RenyiELBO, + Trace_ELBO, + TraceGraph_ELBO, + TraceMeanField_ELBO, +) from numpyro.infer.hmc import HMC, NUTS from numpyro.infer.hmc_gibbs import HMCECS, DiscreteHMCGibbs, HMCGibbs from numpyro.infer.initialization import ( @@ -43,5 +49,6 @@ "SA", "SVI", "Trace_ELBO", + "TraceGraph_ELBO", "TraceMeanField_ELBO", ] diff --git a/numpyro/infer/elbo.py b/numpyro/infer/elbo.py index e251f0320..a816847c2 100644 --- a/numpyro/infer/elbo.py +++ b/numpyro/infer/elbo.py @@ -1,6 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +from operator import itemgetter import warnings from jax import random, vmap @@ -11,7 +12,7 @@ from numpyro.distributions.kl import kl_divergence from numpyro.distributions.util import scale_and_mask from numpyro.handlers import replay, seed, substitute, trace -from numpyro.infer.util import log_density +from numpyro.infer.util import get_importance_trace, log_density class Trace_ELBO: @@ -280,3 +281,265 @@ def single_particle_elbo(rng_key): renyi_elbo = avg_log_exp / (1.0 - self.alpha) weighted_elbo = jnp.dot(stop_gradient(weights), elbos) / self.num_particles return -(stop_gradient(renyi_elbo - weighted_elbo) + weighted_elbo) + + +def _get_plate_stacks(trace): + """ + This builds a dict mapping site name to a set of plate stacks. Each + plate stack is a list of :class:`CondIndepStackFrame`s corresponding to + a :class:`plate`. This information is used by :class:`Trace_ELBO` and + :class:`TraceGraph_ELBO`. + """ + return { + name: [f for f in node["cond_indep_stack"]] + for name, node in trace.items() + if node["type"] == "sample" + } + + +class MultiFrameTensor(dict): + """ + A container for sums of Tensors among different :class:`plate` contexts. + Used in :class:`~numpyro.infer.elbo.TraceGraph_ELBO` to simplify + downstream cost computation logic. + + Example:: + + downstream_cost = MultiFrameTensor() + for site in downstream_nodes: + downstream_cost.add((site["cond_indep_stack"], site["log_prob"])) + downstream_cost.add(*other_costs.items()) # add in bulk + summed = downstream_cost.sum_to(target_site["cond_indep_stack"]) + """ + + def __init__(self, *items): + super().__init__() + self.add(*items) + + def add(self, *items): + """ + Add a collection of (cond_indep_stack, tensor) pairs. Keys are + ``cond_indep_stack``s, i.e. tuples of :class:`CondIndepStackFrame`s. + Values are :class:`numpy.ndarray`s. + """ + for cond_indep_stack, value in items: + frames = frozenset(f for f in cond_indep_stack) + assert all(f.dim < 0 and -jnp.ndim(value) <= f.dim for f in frames) + if frames in self: + self[frames] = self[frames] + value + else: + self[frames] = value + + def sum_to(self, target_frames): + total = None + for frames, value in self.items(): + for f in frames: + if f not in target_frames and jnp.shape(value)[f.dim] != 1: + value = value.sum(f.dim, keepdims=True) + while jnp.shape(value) and jnp.shape(value)[0] == 1: + value = value.squeeze(0) + total = value if total is None else total + value + return 0.0 if total is None else total + + def __repr__(self): + return "%s(%s)" % ( + type(self).__name__, + ",\n\t".join(["({}, ...)".format(frames) for frames in self]), + ) + + +def _identify_dense_edges(trace): + succ = {} + for name, node in trace.items(): + if node["type"] == "sample": + succ[name] = set() + for name, node in trace.items(): + if node["type"] == "sample": + for past_name, past_node in trace.items(): + if past_node["type"] == "sample": + if past_name == name: + break + # XXX: different from Pyro, we always add edge past_name -> name + succ[past_name].add(name) + return succ + + +def _topological_sort(succ, reverse=False): + """ + Return a list of nodes (site names) in topologically sorted order. + """ + + def dfs(site, visited): + if site in visited: + return + for s in succ[site]: + for node in dfs(s, visited): + yield node + visited.add(site) + yield site + + visited = set() + top_sorted = [] + for s in succ: + for node in dfs(s, visited): + top_sorted.append(node) + return top_sorted if reverse else list(reversed(top_sorted)) + + +def _compute_downstream_costs(model_trace, guide_trace, non_reparam_nodes): + model_successors = _identify_dense_edges(model_trace) + guide_successors = _identify_dense_edges(guide_trace) + # recursively compute downstream cost nodes for all sample sites in model and guide + # (even though ultimately just need for non-reparameterizable sample sites) + # 1. downstream costs used for rao-blackwellization + # 2. model observe sites (as well as terms that arise from the model and guide having different + # dependency structures) are taken care of via 'children_in_model' below + topo_sort_guide_nodes = _topological_sort(guide_successors, reverse=True) + topo_sort_guide_nodes = [ + x for x in topo_sort_guide_nodes if guide_trace[x]["type"] == "sample" + ] + ordered_guide_nodes_dict = {n: i for i, n in enumerate(topo_sort_guide_nodes)} + + downstream_guide_cost_nodes = {} + downstream_costs = {} + stacks = _get_plate_stacks(model_trace) + + for node in topo_sort_guide_nodes: + downstream_costs[node] = MultiFrameTensor( + ( + stacks[node], + model_trace[node]["log_prob"] - guide_trace[node]["log_prob"], + ) + ) + nodes_included_in_sum = set([node]) + downstream_guide_cost_nodes[node] = set([node]) + # make more efficient by ordering children appropriately (higher children first) + children = [(k, -ordered_guide_nodes_dict[k]) for k in guide_successors[node]] + sorted_children = sorted(children, key=itemgetter(1)) + for child, _ in sorted_children: + child_cost_nodes = downstream_guide_cost_nodes[child] + downstream_guide_cost_nodes[node].update(child_cost_nodes) + if nodes_included_in_sum.isdisjoint(child_cost_nodes): # avoid duplicates + downstream_costs[node].add(*downstream_costs[child].items()) + # XXX nodes_included_in_sum logic could be more fine-grained, possibly leading + # to speed-ups in case there are many duplicates + nodes_included_in_sum.update(child_cost_nodes) + missing_downstream_costs = ( + downstream_guide_cost_nodes[node] - nodes_included_in_sum + ) + # include terms we missed because we had to avoid duplicates + for missing_node in missing_downstream_costs: + downstream_costs[node].add( + ( + stacks[missing_node], + model_trace[missing_node]["log_prob"] + - guide_trace[missing_node]["log_prob"], + ) + ) + + # finish assembling complete downstream costs + # (the above computation may be missing terms from model) + for site in non_reparam_nodes: + children_in_model = set() + for node in downstream_guide_cost_nodes[site]: + children_in_model.update(model_successors[node]) + # remove terms accounted for above + children_in_model.difference_update(downstream_guide_cost_nodes[site]) + for child in children_in_model: + assert model_trace[child]["type"] == "sample" + downstream_costs[site].add((stacks[child], model_trace[child]["log_prob"])) + downstream_guide_cost_nodes[site].update([child]) + + for k in non_reparam_nodes: + downstream_costs[k] = downstream_costs[k].sum_to( + guide_trace[k]["cond_indep_stack"] + ) + + return downstream_costs, downstream_guide_cost_nodes + + +class TraceGraph_ELBO: + """ + A TraceGraph implementation of ELBO-based SVI. The gradient estimator + is constructed along the lines of reference [1] specialized to the case + of the ELBO. It supports arbitrary dependency structure for the model + and guide. + Where possible, conditional dependency information as recorded in the + trace is used to reduce the variance of the gradient estimator. + In particular two kinds of conditional dependency information are + used to reduce variance: + + - the sequential order of samples (z is sampled after y => y does not depend on z) + - :class:`~numpyro.plate` generators + + References + + [1] `Gradient Estimation Using Stochastic Computation Graphs`, + John Schulman, Nicolas Heess, Theophane Weber, Pieter Abbeel + """ + + def __init__(self, num_particles=1): + self.num_particles = num_particles + + def loss(self, rng_key, param_map, model, guide, *args, **kwargs): + """ + Evaluates the ELBO with an estimator that uses num_particles many samples/particles. + + :param jax.random.PRNGKey rng_key: random number generator seed. + :param dict param_map: dictionary of current parameter values keyed by site + name. + :param model: Python callable with NumPyro primitives for the model. + :param guide: Python callable with NumPyro primitives for the guide. + :param args: arguments to the model / guide (these can possibly vary during + the course of fitting). + :param kwargs: keyword arguments to the model / guide (these can possibly vary + during the course of fitting). + :return: negative of the Evidence Lower Bound (ELBO) to be minimized. + """ + + def single_particle_elbo(rng_key): + model_seed, guide_seed = random.split(rng_key) + seeded_model = seed(model, model_seed) + seeded_guide = seed(guide, guide_seed) + model_trace, guide_trace = get_importance_trace( + seeded_model, seeded_guide, args, kwargs, param_map + ) + + # XXX: different from Pyro, we don't support baseline_loss here + non_reparam_nodes = { + name + for name, site in guide_trace.items() + if site["type"] == "sample" + and (not site["is_observed"]) + and (not site["fn"].has_rsample) + } + if non_reparam_nodes: + downstream_costs, _ = _compute_downstream_costs( + model_trace, guide_trace, non_reparam_nodes + ) + + elbo = 0.0 + for site in model_trace.values(): + if site["type"] == "sample": + elbo = elbo + jnp.sum(site["log_prob"]) + for name, site in guide_trace.items(): + if site["type"] == "sample": + log_prob_sum = jnp.sum(site["log_prob"]) + if name in non_reparam_nodes: + surrogate = jnp.sum( + site["log_prob"] * stop_gradient(downstream_costs[name]) + ) + log_prob_sum = ( + stop_gradient(log_prob_sum + surrogate) - surrogate + ) + elbo = elbo - log_prob_sum + + return elbo + + # Return (-elbo) since by convention we do gradient descent on a loss and + # the ELBO is a lower bound that needs to be maximized. + if self.num_particles == 1: + return -single_particle_elbo(rng_key) + else: + rng_keys = random.split(rng_key, self.num_particles) + return -jnp.mean(vmap(single_particle_elbo)(rng_keys)) diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index d24f730dc..b4aee6ad5 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -16,7 +16,7 @@ from numpyro.distributions import constraints from numpyro.distributions.transforms import biject_to from numpyro.distributions.util import is_identically_one, sum_rightmost -from numpyro.handlers import seed, substitute, trace +from numpyro.handlers import replay, seed, substitute, trace from numpyro.infer.initialization import init_to_uniform, init_to_value from numpyro.util import not_jax_tracer, soft_vmap, while_loop @@ -69,6 +69,55 @@ def log_density(model, model_args, model_kwargs, params): return log_joint, model_trace +class _without_rsample_stop_gradient(numpyro.primitives.Messenger): + """ + Stop gradient for samples at latent sample sites for which has_rsample=False. + """ + + def postprocess_message(self, msg): + if ( + msg["type"] == "sample" + and (not msg["is_observed"]) + and (not msg["fn"].has_rsample) + ): + msg["value"] = lax.stop_gradient(msg["value"]) + # TODO: reconsider this logic + # here we clear all the cached value so that gradients of log_prob(value) w.r.t. + # all parameters of the transformed distributions match the behavior of + # TransformedDistribution(d, transform) in Pyro with transform.cache_size == 0 + msg["intermediates"] = None + + +def get_importance_trace(model, guide, args, kwargs, params): + """ + (EXPERIMENTAL) Returns traces from the guide and the model that is run against it. + The returned traces also store the log probability at each site. + + .. note:: Gradients are blocked at latent sites which do not have reparametrized samplers. + """ + guide = substitute(guide, data=params) + with _without_rsample_stop_gradient(): + guide_trace = trace(guide).get_trace(*args, **kwargs) + model = substitute(replay(model, guide_trace), data=params) + model_trace = trace(model).get_trace(*args, **kwargs) + for tr in (guide_trace, model_trace): + for site in tr.values(): + if site["type"] == "sample": + if "log_prob" not in site: + value = site["value"] + intermediates = site["intermediates"] + scale = site["scale"] + if intermediates: + log_prob = site["fn"].log_prob(value, intermediates) + else: + log_prob = site["fn"].log_prob(value) + + if (scale is not None) and (not is_identically_one(scale)): + log_prob = scale * log_prob + site["log_prob"] = log_prob + return model_trace, guide_trace + + def transform_fn(transforms, params, invert=False): """ (EXPERIMENTAL INTERFACE) Callable that applies a transformation from the `transforms` diff --git a/test/infer/test_compute_downstream_costs.py b/test/infer/test_compute_downstream_costs.py new file mode 100644 index 000000000..38d770995 --- /dev/null +++ b/test/infer/test_compute_downstream_costs.py @@ -0,0 +1,369 @@ +# Copyright Contributors to the Pyro project. +# Copyright (c) 2017-2019 Uber Technologies, Inc. +# SPDX-License-Identifier: Apache-2.0 + +import math + +from numpy.testing import assert_allclose +import pytest + +import jax.numpy as jnp + +import numpyro +import numpyro.distributions as dist +import numpyro.handlers as handlers +from numpyro.infer.elbo import ( + MultiFrameTensor, + _compute_downstream_costs, + _get_plate_stacks, + _identify_dense_edges, +) + + +def _brute_force_compute_downstream_costs( + model_trace, guide_trace, non_reparam_nodes # +): + + model_successors = _identify_dense_edges(model_trace) + guide_successors = _identify_dense_edges(guide_trace) + guide_nodes = [x for x in guide_trace if guide_trace[x]["type"] == "sample"] + downstream_costs, downstream_guide_cost_nodes = {}, {} + stacks = _get_plate_stacks(model_trace) + + for node in guide_nodes: + downstream_costs[node] = MultiFrameTensor( + ( + stacks[node], + model_trace[node]["log_prob"] - guide_trace[node]["log_prob"], + ) + ) + downstream_guide_cost_nodes[node] = set([node]) + + descendants = guide_successors[node] + + for desc in descendants: + desc_mft = MultiFrameTensor( + ( + stacks[desc], + model_trace[desc]["log_prob"] - guide_trace[desc]["log_prob"], + ) + ) + downstream_costs[node].add(*desc_mft.items()) + downstream_guide_cost_nodes[node].update([desc]) + + for site in non_reparam_nodes: + children_in_model = set() + for node in downstream_guide_cost_nodes[site]: + children_in_model.update(model_successors[node]) + children_in_model.difference_update(downstream_guide_cost_nodes[site]) + for child in children_in_model: + assert model_trace[child]["type"] == "sample" + child_mft = MultiFrameTensor( + (stacks[child], model_trace[child]["log_prob"]) + ) + downstream_costs[site].add(*child_mft.items()) + downstream_guide_cost_nodes[site].update([child]) + + for k in non_reparam_nodes: + downstream_costs[k] = downstream_costs[k].sum_to( + guide_trace[k]["cond_indep_stack"] + ) + + return downstream_costs, downstream_guide_cost_nodes + + +def big_model_guide( + include_obs=True, + include_single=False, + include_inner_1=False, + flip_c23=False, + include_triple=False, + include_z1=False, +): + p0 = math.exp(-0.20) + p1 = math.exp(-0.33) + p2 = math.exp(-0.70) + if include_triple: + with numpyro.plate("plate_triple1", 6) as ind_triple1: + with numpyro.plate("plate_triple2", 7) as ind_triple2: + if include_z1: + numpyro.sample( + "z1", + dist.Bernoulli(p2).expand_by( + [len(ind_triple2), len(ind_triple1)] + ), + ) + with numpyro.plate("plate_triple3", 9) as ind_triple3: + numpyro.sample( + "z0", + dist.Bernoulli(p2).expand_by( + [len(ind_triple3), len(ind_triple2), len(ind_triple1)] + ), + ) + numpyro.sample("a1", dist.Bernoulli(p0)) + if include_single: + with numpyro.plate("plate_single", 5) as ind_single: + b0 = numpyro.sample("b0", dist.Bernoulli(p0).expand_by([len(ind_single)])) + assert b0.shape == (5,) + with numpyro.plate("plate_outer", 2) as ind_outer: + numpyro.sample("b1", dist.Bernoulli(p0).expand_by([len(ind_outer)])) + if include_inner_1: + with numpyro.plate("plate_inner_1", 3) as ind_inner: + numpyro.sample( + "c1", dist.Bernoulli(p1).expand_by([len(ind_inner), len(ind_outer)]) + ) + if flip_c23 and not include_obs: + numpyro.sample( + "c3", + dist.Bernoulli(p0).expand_by([len(ind_inner), len(ind_outer)]), + ) + numpyro.sample( + "c2", + dist.Bernoulli(p1).expand_by([len(ind_inner), len(ind_outer)]), + ) + else: + numpyro.sample( + "c2", + dist.Bernoulli(p0).expand_by([len(ind_inner), len(ind_outer)]), + ) + numpyro.sample( + "c3", + dist.Bernoulli(p2).expand_by([len(ind_inner), len(ind_outer)]), + ) + with numpyro.plate("plate_inner_2", 4) as ind_inner: + numpyro.sample( + "d1", dist.Bernoulli(p0).expand_by([len(ind_inner), len(ind_outer)]) + ) + d2 = numpyro.sample( + "d2", dist.Bernoulli(p2).expand_by([len(ind_inner), len(ind_outer)]) + ) + assert d2.shape == (4, 2) + if include_obs: + numpyro.sample( + "obs", + dist.Bernoulli(p0).expand_by([len(ind_inner), len(ind_outer)]), + obs=jnp.ones(d2.shape), + ) + + +@pytest.mark.parametrize("include_inner_1", [True, False]) +@pytest.mark.parametrize("include_single", [True, False]) +@pytest.mark.parametrize("flip_c23", [True, False]) +@pytest.mark.parametrize("include_triple", [True, False]) +@pytest.mark.parametrize("include_z1", [True, False]) +def test_compute_downstream_costs_big_model_guide_pair( + include_inner_1, include_single, flip_c23, include_triple, include_z1 +): + seeded_guide = handlers.seed(big_model_guide, rng_seed=0) + guide_trace = handlers.trace(seeded_guide).get_trace( + include_obs=False, + include_inner_1=include_inner_1, + include_single=include_single, + flip_c23=flip_c23, + include_triple=include_triple, + include_z1=include_z1, + ) + model_trace = handlers.trace(handlers.replay(seeded_guide, guide_trace)).get_trace( + include_obs=True, + include_inner_1=include_inner_1, + include_single=include_single, + flip_c23=flip_c23, + include_triple=include_triple, + include_z1=include_z1, + ) + + for trace in (model_trace, guide_trace): + for site in trace.values(): + if site["type"] == "sample": + site["log_prob"] = site["fn"].log_prob(site["value"]) + non_reparam_nodes = set( + name + for name, site in guide_trace.items() + if site["type"] == "sample" + and (site["is_observed"] or not site["fn"].has_rsample) + ) + + dc, dc_nodes = _compute_downstream_costs( + model_trace, guide_trace, non_reparam_nodes + ) + + dc_brute, dc_nodes_brute = _brute_force_compute_downstream_costs( + model_trace, guide_trace, non_reparam_nodes + ) + + assert dc_nodes == dc_nodes_brute + + expected_nodes_full_model = { + "a1": {"c2", "a1", "d1", "c1", "obs", "b1", "d2", "c3", "b0"}, + "d2": {"obs", "d2"}, + "d1": {"obs", "d1", "d2"}, + "c3": {"d2", "obs", "d1", "c3"}, + "b0": {"b0", "d1", "c1", "obs", "b1", "d2", "c3", "c2"}, + "b1": {"obs", "b1", "d1", "d2", "c3", "c1", "c2"}, + "c1": {"d1", "c1", "obs", "d2", "c3", "c2"}, + "c2": {"obs", "d1", "c3", "d2", "c2"}, + } + if not include_triple and include_inner_1 and include_single and not flip_c23: + assert dc_nodes == expected_nodes_full_model + + expected_b1 = model_trace["b1"]["log_prob"] - guide_trace["b1"]["log_prob"] + expected_b1 += (model_trace["d2"]["log_prob"] - guide_trace["d2"]["log_prob"]).sum( + 0 + ) + expected_b1 += (model_trace["d1"]["log_prob"] - guide_trace["d1"]["log_prob"]).sum( + 0 + ) + expected_b1 += model_trace["obs"]["log_prob"].sum(0, keepdims=False) + if include_inner_1: + expected_b1 += ( + model_trace["c1"]["log_prob"] - guide_trace["c1"]["log_prob"] + ).sum(0) + expected_b1 += ( + model_trace["c2"]["log_prob"] - guide_trace["c2"]["log_prob"] + ).sum(0) + expected_b1 += ( + model_trace["c3"]["log_prob"] - guide_trace["c3"]["log_prob"] + ).sum(0) + assert_allclose(expected_b1, dc["b1"], atol=1.0e-6) + + if include_single: + expected_b0 = model_trace["b0"]["log_prob"] - guide_trace["b0"]["log_prob"] + expected_b0 += ( + model_trace["b1"]["log_prob"] - guide_trace["b1"]["log_prob"] + ).sum() + expected_b0 += ( + model_trace["d2"]["log_prob"] - guide_trace["d2"]["log_prob"] + ).sum() + expected_b0 += ( + model_trace["d1"]["log_prob"] - guide_trace["d1"]["log_prob"] + ).sum() + expected_b0 += model_trace["obs"]["log_prob"].sum() + if include_inner_1: + expected_b0 += ( + model_trace["c1"]["log_prob"] - guide_trace["c1"]["log_prob"] + ).sum() + expected_b0 += ( + model_trace["c2"]["log_prob"] - guide_trace["c2"]["log_prob"] + ).sum() + expected_b0 += ( + model_trace["c3"]["log_prob"] - guide_trace["c3"]["log_prob"] + ).sum() + assert_allclose(expected_b0, dc["b0"], atol=1.0e-6) + assert dc["b0"].shape == (5,) + + if include_inner_1: + expected_c3 = model_trace["c3"]["log_prob"] - guide_trace["c3"]["log_prob"] + expected_c3 += ( + model_trace["d1"]["log_prob"] - guide_trace["d1"]["log_prob"] + ).sum(0) + expected_c3 += ( + model_trace["d2"]["log_prob"] - guide_trace["d2"]["log_prob"] + ).sum(0) + expected_c3 += model_trace["obs"]["log_prob"].sum(0) + + expected_c2 = model_trace["c2"]["log_prob"] - guide_trace["c2"]["log_prob"] + expected_c2 += ( + model_trace["d1"]["log_prob"] - guide_trace["d1"]["log_prob"] + ).sum(0) + expected_c2 += ( + model_trace["d2"]["log_prob"] - guide_trace["d2"]["log_prob"] + ).sum(0) + expected_c2 += model_trace["obs"]["log_prob"].sum(0) + + expected_c1 = model_trace["c1"]["log_prob"] - guide_trace["c1"]["log_prob"] + + if flip_c23: + expected_c3 += model_trace["c2"]["log_prob"] - guide_trace["c2"]["log_prob"] + expected_c2 += model_trace["c3"]["log_prob"] + else: + expected_c2 += model_trace["c3"]["log_prob"] - guide_trace["c3"]["log_prob"] + expected_c2 += model_trace["c2"]["log_prob"] - guide_trace["c2"]["log_prob"] + expected_c1 += expected_c3 + + assert_allclose(expected_c1, dc["c1"], atol=1.0e-6) + assert_allclose(expected_c2, dc["c2"], atol=1.0e-6) + assert_allclose(expected_c3, dc["c3"], atol=1.0e-6) + + expected_d1 = model_trace["d1"]["log_prob"] - guide_trace["d1"]["log_prob"] + expected_d1 += model_trace["d2"]["log_prob"] - guide_trace["d2"]["log_prob"] + expected_d1 += model_trace["obs"]["log_prob"] + + expected_d2 = model_trace["d2"]["log_prob"] - guide_trace["d2"]["log_prob"] + expected_d2 += model_trace["obs"]["log_prob"] + + if include_triple: + expected_z0 = ( + dc["a1"] + model_trace["z0"]["log_prob"] - guide_trace["z0"]["log_prob"] + ) + assert_allclose(expected_z0, dc["z0"], atol=1.0e-6) + assert_allclose(expected_d2, dc["d2"], atol=1.0e-6) + assert_allclose(expected_d1, dc["d1"], atol=1.0e-6) + + assert dc["b1"].shape == (2,) + assert dc["d2"].shape == (4, 2) + + for k in dc: + assert guide_trace[k]["log_prob"].shape == dc[k].shape + assert_allclose(dc[k], dc_brute[k]) + + +def plate_reuse_model_guide(include_obs=True, dim1=3, dim2=2): + p0 = math.exp(-0.40 - include_obs * 0.2) + p1 = math.exp(-0.33 - include_obs * 0.1) + numpyro.sample("a1", dist.Bernoulli(p0 * p1)) + my_plate1 = numpyro.plate("plate1", dim1, dim=-1) + my_plate2 = numpyro.plate("plate2", dim2, dim=-2) + with my_plate1 as ind1: + with my_plate2 as ind2: + numpyro.sample("c1", dist.Bernoulli(p1).expand_by([len(ind2), len(ind1)])) + numpyro.sample("b1", dist.Bernoulli(p0 * p1)) + with my_plate2 as ind2: + with my_plate1 as ind1: + c2 = numpyro.sample( + "c2", dist.Bernoulli(p1).expand_by([len(ind2), len(ind1)]) + ) + if include_obs: + numpyro.sample("obs", dist.Bernoulli(c2), obs=jnp.ones(c2.shape)) + + +@pytest.mark.parametrize("dim1", [2, 5]) +@pytest.mark.parametrize("dim2", [3, 4]) +def test_compute_downstream_costs_plate_reuse(dim1, dim2): + seeded_guide = handlers.seed(plate_reuse_model_guide, rng_seed=0) + guide_trace = handlers.trace(seeded_guide).get_trace( + include_obs=False, dim1=dim1, dim2=dim2 + ) + model_trace = handlers.trace(handlers.replay(seeded_guide, guide_trace)).get_trace( + include_obs=True, dim1=dim1, dim2=dim2 + ) + + for trace in (model_trace, guide_trace): + for site in trace.values(): + if site["type"] == "sample": + site["log_prob"] = site["fn"].log_prob(site["value"]) + non_reparam_nodes = set( + name + for name, site in guide_trace.items() + if site["type"] == "sample" + and (site["is_observed"] or not site["fn"].has_rsample) + ) + + dc, dc_nodes = _compute_downstream_costs( + model_trace, guide_trace, non_reparam_nodes + ) + + dc_brute, dc_nodes_brute = _brute_force_compute_downstream_costs( + model_trace, guide_trace, non_reparam_nodes + ) + + assert dc_nodes == dc_nodes_brute + + for k in dc: + assert guide_trace[k]["log_prob"].shape == dc[k].shape + assert_allclose(dc[k], dc_brute[k]) + + expected_c1 = model_trace["c1"]["log_prob"] - guide_trace["c1"]["log_prob"] + expected_c1 += (model_trace["b1"]["log_prob"] - guide_trace["b1"]["log_prob"]).sum() + expected_c1 += model_trace["c2"]["log_prob"] - guide_trace["c2"]["log_prob"] + expected_c1 += model_trace["obs"]["log_prob"] + assert_allclose(expected_c1, dc["c1"]) diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index d0e7a0a6c..6e51122dd 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -1,6 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +import numpy as np from numpy.testing import assert_allclose import pytest @@ -15,7 +16,7 @@ from numpyro.distributions import constraints from numpyro.distributions.transforms import AffineTransform, SigmoidTransform from numpyro.handlers import substitute -from numpyro.infer import SVI, RenyiELBO, Trace_ELBO +from numpyro.infer import SVI, RenyiELBO, Trace_ELBO, TraceGraph_ELBO from numpyro.util import fori_loop @@ -232,3 +233,267 @@ def guide(): svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) with pytest.warns(UserWarning, match="SVI does not support models with discrete"): svi.run(random.PRNGKey(0), 10) + + +def test_tracegraph_normal_normal(): + # normal-normal; known covariance + lam0 = jnp.array([0.1, 0.1]) # precision of prior + loc0 = jnp.array([0.0, 0.5]) # prior mean + # known precision of observation noise + lam = jnp.array([6.0, 4.0]) + data = [] + data.append(jnp.array([-0.1, 0.3])) + data.append(jnp.array([0.0, 0.4])) + data.append(jnp.array([0.2, 0.5])) + data.append(jnp.array([0.1, 0.7])) + n_data = len(data) + sum_data = data[0] + data[1] + data[2] + data[3] + analytic_lam_n = lam0 + n_data * lam + analytic_log_sig_n = -0.5 * jnp.log(analytic_lam_n) + analytic_loc_n = sum_data * (lam / analytic_lam_n) + loc0 * (lam0 / analytic_lam_n) + + class FakeNormal(dist.Normal): + reparametrized_params = [] + + def model(): + with numpyro.plate("plate", 2): + loc_latent = numpyro.sample( + "loc_latent", FakeNormal(loc0, jnp.power(lam0, -0.5)) + ) + for i, x in enumerate(data): + numpyro.sample( + "obs_{}".format(i), + dist.Normal(loc_latent, jnp.power(lam, -0.5)), + obs=x, + ) + return loc_latent + + def guide(): + loc_q = numpyro.param("loc_q", analytic_loc_n + jnp.array([0.334, 0.334])) + log_sig_q = numpyro.param( + "log_sig_q", analytic_log_sig_n + jnp.array([-0.29, -0.29]) + ) + sig_q = jnp.exp(log_sig_q) + with numpyro.plate("plate", 2): + loc_latent = numpyro.sample("loc_latent", FakeNormal(loc_q, sig_q)) + return loc_latent + + adam = optim.Adam(step_size=0.0015, b1=0.97, b2=0.999) + svi = SVI(model, guide, adam, loss=TraceGraph_ELBO()) + svi_result = svi.run(jax.random.PRNGKey(0), 5000) + + loc_error = jnp.sum(jnp.power(analytic_loc_n - svi_result.params["loc_q"], 2.0)) + log_sig_error = jnp.sum( + jnp.power(analytic_log_sig_n - svi_result.params["log_sig_q"], 2.0) + ) + + assert_allclose(loc_error, 0, atol=0.05) + assert_allclose(log_sig_error, 0, atol=0.05) + + +def test_tracegraph_beta_bernoulli(): + # bernoulli-beta model + # beta prior hyperparameter + alpha0 = 1.0 + beta0 = 1.0 # beta prior hyperparameter + data = jnp.array([0.0, 1.0, 1.0, 1.0]) + n_data = float(len(data)) + data_sum = data.sum() + alpha_n = alpha0 + data_sum # posterior alpha + beta_n = beta0 - data_sum + n_data # posterior beta + log_alpha_n = jnp.log(alpha_n) + log_beta_n = jnp.log(beta_n) + + class FakeBeta(dist.Beta): + reparametrized_params = [] + + def model(): + p_latent = numpyro.sample("p_latent", FakeBeta(alpha0, beta0)) + with numpyro.plate("data", len(data)): + numpyro.sample("obs", dist.Bernoulli(p_latent), obs=data) + return p_latent + + def guide(): + alpha_q_log = numpyro.param("alpha_q_log", log_alpha_n + 0.17) + beta_q_log = numpyro.param("beta_q_log", log_beta_n - 0.143) + alpha_q, beta_q = jnp.exp(alpha_q_log), jnp.exp(beta_q_log) + p_latent = numpyro.sample("p_latent", FakeBeta(alpha_q, beta_q)) + with numpyro.plate("data", len(data)): + pass + return p_latent + + adam = optim.Adam(step_size=0.0007, b1=0.95, b2=0.999) + svi = SVI(model, guide, adam, loss=TraceGraph_ELBO()) + svi_result = svi.run(jax.random.PRNGKey(0), 3000) + + alpha_error = jnp.sum( + jnp.power(log_alpha_n - svi_result.params["alpha_q_log"], 2.0) + ) + beta_error = jnp.sum(jnp.power(log_beta_n - svi_result.params["beta_q_log"], 2.0)) + + assert_allclose(alpha_error, 0, atol=0.03) + assert_allclose(beta_error, 0, atol=0.04) + + +def test_tracegraph_gamma_exponential(): + # exponential-gamma model + # gamma prior hyperparameter + alpha0 = 1.0 + # gamma prior hyperparameter + beta0 = 1.0 + n_data = 2 + data = jnp.array([3.0, 2.0]) # two observations + alpha_n = alpha0 + n_data # posterior alpha + beta_n = beta0 + data.sum() # posterior beta + log_alpha_n = jnp.log(alpha_n) + log_beta_n = jnp.log(beta_n) + + class FakeGamma(dist.Gamma): + reparametrized_params = [] + + def model(): + lambda_latent = numpyro.sample("lambda_latent", FakeGamma(alpha0, beta0)) + with numpyro.plate("data", len(data)): + numpyro.sample("obs", dist.Exponential(lambda_latent), obs=data) + return lambda_latent + + def guide(): + alpha_q_log = numpyro.param("alpha_q_log", log_alpha_n + 0.17) + beta_q_log = numpyro.param("beta_q_log", log_beta_n - 0.143) + alpha_q, beta_q = jnp.exp(alpha_q_log), jnp.exp(beta_q_log) + numpyro.sample("lambda_latent", FakeGamma(alpha_q, beta_q)) + with numpyro.plate("data", len(data)): + pass + + adam = optim.Adam(step_size=0.0007, b1=0.95, b2=0.999) + svi = SVI(model, guide, adam, loss=TraceGraph_ELBO()) + svi_result = svi.run(jax.random.PRNGKey(0), 8000) + + alpha_error = jnp.sum( + jnp.power(log_alpha_n - svi_result.params["alpha_q_log"], 2.0) + ) + beta_error = jnp.sum(jnp.power(log_beta_n - svi_result.params["beta_q_log"], 2.0)) + + assert_allclose(alpha_error, 0, atol=0.04) + assert_allclose(beta_error, 0, atol=0.04) + + +@pytest.mark.parametrize( + "num_latents,num_steps,step_size,atol,difficulty", + [ + (3, 5000, 0.003, 0.05, 0.6), + (5, 6000, 0.003, 0.05, 0.6), + (7, 8000, 0.003, 0.05, 0.6), + ], +) +def test_tracegraph_gaussian_chain(num_latents, num_steps, step_size, atol, difficulty): + loc0 = 0.2 + data = jnp.array([-0.1, 0.03, 0.2, 0.1]) + n_data = data.shape[0] + sum_data = data.sum() + N = num_latents + lambdas = [1.5 * (k + 1) / N for k in range(N + 1)] + lambdas = list(map(lambda x: jnp.array([x]), lambdas)) + lambda_tilde_posts = [lambdas[0]] + for k in range(1, N): + lambda_tilde_k = (lambdas[k] * lambda_tilde_posts[k - 1]) / ( + lambdas[k] + lambda_tilde_posts[k - 1] + ) + lambda_tilde_posts.append(lambda_tilde_k) + lambda_posts = [ + None + ] # this is never used (just a way of shifting the indexing by 1) + for k in range(1, N): + lambda_k = lambdas[k] + lambda_tilde_posts[k - 1] + lambda_posts.append(lambda_k) + lambda_N_post = (n_data * lambdas[N]) + lambda_tilde_posts[N - 1] + lambda_posts.append(lambda_N_post) + target_kappas = [None] + target_kappas.extend([lambdas[k] / lambda_posts[k] for k in range(1, N)]) + target_mus = [None] + target_mus.extend( + [loc0 * lambda_tilde_posts[k - 1] / lambda_posts[k] for k in range(1, N)] + ) + target_loc_N = ( + sum_data * lambdas[N] / lambda_N_post + + loc0 * lambda_tilde_posts[N - 1] / lambda_N_post + ) + target_mus.append(target_loc_N) + np.random.seed(0) + while True: + mask = np.random.binomial(1, 0.3, (N,)) + if mask.sum() < 0.4 * N and mask.sum() > 0.5: + which_nodes_reparam = mask + break + + class FakeNormal(dist.Normal): + reparametrized_params = [] + + def model(difficulty=0.0): + next_mean = loc0 + for k in range(1, N + 1): + latent_dist = dist.Normal(next_mean, jnp.power(lambdas[k - 1], -0.5)) + loc_latent = numpyro.sample("loc_latent_{}".format(k), latent_dist) + next_mean = loc_latent + + loc_N = next_mean + with numpyro.plate("data", data.shape[0]): + numpyro.sample( + "obs", dist.Normal(loc_N, jnp.power(lambdas[N], -0.5)), obs=data + ) + return loc_N + + def guide(difficulty=0.0): + previous_sample = None + for k in reversed(range(1, N + 1)): + loc_q = numpyro.param( + f"loc_q_{k}", + lambda key: target_mus[k] + + difficulty * (0.1 * random.normal(key) - 0.53), + ) + log_sig_q = numpyro.param( + f"log_sig_q_{k}", + lambda key: -0.5 * jnp.log(lambda_posts[k]) + + difficulty * (0.1 * random.normal(key) - 0.53), + ) + sig_q = jnp.exp(log_sig_q) + kappa_q = None + if k != N: + kappa_q = numpyro.param( + "kappa_q_%d" % k, + lambda key: target_kappas[k] + + difficulty * (0.1 * random.normal(key) - 0.53), + ) + mean_function = loc_q if k == N else kappa_q * previous_sample + loc_q + node_flagged = True if which_nodes_reparam[k - 1] == 1.0 else False + Normal = dist.Normal if node_flagged else FakeNormal + loc_latent = numpyro.sample(f"loc_latent_{k}", Normal(mean_function, sig_q)) + previous_sample = loc_latent + return previous_sample + + adam = optim.Adam(step_size=step_size, b1=0.95, b2=0.999) + svi = SVI(model, guide, adam, loss=TraceGraph_ELBO()) + svi_result = svi.run(jax.random.PRNGKey(0), num_steps, difficulty=difficulty) + + kappa_errors, log_sig_errors, loc_errors = [], [], [] + for k in range(1, N + 1): + if k != N: + kappa_error = jnp.sum( + jnp.power(svi_result.params[f"kappa_q_{k}"] - target_kappas[k], 2) + ) + kappa_errors.append(kappa_error) + + loc_errors.append( + jnp.sum(jnp.power(svi_result.params[f"loc_q_{k}"] - target_mus[k], 2)) + ) + log_sig_error = jnp.sum( + jnp.power( + svi_result.params[f"log_sig_q_{k}"] + 0.5 * jnp.log(lambda_posts[k]), 2 + ) + ) + log_sig_errors.append(log_sig_error) + + max_errors = (np.max(loc_errors), np.max(log_sig_errors), np.max(kappa_errors)) + + for i in range(3): + assert_allclose(max_errors[i], 0, atol=atol) From 42763d4bbb2bc508e66f244d995c51a0e370304d Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 22 Jun 2021 10:19:15 -0500 Subject: [PATCH 125/222] Refactor TFP wrappers to avoid new metadata logic (#1064) * refactor TFP wrappers to avoid metadata logic * make TransformedDistribution work * raise attribute error for missing attributes --- numpyro/contrib/tfp/distributions.py | 147 +++++++++++++++++---------- test/contrib/test_tfp.py | 19 ++-- 2 files changed, 104 insertions(+), 62 deletions(-) diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index 30b24f532..b4ff3eb08 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -1,6 +1,8 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +import inspect + import numpy as np import jax.numpy as jnp @@ -103,42 +105,78 @@ def _transform_to_bijector_constraint(constraint): return BijectorTransform(constraint.bijector) -_TFPDistributionMeta = type(tfd.Distribution) +class _TFPDistributionMeta(type(NumPyroDistribution)): + def __getitem__(cls, tfd_class): + assert issubclass(tfd_class, tfd.Distribution) + def init(self, *args, **kwargs): + self.tfp_dist = tfd_class(*args, **kwargs) -# XXX: we create this mixin class to avoid metaclass conflict between TFP and NumPyro Ditribution -class _TFPMixinMeta(_TFPDistributionMeta, type(NumPyroDistribution)): - def __init__(cls, name, bases, dct): - # XXX: _TFPDistributionMeta.__init__ registers cls as a PyTree - # for some reasons, when defining metaclass of TFPDistributionMixin to be _TFPMixinMeta, - # TFPDistributionMixin will be registered as a PyTree 2 times, which is not allowed - # in JAX, so we skip registering TFPDistributionMixin as a PyTree. - if name == "TFPDistributionMixin": - super(_TFPDistributionMeta, cls).__init__(name, bases, dct) - else: - super(_TFPMixinMeta, cls).__init__(name, bases, dct) + init.__signature__ = inspect.signature(tfd_class.__init__) + + _PyroDist = type(tfd_class.__name__, (TFPDistribution,), {}) + _PyroDist.tfd_class = tfd_class + _PyroDist.__init__ = init + return _PyroDist -class TFPDistributionMixin(NumPyroDistribution, metaclass=_TFPMixinMeta): +class TFPDistribution(NumPyroDistribution, metaclass=_TFPDistributionMeta): """ - A mixin layer to make TensorFlow Probability (TFP) distribution compatible - with NumPyro internal. + A thin wrapper for TensorFlow Probability (TFP) distributions. The constructor + has the same signature as the corresponding TFP distribution. + + This class can be used to convert a TFP distribution to a NumPyro-compatible one + as follows:: + + d = TFPDistribution[tfd.Normal](0, 1) + """ - def __init_subclass__(cls, **kwargs): - # skip register pytree because TFP distributions are already pytrees - super(object, cls).__init_subclass__(**kwargs) + tfd_class = None - def __call__(self, *args, **kwargs): - key = kwargs.pop("rng_key") - sample_intermediates = kwargs.pop("sample_intermediates", False) - if sample_intermediates: - return self.sample(*args, seed=key, **kwargs), [] - return self.sample(*args, seed=key, **kwargs) + def __getattr__(self, name): + # return parameters from the constructor + if name in self.tfp_dist.parameters: + return self.tfp_dist.parameters[name] + elif name in ["dtype", "reparameterization_type"]: + return getattr(self.tfp_dist, name) + raise AttributeError(name) + + @property + def batch_shape(self): + return self.tfp_dist.batch_shape + + @property + def event_shape(self): + return self.tfp_dist.event_shape + + @property + def has_rsample(self): + return self.tfp_dist.reparameterization_type is tfd.FULLY_REPARAMETERIZED + + def sample(self, key, sample_shape=()): + return self.tfp_dist.sample(sample_shape=sample_shape, seed=key) + + def log_prob(self, value): + return self.tfp_dist.log_prob(value) + + @property + def mean(self): + return self.tfp_dist.mean() + + @property + def variance(self): + return self.tfp_dist.variance() + + def cdf(self, value): + return self.tfp_dist.cdf(value) + + def icdf(self, q): + return self.tfp_dist.quantile(q) @property def support(self): - bijector = self._default_event_space_bijector() + bijector = self.tfp_dist._default_event_space_bijector() if bijector is not None: return BijectorConstraint(bijector) else: @@ -150,40 +188,43 @@ def is_discrete(self): return self.support is None -class InverseGamma(tfd.InverseGamma, TFPDistributionMixin): - arg_constraints = { - "concentration": constraints.positive, - "scale": constraints.positive, - } - +InverseGamma = TFPDistribution[tfd.InverseGamma] +InverseGamma.arg_constraints = { + "concentration": constraints.positive, + "scale": constraints.positive, +} -class OneHotCategorical(tfd.OneHotCategorical, TFPDistributionMixin): - arg_constraints = {"logits": constraints.real_vector} - has_enumerate_support = True - support = constraints.simplex - is_discrete = True - def enumerate_support(self, expand=True): - n = self.event_shape[-1] - values = jnp.identity(n, dtype=jnp.result_type(self.dtype)) - values = values.reshape((n,) + (1,) * len(self.batch_shape) + (n,)) - if expand: - values = jnp.broadcast_to(values, (n,) + self.batch_shape + (n,)) - return values +def _onehot_enumerate_support(self, expand=True): + n = self.event_shape[-1] + values = jnp.identity(n, dtype=jnp.result_type(self.dtype)) + values = values.reshape((n,) + (1,) * len(self.batch_shape) + (n,)) + if expand: + values = jnp.broadcast_to(values, (n,) + self.batch_shape + (n,)) + return values -class OrderedLogistic(tfd.OrderedLogistic, TFPDistributionMixin): - arg_constraints = {"cutpoints": constraints.ordered_vector, "loc": constraints.real} +OneHotCategorical = TFPDistribution[tfd.OneHotCategorical] +OneHotCategorical.arg_constraints = {"logits": constraints.real_vector} +OneHotCategorical.has_enumerate_support = True +OneHotCategorical.support = constraints.simplex +OneHotCategorical.is_discrete = True +OneHotCategorical.enumerate_support = _onehot_enumerate_support +OrderedLogistic = TFPDistribution[tfd.OrderedLogistic] +OrderedLogistic.arg_constraints = { + "cutpoints": constraints.ordered_vector, + "loc": constraints.real, +} -class Pareto(tfd.Pareto, TFPDistributionMixin): - arg_constraints = { - "concentration": constraints.positive, - "scale": constraints.positive, - } +Pareto = TFPDistribution[tfd.Pareto] +Pareto.arg_constraints = { + "concentration": constraints.positive, + "scale": constraints.positive, +} -__all__ = ["BijectorConstraint", "BijectorTransform", "TFPDistributionMixin"] +__all__ = ["BijectorConstraint", "BijectorTransform", "TFPDistribution"] _len_all = len(__all__) for _name, _Dist in tfd.__dict__.items(): if not isinstance(_Dist, type): @@ -196,7 +237,7 @@ class Pareto(tfd.Pareto, TFPDistributionMixin): try: _PyroDist = locals()[_name] except KeyError: - _PyroDist = type(_name, (_Dist, TFPDistributionMixin), {}) + _PyroDist = TFPDistribution[_Dist] _PyroDist.__module__ = __name__ if hasattr(numpyro_dist, _name): numpyro_dist_class = getattr(numpyro_dist, _name) @@ -212,7 +253,7 @@ class Pareto(tfd.Pareto, TFPDistributionMixin): _PyroDist.__doc__ = """ Wraps `{}.{} `_ - with :class:`~numpyro.contrib.tfp.distributions.TFPDistributionMixin`. + with :class:`~numpyro.contrib.tfp.distributions.TFPDistribution`. """.format( _Dist.__module__, _Dist.__name__, _Dist.__name__ ) diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index eeb3ea1e2..aa6fc7dbe 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -55,11 +55,12 @@ def test_independent(): @pytest.mark.filterwarnings("ignore:can't resolve package") def test_transformed_distributions(): from tensorflow_probability.substrates.jax import bijectors as tfb + from tensorflow_probability.substrates.jax.distributions import Normal as TFPNormal from numpyro.contrib.tfp import distributions as tfd d = dist.TransformedDistribution(dist.Normal(0, 1), dist.transforms.ExpTransform()) - d1 = tfd.TransformedDistribution(tfd.Normal(0, 1), tfb.Exp()) + d1 = tfd.TransformedDistribution(TFPNormal(0, 1), tfb.Exp()) d2 = dist.TransformedDistribution( dist.Normal(0, 1), tfd.BijectorTransform(tfb.Exp()) ) @@ -73,19 +74,19 @@ def test_transformed_distributions(): @pytest.mark.filterwarnings("ignore:can't resolve package") def test_logistic_regression(): - from numpyro.contrib.tfp import distributions as dist + from numpyro.contrib.tfp import distributions as tfd N, dim = 3000, 3 num_warmup, num_samples = (1000, 1000) data = random.normal(random.PRNGKey(0), (N, dim)) true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) - labels = dist.Bernoulli(logits=logits)(rng_key=random.PRNGKey(1)) + labels = tfd.Bernoulli(logits=logits)(rng_key=random.PRNGKey(1)) def model(labels): - coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + coefs = numpyro.sample("coefs", tfd.Normal(jnp.zeros(dim), jnp.ones(dim))) logits = numpyro.deterministic("logits", jnp.sum(coefs * data, axis=-1)) - return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) + return numpyro.sample("obs", tfd.Bernoulli(logits=logits), obs=labels) kernel = NUTS(model) mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) @@ -101,19 +102,19 @@ def model(labels): # TODO: remove after https://github.com/tensorflow/probability/issues/1072 is resolved @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_beta_bernoulli(): - from numpyro.contrib.tfp import distributions as dist + from numpyro.contrib.tfp import distributions as tfd num_warmup, num_samples = (500, 2000) def model(data): alpha = jnp.array([1.1, 1.1]) beta = jnp.array([1.1, 1.1]) - p_latent = numpyro.sample("p_latent", dist.Beta(alpha, beta)) - numpyro.sample("obs", dist.Bernoulli(p_latent), obs=data) + p_latent = numpyro.sample("p_latent", tfd.Beta(alpha, beta)) + numpyro.sample("obs", tfd.Bernoulli(p_latent), obs=data) return p_latent true_probs = jnp.array([0.9, 0.1]) - data = dist.Bernoulli(true_probs)(rng_key=random.PRNGKey(1), sample_shape=(1000, 2)) + data = tfd.Bernoulli(true_probs)(rng_key=random.PRNGKey(1), sample_shape=(1000, 2)) kernel = NUTS(model=model, trajectory_length=0.1) mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(2), data) From 5bcea0184fc547b0d1137e8ee221a9606f45bfca Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 23 Jun 2021 09:58:41 -0500 Subject: [PATCH 126/222] Support for mutable params (#1016) --- Makefile | 2 +- examples/covtype.py | 3 +- examples/hmcecs.py | 5 +- numpyro/contrib/control_flow/cond.py | 2 +- numpyro/contrib/module.py | 218 ++++++++++++++++++++++----- numpyro/handlers.py | 4 +- numpyro/infer/elbo.py | 195 +++++++++++++++--------- numpyro/infer/svi.py | 74 ++++++--- numpyro/optim.py | 40 ++--- numpyro/primitives.py | 32 ++++ test/contrib/test_control_flow.py | 3 +- test/contrib/test_module.py | 88 ++++++++++- test/infer/test_autoguide.py | 3 +- test/infer/test_svi.py | 42 +++++- 14 files changed, 545 insertions(+), 166 deletions(-) diff --git a/Makefile b/Makefile index fcdad2f4b..468e9c391 100644 --- a/Makefile +++ b/Makefile @@ -17,7 +17,7 @@ install: FORCE pip install -e .[dev,doc,test,examples] doctest: FORCE - $(MAKE) -C docs doctest + JAX_PLATFORM_NAME=cpu $(MAKE) -C docs doctest test: lint FORCE pytest -v test diff --git a/examples/covtype.py b/examples/covtype.py index f00c1b0b1..e62867ea1 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -174,7 +174,8 @@ def benchmark_hmc(args, features, labels): subsample_size = 1000 guide = AutoBNAFNormal(model, num_flows=1, hidden_factors=[8]) svi = SVI(model, guide, numpyro.optim.Adam(0.01), Trace_ELBO()) - params, losses = svi.run(random.PRNGKey(2), 2000, features, labels) + svi_result = svi.run(random.PRNGKey(2), 2000, features, labels) + params, losses = svi_result.params, svi_result.losses plt.plot(losses) plt.show() diff --git a/examples/hmcecs.py b/examples/hmcecs.py index c6abdc4ed..010898009 100644 --- a/examples/hmcecs.py +++ b/examples/hmcecs.py @@ -50,9 +50,8 @@ def run_hmcecs(hmcecs_key, args, data, obs, inner_kernel): optimizer = numpyro.optim.Adam(step_size=1e-3) guide = autoguide.AutoDelta(model) svi = SVI(model, guide, optimizer, loss=Trace_ELBO()) - params, losses = svi.run( - svi_key, args.num_svi_steps, data, obs, args.subsample_size - ) + svi_result = svi.run(svi_key, args.num_svi_steps, data, obs, args.subsample_size) + params, losses = svi_result.params, svi_result.losses ref_params = {"theta": params["theta_auto_loc"]} # taylor proxy estimates log likelihood (ll) by diff --git a/numpyro/contrib/control_flow/cond.py b/numpyro/contrib/control_flow/cond.py index 54c0b20d1..338f90309 100644 --- a/numpyro/contrib/control_flow/cond.py +++ b/numpyro/contrib/control_flow/cond.py @@ -111,7 +111,7 @@ def cond(pred, true_fun, false_fun, operand): ... return cond(cluster > 0, true_fun, false_fun, None) >>> >>> svi = SVI(model, guide, numpyro.optim.Adam(1e-2), Trace_ELBO(num_particles=100)) - >>> params, losses = svi.run(random.PRNGKey(0), num_steps=2500) + >>> svi_result = svi.run(random.PRNGKey(0), num_steps=2500) .. warning:: This is an experimental utility function that allows users to use JAX control flow with NumPyro's effect handlers. Currently, `sample` and diff --git a/numpyro/contrib/module.py b/numpyro/contrib/module.py index ffdad805f..b6f5114bc 100644 --- a/numpyro/contrib/module.py +++ b/numpyro/contrib/module.py @@ -5,10 +5,12 @@ from copy import deepcopy from functools import partial -from jax import numpy as jnp +from jax import random +import jax.numpy as jnp from jax.tree_util import register_pytree_node, tree_flatten, tree_unflatten import numpyro +from numpyro.primitives import mutable as numpyro_mutable __all__ = [ "flax_module", @@ -18,16 +20,40 @@ ] -def flax_module(name, nn_module, *, input_shape=None, **kwargs): +def flax_module( + name, nn_module, *, input_shape=None, apply_rng=None, mutable=None, **kwargs +): """ Declare a :mod:`~flax` style neural network inside a model so that its parameters are registered for optimization via :func:`~numpyro.primitives.param` statements. + Given a flax ``nn_module``, in flax to evaluate the module with + a given set of parameters, we use: ``nn_module.apply(params, x)``. + In a NumPyro model, the pattern will be:: + + net = flax_module("net", nn_module) + y = net(x) + + or with dropout layers:: + + net = flax_module("net", nn_module, apply_rng=["dropout"]) + rng_key = numpyro.prng_key() + y = net(x, rngs={"dropout": rng_key}) + :param str name: name of the module to be registered. - :param flax.nn.Module nn_module: a `flax` Module which has .init and .apply methods + :param flax.linen.Module nn_module: a `flax` Module which has .init and .apply methods :param tuple input_shape: shape of the input taken by the neural network. + :param list apply_rng: A list to indicate which extra rng _kinds_ are needed for + ``nn_module``. For example, when ``nn_module`` includes dropout layers, we + need to set ``apply_rng=["dropout"]``. Defaults to None, which means no extra + rng key is needed. Please see + `Flax Linen Intro `_ + for more information in how Flax deals with stochastic layers like dropout. + :param list mutable: A list to indicate mutable states of ``nn_module``. For example, + if your module has BatchNorm layer, we will need to define ``mutable=["batch_stats"]``. + See the above `Flax Linen Intro` tutorial for more information. :param kwargs: optional keyword arguments to initialize flax neural network as an alternative to `input_shape` :return: a callable with bound parameters that takes an array @@ -45,28 +71,84 @@ def flax_module(name, nn_module, *, input_shape=None, **kwargs): ) from e module_key = name + "$params" nn_params = numpyro.param(module_key) + + if mutable: + nn_state = numpyro_mutable(name + "$state") + assert nn_state is None or isinstance(nn_state, dict) + assert (nn_state is None) == (nn_params is None) + if nn_params is None: - args = (jnp.ones(input_shape),) if input_shape is not None else () # feed in dummy data to init params + args = (jnp.ones(input_shape),) if input_shape is not None else () rng_key = numpyro.prng_key() - _, nn_params = nn_module.init(rng_key, *args, **kwargs) + # split rng_key into a dict of rng_kind: rng_key + rngs = {} + if apply_rng: + assert isinstance(apply_rng, list) + for kind in apply_rng: + rng_key, subkey = random.split(rng_key) + rngs[kind] = subkey + rngs["params"] = rng_key + + nn_vars = flax.core.unfreeze(nn_module.init(rngs, *args, **kwargs)) + if "params" not in nn_vars: + raise ValueError( + "Your nn_module does not have any parameter. Currently, it is not" + " supported in NumPyro. Please make a github issue if you need" + " that feature." + ) + nn_params = nn_vars["params"] + if mutable: + nn_state = {k: v for k, v in nn_vars.items() if k != "params"} + assert set(mutable) == set(nn_state) + numpyro_mutable(name + "$state", nn_state) # make sure that nn_params keep the same order after unflatten params_flat, tree_def = tree_flatten(nn_params) nn_params = tree_unflatten(tree_def, params_flat) numpyro.param(module_key, nn_params) - return partial(nn_module.call, nn_params) + def apply_with_state(params, *args, **kwargs): + params = {"params": params, **nn_state} + out, new_state = nn_module.apply(params, mutable=mutable, *args, **kwargs) + nn_state.update(**new_state) + return out + + def apply_without_state(params, *args, **kwargs): + return nn_module.apply({"params": params}, *args, **kwargs) + + apply_fn = apply_with_state if mutable else apply_without_state + return partial(apply_fn, nn_params) -def haiku_module(name, nn_module, *, input_shape=None, **kwargs): + +def haiku_module(name, nn_module, *, input_shape=None, apply_rng=False, **kwargs): """ Declare a :mod:`~haiku` style neural network inside a model so that its parameters are registered for optimization via :func:`~numpyro.primitives.param` statements. + Given a haiku ``nn_module``, in haiku to evaluate the module with + a given set of parameters, we use: ``nn_module.apply(params, None, x)``. + In a NumPyro model, the pattern will be:: + + net = haiku_module("net", nn_module) + y = net(x) # or y = net(rng_key, x) + + or with dropout layers:: + + net = haiku_module("net", nn_module, apply_rng=True) + rng_key = numpyro.prng_key() + y = net(rng_key, x) + :param str name: name of the module to be registered. - :param haiku.Module nn_module: a `haiku` Module which has .init and .apply methods + :param nn_module: a `haiku` Module which has .init and .apply methods + :type nn_module: haiku.Transformed or haiku.TransformedWithState :param tuple input_shape: shape of the input taken by the neural network. + :param bool apply_rng: A flag to indicate if the returned callable requires + an rng argument (e.g. when ``nn_module`` includes dropout layers). Defaults + to False, which means no rng argument is needed. If this is True, the signature + of the returned callable ``nn = haiku_module(..., apply_rng=True)`` will be + ``nn(rng_key, x)`` (rather than ``nn(x)``). :param kwargs: optional keyword arguments to initialize flax neural network as an alternative to `input_shape` :return: a callable with bound parameters that takes an array @@ -74,7 +156,7 @@ def haiku_module(name, nn_module, *, input_shape=None, **kwargs): array. """ try: - import haiku # noqa: F401 + import haiku as hk # noqa: F401 except ImportError as e: raise ImportError( "Looking like you want to use haiku to declare " @@ -83,21 +165,42 @@ def haiku_module(name, nn_module, *, input_shape=None, **kwargs): "It can be installed with `pip install dm-haiku`." ) from e + if not apply_rng: + nn_module = hk.without_apply_rng(nn_module) + module_key = name + "$params" nn_params = numpyro.param(module_key) + with_state = isinstance(nn_module, hk.TransformedWithState) + if with_state: + nn_state = numpyro_mutable(name + "$state") + assert nn_state is None or isinstance(nn_state, dict) + assert (nn_state is None) == (nn_params is None) + if nn_params is None: args = (jnp.ones(input_shape),) if input_shape is not None else () # feed in dummy data to init params rng_key = numpyro.prng_key() - nn_params = nn_module.init(rng_key, *args, **kwargs) + if with_state: + nn_params, nn_state = nn_module.init(rng_key, *args, **kwargs) + nn_state = dict(nn_state) + numpyro_mutable(name + "$state", nn_state) + else: + nn_params = nn_module.init(rng_key, *args, **kwargs) # haiku init returns an immutable dict - nn_params = haiku.data_structures.to_mutable_dict(nn_params) + nn_params = hk.data_structures.to_mutable_dict(nn_params) # we cast it to a mutable one to be able to set priors for parameters # make sure that nn_params keep the same order after unflatten params_flat, tree_def = tree_flatten(nn_params) nn_params = tree_unflatten(tree_def, params_flat) numpyro.param(module_key, nn_params) - return partial(nn_module.apply, nn_params, None) + + def apply_with_state(params, *args, **kwargs): + out, new_state = nn_module.apply(params, nn_state, *args, **kwargs) + nn_state.update(**new_state) + return out + + apply_fn = apply_with_state if with_state else nn_module.apply + return partial(apply_fn, nn_params) # register an "empty" parameter which only stores its shape @@ -133,7 +236,9 @@ def _update_params(params, new_params, prior, prefix=""): ) -def random_flax_module(name, nn_module, prior, *, input_shape=None, **kwargs): +def random_flax_module( + name, nn_module, prior, *, input_shape=None, apply_rng=None, mutable=None, **kwargs +): """ A primitive to place a prior over the parameters of the Flax module `nn_module`. @@ -141,30 +246,41 @@ def random_flax_module(name, nn_module, prior, *, input_shape=None, **kwargs): Parameters of a Flax module are stored in a nested dict. For example, the module `B` defined as follows:: - class A(nn.Module): - def apply(self, x): - return nn.Dense(x, 1, bias=False, name='dense') + class A(flax.linen.Module): + @flax.linen.compact + def __call__(self, x): + return nn.Dense(1, use_bias=False, name='dense')(x) - class B(nn.Module): - def apply(self, x): - return A(x, name='inner') + class B(flax.linen.Module): + @flax.linen.compact + def __call__(self, x): + return A(name='inner')(x) has parameters `{'inner': {'dense': {'kernel': param_value}}}`. In the argument `prior`, to specify `kernel` parameter, we join the path to it using dots: `prior={"inner.dense.kernel": param_prior}`. :param str name: name of NumPyro module - :param flax.nn.Module: the module to be registered with NumPyro + :param flax.linen.Module: the module to be registered with NumPyro :param prior: a NumPyro distribution or a Python dict with parameter names as keys and respective distributions as values. For example:: net = random_flax_module("net", - flax.nn.Dense.partial(features=1), + flax.linen.Dense(features=1), prior={"bias": dist.Cauchy(), "kernel": dist.Normal()}, input_shape=(4,)) - :type param: dict or ~numpyro.distributions.Distribution + :type prior: dict or ~numpyro.distributions.Distribution :param tuple input_shape: shape of the input taken by the neural network. + :param list apply_rng: A list to indicate which extra rng _kinds_ are needed for + ``nn_module``. For example, when ``nn_module`` includes dropout layers, we + need to set ``apply_rng=["dropout"]``. Defaults to None, which means no extra + rng key is needed. Please see + `Flax Linen Intro `_ + for more information in how Flax deals with stochastic layers like dropout. + :param list mutable: A list to indicate mutable states of ``nn_module``. For example, + if your module has BatchNorm layer, we will need to define ``mutable=["batch_stats"]``. + See the above `Flax Linen Intro` tutorial for more information. :param kwargs: optional keyword arguments to initialize flax neural network as an alternative to `input_shape` :returns: a sampled module @@ -176,30 +292,33 @@ def apply(self, x): # NB: this example is ported from https://github.com/ctallec/pyvarinf/blob/master/main_regression.ipynb >>> import numpy as np; np.random.seed(0) >>> import tqdm - >>> from flax import nn + >>> from flax import linen as nn >>> from jax import jit, random >>> import numpyro >>> import numpyro.distributions as dist >>> from numpyro.contrib.module import random_flax_module >>> from numpyro.infer import Predictive, SVI, TraceMeanField_ELBO, autoguide, init_to_feasible - >>> + ... >>> class Net(nn.Module): - ... def apply(self, x, n_units): - ... x = nn.Dense(x[..., None], features=n_units) + ... n_units: int + ... + ... @nn.compact + ... def __call__(self, x): + ... x = nn.Dense(self.n_units)(x[..., None]) ... x = nn.relu(x) - ... x = nn.Dense(x, features=n_units) + ... x = nn.Dense(self.n_units)(x) ... x = nn.relu(x) - ... mean = nn.Dense(x, features=1) - ... rho = nn.Dense(x, features=1) + ... mean = nn.Dense(1)(x) + ... rho = nn.Dense(1)(x) ... return mean.squeeze(), rho.squeeze() - >>> + ... >>> def generate_data(n_samples): ... x = np.random.normal(size=n_samples) ... y = np.cos(x * 3) + np.random.normal(size=n_samples) * np.abs(x) / 2 ... return x, y - >>> + ... >>> def model(x, y=None, batch_size=None): - ... module = Net.partial(n_units=32) + ... module = Net(n_units=32) ... net = random_flax_module("nn", module, dist.Normal(0, 0.1), input_shape=()) ... with numpyro.plate("batch", x.shape[0], subsample_size=batch_size): ... batch_x = numpyro.subsample(x, event_dim=0) @@ -207,14 +326,14 @@ def apply(self, x): ... mean, rho = net(batch_x) ... sigma = nn.softplus(rho) ... numpyro.sample("obs", dist.Normal(mean, sigma), obs=batch_y) - >>> + ... >>> n_train_data = 5000 >>> x_train, y_train = generate_data(n_train_data) >>> guide = autoguide.AutoNormal(model, init_loc_fn=init_to_feasible) >>> svi = SVI(model, guide, numpyro.optim.Adam(5e-3), TraceMeanField_ELBO()) - >>> >>> n_iterations = 3000 - >>> params, losses = svi.run(random.PRNGKey(0), n_iterations, x_train, y_train, batch_size=256) + >>> svi_result = svi.run(random.PRNGKey(0), n_iterations, x_train, y_train, batch_size=256) + >>> params, losses = svi_result.params, svi_result.losses >>> n_test_data = 100 >>> x_test, y_test = generate_data(n_test_data) >>> predictive = Predictive(model, guide=guide, params=params, num_samples=1000) @@ -222,7 +341,14 @@ def apply(self, x): >>> assert losses[-1] < 3000 >>> assert np.sqrt(np.mean(np.square(y_test - y_pred))) < 1 """ - nn = flax_module(name, nn_module, input_shape=input_shape, **kwargs) + nn = flax_module( + name, + nn_module, + input_shape=input_shape, + apply_rng=apply_rng, + mutable=mutable, + **kwargs + ) params = nn.args[0] new_params = deepcopy(params) with numpyro.handlers.scope(prefix=name): @@ -231,12 +357,15 @@ def apply(self, x): return nn_new -def random_haiku_module(name, nn_module, prior, *, input_shape=None, **kwargs): +def random_haiku_module( + name, nn_module, prior, *, input_shape=None, apply_rng=False, **kwargs +): """ A primitive to place a prior over the parameters of the Haiku module `nn_module`. :param str name: name of NumPyro module - :param haiku.Module: the module to be registered with NumPyro + :param nn_module: the module to be registered with NumPyro + :type nn_module: haiku.Transformed or haiku.TransformedWithState :param prior: a NumPyro distribution or a Python dict with parameter names as keys and respective distributions as values. For example:: @@ -245,11 +374,20 @@ def random_haiku_module(name, nn_module, prior, *, input_shape=None, **kwargs): prior={"linear.b": dist.Cauchy(), "linear.w": dist.Normal()}, input_shape=(4,)) - :type param: dict or ~numpyro.distributions.Distribution + :type prior: dict or ~numpyro.distributions.Distribution :param tuple input_shape: shape of the input taken by the neural network. + :param bool apply_rng: A flag to indicate if the returned callable requires + an rng argument (e.g. when ``nn_module`` includes dropout layers). Defaults + to False, which means no rng argument is needed. If this is True, the signature + of the returned callable ``nn = haiku_module(..., apply_rng=True)`` will be + ``nn(rng_key, x)`` (rather than ``nn(x)``). + :param kwargs: optional keyword arguments to initialize flax neural network + as an alternative to `input_shape` :returns: a sampled module """ - nn = haiku_module(name, nn_module, input_shape=input_shape, **kwargs) + nn = haiku_module( + name, nn_module, input_shape=input_shape, apply_rng=apply_rng, **kwargs + ) params = nn.args[0] new_params = deepcopy(params) with numpyro.handlers.scope(prefix=name): diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 53be5116d..8f1386b9e 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -600,7 +600,7 @@ class scope(Messenger): """ This handler prepend a prefix followed by a divider to the name of sample sites. - Example:: + **Example** .. doctest:: @@ -745,7 +745,7 @@ def __init__(self, fn=None, data=None, substitute_fn=None): super(substitute, self).__init__(fn) def process_message(self, msg): - if (msg["type"] not in ("sample", "param", "plate")) or msg.get( + if (msg["type"] not in ("sample", "param", "mutable", "plate")) or msg.get( "_control_flow_done", False ): if msg["type"] == "control_flow": diff --git a/numpyro/infer/elbo.py b/numpyro/infer/elbo.py index a816847c2..8f3e58585 100644 --- a/numpyro/infer/elbo.py +++ b/numpyro/infer/elbo.py @@ -15,7 +15,60 @@ from numpyro.infer.util import get_importance_trace, log_density -class Trace_ELBO: +class ELBO: + """ + Base class for all ELBO objectives. + + Subclasses should implement either :meth:`loss` or :meth:`loss_with_mutable_state`. + + :param num_particles: The number of particles/samples used to form the ELBO + (gradient) estimators. + """ + + def __init__(self, num_particles=1): + self.num_particles = num_particles + + def loss(self, rng_key, param_map, model, guide, *args, **kwargs): + """ + Evaluates the ELBO with an estimator that uses num_particles many samples/particles. + + :param jax.random.PRNGKey rng_key: random number generator seed. + :param dict param_map: dictionary of current parameter values keyed by site + name. + :param model: Python callable with NumPyro primitives for the model. + :param guide: Python callable with NumPyro primitives for the guide. + :param args: arguments to the model / guide (these can possibly vary during + the course of fitting). + :param kwargs: keyword arguments to the model / guide (these can possibly vary + during the course of fitting). + :return: negative of the Evidence Lower Bound (ELBO) to be minimized. + """ + return self.loss_with_mutable_state( + rng_key, param_map, model, guide, *args, **kwargs + )["loss"] + + def loss_with_mutable_state( + self, rng_key, param_map, model, guide, *args, **kwargs + ): + """ + Likes :meth:`loss` but also update and return the mutable state, which stores the + values at :func:`~numpyro.mutable` sites. + + :param jax.random.PRNGKey rng_key: random number generator seed. + :param dict param_map: dictionary of current parameter values keyed by site + name. + :param model: Python callable with NumPyro primitives for the model. + :param guide: Python callable with NumPyro primitives for the guide. + :param args: arguments to the model / guide (these can possibly vary during + the course of fitting). + :param kwargs: keyword arguments to the model / guide (these can possibly vary + during the course of fitting). + :return: a tuple of ELBO loss and the mutable state + """ + raise NotImplementedError("This ELBO objective does not support mutable state.") + + +class Trace_ELBO(ELBO): """ A trace implementation of ELBO-based SVI. The estimator is constructed along the lines of references [1] and [2]. There are no restrictions on the @@ -43,52 +96,56 @@ class Trace_ELBO: def __init__(self, num_particles=1): self.num_particles = num_particles - def loss(self, rng_key, param_map, model, guide, *args, **kwargs): - """ - Evaluates the ELBO with an estimator that uses num_particles many samples/particles. - - :param jax.random.PRNGKey rng_key: random number generator seed. - :param dict param_map: dictionary of current parameter values keyed by site - name. - :param model: Python callable with NumPyro primitives for the model. - :param guide: Python callable with NumPyro primitives for the guide. - :param args: arguments to the model / guide (these can possibly vary during - the course of fitting). - :param kwargs: keyword arguments to the model / guide (these can possibly vary - during the course of fitting). - :return: negative of the Evidence Lower Bound (ELBO) to be minimized. - """ - + def loss_with_mutable_state( + self, rng_key, param_map, model, guide, *args, **kwargs + ): def single_particle_elbo(rng_key): + params = param_map.copy() model_seed, guide_seed = random.split(rng_key) seeded_model = seed(model, model_seed) seeded_guide = seed(guide, guide_seed) guide_log_density, guide_trace = log_density( seeded_guide, args, kwargs, param_map ) + mutable_params = { + name: site["value"] + for name, site in guide_trace.items() + if site["type"] == "mutable" + } + params.update(mutable_params) seeded_model = replay(seeded_model, guide_trace) - model_log_density, _ = log_density(seeded_model, args, kwargs, param_map) + model_log_density, model_trace = log_density( + seeded_model, args, kwargs, params + ) + mutable_params.update( + { + name: site["value"] + for name, site in model_trace.items() + if site["type"] == "mutable" + } + ) # log p(z) - log q(z) - elbo = model_log_density - guide_log_density - return elbo + elbo_particle = model_log_density - guide_log_density + if mutable_params: + if self.num_particles == 1: + return elbo_particle, mutable_params + else: + raise ValueError( + "Currently, we only support mutable states with num_particles=1." + ) + else: + return elbo_particle, None # Return (-elbo) since by convention we do gradient descent on a loss and # the ELBO is a lower bound that needs to be maximized. if self.num_particles == 1: - return -single_particle_elbo(rng_key) + elbo, mutable_state = single_particle_elbo(rng_key) + return {"loss": -elbo, "mutable_state": mutable_state} else: rng_keys = random.split(rng_key, self.num_particles) - return -jnp.mean(vmap(single_particle_elbo)(rng_keys)) - - -class ELBO(Trace_ELBO): - def __init__(self, num_particles=1): - warnings.warn( - "Using ELBO directly in SVI is deprecated. Please use Trace_ELBO class instead.", - FutureWarning, - ) - super().__init__(num_particles=num_particles) + elbos, mutable_state = vmap(single_particle_elbo)(rng_keys) + return {"loss": -jnp.mean(elbos), "mutable_state": mutable_state} def _get_log_prob_sum(site): @@ -128,7 +185,7 @@ def _check_mean_field_requirement(model_trace, guide_trace): ) -class TraceMeanField_ELBO(Trace_ELBO): +class TraceMeanField_ELBO(ELBO): """ A trace implementation of ELBO-based SVI. This is currently the only ELBO estimator in NumPyro that uses analytic KL divergences when those @@ -146,30 +203,31 @@ class TraceMeanField_ELBO(Trace_ELBO): dependency structures. """ - def loss(self, rng_key, param_map, model, guide, *args, **kwargs): - """ - Evaluates the ELBO with an estimator that uses num_particles many samples/particles. - - :param jax.random.PRNGKey rng_key: random number generator seed. - :param dict param_map: dictionary of current parameter values keyed by site - name. - :param model: Python callable with NumPyro primitives for the model. - :param guide: Python callable with NumPyro primitives for the guide. - :param args: arguments to the model / guide (these can possibly vary during - the course of fitting). - :param kwargs: keyword arguments to the model / guide (these can possibly vary - during the course of fitting). - :return: negative of the Evidence Lower Bound (ELBO) to be minimized. - """ - + def loss_with_mutable_state( + self, rng_key, param_map, model, guide, *args, **kwargs + ): def single_particle_elbo(rng_key): + params = param_map.copy() model_seed, guide_seed = random.split(rng_key) seeded_model = seed(model, model_seed) seeded_guide = seed(guide, guide_seed) subs_guide = substitute(seeded_guide, data=param_map) guide_trace = trace(subs_guide).get_trace(*args, **kwargs) - subs_model = substitute(replay(seeded_model, guide_trace), data=param_map) + mutable_params = { + name: site["value"] + for name, site in guide_trace.items() + if site["type"] == "mutable" + } + params.update(mutable_params) + subs_model = substitute(replay(seeded_model, guide_trace), data=params) model_trace = trace(subs_model).get_trace(*args, **kwargs) + mutable_params.update( + { + name: site["value"] + for name, site in model_trace.items() + if site["type"] == "mutable" + } + ) _check_mean_field_requirement(model_trace, guide_trace) elbo_particle = 0 @@ -196,16 +254,26 @@ def single_particle_elbo(rng_key): assert site["infer"].get("is_auxiliary") elbo_particle = elbo_particle - _get_log_prob_sum(site) - return elbo_particle + if mutable_params: + if self.num_particles == 1: + return elbo_particle, mutable_params + else: + raise ValueError( + "Currently, we only support mutable states with num_particles=1." + ) + else: + return elbo_particle, None if self.num_particles == 1: - return -single_particle_elbo(rng_key) + elbo, mutable_state = single_particle_elbo(rng_key) + return {"loss": -elbo, "mutable_state": mutable_state} else: rng_keys = random.split(rng_key, self.num_particles) - return -jnp.mean(vmap(single_particle_elbo)(rng_keys)) + elbos, mutable_state = vmap(single_particle_elbo)(rng_keys) + return {"loss": -jnp.mean(elbos), "mutable_state": mutable_state} -class RenyiELBO(Trace_ELBO): +class RenyiELBO(ELBO): r""" An implementation of Renyi's :math:`\alpha`-divergence variational inference following reference [1]. @@ -235,24 +303,9 @@ def __init__(self, alpha=0, num_particles=2): "for the case alpha = 1." ) self.alpha = alpha - super(RenyiELBO, self).__init__(num_particles=num_particles) + super().__init__(num_particles=num_particles) def loss(self, rng_key, param_map, model, guide, *args, **kwargs): - """ - Evaluates the Renyi ELBO with an estimator that uses num_particles many samples/particles. - - :param jax.random.PRNGKey rng_key: random number generator seed. - :param dict param_map: dictionary of current parameter values keyed by site - name. - :param model: Python callable with NumPyro primitives for the model. - :param guide: Python callable with NumPyro primitives for the guide. - :param args: arguments to the model / guide (these can possibly vary during - the course of fitting). - :param kwargs: keyword arguments to the model / guide (these can possibly vary - during the course of fitting). - :returns: negative of the Renyi Evidence Lower Bound (ELBO) to be minimized. - """ - def single_particle_elbo(rng_key): model_seed, guide_seed = random.split(rng_key) seeded_model = seed(model, model_seed) @@ -458,7 +511,7 @@ def _compute_downstream_costs(model_trace, guide_trace, non_reparam_nodes): return downstream_costs, downstream_guide_cost_nodes -class TraceGraph_ELBO: +class TraceGraph_ELBO(ELBO): """ A TraceGraph implementation of ELBO-based SVI. The gradient estimator is constructed along the lines of reference [1] specialized to the case @@ -479,7 +532,7 @@ class TraceGraph_ELBO: """ def __init__(self, num_particles=1): - self.num_particles = num_particles + super().__init__(num_particles=num_particles) def loss(self, rng_key, param_map, model, guide, *args, **kwargs): """ diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index ddf120644..7df085062 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -17,28 +17,52 @@ from numpyro.infer.util import helpful_support_errors, transform_fn from numpyro.optim import _NumPyroOptim -SVIState = namedtuple("SVIState", ["optim_state", "rng_key"]) +SVIState = namedtuple("SVIState", ["optim_state", "mutable_state", "rng_key"]) """ A :func:`~collections.namedtuple` consisting of the following fields: - **optim_state** - current optimizer's state. + - **mutable_state** - extra state to store values of `"mutable"` sites - **rng_key** - random number generator seed used for the iteration. """ -SVIRunResult = namedtuple("SVIRunResult", ["params", "losses"]) +SVIRunResult = namedtuple("SVIRunResult", ["params", "state", "losses"]) """ A :func:`~collections.namedtuple` consisting of the following fields: - **params** - the optimized parameters. + - **state** - the last :class:`SVIState` - **losses** - the losses collected at every step. """ -def _apply_loss_fn( - loss_fn, rng_key, constrain_fn, model, guide, args, kwargs, static_kwargs, params +def _make_loss_fn( + elbo, + rng_key, + constrain_fn, + model, + guide, + args, + kwargs, + static_kwargs, + mutable_state=None, ): - return loss_fn( - rng_key, constrain_fn(params), model, guide, *args, **kwargs, **static_kwargs - ) + def loss_fn(params): + params = constrain_fn(params) + if mutable_state is not None: + params.update(mutable_state) + result = elbo.loss_with_mutable_state( + rng_key, params, model, guide, *args, **kwargs, **static_kwargs + ) + return result["loss"], result["mutable_state"] + else: + return ( + elbo.loss( + rng_key, params, model, guide, *args, **kwargs, **static_kwargs + ), + None, + ) + + return loss_fn class SVI(object): @@ -150,6 +174,7 @@ def init(self, rng_key, *args, **kwargs): ) params = {} inv_transforms = {} + mutable_state = {} # NB: params in model_trace will be overwritten by params in guide_trace for site in list(model_trace.values()) + list(guide_trace.values()): if site["type"] == "param": @@ -158,6 +183,8 @@ def init(self, rng_key, *args, **kwargs): transform = biject_to(constraint) inv_transforms[site["name"]] = transform params[site["name"]] = transform.inv(site["value"]) + elif site["type"] == "mutable": + mutable_state[site["name"]] = site["value"] elif ( site["type"] == "sample" and (not site["is_observed"]) @@ -167,13 +194,16 @@ def init(self, rng_key, *args, **kwargs): "Currently, SVI does not support models with discrete latent variables" ) + if not mutable_state: + mutable_state = None self.constrain_fn = partial(transform_fn, inv_transforms) # we convert weak types like float to float32/float64 # to avoid recompiling body_fn in svi.run - params = tree_map( - lambda x: lax.convert_element_type(x, jnp.result_type(x)), params + params, mutable_state = tree_map( + lambda x: lax.convert_element_type(x, jnp.result_type(x)), + (params, mutable_state), ) - return SVIState(self.optim.init(params), rng_key) + return SVIState(self.optim.init(params), mutable_state, rng_key) def get_params(self, svi_state): """ @@ -198,9 +228,8 @@ def update(self, svi_state, *args, **kwargs): :return: tuple of `(svi_state, loss)`. """ rng_key, rng_key_step = random.split(svi_state.rng_key) - loss_fn = partial( - _apply_loss_fn, - self.loss.loss, + loss_fn = _make_loss_fn( + self.loss, rng_key_step, self.constrain_fn, self.model, @@ -208,11 +237,12 @@ def update(self, svi_state, *args, **kwargs): args, kwargs, self.static_kwargs, + mutable_state=svi_state.mutable_state, ) - loss_val, optim_state = self.optim.eval_and_update( + (loss_val, mutable_state), optim_state = self.optim.eval_and_update( loss_fn, svi_state.optim_state ) - return SVIState(optim_state, rng_key), loss_val + return SVIState(optim_state, mutable_state, rng_key), loss_val def stable_update(self, svi_state, *args, **kwargs): """ @@ -227,9 +257,8 @@ def stable_update(self, svi_state, *args, **kwargs): :return: tuple of `(svi_state, loss)`. """ rng_key, rng_key_step = random.split(svi_state.rng_key) - loss_fn = partial( - _apply_loss_fn, - self.loss.loss, + loss_fn = _make_loss_fn( + self.loss, rng_key_step, self.constrain_fn, self.model, @@ -237,11 +266,12 @@ def stable_update(self, svi_state, *args, **kwargs): args, kwargs, self.static_kwargs, + mutable_state=svi_state.mutable_state, ) - loss_val, optim_state = self.optim.eval_and_stable_update( + (loss_val, mutable_state), optim_state = self.optim.eval_and_stable_update( loss_fn, svi_state.optim_state ) - return SVIState(optim_state, rng_key), loss_val + return SVIState(optim_state, mutable_state, rng_key), loss_val def run( self, @@ -311,7 +341,9 @@ def body_fn(svi_state, _): else: svi_state, losses = lax.scan(body_fn, svi_state, None, length=num_steps) - return SVIRunResult(self.get_params(svi_state), losses) + # XXX: we also return the last svi_state for further inspection of both + # optimizer's state and mutable state. + return SVIRunResult(self.get_params(svi_state), svi_state, losses) def evaluate(self, svi_state, *args, **kwargs): """ diff --git a/numpyro/optim.py b/numpyro/optim.py index bf205e860..bc33f36b3 100644 --- a/numpyro/optim.py +++ b/numpyro/optim.py @@ -8,7 +8,7 @@ """ from collections import namedtuple -from typing import Callable, Tuple, TypeVar +from typing import Any, Callable, Tuple, TypeVar from jax import lax, value_and_grad from jax.experimental import optimizers @@ -60,7 +60,7 @@ def update(self, g: _Params, state: _IterOptState) -> _IterOptState: opt_state = self.update_fn(i, g, opt_state) return i + 1, opt_state - def eval_and_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: + def eval_and_update(self, fn: Callable[[Any], Tuple], state: _IterOptState): """ Performs an optimization step for the objective function `fn`. For most optimizers, the update is performed based on the gradient @@ -69,17 +69,17 @@ def eval_and_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: by reevaluating the function multiple times to get optimal parameters. - :param fn: objective function. + :param fn: an objective function returning a pair where the first item + is a scalar loss function to be differentiated and the second item + is an auxiliary output. :param state: current optimizer state. :return: a pair of the output of objective function and the new optimizer state. """ params = self.get_params(state) - out, grads = value_and_grad(fn)(params) - return out, self.update(grads, state) + (out, aux), grads = value_and_grad(fn, has_aux=True)(params) + return (out, aux), self.update(grads, state) - def eval_and_stable_update( - self, fn: Callable, state: _IterOptState - ) -> _IterOptState: + def eval_and_stable_update(self, fn: Callable[[Any], Tuple], state: _IterOptState): """ Like :meth:`eval_and_update` but when the value of the objective function or the gradients are not finite, we will not update the input `state` @@ -90,14 +90,14 @@ def eval_and_stable_update( :return: a pair of the output of objective function and the new optimizer state. """ params = self.get_params(state) - out, grads = value_and_grad(fn)(params) + (out, aux), grads = value_and_grad(fn, has_aux=True)(params) out, state = lax.cond( jnp.isfinite(out) & jnp.isfinite(ravel_pytree(grads)[0]).all(), lambda _: (out, self.update(grads, state)), lambda _: (jnp.nan, state), None, ) - return out, state + return (out, aux), state def get_params(self, state: _IterOptState) -> _Params: """ @@ -265,15 +265,21 @@ def __init__(self, method="BFGS", **kwargs): self._method = method self._kwargs = kwargs - def eval_and_update(self, fn: Callable, state: _IterOptState) -> _IterOptState: + def eval_and_update(self, fn: Callable[[Any], Tuple], state: _IterOptState): i, (flat_params, unravel_fn) = state + + def loss_fn(x): + x = unravel_fn(x) + out, aux = fn(x) + if aux is not None: + raise ValueError( + "Minimize does not support models with mutable states." + ) + return out + results = minimize( - lambda x: fn(unravel_fn(x)), - flat_params, - (), - method=self._method, - **self._kwargs + loss_fn, flat_params, (), method=self._method, **self._kwargs ) flat_params, out = results.x, results.fun state = (i + 1, _MinimizeState(flat_params, unravel_fn)) - return out, state + return (out, None), state diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 8c998702c..f5be24bb4 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -238,6 +238,38 @@ def deterministic(name, value): return msg["value"] +def mutable(name, init_value=None): + """ + This primitive is used to store a mutable value that can be changed + during model execution:: + + a = numpyro.mutable("a", {"value": 1.}) + a["value"] = 2. + assert numpyro.mutable("a")["value"] == 2. + + For example, this can be used to store and update information like + running mean/variance in a neural network batch normalization layer. + + :param str name: name of the mutable site. + :param init_value: mutable value to record in the trace. + """ + if not _PYRO_STACK: + return init_value + + initial_msg = { + "type": "mutable", + "name": name, + "fn": identity, + "args": (init_value,), + "kwargs": {}, + "value": init_value, + } + + # ...and use apply_stack to send it to the Messengers + msg = apply_stack(initial_msg) + return msg["value"] + + def _inspect(): """ EXPERIMENTAL Inspect the Pyro stack. diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 1a4392273..520ebfa7e 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -163,7 +163,8 @@ def false_fun(_): cond(cluster > 0, true_fun, false_fun, None) svi = SVI(model, guide, numpyro.optim.Adam(1e-2), Trace_ELBO(num_particles=100)) - params, losses = svi.run(random.PRNGKey(0), num_steps=2500) + svi_result = svi.run(random.PRNGKey(0), num_steps=2500) + params = svi_result.params predictive = Predictive( model, diff --git a/test/contrib/test_module.py b/test/contrib/test_module.py index 2e411f62d..62ef56869 100644 --- a/test/contrib/test_module.py +++ b/test/contrib/test_module.py @@ -48,7 +48,6 @@ class TestHaikuModule(hk.Module): def __init__(self, dim: int = 100): super().__init__() self._dim = dim - return def __call__(self, w, x): l1 = hk.Linear(self._dim, name="w_linear")(w) @@ -64,7 +63,7 @@ def __call__(self, w, x): def flax_model_by_shape(x, y): import flax - linear_module = flax.nn.Dense.partial(features=100) + linear_module = flax.linen.Dense(features=100) nn = flax_module("nn", linear_module, input_shape=(100,)) mean = nn(x) numpyro.sample("y", numpyro.distributions.Normal(mean, 0.1), obs=y) @@ -73,7 +72,7 @@ def flax_model_by_shape(x, y): def flax_model_by_kwargs(x, y): import flax - linear_module = flax.nn.Dense.partial(features=100) + linear_module = flax.linen.Dense(features=100) nn = flax_module("nn", linear_module, inputs=x) mean = nn(x) numpyro.sample("y", numpyro.distributions.Normal(mean, 0.1), obs=y) @@ -149,12 +148,12 @@ def test_update_params(): @pytest.mark.parametrize("backend", ["flax", "haiku"]) @pytest.mark.parametrize("init", ["shape", "kwargs"]) -def test_random_module__mcmc(backend, init): +def test_random_module_mcmc(backend, init): if backend == "flax": import flax - linear_module = flax.nn.Dense.partial(features=1) + linear_module = flax.linen.Dense(features=1) bias_name = "bias" weight_name = "kernel" random_module = random_flax_module @@ -206,3 +205,82 @@ def model(data, labels): true_coefs, atol=0.22, ) + + +@pytest.mark.parametrize("dropout", [True, False]) +@pytest.mark.parametrize("batchnorm", [True, False]) +def test_haiku_state_dropout_smoke(dropout, batchnorm): + import haiku as hk + + def fn(x): + if dropout: + x = hk.dropout(hk.next_rng_key(), 0.5, x) + if batchnorm: + x = hk.BatchNorm(create_offset=True, create_scale=True, decay_rate=0.001)( + x, is_training=True + ) + return x + + def model(): + transform = hk.transform_with_state if batchnorm else hk.transform + nn = haiku_module("nn", transform(fn), apply_rng=dropout, input_shape=(4, 3)) + x = numpyro.sample("x", dist.Normal(0, 1).expand([4, 3]).to_event(2)) + if dropout: + y = nn(numpyro.prng_key(), x) + else: + y = nn(x) + numpyro.deterministic("y", y) + + with handlers.trace(model) as tr, handlers.seed(rng_seed=0): + model() + + if batchnorm: + assert set(tr.keys()) == {"nn$params", "nn$state", "x", "y"} + assert tr["nn$state"]["type"] == "mutable" + else: + assert set(tr.keys()) == {"nn$params", "x", "y"} + + +@pytest.mark.parametrize("dropout", [True, False]) +@pytest.mark.parametrize("batchnorm", [True, False]) +def test_flax_state_dropout_smoke(dropout, batchnorm): + import flax.linen as nn + + class Net(nn.Module): + @nn.compact + def __call__(self, x): + x = nn.Dense(10)(x) + if dropout: + x = nn.Dropout(0.5, deterministic=False)(x) + if batchnorm: + x = nn.BatchNorm( + use_bias=True, + use_scale=True, + momentum=0.999, + use_running_average=False, + )(x) + return x + + def model(): + net = flax_module( + "nn", + Net(), + apply_rng=["dropout"] if dropout else None, + mutable=["batch_stats"] if batchnorm else None, + input_shape=(4, 3), + ) + x = numpyro.sample("x", dist.Normal(0, 1).expand([4, 3]).to_event(2)) + if dropout: + y = net(x, rngs={"dropout": numpyro.prng_key()}) + else: + y = net(x) + numpyro.deterministic("y", y) + + with handlers.trace(model) as tr, handlers.seed(rng_seed=0): + model() + + if batchnorm: + assert set(tr.keys()) == {"nn$params", "nn$state", "x", "y"} + assert tr["nn$state"]["type"] == "mutable" + else: + assert set(tr.keys()) == {"nn$params", "x", "y"} diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 606f2f08d..197ea1f18 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -471,7 +471,8 @@ def model(y=None): optimiser = numpyro.optim.Adam(step_size=0.01) svi = SVI(model, guide, optimiser, Trace_ELBO()) - params, losses = svi.run(random.PRNGKey(0), num_steps=500, y=y_train) + svi_result = svi.run(random.PRNGKey(0), num_steps=500, y=y_train) + params = svi_result.params posterior_samples = guide.sample_posterior( random.PRNGKey(0), params, sample_shape=(1000,) ) diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index 6e51122dd..6f890db98 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -16,7 +16,14 @@ from numpyro.distributions import constraints from numpyro.distributions.transforms import AffineTransform, SigmoidTransform from numpyro.handlers import substitute -from numpyro.infer import SVI, RenyiELBO, Trace_ELBO, TraceGraph_ELBO +from numpyro.infer import ( + SVI, + RenyiELBO, + Trace_ELBO, + TraceGraph_ELBO, + TraceMeanField_ELBO, +) +from numpyro.primitives import mutable as numpyro_mutable from numpyro.util import fori_loop @@ -96,7 +103,8 @@ def guide(data): numpyro.sample("beta", dist.Beta(alpha_q, beta_q)) svi = SVI(model, guide, optim.Adam(0.05), Trace_ELBO()) - params, losses = svi.run(random.PRNGKey(1), 1000, data, progress_bar=progress_bar) + svi_result = svi.run(random.PRNGKey(1), 1000, data, progress_bar=progress_bar) + params, losses = svi_result.params, svi_result.losses assert losses.shape == (1000,) assert_allclose( params["alpha_q"] / (params["alpha_q"] + params["beta_q"]), @@ -235,6 +243,36 @@ def guide(): svi.run(random.PRNGKey(0), 10) +@pytest.mark.parametrize("stable_update", [True, False]) +@pytest.mark.parametrize("num_particles", [1, 10]) +@pytest.mark.parametrize("elbo", [Trace_ELBO, TraceMeanField_ELBO]) +def test_mutable_state(stable_update, num_particles, elbo): + def model(): + x = numpyro.sample("x", dist.Normal(-1, 1)) + numpyro_mutable("x1p", x + 1) + + def guide(): + loc = numpyro.param("loc", 0.0) + p = numpyro_mutable("loc1p", {"value": None}) + # we can modify the content of `p` if it is a dict + p["value"] = loc + 2 + numpyro.sample("x", dist.Normal(loc, 0.1)) + + svi = SVI(model, guide, optim.Adam(0.1), elbo(num_particles=num_particles)) + if num_particles > 1: + with pytest.raises(ValueError, match="mutable state"): + svi_result = svi.run(random.PRNGKey(0), 1000, stable_update=stable_update) + return + svi_result = svi.run(random.PRNGKey(0), 1000, stable_update=stable_update) + params = svi_result.params + mutable_state = svi_result.state.mutable_state + assert set(mutable_state) == {"x1p", "loc1p"} + assert_allclose(mutable_state["loc1p"]["value"], params["loc"] + 2, atol=0.1) + # here, the initial loc has value 0., hence x1p will have init value near 1 + # it won't be updated during SVI run because it is not a mutable state + assert_allclose(mutable_state["x1p"], 1.0, atol=0.2) + + def test_tracegraph_normal_normal(): # normal-normal; known covariance lam0 = jnp.array([0.1, 0.1]) # precision of prior From 0d103ba5a39b96a821673e79aafd15c2a18aa093 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 23 Jun 2021 22:22:09 -0500 Subject: [PATCH 127/222] Exploring nested sampling (#807) * subclass Reparam * add some examples * add diagnostic * update notebook with resampling * restrict the domain * compare with mcmc results * update a working multimodal result * temp save * add example and documentation * fix typo * fix typos and add to toc * add contrib.rst * cleanup TruncatedNormal/Cauchy and Uniform * make some changes for new jaxns api, not working yet * fix some typos * fix typo at Uniform logprob * make truncated distribution tests pass * fix lint * fix failing tests * update for the new api * add icdf method to tensorflow * fix reparam batch logic * fix event dim of projectednormalreparam * add missing icdf methods * enum is working * add gaussian shell example * add tests for gaussian shells * run make license * add jaxns to the dependency * add EXPERIMENTAL warning * fix docs * temporary save * add tests for nested sampling * adjust precision * fix tests * make format * add jaxns to docs requirement * pump jaxns version * use jaxns default arguments * increase threshold of discretehmcgibbs * add a better docstring for diagnostics * increase threshold for hmcgibss in x64 * monkeypatch jaxns x64 dtype * make sure that float32 can be used * perform optimization * avoid singularity at 0 * add note about enable x64 * add print summary * address comments during pair review * revert change at tfp * restrict tfp version --- docs/requirements.txt | 1 + .../_static/img/examples/gaussian_shells.png | Bin 0 -> 134094 bytes docs/source/api.rst | 9 + docs/source/contrib.rst | 8 + docs/source/index.rst | 1 + examples/gaussian_shells.py | 138 +++++++ numpyro/contrib/nested_sampling.py | 336 ++++++++++++++++++ numpyro/distributions/continuous.py | 37 ++ setup.py | 1 + test/contrib/test_nested_sampling.py | 87 +++++ test/test_examples.py | 2 + 11 files changed, 620 insertions(+) create mode 100644 docs/source/_static/img/examples/gaussian_shells.png create mode 100644 docs/source/contrib.rst create mode 100644 examples/gaussian_shells.py create mode 100644 numpyro/contrib/nested_sampling.py create mode 100644 test/contrib/test_nested_sampling.py diff --git a/docs/requirements.txt b/docs/requirements.txt index d7f878f7c..56c361b0f 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -3,6 +3,7 @@ flax funsor jax>=0.1.65 jaxlib>=0.1.45 +jaxns==0.0.7 optax==0.0.6 nbsphinx>=0.8.5 sphinx-gallery diff --git a/docs/source/_static/img/examples/gaussian_shells.png b/docs/source/_static/img/examples/gaussian_shells.png new file mode 100644 index 0000000000000000000000000000000000000000..c2061c7d907bb18e69c6d8f6e8af62edc0444168 GIT binary patch literal 134094 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 |p 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 literal 0 HcmV?d00001 diff --git a/docs/source/api.rst b/docs/source/api.rst index 64f7dce89..9478f6663 100644 --- a/docs/source/api.rst +++ b/docs/source/api.rst @@ -37,3 +37,12 @@ Inference optimizers diagnostics utilities + +Contributed Code +---------------- + +.. toctree:: + :glob: + :maxdepth: 1 + + contrib diff --git a/docs/source/contrib.rst b/docs/source/contrib.rst new file mode 100644 index 000000000..acb050a94 --- /dev/null +++ b/docs/source/contrib.rst @@ -0,0 +1,8 @@ +Nested Sampling +~~~~~~~~~~~~~~~ + +.. autoclass:: numpyro.contrib.nested_sampling.NestedSampler + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource diff --git a/docs/source/index.rst b/docs/source/index.rst index 0a24a2a84..99d0e08e2 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -37,6 +37,7 @@ NumPyro documentation examples/annotation examples/hmm_enum examples/capture_recapture + examples/gaussian_shells tutorials/discrete_imputation .. nbgallery:: diff --git a/examples/gaussian_shells.py b/examples/gaussian_shells.py new file mode 100644 index 000000000..262c6dd7d --- /dev/null +++ b/examples/gaussian_shells.py @@ -0,0 +1,138 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +""" +Example: Nested Sampling for Gaussian Shells +============================================ + +This example illustrates the usage of the contrib class NestedSampler, +which is a wrapper of `jaxns` library ([1]) to be used for NumPyro models. + +Here we will replicate the Gaussian Shells demo at [2] and compare against +NUTS sampler. + +**References:** + + 1. jaxns library: https://github.com/Joshuaalbert/jaxns + 2. dynesty's Gaussian Shells demo: + https://github.com/joshspeagle/dynesty/blob/master/demos/Examples%20--%20Gaussian%20Shells.ipynb +""" + +import argparse + +import matplotlib.pyplot as plt + +from jax import random +import jax.numpy as jnp + +import numpyro +from numpyro.contrib.nested_sampling import NestedSampler +import numpyro.distributions as dist +from numpyro.infer import MCMC, NUTS, DiscreteHMCGibbs + + +class GaussianShell(dist.Distribution): + support = dist.constraints.real_vector + + def __init__(self, loc, radius, width): + self.loc, self.radius, self.width = loc, radius, width + super().__init__(batch_shape=loc.shape[:-1], event_shape=loc.shape[-1:]) + + def sample(self, key, sample_shape=()): + return jnp.zeros( + sample_shape + self.shape() + ) # a dummy sample to initialize the samplers + + def log_prob(self, value): + normalizer = (-0.5) * (jnp.log(2.0 * jnp.pi) + 2.0 * jnp.log(self.width)) + d = jnp.linalg.norm(value - self.loc, axis=-1) + return normalizer - 0.5 * ((d - self.radius) / self.width) ** 2 + + +def model(center1, center2, radius, width, enum=False): + z = numpyro.sample( + "z", dist.Bernoulli(0.5), infer={"enumerate": "parallel"} if enum else {} + ) + x = numpyro.sample("x", dist.Uniform(-6.0, 6.0).expand([2]).to_event(1)) + center = jnp.stack([center1, center2])[z] + numpyro.sample("shell", GaussianShell(center, radius, width), obs=x) + + +def run_inference(args, data): + print("=== Performing Nested Sampling ===") + ns = NestedSampler(model) + ns.run(random.PRNGKey(0), **data, enum=args.enum) + ns.print_summary() + # samples obtained from nested sampler are weighted, so + # we need to provide random key to resample from those weighted samples + ns_samples = ns.get_samples(random.PRNGKey(1), num_samples=args.num_samples) + + print("\n=== Performing MCMC Sampling ===") + if args.enum: + mcmc = MCMC( + NUTS(model), num_warmup=args.num_warmup, num_samples=args.num_samples + ) + else: + mcmc = MCMC( + DiscreteHMCGibbs(NUTS(model)), + num_warmup=args.num_warmup, + num_samples=args.num_samples, + ) + mcmc.run(random.PRNGKey(2), **data) + mcmc.print_summary() + mcmc_samples = mcmc.get_samples() + + return ns_samples["x"], mcmc_samples["x"] + + +def main(args): + data = dict( + radius=2.0, + width=0.1, + center1=jnp.array([-3.5, 0.0]), + center2=jnp.array([3.5, 0.0]), + ) + ns_samples, mcmc_samples = run_inference(args, data) + + # plotting + fig, (ax1, ax2) = plt.subplots( + 2, 1, sharex=True, figsize=(8, 8), constrained_layout=True + ) + + ax1.plot(mcmc_samples[:, 0], mcmc_samples[:, 1], "ro", alpha=0.2) + ax1.set( + xlim=(-6, 6), + ylim=(-2.5, 2.5), + ylabel="x[1]", + title="Gaussian-shell samples using NUTS", + ) + + ax2.plot(ns_samples[:, 0], ns_samples[:, 1], "ro", alpha=0.2) + ax2.set( + xlim=(-6, 6), + ylim=(-2.5, 2.5), + xlabel="x[0]", + ylabel="x[1]", + title="Gaussian-shell samples using Nested Sampler", + ) + + plt.savefig("gaussian_shells_plot.pdf") + + +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser(description="Nested sampler for Gaussian shells") + parser.add_argument("-n", "--num-samples", nargs="?", default=10000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument( + "--enum", + action="store_true", + default=False, + help="whether to enumerate over the discrete latent variable", + ) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') + args = parser.parse_args() + + numpyro.set_platform(args.device) + + main(args) diff --git a/numpyro/contrib/nested_sampling.py b/numpyro/contrib/nested_sampling.py new file mode 100644 index 000000000..6ca9ce7cc --- /dev/null +++ b/numpyro/contrib/nested_sampling.py @@ -0,0 +1,336 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +from functools import singledispatch +import warnings + +from jax import config, nn, random, tree_util +import jax.numpy as jnp + +try: + # jaxns changes the default precision to double precision + # so here we undo that action + use_x64 = config.jax_enable_x64 + + from jaxns.nested_sampling import NestedSampler as OrigNestedSampler + from jaxns.plotting import plot_cornerplot, plot_diagnostics + from jaxns.prior_transforms.common import ContinuousPrior + from jaxns.prior_transforms.prior_chain import PriorChain, UniformBase + from jaxns.utils import summary + + config.update("jax_enable_x64", use_x64) +except ImportError as e: + raise ImportError( + "To use this module, please install `jaxns` package. It can be" + " installed with `pip install jaxns`" + ) from e + +import numpyro +import numpyro.distributions as dist +from numpyro.handlers import reparam, seed, trace +from numpyro.infer import Predictive +from numpyro.infer.reparam import Reparam +from numpyro.infer.util import _guess_max_plate_nesting, _validate_model, log_density + +__all__ = ["NestedSampler"] + + +class UniformPrior(ContinuousPrior): + def __init__(self, name, shape): + prior_base = UniformBase(shape, jnp.result_type(float)) + super().__init__(name, shape, parents=[], tracked=True, prior_base=prior_base) + + def transform_U(self, U, **kwargs): + return U + + +@singledispatch +def uniform_reparam_transform(d): + """ + A helper for :class:`UniformReparam` to get the transform that transforms + a uniform distribution over a unit hypercube to the target distribution `d`. + """ + if isinstance(d, dist.TransformedDistribution): + outer_transform = dist.transforms.ComposeTransform(d.transforms) + return lambda q: outer_transform(uniform_reparam_transform(d.base_dist)(q)) + + if isinstance( + d, (dist.Independent, dist.ExpandedDistribution, dist.MaskedDistribution) + ): + return lambda q: uniform_reparam_transform(d.base_dist)(q) + + return d.icdf + + +@uniform_reparam_transform.register(dist.MultivariateNormal) +def _(d): + outer_transform = dist.transforms.LowerCholeskyAffine(d.loc, d.scale_tril) + return lambda q: outer_transform(dist.Normal(0, 1).icdf(q)) + + +@uniform_reparam_transform.register(dist.BernoulliLogits) +@uniform_reparam_transform.register(dist.BernoulliProbs) +def _(d): + def transform(q): + x = q < d.probs + return x.astype(jnp.result_type(x, int)) + + return transform + + +@uniform_reparam_transform.register(dist.CategoricalLogits) +@uniform_reparam_transform.register(dist.CategoricalProbs) +def _(d): + return lambda q: jnp.sum(jnp.cumsum(d.probs, axis=-1) < q[..., None], axis=-1) + + +@uniform_reparam_transform.register(dist.Dirichlet) +def _(d): + gamma_dist = dist.Gamma(d.concentration) + + def transform_fn(q): + # NB: icdf is not available yet for Gamma distribution + # so this will raise an NotImplementedError for now. + # We will need scipy.special.gammaincinv, which is not available yet in JAX + # see issue: https://github.com/google/jax/issues/5350 + # TODO: consider wrap jaxns GammaPrior transform implementation + gammas = uniform_reparam_transform(gamma_dist)(q) + return gammas / gammas.sum(-1, keepdims=True) + + return transform_fn + + +class UniformReparam(Reparam): + """ + Reparameterize a distribution to a Uniform over the unit hypercube. + + Most univariate distribution uses Inverse CDF for the reparameterization. + """ + + def __call__(self, name, fn, obs): + assert obs is None, "TransformReparam does not support observe statements" + shape = fn.shape() + fn, expand_shape, event_dim = self._unwrap(fn) + transform = uniform_reparam_transform(fn) + tiny = jnp.finfo(jnp.result_type(float)).tiny + + x = numpyro.sample( + "{}_base".format(name), + dist.Uniform(tiny, 1).expand(shape).to_event(event_dim).mask(False), + ) + # Simulate a numpyro.deterministic() site. + return None, transform(x) + + +class NestedSampler: + """ + (EXPERIMENTAL) A wrapper for `jaxns`, a nested sampling package based on JAX. + + See reference [1] for details on the meaning of each parameter. + Please consider citing this reference if you use the nested sampler in your research. + + .. note:: To enumerate over a discrete latent variable, you can add the keyword + `infer={"enumerate": "parallel"}` to the corresponding `sample` statement. + + .. note:: To improve the performance, please consider enabling x64 mode at the beginning + of your NumPyro program ``numpyro.enable_x64()``. + + **References** + + 1. *JAXNS: a high-performance nested sampling package based on JAX*, + Joshua G. Albert (https://arxiv.org/abs/2012.15286) + + :param callable model: a call with NumPyro primitives + :param int num_live_points: the number of live points. As a rule-of-thumb, we should + allocate around 50 live points per possible mode. + :param int max_samples: the maximum number of iterations and samples + :param str sampler_name: either "slice" (default value) or "multi_ellipsoid" + :param int depth: an integer which determines the maximum number of ellipsoids to + construct via hierarchical splitting (typical range: 3 - 9, default to 5) + :param int num_slices: the number of slice sampling proposals at each sampling step + (typical range: 1 - 5, default to 5) + :param float termination_frac: termination condition (typical range: 0.001 - 0.01) + (default to 0.01). + + **Example** + + .. doctest:: + + >>> from jax import random + >>> import jax.numpy as jnp + >>> import numpyro + >>> import numpyro.distributions as dist + >>> from numpyro.contrib.nested_sampling import NestedSampler + + >>> true_coefs = jnp.array([1., 2., 3.]) + >>> data = random.normal(random.PRNGKey(0), (2000, 3)) + >>> labels = dist.Bernoulli(logits=(true_coefs * data).sum(-1)).sample(random.PRNGKey(1)) + >>> + >>> def model(data, labels): + ... coefs = numpyro.sample('coefs', dist.Normal(0, 1).expand([3])) + ... intercept = numpyro.sample('intercept', dist.Normal(0., 10.)) + ... return numpyro.sample('y', dist.Bernoulli(logits=(coefs * data + intercept).sum(-1)), + ... obs=labels) + >>> + >>> ns = NestedSampler(model) + >>> ns.run(random.PRNGKey(2), data, labels) + >>> samples = ns.get_samples(random.PRNGKey(3), num_samples=1000) + >>> assert jnp.mean(jnp.abs(samples['intercept'])) < 0.05 + >>> print(jnp.mean(samples['coefs'], axis=0)) # doctest: +SKIP + [0.93661342 1.95034876 2.86123884] + """ + + def __init__( + self, + model, + *, + num_live_points=1000, + max_samples=100000, + sampler_name="slice", + depth=5, + num_slices=5, + termination_frac=0.01 + ): + self.model = model + self.num_live_points = num_live_points + self.max_samples = max_samples + self.termination_frac = termination_frac + self.sampler_name = sampler_name + self.depth = depth + self.num_slices = num_slices + self._samples = None + self._log_weights = None + self._results = None + + def run(self, rng_key, *args, **kwargs): + """ + Run the nested samplers and collect weighted samples. + + :param random.PRNGKey rng_key: Random number generator key to be used for the sampling. + :param args: The arguments needed by the `model`. + :param kwargs: The keyword arguments needed by the `model`. + """ + rng_sampling, rng_predictive = random.split(rng_key) + # reparam the model so that latent sites have Uniform(0, 1) priors + prototype_trace = trace(seed(self.model, rng_key)).get_trace(*args, **kwargs) + param_names = [ + site["name"] + for site in prototype_trace.values() + if site["type"] == "sample" + and not site["is_observed"] + and site["infer"].get("enumerate", "") != "parallel" + ] + deterministics = [ + site["name"] + for site in prototype_trace.values() + if site["type"] == "deterministic" + ] + reparam_model = reparam( + self.model, config={k: UniformReparam() for k in param_names} + ) + + # enable enumerate if needed + has_enum = any( + site["type"] == "sample" + and site["infer"].get("enumerate", "") == "parallel" + for site in prototype_trace.values() + ) + if has_enum: + from numpyro.contrib.funsor import enum, log_density as log_density_ + + max_plate_nesting = _guess_max_plate_nesting(prototype_trace) + _validate_model(prototype_trace) + reparam_model = enum(reparam_model, -max_plate_nesting - 1) + else: + log_density_ = log_density + + def loglik_fn(**params): + return log_density_(reparam_model, args, kwargs, params)[0] + + # use NestedSampler with identity prior chain + prior_chain = PriorChain() + for name in param_names: + prior = UniformPrior(name + "_base", prototype_trace[name]["fn"].shape()) + prior_chain.push(prior) + # XXX: the `marginalised` keyword in jaxns can be used to get expectation of some + # quantity over posterior samples; it can be helpful to expose it in this wrapper + ns = OrigNestedSampler( + loglik_fn, + prior_chain, + sampler_name=self.sampler_name, + sampler_kwargs={"depth": self.depth, "num_slices": self.num_slices}, + max_samples=self.max_samples, + num_live_points=self.num_live_points, + collect_samples=True, + ) + # some places of jaxns uses float64 and raises some warnings if the default dtype is + # float32, so we suppress them here to avoid confusion + with warnings.catch_warnings(): + warnings.filterwarnings( + "ignore", message=".*will be truncated to dtype float32.*" + ) + results = ns(rng_sampling, termination_frac=self.termination_frac) + # transform base samples back to original domains + # Here we only transform the first valid num_samples samples + # NB: the number of weighted samples obtained from jaxns is results.num_samples + # and only the first num_samples values of results.samples are valid. + num_samples = results.num_samples + samples = tree_util.tree_map(lambda x: x[:num_samples], results.samples) + predictive = Predictive( + reparam_model, samples, return_sites=param_names + deterministics + ) + samples = predictive(rng_predictive, *args, **kwargs) + # replace base samples in jaxns results by transformed samples + self._results = results._replace(samples=samples) + + def get_samples(self, rng_key, num_samples): + """ + Draws samples from the weighted samples collected from the run. + + :param random.PRNGKey rng_key: Random number generator key to be used to draw samples. + :param int num_samples: The number of samples. + :return: a dict of posterior samples + """ + if self._results is None: + raise RuntimeError( + "NestedSampler.run(...) method should be called first to obtain results." + ) + + samples, log_weights = self.get_weighted_samples() + p = nn.softmax(log_weights) + idx = random.choice(rng_key, log_weights.shape[0], (num_samples,), p=p) + return {k: v[idx] for k, v in samples.items()} + + def get_weighted_samples(self): + """ + Gets weighted samples and their corresponding log weights. + """ + if self._results is None: + raise RuntimeError( + "NestedSampler.run(...) method should be called first to obtain results." + ) + + num_samples = self._results.num_samples + return self._results.samples, self._results.log_p[:num_samples] + + def print_summary(self): + """ + Print summary of the result. This is a wrapper of :func:`jaxns.utils.summary`. + """ + if self._results is None: + raise RuntimeError( + "NestedSampler.run(...) method should be called first to obtain results." + ) + summary(self._results) + + def diagnostics(self): + """ + Plot diagnostics of the result. This is a wrapper of :func:`jaxns.plotting.plot_diagnostics` + and :func:`jaxns.plotting.plot_cornerplot`. + """ + if self._results is None: + raise RuntimeError( + "NestedSampler.run(...) method should be called first to obtain results." + ) + plot_diagnostics(self._results) + plot_cornerplot(self._results) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 95797595e..53119ca5b 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -236,6 +236,12 @@ def mean(self): def variance(self): return jnp.reciprocal(self.rate ** 2) + def cdf(self, value): + return -jnp.expm1(-self.rate * value) + + def icdf(self, q): + return -jnp.log1p(-q) / self.rate + class Gamma(Distribution): arg_constraints = { @@ -354,6 +360,12 @@ def sample(self, key, sample_shape=()): def log_prob(self, value): return self._cauchy.log_prob(value) + jnp.log(2) + def cdf(self, value): + return self._cauchy.cdf(value) * 2 - 1 + + def icdf(self, q): + return self._cauchy.icdf((q + 1) / 2) + @property def mean(self): return jnp.full(self.batch_shape, jnp.inf) @@ -383,6 +395,12 @@ def sample(self, key, sample_shape=()): def log_prob(self, value): return self._normal.log_prob(value) + jnp.log(2) + def cdf(self, value): + return self._normal.cdf(value) * 2 - 1 + + def icdf(self, q): + return self._normal.icdf((q + 1) / 2) + @property def mean(self): return jnp.sqrt(2 / jnp.pi) * self.scale @@ -465,6 +483,12 @@ def mean(self): def variance(self): return jnp.broadcast_to(jnp.pi ** 2 / 6.0 * self.scale ** 2, self.batch_shape) + def cdf(self, value): + return jnp.exp(-jnp.exp((self.loc - value) / self.scale)) + + def icdf(self, q): + return self.loc - self.scale * jnp.log(-jnp.log(q)) + class Laplace(Distribution): arg_constraints = {"loc": constraints.real, "scale": constraints.positive} @@ -1238,6 +1262,12 @@ def variance(self): def support(self): return constraints.greater_than(self.scale) + def cdf(self, value): + return 1 - jnp.power(self.scale / value, self.alpha) + + def icdf(self, q): + return self.scale / jnp.power(1 - q, 1 / self.alpha) + def tree_flatten(self): return super(TransformedDistribution, self).tree_flatten() @@ -1397,6 +1427,13 @@ def log_prob(self, value): shape = lax.broadcast_shapes(jnp.shape(value), self.batch_shape) return -jnp.broadcast_to(jnp.log(self.high - self.low), shape) + def cdf(self, value): + cdf = (value - self.low) / (self.high - self.low) + return jnp.clip(cdf, a_min=0.0, a_max=1.0) + + def icdf(self, value): + return self.low + value * (self.high - self.low) + @property def mean(self): return self.low + (self.high - self.low) / 2.0 diff --git a/setup.py b/setup.py index b43b3913a..0342cddd4 100644 --- a/setup.py +++ b/setup.py @@ -58,6 +58,7 @@ # TODO: bump funsor version before the release "funsor @ git+https://github.com/pyro-ppl/funsor.git@d5574988665dd822ec64e41f2b54b9dc929959dc", "graphviz", + "jaxns==0.0.7", "optax==0.0.6", # TODO: change this to tensorflow_probability>0.12.1 when the next version # of tfp is released. The current release is not compatible with jax>=0.2.12. diff --git a/test/contrib/test_nested_sampling.py b/test/contrib/test_nested_sampling.py new file mode 100644 index 000000000..a45f2c067 --- /dev/null +++ b/test/contrib/test_nested_sampling.py @@ -0,0 +1,87 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import numpy as np +from numpy.testing import assert_allclose +import pytest + +from jax import random +import jax.numpy as jnp + +import numpyro +from numpyro.contrib.nested_sampling import NestedSampler, UniformReparam +import numpyro.distributions as dist +from numpyro.distributions.transforms import AffineTransform, ExpTransform + + +# Test helper to extract a few central moments from samples. +def get_moments(x): + m1 = jnp.mean(x, axis=0) + x = x - m1 + xx = x * x + xxx = x * xx + xxxx = xx * xx + m2 = jnp.mean(xx, axis=0) + m3 = jnp.mean(xxx, axis=0) / m2 ** 1.5 + m4 = jnp.mean(xxxx, axis=0) / m2 ** 2 + return jnp.stack([m1, m2, m3, m4]) + + +@pytest.mark.parametrize( + "batch_shape,base_batch_shape", + [ + ((), ()), + ((4,), (4,)), + ((2, 3), (2, 3)), + ((2, 3), ()), + ], + ids=str, +) +@pytest.mark.parametrize("event_shape", [(), (5,)], ids=str) +def test_log_normal(batch_shape, base_batch_shape, event_shape): + shape = batch_shape + event_shape + base_shape = base_batch_shape + event_shape + loc = np.random.rand(*base_shape) * 2 - 1 + scale = np.random.rand(*base_shape) + 0.5 + num_samples = 1000000 + + def model(): + fn = dist.TransformedDistribution( + dist.Normal(jnp.zeros_like(loc), jnp.ones_like(scale)), + [AffineTransform(loc, scale), ExpTransform()], + ).expand(shape) + if event_shape: + fn = fn.to_event(len(event_shape)).expand_by([num_samples]) + with numpyro.plate_stack("plates", batch_shape): + with numpyro.plate("particles", num_samples): + return numpyro.sample("x", fn) + + with numpyro.handlers.trace() as tr: + value = numpyro.handlers.seed(model, 0)() + expected_moments = get_moments(jnp.log(value)) + + with numpyro.handlers.trace() as tr: + with numpyro.handlers.reparam(config={"x": UniformReparam()}): + value = numpyro.handlers.seed(model, 0)() + assert tr["x"]["type"] == "deterministic" + actual_moments = get_moments(jnp.log(value)) + assert_allclose(actual_moments, expected_moments, atol=0.05, rtol=0.01) + + +@pytest.mark.parametrize("rho", [-0.7, 0.8]) +def test_dense_mass(rho): + true_cov = jnp.array([[10.0, rho], [rho, 0.1]]) + + def model(): + numpyro.sample( + "x", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=true_cov) + ) + + ns = NestedSampler(model) + ns.run(random.PRNGKey(0)) + + samples = ns.get_samples(random.PRNGKey(1), 1000)["x"] + assert_allclose(jnp.mean(samples[:, 0]), jnp.array(0.0), atol=0.5) + assert_allclose(jnp.mean(samples[:, 1]), jnp.array(0.0), atol=0.1) + assert_allclose(jnp.mean(samples[:, 0] * samples[:, 1]), jnp.array(rho), atol=0.20) + assert_allclose(jnp.var(samples, axis=0), jnp.array([10.0, 0.1]), rtol=0.20) diff --git a/test/test_examples.py b/test/test_examples.py index 9f29f6e9f..436110e73 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -22,6 +22,8 @@ "capture_recapture.py --num-samples 4 --num-warmup 1 -m 3", "capture_recapture.py --num-samples 4 --num-warmup 1 -m 5", "covtype.py --algo HMC --num-samples 10 --num-warmup 10", + "gaussian_shells.py --num-samples 100", + "gaussian_shells.py --num-samples 100 --enum", "gp.py --num-samples 10 --num-warmup 10 --num-chains 2", "hmcecs.py --subsample_size 5 --num_svi_steps 1 --num_blocks 1 " "--dataset mock --num_warmup 1 --num_samples 5 --num_datapoints 100", From 77be4d8171b0570bcabbebf1456f70ef94f9d0e8 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 23 Jun 2021 22:36:46 -0500 Subject: [PATCH 128/222] Fix AutoNormal.quantiles (#1066) * fix AutoNormal.quantiles and add docs * force tfp release less than 0.14.0.dev * rearange docs * fix docs --- docs/source/autoguide.rst | 10 +++- numpyro/infer/autoguide.py | 107 ++++++++++++++--------------------- test/infer/test_autoguide.py | 4 ++ 3 files changed, 56 insertions(+), 65 deletions(-) diff --git a/docs/source/autoguide.rst b/docs/source/autoguide.rst index df45bb0af..b56ea97b3 100644 --- a/docs/source/autoguide.rst +++ b/docs/source/autoguide.rst @@ -3,6 +3,14 @@ Automatic Guide Generation .. automodule:: numpyro.infer.autoguide +AutoGuide +--------- +.. autoclass:: numpyro.infer.autoguide.AutoGuide + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + AutoContinuous -------------- .. autoclass:: numpyro.infer.autoguide.AutoContinuous @@ -73,4 +81,4 @@ AutoDelta :members: :undoc-members: :show-inheritance: - :member-order: bysource \ No newline at end of file + :member-order: bysource diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 8a2274dba..89bcf8349 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -113,15 +113,18 @@ def __call__(self, *args, **kwargs): raise NotImplementedError @abstractmethod - def sample_posterior(self, rng_key, params, *args, **kwargs): + def sample_posterior(self, rng_key, params, sample_shape=()): """ Generate samples from the approximate posterior over the latent sites in the model. - :param jax.random.PRNGKey rng_key: PRNG seed. - :param params: Current parameters of model and autoguide. - :param sample_shape: (keyword argument) shape of samples to be drawn. - :return: batch of samples from the approximate posterior. + :param jax.random.PRNGKey rng_key: random key to be used draw samples. + :param dict params: Current parameters of model and autoguide. + The parameters can be obtained using :meth:`~numpyro.infer.svi.SVI.get_params` + method from :class:`~numpyro.infer.svi.SVI`. + :param tuple sample_shape: sample shape of each latent site, defaults to (). + :return: a dict containing samples drawn the this guide. + :rtype: dict """ raise NotImplementedError @@ -161,6 +164,33 @@ def _setup_prototype(self, *args, **kwargs): elif site["type"] == "plate": self._prototype_frame_full_sizes[name] = site["args"][0] + def median(self, params): + """ + Returns the posterior median value of each latent variable. + + :param dict params: A dict containing parameter values. + The parameters can be obtained using :meth:`~numpyro.infer.svi.SVI.get_params` + method from :class:`~numpyro.infer.svi.SVI`. + :return: A dict mapping sample site name to median value. + :rtype: dict + """ + raise NotImplementedError + + def quantiles(self, params, quantiles): + """ + Returns posterior quantiles each latent variable. Example:: + + print(guide.quantiles(params, [0.05, 0.5, 0.95])) + + :param dict params: A dict containing parameter values. + The parameters can be obtained using :meth:`~numpyro.infer.svi.SVI.get_params` + method from :class:`~numpyro.infer.svi.SVI`. + :param list quantiles: A list of requested quantiles between 0 and 1. + :return: A dict mapping sample site name to an array of quantile values. + :rtype: dict + """ + raise NotImplementedError + class AutoNormal(AutoGuide): """ @@ -168,7 +198,7 @@ class AutoNormal(AutoGuide): to construct a guide over the entire latent space. The guide does not depend on the model's ``*args, **kwargs``. - This should be equivalent to :class: `AutoDiagonalNormal` , but with + This should be equivalent to :class:`AutoDiagonalNormal` , but with more convenient site names and with better support for mean field ELBO. Usage:: @@ -231,12 +261,6 @@ def _setup_prototype(self, *args, **kwargs): ) def __call__(self, *args, **kwargs): - """ - An automatic guide with the same ``*args, **kwargs`` as the base ``model``. - - :return: A dict mapping sample site name to sampled value. - :rtype: dict - """ if self.prototype_trace is None: # run model to inspect the model structure self._setup_prototype(*args, **kwargs) @@ -314,10 +338,15 @@ def median(self, params): return self._constrain(locs) def quantiles(self, params, quantiles): - quantiles = jnp.array(quantiles)[..., None] + quantiles = jnp.array(quantiles) locs = {k: params["{}_{}_loc".format(k, self.prefix)] for k in self._init_locs} scales = {k: params["{}_{}_scale".format(k, self.prefix)] for k in locs} - latent = {k: dist.Normal(locs[k], scales[k]).icdf(quantiles) for k in locs} + latent = { + k: dist.Normal(locs[k], scales[k]).icdf( + quantiles.reshape((-1,) + (1,) * jnp.ndim(locs[k])) + ) + for k in locs + } return self._constrain(latent) @@ -413,12 +442,6 @@ def sample_posterior(self, rng_key, params, sample_shape=()): return latent_samples def median(self, params): - """ - Returns the posterior median value of each latent variable. - - :return: A dict mapping sample site name to median tensor. - :rtype: dict - """ locs = {k: params["{}_{}_loc".format(k, self.prefix)] for k in self._init_locs} return locs @@ -473,12 +496,6 @@ def _sample_latent(self, *args, **kwargs): ) def __call__(self, *args, **kwargs): - """ - An automatic guide with the same ``*args, **kwargs`` as the base ``model``. - - :return: A dict mapping sample site name to sampled value. - :rtype: dict - """ if self.prototype_trace is None: # run model to inspect the model structure self._setup_prototype(*args, **kwargs) @@ -585,49 +602,11 @@ def get_posterior(self, params): return dist.TransformedDistribution(base_dist, transform) def sample_posterior(self, rng_key, params, sample_shape=()): - """ - Get samples from the learned posterior. - - :param jax.random.PRNGKey rng_key: random key to be used draw samples. - :param dict params: Current parameters of model and autoguide. - The parameters can be obtained using :meth:`~numpyro.infer.svi.SVI.get_params` - method from :class:`~numpyro.infer.svi.SVI`. - :param tuple sample_shape: batch shape of each latent sample, defaults to (). - :return: a dict containing samples drawn the this guide. - :rtype: dict - """ latent_sample = handlers.substitute( handlers.seed(self._sample_latent, rng_key), params )(sample_shape=sample_shape) return self._unpack_and_constrain(latent_sample, params) - def median(self, params): - """ - Returns the posterior median value of each latent variable. - - :param dict params: A dict containing parameter values. - The parameters can be obtained using :meth:`~numpyro.infer.svi.SVI.get_params` - method from :class:`~numpyro.infer.svi.SVI`. - :return: A dict mapping sample site name to median tensor. - :rtype: dict - """ - raise NotImplementedError - - def quantiles(self, params, quantiles): - """ - Returns posterior quantiles each latent variable. Example:: - - print(guide.quantiles(opt_state, [0.05, 0.5, 0.95])) - - :param dict params: A dict containing parameter values. - The parameters can be obtained using :meth:`~numpyro.infer.svi.SVI.get_params` - method from :class:`~numpyro.infer.svi.SVI`. - :param list quantiles: A list of requested quantiles between 0 and 1. - :return: A dict mapping sample site name to a list of quantile values. - :rtype: dict - """ - raise NotImplementedError - class AutoDiagonalNormal(AutoContinuous): """ diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 197ea1f18..5f162d5e6 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -81,6 +81,10 @@ def body_fn(i, val): ) assert_allclose(jnp.mean(posterior_samples["beta"], 0), true_coefs, atol=0.05) + if auto_class not in [AutoDelta, AutoIAFNormal, AutoBNAFNormal]: + quantiles = guide.quantiles(params, [0.2, 0.5, 0.8]) + assert quantiles["beta"].shape == (3, 2) + # Predictive can be instantiated from posterior samples... predictive = Predictive(model, posterior_samples=posterior_samples) predictive_samples = predictive(random.PRNGKey(1), None) From 86c65cf56d752190575e93c44b385256162a8a03 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Sun, 27 Jun 2021 16:05:39 +0100 Subject: [PATCH 129/222] fixup Bayesian Regression, add prior predictive (#1076) --- notebooks/source/bayesian_regression.ipynb | 4477 ++++++++++---------- 1 file changed, 2313 insertions(+), 2164 deletions(-) diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 39c6a0aa7..9a72853c3 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -1,2211 +1,2360 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Bayesian Regression Using NumPyro\n", - "\n", - "In this tutorial, we will explore how to do bayesian regression in NumPyro, using a simple example adapted from Statistical Rethinking [[1](#References)]. In particular, we would like to explore the following:\n", - "\n", - " - Write a simple model using the `sample` NumPyro primitive.\n", - " - Run inference using MCMC in NumPyro, in particular, using the No U-Turn Sampler (NUTS) to get a posterior distribution over our regression parameters of interest.\n", - " - Learn about inference utilities such as `Predictive` and `log_likelihood`.\n", - " - Learn how we can use effect-handlers in NumPyro to generate execution traces from the model, condition on sample statements, seed models with RNG seeds, etc., and use this to implement various utilities that will be useful for MCMC. e.g. computing model log likelihood, generating empirical distribution over the posterior predictive, etc.\n", - "\n", - "## Tutorial Outline:\n", - "\n", - "1. [Dataset](#Dataset)\n", - "2. [Regression Model to Predict Divorce Rate](#Regression-Model-to-Predict-Divorce-Rate)\n", - " - [Model-1: Predictor-Marriage Rate](#Model-1:-Predictor---Marriage-Rate)\n", - " - [Posterior Distribution over the Regression Parameters](#Posterior-Distribution-over-the-Regression-Parameters)\n", - " - [Posterior Predictive Distribution](#Posterior-Predictive-Distribution)\n", - " - [Predictive Utility With Effect Handlers](#Predictive-Utility-With-Effect-Handlers)\n", - " - [Model Predictive Density](#Model-Predictive-Density)\n", - " - [Model-2: Predictor-Median Age of Marriage](#Model-2:-Predictor---Median-Age-of-Marriage)\n", - " - [Model-3: Predictor-Marriage Rate and Median Age of Marriage](#Model-3:-Predictor---Marriage-Rate-and-Median-Age-of-Marriage)\n", - " - [Divorce Rate Residuals by State](#Divorce-Rate-Residuals-by-State)\n", - "3. [Regression Model with Measurement Error](#Regression-Model-with-Measurement-Error)\n", - " - [Effect of Incorporating Measurement Noise on Residuals](#Effect-of-Incorporating-Measurement-Noise-on-Residuals)\n", - "4. [References](#References)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "\n", - "from IPython.display import set_matplotlib_formats\n", - "import jax.numpy as jnp\n", - "from jax import random, vmap\n", - "from jax.scipy.special import logsumexp\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "\n", - "import numpyro\n", - "from numpyro.diagnostics import hpdi\n", - "import numpyro.distributions as dist\n", - "from numpyro import handlers\n", - "from numpyro.infer import MCMC, NUTS\n", - "\n", - "plt.style.use('bmh')\n", - "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", - " set_matplotlib_formats('svg')\n", - "\n", - "assert numpyro.__version__.startswith('0.6.0')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Dataset\n", - "\n", - "For this example, we will use the `WaffleDivorce` dataset from Chapter 05, Statistical Rethinking [[1](#References)]. The dataset contains divorce rates in each of the 50 states in the USA, along with predictors such as population, median age of marriage, whether it is a Southern state and, curiously, number of Waffle Houses." - ] + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.8" + }, + "colab": { + "name": "bayesian_regression.ipynb", + "provenance": [] + } }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ + "cells": [ { - "data": { - "text/html": [ - "

    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    LocationLocPopulationMedianAgeMarriageMarriageMarriage SEDivorceDivorce SEWaffleHousesSouthSlaves1860Population1860PropSlaves1860
    0AlabamaAL4.7825.320.21.2712.70.7912814350809642010.450000
    1AlaskaAK0.7125.226.02.9312.52.0500000.000000
    2ArizonaAZ6.3325.820.30.9810.80.74180000.000000
    3ArkansasAR2.9224.326.41.7013.51.224111111154354500.260000
    4CaliforniaCA37.2526.819.10.398.00.240003799940.000000
    5ColoradoCO5.0325.723.51.2411.60.941100342770.000000
    6ConnecticutCT3.5727.617.11.066.70.770004601470.000000
    7DelawareDE0.9026.623.12.898.91.393017981122160.016000
    8District of ColumbiaDC0.6029.717.72.536.31.89000750800.000000
    9FloridaFL18.8026.417.00.588.50.321331617451404240.440000
    10GeorgiaGA9.6925.922.10.8111.50.58381146219810572860.440000
    11HawaiiHI1.3626.924.92.548.31.2700000.000000
    12IdahoID1.5723.225.81.847.71.0500000.000000
    13IllinoisIL12.8327.017.90.588.00.4520017119510.000000
    14IndianaIN6.4825.719.80.8111.00.63170013504280.000000
    15IowaIA3.0525.421.51.4610.20.910006749130.000000
    16KansasKS2.8525.022.11.4810.61.096021072060.000019
    17KentuckyKY4.3424.822.21.1112.60.7564122548311556840.000000
    18LouisianaLA4.5325.920.61.1911.00.896613317267080020.470000
    19MaineME1.3326.413.51.4013.01.480006282790.000000
    20MarylandMD5.7727.318.31.028.80.69110871896870490.130000
    21MassachusettsMA6.5528.515.80.707.80.5200012310660.000000
    22MichiganMI9.8826.416.50.699.20.530007491130.000000
    23MinnesotaMN5.3026.315.30.777.40.600001720230.000000
    24MississippiMS2.9725.819.31.5411.11.017214366317913050.550000
    25MissouriMO5.9925.618.60.819.50.6739111493111820120.097000
    26MontanaMT0.9925.718.52.319.11.7100000.000000
    27NebraskaNE1.8325.419.61.448.80.940015288410.000520
    28New HampshireNH1.3226.816.71.7610.11.610003260730.000000
    29New JerseyNJ8.7927.714.80.596.10.4600186720350.000027
    30New MexicoNM2.0625.820.41.9010.21.11200935160.000000
    31New YorkNY19.3828.416.80.476.60.3100038807350.000000
    32North CarolinaNC9.5425.720.40.989.90.4814213310599926220.330000
    33North DakotaND0.6725.326.72.938.01.4400000.000000
    34OhioOH11.5426.316.90.619.50.45640023395110.000000
    35OklahomaOK3.7524.423.81.2912.81.01160000.000000
    36OregonOR3.8326.018.91.1010.40.80000524650.000000
    37PennsylvaniaPA12.7027.115.50.487.70.43110029062150.000000
    38Rhode IslandRI1.0528.215.02.119.41.790001746200.000000
    39South CarolinaSC4.6326.418.11.188.10.7014414024067037080.570000
    40South DakotaSD0.8125.620.12.6410.92.5000048370.000000
    41TennesseeTN6.3525.219.40.8511.40.75103127571911098010.200000
    42TexasTX25.1525.221.50.6110.00.359911825666042150.300000
    43UtahUT2.7623.329.61.7710.20.93000402730.000000
    44VermontVT0.6326.916.42.409.61.870003150980.000000
    45VirginiaVA8.0026.420.50.838.90.5240149086512196300.400000
    46WashingtonWA6.7225.921.41.0010.00.65000115940.000000
    47West VirginiaWV1.8525.022.21.6910.91.3441183713766880.049000
    48WisconsinWI5.6926.317.20.798.30.570007758810.000000
    49WyomingWY0.5624.230.73.9210.31.9000000.000000
    \n", - "
    " + "cell_type": "markdown", + "metadata": { + "id": "ZJhD80bfN7ly" + }, + "source": [ + "# Bayesian Regression Using NumPyro\n", + "\n", + "In this tutorial, we will explore how to do bayesian regression in NumPyro, using a simple example adapted from Statistical Rethinking [[1](#References)]. In particular, we would like to explore the following:\n", + "\n", + " - Write a simple model using the `sample` NumPyro primitive.\n", + " - Run inference using MCMC in NumPyro, in particular, using the No U-Turn Sampler (NUTS) to get a posterior distribution over our regression parameters of interest.\n", + " - Learn about inference utilities such as `Predictive` and `log_likelihood`.\n", + " - Learn how we can use effect-handlers in NumPyro to generate execution traces from the model, condition on sample statements, seed models with RNG seeds, etc., and use this to implement various utilities that will be useful for MCMC. e.g. computing model log likelihood, generating empirical distribution over the posterior predictive, etc.\n", + "\n", + "## Tutorial Outline:\n", + "\n", + "1. [Dataset](#Dataset)\n", + "2. [Regression Model to Predict Divorce Rate](#Regression-Model-to-Predict-Divorce-Rate)\n", + " - [Model-1: Predictor-Marriage Rate](#Model-1:-Predictor---Marriage-Rate)\n", + " - [Posterior Distribution over the Regression Parameters](#Posterior-Distribution-over-the-Regression-Parameters)\n", + " - [Posterior Predictive Distribution](#Posterior-Predictive-Distribution)\n", + " - [Predictive Utility With Effect Handlers](#Predictive-Utility-With-Effect-Handlers)\n", + " - [Model Predictive Density](#Model-Predictive-Density)\n", + " - [Model-2: Predictor-Median Age of Marriage](#Model-2:-Predictor---Median-Age-of-Marriage)\n", + " - [Model-3: Predictor-Marriage Rate and Median Age of Marriage](#Model-3:-Predictor---Marriage-Rate-and-Median-Age-of-Marriage)\n", + " - [Divorce Rate Residuals by State](#Divorce-Rate-Residuals-by-State)\n", + "3. [Regression Model with Measurement Error](#Regression-Model-with-Measurement-Error)\n", + " - [Effect of Incorporating Measurement Noise on Residuals](#Effect-of-Incorporating-Measurement-Noise-on-Residuals)\n", + "4. [References](#References)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FlhcyvtqN7l1" + }, + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "B_9Gru7DN7l3" + }, + "source": [ + "import os\n", + "\n", + "from IPython.display import set_matplotlib_formats\n", + "import jax.numpy as jnp\n", + "from jax import random, vmap\n", + "from jax.scipy.special import logsumexp\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "import numpyro\n", + "from numpyro.diagnostics import hpdi\n", + "import numpyro.distributions as dist\n", + "from numpyro import handlers\n", + "from numpyro.infer import MCMC, NUTS\n", + "\n", + "plt.style.use('bmh')\n", + "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", + " set_matplotlib_formats('svg')\n", + "\n", + "assert numpyro.__version__.startswith('0.6.0')" ], - "text/plain": [ - " Location Loc Population MedianAgeMarriage Marriage \\\n", - "0 Alabama AL 4.78 25.3 20.2 \n", - "1 Alaska AK 0.71 25.2 26.0 \n", - "2 Arizona AZ 6.33 25.8 20.3 \n", - "3 Arkansas AR 2.92 24.3 26.4 \n", - "4 California CA 37.25 26.8 19.1 \n", - "5 Colorado CO 5.03 25.7 23.5 \n", - "6 Connecticut CT 3.57 27.6 17.1 \n", - "7 Delaware DE 0.90 26.6 23.1 \n", - "8 District of Columbia DC 0.60 29.7 17.7 \n", - "9 Florida FL 18.80 26.4 17.0 \n", - "10 Georgia GA 9.69 25.9 22.1 \n", - "11 Hawaii HI 1.36 26.9 24.9 \n", - "12 Idaho ID 1.57 23.2 25.8 \n", - "13 Illinois IL 12.83 27.0 17.9 \n", - "14 Indiana IN 6.48 25.7 19.8 \n", - "15 Iowa IA 3.05 25.4 21.5 \n", - "16 Kansas KS 2.85 25.0 22.1 \n", - "17 Kentucky KY 4.34 24.8 22.2 \n", - "18 Louisiana LA 4.53 25.9 20.6 \n", - "19 Maine ME 1.33 26.4 13.5 \n", - "20 Maryland MD 5.77 27.3 18.3 \n", - "21 Massachusetts MA 6.55 28.5 15.8 \n", - "22 Michigan MI 9.88 26.4 16.5 \n", - "23 Minnesota MN 5.30 26.3 15.3 \n", - "24 Mississippi MS 2.97 25.8 19.3 \n", - "25 Missouri MO 5.99 25.6 18.6 \n", - "26 Montana MT 0.99 25.7 18.5 \n", - "27 Nebraska NE 1.83 25.4 19.6 \n", - "28 New Hampshire NH 1.32 26.8 16.7 \n", - "29 New Jersey NJ 8.79 27.7 14.8 \n", - "30 New Mexico NM 2.06 25.8 20.4 \n", - "31 New York NY 19.38 28.4 16.8 \n", - "32 North Carolina NC 9.54 25.7 20.4 \n", - "33 North Dakota ND 0.67 25.3 26.7 \n", - "34 Ohio OH 11.54 26.3 16.9 \n", - "35 Oklahoma OK 3.75 24.4 23.8 \n", - "36 Oregon OR 3.83 26.0 18.9 \n", - "37 Pennsylvania PA 12.70 27.1 15.5 \n", - "38 Rhode Island RI 1.05 28.2 15.0 \n", - "39 South Carolina SC 4.63 26.4 18.1 \n", - "40 South Dakota SD 0.81 25.6 20.1 \n", - "41 Tennessee TN 6.35 25.2 19.4 \n", - "42 Texas TX 25.15 25.2 21.5 \n", - "43 Utah UT 2.76 23.3 29.6 \n", - "44 Vermont VT 0.63 26.9 16.4 \n", - "45 Virginia VA 8.00 26.4 20.5 \n", - "46 Washington WA 6.72 25.9 21.4 \n", - "47 West Virginia WV 1.85 25.0 22.2 \n", - "48 Wisconsin WI 5.69 26.3 17.2 \n", - "49 Wyoming WY 0.56 24.2 30.7 \n", - "\n", - " Marriage SE Divorce Divorce SE WaffleHouses South Slaves1860 \\\n", - "0 1.27 12.7 0.79 128 1 435080 \n", - "1 2.93 12.5 2.05 0 0 0 \n", - "2 0.98 10.8 0.74 18 0 0 \n", - "3 1.70 13.5 1.22 41 1 111115 \n", - "4 0.39 8.0 0.24 0 0 0 \n", - "5 1.24 11.6 0.94 11 0 0 \n", - "6 1.06 6.7 0.77 0 0 0 \n", - "7 2.89 8.9 1.39 3 0 1798 \n", - "8 2.53 6.3 1.89 0 0 0 \n", - "9 0.58 8.5 0.32 133 1 61745 \n", - "10 0.81 11.5 0.58 381 1 462198 \n", - "11 2.54 8.3 1.27 0 0 0 \n", - "12 1.84 7.7 1.05 0 0 0 \n", - "13 0.58 8.0 0.45 2 0 0 \n", - "14 0.81 11.0 0.63 17 0 0 \n", - "15 1.46 10.2 0.91 0 0 0 \n", - "16 1.48 10.6 1.09 6 0 2 \n", - "17 1.11 12.6 0.75 64 1 225483 \n", - "18 1.19 11.0 0.89 66 1 331726 \n", - "19 1.40 13.0 1.48 0 0 0 \n", - "20 1.02 8.8 0.69 11 0 87189 \n", - "21 0.70 7.8 0.52 0 0 0 \n", - "22 0.69 9.2 0.53 0 0 0 \n", - "23 0.77 7.4 0.60 0 0 0 \n", - "24 1.54 11.1 1.01 72 1 436631 \n", - "25 0.81 9.5 0.67 39 1 114931 \n", - "26 2.31 9.1 1.71 0 0 0 \n", - "27 1.44 8.8 0.94 0 0 15 \n", - "28 1.76 10.1 1.61 0 0 0 \n", - "29 0.59 6.1 0.46 0 0 18 \n", - "30 1.90 10.2 1.11 2 0 0 \n", - "31 0.47 6.6 0.31 0 0 0 \n", - "32 0.98 9.9 0.48 142 1 331059 \n", - "33 2.93 8.0 1.44 0 0 0 \n", - "34 0.61 9.5 0.45 64 0 0 \n", - "35 1.29 12.8 1.01 16 0 0 \n", - "36 1.10 10.4 0.80 0 0 0 \n", - "37 0.48 7.7 0.43 11 0 0 \n", - "38 2.11 9.4 1.79 0 0 0 \n", - "39 1.18 8.1 0.70 144 1 402406 \n", - "40 2.64 10.9 2.50 0 0 0 \n", - "41 0.85 11.4 0.75 103 1 275719 \n", - "42 0.61 10.0 0.35 99 1 182566 \n", - "43 1.77 10.2 0.93 0 0 0 \n", - "44 2.40 9.6 1.87 0 0 0 \n", - "45 0.83 8.9 0.52 40 1 490865 \n", - "46 1.00 10.0 0.65 0 0 0 \n", - "47 1.69 10.9 1.34 4 1 18371 \n", - "48 0.79 8.3 0.57 0 0 0 \n", - "49 3.92 10.3 1.90 0 0 0 \n", - "\n", - " Population1860 PropSlaves1860 \n", - "0 964201 0.450000 \n", - "1 0 0.000000 \n", - "2 0 0.000000 \n", - "3 435450 0.260000 \n", - "4 379994 0.000000 \n", - "5 34277 0.000000 \n", - "6 460147 0.000000 \n", - "7 112216 0.016000 \n", - "8 75080 0.000000 \n", - "9 140424 0.440000 \n", - "10 1057286 0.440000 \n", - "11 0 0.000000 \n", - "12 0 0.000000 \n", - "13 1711951 0.000000 \n", - "14 1350428 0.000000 \n", - "15 674913 0.000000 \n", - "16 107206 0.000019 \n", - "17 1155684 0.000000 \n", - "18 708002 0.470000 \n", - "19 628279 0.000000 \n", - "20 687049 0.130000 \n", - "21 1231066 0.000000 \n", - "22 749113 0.000000 \n", - "23 172023 0.000000 \n", - "24 791305 0.550000 \n", - "25 1182012 0.097000 \n", - "26 0 0.000000 \n", - "27 28841 0.000520 \n", - "28 326073 0.000000 \n", - "29 672035 0.000027 \n", - "30 93516 0.000000 \n", - "31 3880735 0.000000 \n", - "32 992622 0.330000 \n", - "33 0 0.000000 \n", - "34 2339511 0.000000 \n", - "35 0 0.000000 \n", - "36 52465 0.000000 \n", - "37 2906215 0.000000 \n", - "38 174620 0.000000 \n", - "39 703708 0.570000 \n", - "40 4837 0.000000 \n", - "41 1109801 0.200000 \n", - "42 604215 0.300000 \n", - "43 40273 0.000000 \n", - "44 315098 0.000000 \n", - "45 1219630 0.400000 \n", - "46 11594 0.000000 \n", - "47 376688 0.049000 \n", - "48 775881 0.000000 \n", - "49 0 0.000000 " + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YfP23JA7N7l3" + }, + "source": [ + "## Dataset\n", + "\n", + "For this example, we will use the `WaffleDivorce` dataset from Chapter 05, Statistical Rethinking [[1](#References)]. The dataset contains divorce rates in each of the 50 states in the USA, along with predictors such as population, median age of marriage, whether it is a Southern state and, curiously, number of Waffle Houses." ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "DATASET_URL = 'https://raw.githubusercontent.com/rmcelreath/rethinking/master/data/WaffleDivorce.csv'\n", - "dset = pd.read_csv(DATASET_URL, sep=';')\n", - "dset" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let us plot the pair-wise relationship amongst the main variables in the dataset, using `seaborn.pairplot`. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "KsCe9ruUN7l4", + "outputId": "f26f9596-9f21-46d6-ec58-33dfc92b58a0" + }, + "source": [ + "DATASET_URL = 'https://raw.githubusercontent.com/rmcelreath/rethinking/master/data/WaffleDivorce.csv'\n", + "dset = pd.read_csv(DATASET_URL, sep=';')\n", + "dset" + ], + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    LocationLocPopulationMedianAgeMarriageMarriageMarriage SEDivorceDivorce SEWaffleHousesSouthSlaves1860Population1860PropSlaves1860
    0AlabamaAL4.7825.320.21.2712.70.7912814350809642010.450000
    1AlaskaAK0.7125.226.02.9312.52.0500000.000000
    2ArizonaAZ6.3325.820.30.9810.80.74180000.000000
    3ArkansasAR2.9224.326.41.7013.51.224111111154354500.260000
    4CaliforniaCA37.2526.819.10.398.00.240003799940.000000
    5ColoradoCO5.0325.723.51.2411.60.941100342770.000000
    6ConnecticutCT3.5727.617.11.066.70.770004601470.000000
    7DelawareDE0.9026.623.12.898.91.393017981122160.016000
    8District of ColumbiaDC0.6029.717.72.536.31.89000750800.000000
    9FloridaFL18.8026.417.00.588.50.321331617451404240.440000
    10GeorgiaGA9.6925.922.10.8111.50.58381146219810572860.440000
    11HawaiiHI1.3626.924.92.548.31.2700000.000000
    12IdahoID1.5723.225.81.847.71.0500000.000000
    13IllinoisIL12.8327.017.90.588.00.4520017119510.000000
    14IndianaIN6.4825.719.80.8111.00.63170013504280.000000
    15IowaIA3.0525.421.51.4610.20.910006749130.000000
    16KansasKS2.8525.022.11.4810.61.096021072060.000019
    17KentuckyKY4.3424.822.21.1112.60.7564122548311556840.000000
    18LouisianaLA4.5325.920.61.1911.00.896613317267080020.470000
    19MaineME1.3326.413.51.4013.01.480006282790.000000
    20MarylandMD5.7727.318.31.028.80.69110871896870490.130000
    21MassachusettsMA6.5528.515.80.707.80.5200012310660.000000
    22MichiganMI9.8826.416.50.699.20.530007491130.000000
    23MinnesotaMN5.3026.315.30.777.40.600001720230.000000
    24MississippiMS2.9725.819.31.5411.11.017214366317913050.550000
    25MissouriMO5.9925.618.60.819.50.6739111493111820120.097000
    26MontanaMT0.9925.718.52.319.11.7100000.000000
    27NebraskaNE1.8325.419.61.448.80.940015288410.000520
    28New HampshireNH1.3226.816.71.7610.11.610003260730.000000
    29New JerseyNJ8.7927.714.80.596.10.4600186720350.000027
    30New MexicoNM2.0625.820.41.9010.21.11200935160.000000
    31New YorkNY19.3828.416.80.476.60.3100038807350.000000
    32North CarolinaNC9.5425.720.40.989.90.4814213310599926220.330000
    33North DakotaND0.6725.326.72.938.01.4400000.000000
    34OhioOH11.5426.316.90.619.50.45640023395110.000000
    35OklahomaOK3.7524.423.81.2912.81.01160000.000000
    36OregonOR3.8326.018.91.1010.40.80000524650.000000
    37PennsylvaniaPA12.7027.115.50.487.70.43110029062150.000000
    38Rhode IslandRI1.0528.215.02.119.41.790001746200.000000
    39South CarolinaSC4.6326.418.11.188.10.7014414024067037080.570000
    40South DakotaSD0.8125.620.12.6410.92.5000048370.000000
    41TennesseeTN6.3525.219.40.8511.40.75103127571911098010.200000
    42TexasTX25.1525.221.50.6110.00.359911825666042150.300000
    43UtahUT2.7623.329.61.7710.20.93000402730.000000
    44VermontVT0.6326.916.42.409.61.870003150980.000000
    45VirginiaVA8.0026.420.50.838.90.5240149086512196300.400000
    46WashingtonWA6.7225.921.41.0010.00.65000115940.000000
    47West VirginiaWV1.8525.022.21.6910.91.3441183713766880.049000
    48WisconsinWI5.6926.317.20.798.30.570007758810.000000
    49WyomingWY0.5624.230.73.9210.31.9000000.000000
    \n", + "
    " + ], + "text/plain": [ + " Location Loc ... Population1860 PropSlaves1860\n", + "0 Alabama AL ... 964201 0.450000\n", + "1 Alaska AK ... 0 0.000000\n", + "2 Arizona AZ ... 0 0.000000\n", + "3 Arkansas AR ... 435450 0.260000\n", + "4 California CA ... 379994 0.000000\n", + "5 Colorado CO ... 34277 0.000000\n", + "6 Connecticut CT ... 460147 0.000000\n", + "7 Delaware DE ... 112216 0.016000\n", + "8 District of Columbia DC ... 75080 0.000000\n", + "9 Florida FL ... 140424 0.440000\n", + "10 Georgia GA ... 1057286 0.440000\n", + "11 Hawaii HI ... 0 0.000000\n", + "12 Idaho ID ... 0 0.000000\n", + "13 Illinois IL ... 1711951 0.000000\n", + "14 Indiana IN ... 1350428 0.000000\n", + "15 Iowa IA ... 674913 0.000000\n", + "16 Kansas KS ... 107206 0.000019\n", + "17 Kentucky KY ... 1155684 0.000000\n", + "18 Louisiana LA ... 708002 0.470000\n", + "19 Maine ME ... 628279 0.000000\n", + "20 Maryland MD ... 687049 0.130000\n", + "21 Massachusetts MA ... 1231066 0.000000\n", + "22 Michigan MI ... 749113 0.000000\n", + "23 Minnesota MN ... 172023 0.000000\n", + "24 Mississippi MS ... 791305 0.550000\n", + "25 Missouri MO ... 1182012 0.097000\n", + "26 Montana MT ... 0 0.000000\n", + "27 Nebraska NE ... 28841 0.000520\n", + "28 New Hampshire NH ... 326073 0.000000\n", + "29 New Jersey NJ ... 672035 0.000027\n", + "30 New Mexico NM ... 93516 0.000000\n", + "31 New York NY ... 3880735 0.000000\n", + "32 North Carolina NC ... 992622 0.330000\n", + "33 North Dakota ND ... 0 0.000000\n", + "34 Ohio OH ... 2339511 0.000000\n", + "35 Oklahoma OK ... 0 0.000000\n", + "36 Oregon OR ... 52465 0.000000\n", + "37 Pennsylvania PA ... 2906215 0.000000\n", + "38 Rhode Island RI ... 174620 0.000000\n", + "39 South Carolina SC ... 703708 0.570000\n", + "40 South Dakota SD ... 4837 0.000000\n", + "41 Tennessee TN ... 1109801 0.200000\n", + "42 Texas TX ... 604215 0.300000\n", + "43 Utah UT ... 40273 0.000000\n", + "44 Vermont VT ... 315098 0.000000\n", + "45 Virginia VA ... 1219630 0.400000\n", + "46 Washington WA ... 11594 0.000000\n", + "47 West Virginia WV ... 376688 0.049000\n", + "48 Wisconsin WI ... 775881 0.000000\n", + "49 Wyoming WY ... 0 0.000000\n", + "\n", + "[50 rows x 13 columns]" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "vars = ['Population', 'MedianAgeMarriage', 'Marriage', 'WaffleHouses', 'South', 'Divorce']\n", - "sns.pairplot(dset, x_vars=vars, y_vars=vars, palette='husl');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "From the plots above, we can clearly observe that there is a relationship between divorce rates and marriage rates in a state (as might be expected), and also between divorce rates and median age of marriage. \n", - "\n", - "There is also a weak relationship between number of Waffle Houses and divorce rates, which is not obvious from the plot above, but will be clearer if we regress `Divorce` against `WaffleHouse` and plot the results. " - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "markdown", + "metadata": { + "id": "Hu-1n8UfN7l6" + }, + "source": [ + "Let us plot the pair-wise relationship amongst the main variables in the dataset, using `seaborn.pairplot`. " ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sns.regplot('WaffleHouses', 'Divorce', dset);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is an example of a spurious association. We do not expect the number of Waffle Houses in a state to affect the divorce rate, but it is likely correlated with other factors that have an effect on the divorce rate. We will not delve into this spurious association in this tutorial, but the interested reader is encouraged to read Chapters 5 and 6 of [[1](#References)] which explores the problem of causal association in the presence of multiple predictors. \n", - "\n", - "For simplicity, we will primarily focus on marriage rate and the median age of marriage as our predictors for divorce rate throughout the remaining tutorial." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Regression Model to Predict Divorce Rate\n", - "\n", - "Let us now write a regressionn model in *NumPyro* to predict the divorce rate as a linear function of marriage rate and median age of marriage in each of the states. \n", - "\n", - "First, note that our predictor variables have somewhat different scales. It is a good practice to standardize our predictors and response variables to mean `0` and standard deviation `1`, which should result in [faster inference](https://mc-stan.org/docs/2_19/stan-users-guide/standardizing-predictors-and-outputs.html)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "standardize = lambda x: (x - x.mean()) / x.std()\n", - "\n", - "dset['AgeScaled'] = dset.MedianAgeMarriage.pipe(standardize)\n", - "dset['MarriageScaled'] = dset.Marriage.pipe(standardize)\n", - "dset['DivorceScaled'] = dset.Divorce.pipe(standardize)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We write the NumPyro model as follows. While the code should largely be self-explanatory, take note of the following:\n", - "\n", - " - In NumPyro, *model* code is any Python callable which can optionally accept additional arguments and keywords. For HMC which we will be using for this tutorial, these arguments and keywords remain static during inference, but we can reuse the same model to generate [predictions](#Posterior-Predictive-Distribution) on new data.\n", - " - In addition to regular Python statements, the model code also contains primitives like `sample`. These primitives can be interpreted with various side-effects using effect handlers. For more on effect handlers, refer to [[3](#References)], [[4](#References)]. For now, just remember that a `sample` statement makes this a stochastic function that samples some latent parameters from a *prior distribution*. Our goal is to infer the *posterior distribution* of these parameters conditioned on observed data.\n", - " - The reason why we have kept our predictors as optional keyword arguments is to be able to reuse the same model as we vary the set of predictors. Likewise, the reason why the response variable is optional is that we would like to reuse this model to sample from the posterior predictive distribution. See the [section](#Posterior-Predictive-Distribution) on plotting the posterior predictive distribution, as an example." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "def model(marriage=None, age=None, divorce=None):\n", - " a = numpyro.sample('a', dist.Normal(0., 0.2))\n", - " M, A = 0., 0.\n", - " if marriage is not None:\n", - " bM = numpyro.sample('bM', dist.Normal(0., 0.5))\n", - " M = bM * marriage\n", - " if age is not None:\n", - " bA = numpyro.sample('bA', dist.Normal(0., 0.5))\n", - " A = bA * age\n", - " sigma = numpyro.sample('sigma', dist.Exponential(1.))\n", - " mu = a + M + A\n", - " numpyro.sample('obs', dist.Normal(mu, sigma), obs=divorce)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Model 1: Predictor - Marriage Rate\n", - "\n", - "We first try to model the divorce rate as depending on a single variable, marriage rate. As mentioned above, we can use the same `model` code as earlier, but only pass values for `marriage` and `divorce` keyword arguments. We will use the No U-Turn Sampler (see [[5](#References)] for more details on the NUTS algorithm) to run inference on this simple model.\n", - "\n", - "The Hamiltonian Monte Carlo (or, the NUTS) implementation in NumPyro takes in a potential energy function. This is the negative log joint density for the model. Therefore, for our model description above, we need to construct a function which given the parameter values returns the potential energy (or negative log joint density). Additionally, the verlet integrator in HMC (or, NUTS) returns sample values simulated using Hamiltonian dynamics in the unconstrained space. As such, continuous variables with bounded support need to be transformed into unconstrained space using bijective transforms. We also need to transform these samples back to their constrained support before returning these values to the user. Thankfully, this is handled on the backend for us, within a convenience class for doing [MCMC inference](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.MCMC) that has the following methods:\n", - "\n", - " - `run(...)`: runs warmup, adapts steps size and mass matrix, and does sampling using the sample from the warmup phase.\n", - " - `print_summary()`: print diagnostic information like quantiles, effective sample size, and the Gelman-Rubin diagnostic.\n", - " - `get_samples()`: gets samples from the posterior distribution.\n", - "\n", - "Note the following:\n", - "\n", - " - JAX uses functional PRNGs. Unlike other languages / frameworks which maintain a global random state, in JAX, every call to a sampler requires an [explicit PRNGKey](https://github.com/google/jax#random-numbers-are-different). We will split our initial random seed for subsequent operations, so that we do not accidentally reuse the same seed.\n", - " - We run inference with the `NUTS` sampler. To run vanilla HMC, we can instead use the [HMC](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.HMC) class." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 3000/3000 [00:06<00:00, 429.13it/s, 3 steps of size 7.48e-01. acc. prob=0.91] \n" - ] + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "pNjxHdVvN7l6", + "outputId": "eb113ed4-bc40-45f5-e82d-c56142336227" + }, + "source": [ + "vars = ['Population', 'MedianAgeMarriage', 'Marriage', 'WaffleHouses', 'South', 'Divorce']\n", + "sns.pairplot(dset, x_vars=vars, y_vars=vars, palette='husl');" + ], + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a -0.00 0.11 -0.00 -0.17 0.18 1804.63 1.00\n", - " bM 0.35 0.13 0.35 0.13 0.56 1556.49 1.00\n", - " sigma 0.94 0.10 0.94 0.78 1.08 1916.15 1.00\n", - "\n", - "Number of divergences: 0\n" - ] - } - ], - "source": [ - "# Start from this source of randomness. We will split keys for subsequent operations.\n", - "rng_key = random.PRNGKey(0)\n", - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "# Run NUTS.\n", - "kernel = NUTS(model)\n", - "mcmc = MCMC(kernel, num_warmup=1000, num_samples=2000)\n", - "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_1 = mcmc.get_samples()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Posterior Distribution over the Regression Parameters\n", - "\n", - "We notice that the progress bar gives us online statistics on the acceptance probability, step size and number of steps taken per sample while running NUTS. In particular, during warmup, we adapt the step size and mass matrix to achieve a certain target acceptance probability which is 0.8, by default. We were able to successfully adapt our step size to achieve this target in the warmup phase.\n", - "\n", - "During warmup, the aim is to adapt hyper-parameters such as step size and mass matrix (the HMC algorithm is very sensitive to these hyper-parameters), and to reach the typical set (see [[6](#References)] for more details). If there are any issues in the model specification, the first signal to notice would be low acceptance probabilities or very high number of steps. We use the sample from the end of the warmup phase to seed the MCMC chain (denoted by the second `sample` progress bar) from which we generate the desired number of samples from our target distribution.\n", - "\n", - "At the end of inference, NumPyro prints the mean, std and 90% CI values for each of the latent parameters. Note that since we standardized our predictors and response variable, we would expect the intercept to have mean 0, as can be seen here. It also prints other convergence diagnostics on the latent parameters in the model, including [effective sample size](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.effective_sample_size) and the [gelman rubin diagnostic](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.gelman_rubin) ($\\hat{R}$). The value for these diagnostics indicates that the chain has converged to the target distribution. In our case, the \"target distribution\" is the posterior distribution over the latent parameters that we are interested in. Note that this is often worth verifying with multiple chains for more complicated models. In the end, `samples_1` is a collection (in our case, a `dict` since `init_samples` was a `dict`) containing samples from the posterior distribution for each of the latent parameters in the model.\n", - "\n", - "To look at our regression fit, let us plot the regression line using our posterior estimates for the regression parameters, along with the 90% Credibility Interval (CI). Note that the [hpdi](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.hpdi) function in NumPyro's diagnostics module can be used to compute CI. In the functions below, note that the collected samples from the posterior are all along the leading axis." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "id": "Nzqje01_N7l7" + }, + "source": [ + "From the plots above, we can clearly observe that there is a relationship between divorce rates and marriage rates in a state (as might be expected), and also between divorce rates and median age of marriage. \n", + "\n", + "There is also a weak relationship between number of Waffle Houses and divorce rates, which is not obvious from the plot above, but will be clearer if we regress `Divorce` against `WaffleHouse` and plot the results. " + ] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 + }, + "id": "jBhug-OzN7l8", + "outputId": "9f95c298-43e7-4f40-cde5-0a9364088980" + }, + "source": [ + "sns.regplot(x='WaffleHouses', y='Divorce', data=dset);" + ], + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX4AAAEGCAYAAABiq/5QAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO29eZhkaVng+3tjj4yI3LMyi+6iWIWLbbPcFhHcsFxYdJCWdsSLekfvHcVmdLzjhj7juIwOiss4F+d6Zx4ZZBEQLiIC9oBK0wpKKw02zdI0jWR3FZVrRMYecU6c890/TkRWZGZkZsTJ+OJ8UfX9nqcqI8+J5XdORr75xXfe731FKYXFYrFYbhxiUQtYLBaLZbLYwG+xWCw3GDbwWywWyw2GDfwWi8Vyg2EDv8Visdxg2MBvsVgsNxiJqAVO4+6771bpdDpqDYvFYpkqGo3GzqVLl1YG7TM+8AM89alPjVphaNbX17l48WLUGkNjffViffVifY/nvvvuWz9un/FTPSIStcJIJJPJqBVGwvrqxfrqxfqGw/jAH4/Ho1YYibm5uagVRsL66sX66sX6hsP4wN/pdKJWGImdnZ2oFUbC+urF+urF+obD+MBvR/x6sb56sb56sb7hMD7wT1sROcdxolYYCeurF+urF+sbDuMDv+/7USuMRLPZjFphJKyvXqyvXqxvOIwP/KZcBR+WtbW1qBVGwvrqxfrqxfqGw/jA77pu1AojsbGxEbXCSFhfvVhfvVjfwZw2RW78Aq5YzPi/TQdIpVJRK4yE9dWL9dWL9T2I5ytqjkfd8U68nw38Y6ZQKEStMBLWVy/WVy/WN6Dd8ak5Hi3XY5h0GOOj6rTl8e/u7katMBLWVy/WVy83sq9SirrjsVl12K47NIcM+jAFI/5EwnjFAywsLEStMBLWVy/WVy83om/HV9TaHRqujx8y3d34Eb9N59SL9dWL9dXLjeTb6vjs1B02qm1qjhc66MMUjPinLfC3Wq2oFUbC+urF+urlevf1laLheNQcj44/vsWsxgd+m8evF+urF+url+vV1/WCi7UNx0cNPXM/PMZP9dg8fr1YX71YX71cb75N12O77rBZc6g7npagD1Mw4p+2dM5MJhO1wkhYX71YX71cD76eH2Tn1B0Pb0K1yWzgHzPZbDZqhZGwvnqxvnqZZt+mGwT7Vmfy1zGNj6rTlsdfKpWiVhgJ66sX66uXafPdLZYotzpcrbTZbbiRBH2YghH/tOXxLy0tRa0wEtZXL9ZXL9Pgq5Si6frUXQ8/k6fajn4wa/yIf9rSOavVatQKI2F99WJ99WKyr+v57DVdrlYdik2XdsfHaTSi1gImFPhF5PUisiUiDxza/m9E5HMi8mkR+c1Bj522wG9Ko4Vhsb56sb56Mc23V0ZhqxZk5hxeaNXpmOE7qXmUNwCvA97Y2yAizwdeAjxdKdUWkXODHmjz+PViffViffViiq/j+dSHyLsvLK5M0Op4JjLiV0rdAxQPbX4l8BqlVLt7n61Bj7V5/HqxvnqxvnqJ0tfvG91vDZl3Xy1uT8juZKKc4/8K4OtF5GMi8mER+epBd7LpnHqxvnqxvnqJwrfd8Sk2XK5WHEpNF8cbfjo6mTZj3UGUKTMJYBF4DvDVwJ+IyBPUodYxxWKR5z3veSQSCTzP4/bbb+fOO+9kY2ODXC5HPB6nUqmwsrJCsVhEKcXKygqbm5vk83kAarUaq6urbG9vIyIsLi6yvb3N7OwsnudRr9dZW1tjY2ODZDLJ3NwcOzs7zM3N4TgOzWZzf38qlaJQKLC7u8vCwgLNZpNWq7W/3/d9KpUKpVKJpaUlqtUqjuPs789ms6RSKcrlMsvLy5TLZVzX3d8/6WMqlUp4nnfiMWUyGbLZrBHHNDMzw/r6+pl/TpM6plKpxOzs7ETee+M4pna7zfr6ujG/T6cdk1KKvb097e+9Wq3O7NIKVzc2kFicTL5AvVwikyvgdVzcdovC4grV4jaJRIrUzAyNyh7Z/Byu06LjtCksrtCsllFKkUxlaNbKzMzO4zQadDrO/uOT6QzxRJJWvUpuboFWrYrndfb3pzIzxGIxWo0a+fklGpU9lFLk5heplXZIZ3OnBl85rUXXuBCRxwHvVUrd0v3+LuA3lFIf6n7/MPAcpdSBz0J33323evrTnz4Rx3Gwvr7OxYsXo9YYGuurF+urF92+rU4wdz9sg5PTKG1eYWH1pjE80+lsPfyZj1+6dOm2QfuiHPG/G3g+8CER+QogBewcvtO05fEvLy9HrTAS1lcv1lcvOnz3Syi4Ht4YK2IC5ObM6B8wqXTOtwJ/BzxFRC6LyA8Drwee0E3xfBvwg4eneQA87+TekaZRLpejVhgJ66sX66uXcfo2XY/dustGtU2l3Rl70Ado1cxYdzCR4bRS6uXH7HrFEI8ds41epi0Lyfrqxfrq5ay+ky6Q5nnRr9qFKSjZYPP49WJ99WJ99RLGVyl1be5+wrVybqg8/rMwbSMQmwetF+url+vZ1/X8oEBa1YmsQJopefzGj/jj8XjUCiORy52eSmUS1lcv1lcvp/kqpWi4Pg3Xox1RJcx+UpmZqBWAKQj808a0/aGyvnqxvno5zrdXQqHp+mdqSj5uTFmQaobFCUxbVk+lUolaYSSsr16sr176fQeVUDAp6AO0GrWoFYApGPFP28XdlRUzLt4Mi/XVi/XVy8rKCk73Qm3D1dOYfJzk583oH2D8iH/aOnAVi4dr0ZmN9dWL9dWDrxS1dodHrm6zVXeou/oak4+TRmUvagVgCkb808a0rTuwvnqxvuOl3enN3QclFDpT1q/DlPNrfOCftpIN0/hReZqwvnox0dfzFY1uY/LOodW0ufnFiKzCYYqv8VM905bHv7m5GbXCSFhfvVjf8PSXUCi3OkeCPkCtdKS8l9GY4mv8cHra0st6ZV6nBeurF+s7GqMWSBumBLFJmOJrfOC3WCzXP003aFvY6oyn/LHlZIyf6pm2PP5azYw83WGxvnqxvsfj+YpKq8PVapvdhkszRNBvN+ta3HRhiq/xI/5py+NfXV2NWmEkrK9erO9RxtncJL8wXf0DTPE1fsQ/bXn829tmFGEaFuurF+sb4PmKarvDRrXNTt3ZT8c8K/W96Vh30MMUX+NH/NOGiEStMBLWVy83uq/T8an15d2Pmxv9/IbF+MA/bXn8i4tm5OkOi/XVy43o6ytFw/GoOz6u5gVWM7PzWp9/3Jjia/xUz7Tl8duP9nqxvno5i6/j+ZQaLlcrDnutjvagD1Db29X+GuPEFF/jh9PTlsc/OzsbtcJIWF+9XO++vXr3dcfD8SZfPiEzM13rJEzxNT7wTxvTln5qffVyvfq6XjB333CirYjpT1mtHlN8jZ/qmbZfnHrdjDzdYbG+ermefFV37n6r5rDZrXcfdUVMp9WI9PVHxRRf40f805bHfyM0q44S66uXQb6dXhkFAxubmNK8fFhM8TV+xD9tF3ev52bVJmB99dLzVUrRdD226w4b1TbVdse4oA/mNC8fFlN8jR/xm5L3OizT9gnF+upl2nzjiQSVVoe64+EZGOgPE48bH8IOYIqvGRYnMG1ZPXNzc1ErjIT11cu0+Da79e6dRJZKe3pWy2fyhagVRsIUX+OneqatZMPOjhn1tofF+urFZN/DRdJaHZ96uRS11khY33DYEf+YmZYRXg/rqxcTfU8qkpbJmTEiHRbrGw7jA78pPSqHxXGcqBVGwvrqxRTfk9oXHrhfZ7qSKaxvOCYy1SMirxeRLRF5YMC+fyciSkQG1is1ZcHDsDSbzagVRsL66iVq33bHp9g4uX1hP267NSGz8WB9wzGpOf43AC84vFFELgDfBjxy3AOnLSviesjbNhnrezq+UtTaHTarDtt1h8YIlTFNyTMfFusbjokEfqXUPcCgQtS/C/wMHP++tHn8erG+epmk7ziKpJmSZz4s1jcckc3xi8hLgCtKqX86KVc/FjM+8egAqVQqaoWRsL560e077iJpicR0nV/rG45IAr+IzAA/TzDNcyLFYpHnPe95JBIJPM/j9ttv584772RjY4NcLkc8HqdSqbCyskKxWEQpxcrKCpubm+TzQSW8Wq3G6uoq29vbiAiLi4tsb28zOzuL53nU63XW1tbY2NggmUwyNzfHzs4Oc3NzOI5Ds9nc359KpSgUCuzu7rKwsECz2aTVau3vB6hUKpRKJZaWlqhWqziOs78/m82SSqUol8ssLy9TLpdxXXd//6SPqVarcfXq1ROPKZPJkM1mjTim2dlZ1tfXz/xzmuQxtVqtsb/3CnNz7FUbNJot8ovLVIvbJFJpkqkMzVqZmdl5nEaDTsehsLhCtbhNMp0hnkjSqlfJzS3QqlXxvM7+/lRmBqV8SptXyM8v0ajsoZQiN79IrbRDOpsDgr6x+YVl6ntFRISZ2Xlqe7tkZvL4vo/Tauw/ZzyeIJMvUC+XyOQKeB0Xt93a359IpEjNzNCo7JHNz+E6LTpO+9r+U45JRGjWKiceUywWo9WoGXFM7WYdSnLmn9Mwx3RiDJ5U1oyIPA54r1LqFhH5KuCvgF7FopuBLwPPVkod+Gx89913q6c//ekTcRwH6+vrXLx4MWqNobG+ehmnb1BGIaiKqasEcmnzCgurN2l5bh1Y3+PZevgzH7906dJtg/ZFMuJXSn0KONf7XkS+BNymlDqy2mXaOnAtLCxErTAS1lcv4/Dt+MHF2obra6+Xk82bt+7gJKxvOCaVzvlW4O+Ap4jIZRH54WEfa9M59WJ99XIW3/4iabUJVcZ0HTPSDYfF+oZjIsNppdTLT9n/uOP2TVvgb7XM+MEOi/XVy6i+Xl8J5CiKpHWc9sRf8yxY33AYP49i8/j1Yn31Mqxv0w26WTU70TYeMiXPfFisbziMz5U0JY//3kfL/PT7HuL73/Zpfvp9D3Hvo+WB97N55nq5nnwPF0mLOuiDOXnmw2J9w2F84Dchj//eR8u87qOXKTZcCukYxYbL6z56eWDwz2QyERiGx/rqZZCv410ro1Bpd/BOKaMwSRKpdNQKI2F9wxF9VD0FEwL/O+7fIhkTMskYIsHXZEx4x/1bR+6bzWYjMAyP9dVLv2/vYu1WbbQyCpMkmZquP6zWNxzRR9VTMKEe/0bVIZ04uLo4nRA2qkcrL5ZKZtTbHhbrq5dSqUTd8disOuw2XNods5MVmrXBU5imYn3DYXzgNyGPf62Qot05OD5rdxRrhaPLr5eWlialNRasrx568/cqXaDUdEPVzYmCmdn5qBVGwvqGw/jAb0I65x23nsP1FS3XR6ngq+sr7rj13JH7VqvVCAzDY33HS8dXlJrX5u+bjXrUSiPhNBqn38kgrG84bOAfgmdfmONVz72ZxZkk1bbP4kySVz33Zp594egqPFMabwyL9R0P7Y7Pbj0I+HXn2vx9p2Om73FYX72Y4hv9PMopmJLH/+wLcwMD/WGu1zxzUzDNt+F4J9bOMSVve1isr15M8TV+xG9KHv+wXE955iZigq/qNjq5Wm1TbLonFkwzJW97WKyvXkzxNT7w7za9ExdMmcY0pxtOA1H6XltwFTQ6GSb/Ppk2I31vWKyvXkzxNT7wAycumDIN2yhEL1H4Op2gs1Xvgu0oxdLiCTOmKofF+urFFF/jA39C1IkLpkyjXDb/j1M/1ncwvlL7+fdbdYd6yAVXrbrZWUiHsb56McXX+Iu7jgr+Nh23YGoQ9z5a5h33b7FRdVgrpLjj1nNDXZgdB8vLyxN5nXFhfQ/S7gRtDJuujxrD2trc3HT1D7C+ejHF1/gRf1KCX77jFkwdZpS6OjqwI2i96PD1fEW13WGj2ma73iunMJ6CCq2aGSO8YbG+ejHF1/gRv3DygqnD9NfVAcgkBVyfd9y/NZFR/7RlIen01fHJa5y+re7ovqWxbo7nRV9yZBSsr15M8TV+xN/0YicumDrMKHV1dGBanvlp6PLV9cnrrL79pZB36g5NzcXSTMnbHhbrqxdTfI0P/Gu5GK998ZOHHimOUldHB6PkmQ9b418nuvLiR6loOgphfIMm5R47dYerEy6FbEre9rBYX72Y4mt84I/H4yPdf5S6OjrI5XJD3S/qaxE9hvUdFV2fvEbx7fiKcqvDRrcyZiuCypipzMzEX/MsWF+9mOJrfODfqDojjYZHqaujg2H/UOkaEY/KqH9Yh0XXJ6/TfJVSNJxrTcqr7U4kvWt7mNBPYhSsr15M8TX+4m4qpvZHw696LkMF8GHr6uigUqmwsHB6ytZG1aGQPvgmmOS1iB7D+o7KHbee43UfvQyuTzohtDtqLJ+8jvN1vGtpmKMssNJNq1EjW4jmvRgG66sXU3yH/vMjImkR+TUR+aKIlLvbvk1EXqVPL8jjn6YFXCsrw128ifpaRI9hfUdF1yevft/eIqutWtDVqu54RgV9gPz8dPQP6GF99WKK7ygj/t8FbgL+N+Avuts+3d3+ujF77ZPq5vFHMRoOQ7FYZGbm9Hk8XSPiURnWNww6PnkVi0US6Qz1tkdjTIusdNKo7DG3Mj2ZXtZXL6b4jhL4Xwo8SSlVFxEfQCl1RURu0qN2kChGw2FQQ444gxExka0w7jGsrwk0XY9quwM18wcAPabp/IL11Y0pvqMEfufw/UVkBdgdq9Eh2komnplzFkaZOonyWkQPXVM946TheFTbHq7vk5k1Y8n7sOTmF6NWGAnrqxdTfEe5xPwO4I9E5PEAInKeYIrnbTrEeqRk8pk5Z2FzczNqhZEw2bfueGx0a973etbWSjsRW42G9dWL9Q3HKCP+nwd+A/gUMAM8BPx34Fc0eO2zlEvz2q95ss6XGCv5fD5qhZEwzVcpRcP1j11klc7qWXegC+urF+s7mNPWrAwd+JVSDvCTwE92p3h21JATViLyeuA7gC2l1C3dba8FvpNgCulh4F8ppfaG9bFcX6huhk617UWad2+xTAuu57NVc9motdmqumzWHDZrDhtVh3Krw2uedfxjhw78IvIDwCeVUvcrpba7254O3KqUetMpD38DwbTQG/u2fRB4tVKqIyK/Abwa+NnDD/Q8b1hFI6jVaiwtmZGyNQxR+/ZSMmtDBvx2s87M7PwEzMaD9dXL9e7b8RW79SC4b/aCezUI8MWGGzqnbZSpnl8FnnFo26PAe4ATA79S6h4RedyhbR/o+/bvgZcNeqwpzdaHZXV1NWqFkYjK11eKWjtoVD5K7n1+Ybr6B1hfvVwPvr4KFqn2gvpGzWGr6rBZc9muO4QpKxWXk/ePEvhngcqhbWVgHH9ufwh4+6AdnY4ZZUyHZXt7mwsXLkStMTST9nU8/0w5+PW9IvPnzmsw04P11cu0+Cql2Gt1ePjRLeqJ/IGR+1bNpRMiuguwlEuylk+xWkhxLp9iNZ9irZBiaSbJ7j9/9tjHjhL4PwN8N/AnfdteChz/7EMgIr8AdIC3DNpfLBZ53vOeRyKRwPM8br/9du688042NjbI5XLE43EqlQorKysUi0WUUqysrLC5ubl/4bJWq7G6usr29jYiwuLiItvb28zOzuJ5HvV6nbW1NTY2Nkgmk8zNzbGzs8Pc3ByO49BsNvf3p1IpCoUCu7u7LCws0Gw2abVa+/sbjQaVSoVSqcTS0hLVahXHcfb3Z7NZUqkU5XKZ5eVlyuUyruvu75/0Me3t7ZFIJE48pkwmQzabDX1MMzMzdFSMUrlMdm6RRmUPpRS5+UVqpZ39C17tZp38wjL1vSIiwszsPLW9XTIzeXzfx2k1QEFp8wrxeIJMvkC9XCKTK+B1XNx2i8LiCtXiNolEitTMDI3KHtn8HK7TouO0r+1PpUmmMjRrZWZm53EaDTodZ39/Mp0hnkjSqlfJzS3QqlXxvM7+/lRmhlgsRqtRIz+/dOwxtWoV3PnFE4+p95wmHFPHaVPavHLiMQ3zc5rUMXXabZq1ypl/TuM4pvzCMhubW5TcOMVOnCvFGiU3HozcGx2c/euttZFi5Hw6xnJGOL+QYz7W5vxsltV8kjwt5heX+44pFxyTn6N9ykvIsAsKROTrgPcTzM0/DDwJuAS8SCn1kSEe/zjgvb2Lu91t/zvwI8AlpVRj0OM+8pGPqKc97WlDOZpAo9HQthJWBzp9ddTPcdstkunMWJ5rElhfvUTh23C8/QupvVF772vDDVcBdjYd51x3tL5aCEbuq/lgFJ9OhCvstvXwZz5+6dKl2wbtG2XE/1HgFuD7gAvAvcBPKKUeDSMlIi8Afgb4xuOCPkxfR6vt7W0uXrwYtcbQjNvXV4qmGwR8xxt/GeTa3i4LqxNZLD4WrK9edPm2O353GibIkukP7tV2uISTmWSMpQzctJBnrW9qZrWQYiapp0rucQwV+EUkTvD5ZF4p9ZpRX0RE3gp8E7AsIpeB/0CQxZMGPigiAH+vlPrRw4/VVTZYF7Ozs1ErjMS4fJ1uG0Pd9XMyM2atOzgN66uXs/i6ns9W3WWre0F1sxoE+s2aQ6kZ7tpiOi7XRux9I/fVQop8Kk6rVjGiOudQgV8p5YnI54El4MujvohS6uUDNv/hqM8zCB19Xc/CtKWfnsXX8xUN16Ph+Psra3XjT+h1xoX11ctpvp6v2Gm4R6ZkNrvNecIMURIx6U7DJFktpPYvrq7mU8xlEnQHsqF8J8UoUz1vAd4rIr8HXIZr50wp9dfjFutxUmDqdbFKxuRAF6th6/broF6vs7w8PSlmYXwn0aT8OJxWg9zc9NTrsb56cVoNsrPzFBudgVMzO3UHL2Q65HIuxWo+yWohfWBqZnEmQeyE4H6arwnnd5TA/8ru1186tF0BTxiLzQBOyuPv72IFkEkKuD7vuH8rssB/vTZb7/hBZ6u6602sX+0gTGlWPSzWdzwoFbTRvDZqd9mottmsttmuP4gbNh1yJnl0aqabDpmIhQvuJzGJ83v/1Sp3PVjk25f4quPuM0rJhsePR2s0Trq4a0oXq342Njam6uLuSb69ujkN16MdQb/aQVSL21N18dH6jkat3dmfbz8wNVNzQ78H5zOJgcH9XC5JMj7ZVoi6z+/9V6u8+RObJARiwrEXKkZqvSgiCeC5BA1ZLgN/p5TSusLqpPmytUKKYsMNRvpdoq7bP20rjZPJ5JHrJN/1lcs87VzeyEYn8bjx3UIPYH2P0nS9/ZoyW4eCfD1kOmQhHT8Q2PunZsKmQ+pA9/m968EiCYF08uRjHqVWz1OBPweyBKUaLgAtEflOpdSZFnGdxElZPaZ0sepnbi76K/aj8Egzzn/9x8skBGaSwlbN4ff/7gqveOYqt54vRK13hEzePKeTuFF92x1/P0Pm8EXVSsh0yGwyduBC6mohxWLK5+bFWWZS05H9p/v9sF13yaVOn6Ia5c/PfwX+G/BbvaqcIvJT3e3PDyM5DCeVbDCli1U/Ozs75HLTUSpWKcWnvngFIU08LvhAKiEoV3HXg0UjA3+9XCKVmZ4Fctezb8dXbNcOpkL2LqyGTYdMxeXIlEzvayEVPzIDUNq8wkwq+oulw6L7/bCSS7LXdEknTw7+owT+ZwDfeqgU838GfiGE39CclsdvQherfqZhxN+/ovZzFeHw2pFUQtium7lwLpMz74/RSUy7r+crdhvuwFWqO/Xw6ZAruaOpkKuFFPOnpEOe5ms6un1f8JRF3vyJTThlymyUwP9l4BuB/tTNrydEXv8omNKjclgcx8x+sJ6vaLoe9UM59+dnYmyX1YERgtNRrOTMvFbhdcz8g3Qc0+DrK8VeM8iYWd+ssOc394P7di1cOmRMYDmXPLCAaa3QS4dMhk6HPMw0nN9+dPveer7AKwjm+n3lHBvfR+3A9R4ReS+wDlwEXgy84kymp2DKgodhaTabY3mecS1Ma7rBatrjcu6feS7FfXseuD6phOB0FB0VjBxMxG23olYYCVN8lVJU2t5+QN/om5rZqjmh0yEXZ7rBvZBkNZ/ufk2xnEtpSYc8jCnnd1gm4Xvr+QK3ni+w9fBnPnXcfUZJ53yPiDwL+B7gMcADwC8qpT5/dtXjmbYsmXHk8Z91YZrr+UEapnN6c5MnXryJV+Ta3PVgke26y0ouyQuesmjk/D6Ym2d+HJP2rTnewFWqmzXn1HZ8xzGXSewH97V8mnPd4H4unyI14XTIw9j3QzhGyep5hlLqk8B/1OhzhDBF2qIs4zBqHv8g1zAL03o596MWR6sWt7n1/E3GBvrDRJ1nPio6fJuu182Y6S5iql2rN1N3wmXM5FNBOuR8osNjV+b3593P5ZNkJ1xAbBTs+yEco0z1fEBEtoG3Am9RSv2zJqcDxGKjjSiiLuOQSg2/huA411bHZ3nm4I/muIVpfl+v2jCljxOJ6NY8hOFG8XU8/2COe9/tcitkOmQixrkBF1TP5YMCYgDV3W0KS9NTcuRGeT+Mm1EC/3ngBcDLgX8SkU8Dfwy8XSm1pUMOYKPm8sb3PcSt53Pcf7V+6ig+6jIOhcLwI+fjXGueot1RJy5M8/xur9oRWxceJjVFvQPg+vLt+Irt+oBVqlWH4hnSIfs7MZ3rC/Kz6aPpkKP4moj1Dccoc/we8D7gfSKSBV5CUL/ntwjKK2shHVNcKbd4YKPGwkyC+UzixFF81GUcdnd397tkncZxrnEhuNg2YGFas1sNs9UZT4G0RmVvvwvRNDBtvrVyibKX3F/M1Mtz36o67DTc0P1U+2u593+dz4YvIAbTd36tbzhGXj8sIhngO4B/CdwG/M24pfrpqFiwjFug7vgsZOXEUXyvjIOnfErNDq6niAs8Zk7b36YDLCwMv5jkuJITj1vM7s/1b1QdVvNJvuN/WebCXIbdxnjTwbJ589cd9GOib386ZC+o9xY1bdcdOn515OeMCSzPJDnXV4Kgv4DYuNIhD2Pi+T0J6xuOUS7uvoig+9a/IOi/+zbglUqpDU1uAMREBcEbcPsSio8bxd9x6zl++55HqLQ6iAQpZx0fSg2Xex8ta5/uaTabQzc3OankxLMvzHHr+QK1dmc/G+O0DJ0wuE6LTG56mm9E5auUotr2jqRC9koBO2GS3YHF7OACYisTSoc8jH0/6MUU31FG/L9FcGH3mUqphzX5HCGGIhkXHE+Rip9ejO3ZF+aYz8S7qYyQiAvzmTiJWGwi8/yt1vB5urTA9BIAACAASURBVMeVnLhlNd8NJvrXMHSctvbXGCe6feu9fqpHqkM6NEMWEJvLHCwg1n9RNep0yMPY94NeTPEdZY4/ko7nbRUjl4zhdHxyqRi1dodio0PHVyRiDBzFN1zFhfn0gQtZSqmJzPOPmsffKznRS8estjsUm5NbjWhKXvGwjMO31S0g1j/f3puaqYVMh8yl4kHTjkMVIhfTQmFmepqX34jvh0liiu+JgV9EfkEp9Wvd279y3P2UUr84brEeKfG5aS7DC5+a42+/VGa91CIZE87lknR8Bl7kjbJc86h5/FE3ODElr3hYhvV1PZ+tmntk1L5RdSi3QvZTTVyrDnkun2StkD7QT3UQpc0rMHP9nV9TsL7hOG3Ef3Pf7Qs6RY5jcSbFa1/8ZADuv1rnptn0fvojMPAib5TlmjOZ00d3vbo5DdefyHTOSSRSk7noPS76fTu+Yqfem5Jx2ay1u18diiH7qSZjciAF8tr0TPLUfqqn+U4D1lcvpvieGPiVUq/s+/a1BEXZFoEi8LdKqU9rdAMOLuAaNlUzynLN2Wx24PZe3n2rE32w7yeZMnsawleKYrc65EbV4culJrutR9ioOezW3dD9VFfyB+fbe1MzZ02HPIzp5/cw1lcvpvieOscvwRDnD4EfAK4QVOO8CXiMiLwJ+CGlsYTmTq3FT7/vIe649dxIUzhRlWsulUoHsnpaHZ9626PZCTd3rJtmrRx5loFSir1WZ+AF1a2aSydsP9Vcsm9q5lpK5NJMkviEMmZMOL+jYH31YorvMBd3/zXwTcDXKqX+obdRRL6aIMvnR4A/0GJHkMffW7D1rU9e4IMPlYzquHWYpaUlnI5PsxP0qo2yMfkwzMzOT+R1lFJUHe/AhdRekN+qObRDpkMuZBNHVqmu5VMsR9BPdRCTOr/jwvrqxRTfYQL/9wM/3h/0AZRS/yAi/xZ4NRoDP8pnp+GSS8a4/2qdVz33ZqM6bkEwHdHu+LQ6Pps7JfIL09Nn1Wk0xrqSsNFLhzzUU3XjDOmQs+n4tZWpMZfHri7sV4c0qZ/qIMZ9fnVjffViiu8wEeppwIeP2fdh4E3j0zlKTBQd32ev5eN6TSM6bvUCveMFX13P37+Q6BraiOU4Op3Rfdsd/8iUTO92NWQ/1Zlk7Eiee28UP9NXHbK0eYWF1eEWyJlAmPMbJdZXL6b4DhP440qpgWvOlVJVEdE65Kp3BLcbS2qON5HVt4fxlaLp+jjdYO+e0BzGlDzdYTnO1/V8turugamZXr2ZsP1U03EZuEp1tVsdcpiMmevl/JqK9dWLKb7DBP6kiDyf4HpZ2OcITS5+be7XU4Pz9nVxWveqQZiSpzsMHV/xxSsbtNKLR1ar7oZMh0zE5Ega5GohHTod8jDTdH7B+urG+oZjmKC9Bbz+lP3a6KiDgSIZE22lF3pTOE03mK8PU+44mTYjXauHrxSlZudIfZnNqsNOvddPtT7Sc8YFlnOHg3uK1XyaxZnxpkMexrTzexrWVy/WNxynBn6l1OPO+iIi8nqCip5bSqlbutsWgbcDjwO+BHyPUqp0+LGHkz3GUWLZ9XxcT+F4Ph1f4flBAbSz1LXvEU9MvlWkUopyq8NmzWWz25Fpo9pmq+aeqZ/q0kxy4NTM8gTTIQ8Txfk9C9ZXL9Y3HJNKP3kD8DrgjX3bfg74K6XUa0Tk57rf/+zhB6ZjB4PWaaUXfKXwfEXHV/gqWDjl+QpPqW6QV2OpY38crXqVbH78Fx+VUkE/1YEFxFzaIfuppmMKnxhPWZnhaau5IFumkOKcIemQh9F1fnVhffVyvflK9/+YBN/EkKDKcLfSsIjQ3dXdLvu3e5+0e2Oyk6ZiJhL4lVL3iMjjDm1+CcH6AIA/Au5mQOBv+gdHlo7nc/stKzgdH08FJZs7/rV/4xi1n4Xc3PD1+AfRdL2BqZBbVSfoSxCCfCq+n9/+4HaDju+TTcZIxIXFpMdmM0bHV7zgKUtncj8r91+tntr0/aznd9JYX71MyvdA0O0G2d7XGBCLBfvisWv3gYOBGoG8nCOXS+1v7xHrBvFJEWXC+apS6mr39gawOvBejTKP/v6rafqQjsGzXvpSzn/Lj/HgF/+ZVGaGWCxGq1EjP79Eo7KHUorc/CK10s5+vmy7WSe/sEx9r4iIMDM7T21vl8xMHt/3cVoNCosrVIvbxOMJMvkC9XKJTK6A13Fx2639/YlEitTMDI3KHtn8HK7TouO09/d32m0KS+do1srMzM7jNBp0Os7+/mQ6gydxLu9UqEqWK6U6W/UORTfOZrVNzQ33hyubiLGcgdVCmpWZOItJj4uri8y4FfLp5P4xvaHispiGuYTD55sZ/td8g0cSKS43OpQ2rww8pkQqTTKVOfGY4okkrXqV3NwCrVoVz+vs7x/m5/SlYpMHL+/QcVI8Z8HF8Vq891Mt0vUUj11d3P85CUK9XDrzz2kSxwRQ2d1i6aaLE3nvjeOYmrUy8UTSmN+nk46pVtym4zjMLi3TqlWZXVikWavidTosrpyjtLNFJjtDPB6nUasyv7RMda+EUoqFpSVKOzvM5HKIQKNeZ2XlHMXdHWIxYWFxkd3tHQqzBZTvU6/XWVtbY2Njg2QySWFujp2dHebm5nAch2azGey/ukEqlaJQKLC7u8vCwgLNZpNWq8Xa2hqXH1lnZWWFbDZLqVRiaWmJarWK4zj7z5/NZkmlUpTLZZaXlymXy7iuu78/l8sRj8epVCqsrKxQLBZRSrGyssLm5uZQHQBFY7WFgy8UjPjf2zfHv6eUmu/bX1JKHfnz/a6/+KB67Wfi+D48Zi7Fr3zbEyfiG5Ygz/wmXM9nu+4OnJoJmw6ZisuR+fa17tRMYch0yN+8e529pku6W+ju6bkG9+5lmM8m+ZlvGr6q6Lg57AXQdv0jXr3zOy2Y5Ct9t3rTB72phN6Ic+fLl1m96eb9EWlv+/5XDk4x7D+jHHyNw+/FXpxRQC/kqO521f1G9W2j73kGTW30fNbX10eqhhs1k/S97777Pn7p0qXbBu2LcsS/KSLnlVJXReQ8x0xJNTrBDzqfjvOyrzKnNAME1w92GweD+0bFZfPjX2C3Hj4dciWX3K8rc64b3FcLKebHkA75gqcs8uZPbILrk0oID1RSdFSwPUq26y651MFjSyWE7frB3gSm5EH3kL7/QfX9HzAuX6EXfPumGfoDeF9A7O2PixCLBT2ch33f5C88hnR6/Bcge68v+//t7znT847a/yJqTPGNMvC/B/hB4DXdr3826E75BDxxaWbgfO8k6PVT3egvHNadd9+uOaGqQ/b3U107NILX2U8V4NbzBV4B+3Pp37Tc4cJjL0RybvtZySW7I/5rx+50FCu5g0FonHnQ+/O23SAaix0MpvH+edxDAbX/YtogeqPW9Uc2OX/hsde20zfK7W7o3d5/tkOBfJJzv6P2k4ga6xuOiQR+EXkrwYXcZRG5DPwHgoD/JyLyw8A68D2DHjs/k9I+BaGUotL2ro3a+3Lez5IOuTjT68iUZDWf7n5NsRxRP9Uet54v7Af6erlEbi7aoA9HP4k4HbX/SaR30SwRE2ZzeXKp+H6QjIkQj12biti/kMa1G4enHyYRUHvPnc/lBqS+RvezP41cLvo6MqNgfcMxqayelx+z69Jpj92uu/zh3etjGfHXHO9oKmT3aytkOuRcJrEf3NfyaeYTLo9dWeBc3sx0yMP09zuYNEEAFmIiPPvCHJlEnD//7A5btaAA33d/1Tm+5sLcgcAZd1IsZM3IhR6GeHxwZy5Tsb56McXX+DKSqZhir+ny5k9s8go4Nfg3Xa9bUyZYxNS/qKkesp9qPhUfUF8mybl8imzy4A+ytHmFhTkzuuwMQ6tRI1sItwq6N1XSPw3SS28bNEXS//2gEfc3P2mRb37SydcaKpUKCwvTk3JoffVifcNhfOBvq1iQ6eH63PVgkVvPF3A8/0CO+2bf1EwlZHXIbCI2cM59NZ/i4d0Gdz1Y5MHtBsWGy8WFNBcXBnfays8Pnws/TN66DvoD9sLiMulEbOCFwsO3D895T3LuucfKilkXd0/D+urF+obD+MCvfJ/L5TbJmLDb6PBT732I4hnSIc/lj5YgWMunKKQHp0Pef7XKmz+xSUIgl5JTP300KnvMrZx+5X7U5x2WeHfqJB4L5sXjEsyN9+bBg6/XjvNyeZuV5WjLXI9CsVhkZmYmao2hsb56sb7hMD7wtzwJaul0L7CeFvTjwsDgvpoP10/1rgeLJIT9/PJ0Ug58+jjMsOsiRnne/mB+eDTeu+jZC+6jMql1HOPC+urF+urFFF/jA/8gJpkOOWx+eY/c/HD58IOeN52IsVN3mU0nSMavBXSdUyqmfPQcFuurF+urF1N8jQ/8cVHERMgmYsRiws89/yIrE0yHHDa/vEettHMkz1y6OeJxke7oHdYKKfaaQeP43px7y/W5aS7NbGZyP5bNzU0j8oqHxfrqxfrqxRRf4/MNkzFIxoVUQrhpNs35QnqiOfAveMoiHRWUD1BK0Xb9IytdYyKk4jGyyTjzs7MsZJOs5FKcL6S5eS7DTXOB97l8iqVckoWZJC9/xiqeCv6IALRcP5LG8cPU9TAJ66sX66sXU3yNH/EDuJ6i3PH4hscPzqTRyeGVrqv5JC/5yhWefWFu8Nx6M0YudXqu7rMvzPGq52Jc43iLxXL9Y3zgT4pCKZhJCg9uN7W/ngCJWOzAHPu3PGmJb/+K5aEuntZqNZaWhkvpNKFx/Ci+JmB99WJ99WKKr/GBv+kH2SytjuLyXmuszx0TIRkXkjEhGY/t3z7LxdTV1cHVpU3F+urF+urF+obD+Dn+bEwhEhSyCldUIRjFp+IxZpJx5jIJlrvz74+ZTbOSSzGfTZJLxUnFY2fOoNne3j7T4yeN9dWL9dWL9Q2H8SN+heD74CtouD6/eUrdnuBCa3CxNRHrjujHUDPn3kfLQ83HR7Ga9SxYX71YX71Y33AYP+Jv+UHD9RiQjl9b4Xr/1SoAyViMXDLOQjaofPmY2TTLuRSzmQQzqfjYgv7rPnqZYsOlkI5RbLi87qOXuffR8pH7Li5GW9d+VKyvXqyvXqxvOIwP/NnYteYWs5k4mWSMVEz4y4dKPGY2zfpek1//0Jf40Xd9jp+/6+GBwfisvOP+LZIxIZMMpoIyyRjJmPCO+4/2jjHlo9ywWF+9WF+9WN9wGB/4HXWthnpcIBmPMZOKsV13+cfLlaFH4mdho+qQThxeZStsVJ0j952dnR3ra+vG+urF+urF+obD+MAfk2ABVzwO5XZwebfdUawVUiONxM/CWiFFu3OwxkbP4TCeF646aFRYX71YX71Y33AYH/hTsaA5s1Lgev6BFa6jjMTPwh23nsP1Fa3u6t2TVtnW6/WxvrZurK9erK9erG84jA/8jopxLp/s1oIXFmeSvOq5N/PsC3MjjcTPQrDK9mYWZ5JU2/4Bh8OY0kx5WKyvXqyvXqxvOIxP50yLT1yEhQHB9o5bz/G6j14G1yedENodpa3ezbCrbE1ppjws1lcv1lcv1jccxgd+TwVNywflzZtY7yaZnJ5+sDBZ32HXQpyEPb96sb56McXX+MB/rpDhtc958rH7Tah308/cnDkuwzAp395aiGRMDmRgveq5jPTzs+dXL9ZXL6b4Gj/H3+mEa7MYFTs7O1ErjMSkfMeVgWXPr16sr15M8TU+8G/UOtz+xvt5031fjlplKEz5iz4sk/IdVwaWPb96sb56McXX+MAfF2h2PP74E5tTEfwdZ7yppLqZlO+4MrDs+dWL9dWLKb7mB/6YCjpuCfzpA2Z8TDqJZlN/z4BxMinfUdZCnIQ9v3qxvnoxxdf4wN/0AsU40HDNWPV2Eqbk6Q7LpHxHWQtxEvb86sX66sUUX+OzerJxH4jhATPJ01saRo0pebrDMknfYTOwTkr7tOdXL9ZXL6b4Rj7iF5GfFJFPi8gDIvJWEcn07/eV0PEVKHjpLctRaQ5NKjXeVcO6Mc33tBLYpvmehvXVi/UNR6SBX0RuAn4cuE0pdQvBjM739t/H8cHzg+qc91+taym7PE4KhcENYkzFNN/T0j5N8z0N66sX6xuOyEf8BNNNWRFJADPAgdSdTLcef0fBF4sNLWWXx8nu7m7UCiNhmu9paZ+m+Z6G9dWL9Q1HpIFfKXUF+C3gEeAqUFZKfaD/Pm1f6IWBuuNrKbs8ThYWFqJWGAnTfE9L+zTN9zSsr16sbzgivbgrIgvAS4DHA3vAO0TkFUqpN/fu4zfKPPL7r6bpQzoG57/1xVRueynr6+vkcjni8TiVSoWVlRWKxSJKKVZWVtjc3CSfzwNQq9VYXV1le3s7qPC5uMj29jazs7N4nke9XmdtbY2NjQ2SySRzc3Ps7OwwNzeH4zg0m839/alUikKhwO7uLgsLCzSbTVqt1v7+Xp5uqVRiaWmJarWK4zj7+7PZLKlUinK5zPLyMuVyGdd19/dP+pguX77MwsLCiceUyWTIZrMTOaaXPW2ej3xmHUTY7KS5OdniKgn+xRPzrK+vk0gkKJVKZ/45TeqYNjc3ecITnjCR9944jqlSqVAqlYz5fTrtmBzHwfd9Y36fTjumy5cvs7S0NJH33omxVyl16p10ISJ3AC9QSv1w9/sfAJ6jlPqx3n3e9f4Pqv/06SCbR4Cb59IsziR57YuPr98TJevr60ZctR8WE31Pyuox0fckrK9erO/x3HfffR+/dOnSbYP2RZ3O+QjwHBGZAZrAJeAf++9Q967N9wocWfQzjoqP48SUPN1hMdH3pLRPE31PwvrqxfqGI+o5/o8B7wTuAz7V9flv/ffJxa99IonFOLDo57TUvyjY2NiI7LXDYH31Yn31Yn3DEXlWj1LqPyilnqqUukUp9f1KqXb/fg8hnRDiMcgk4gdGgpPquTsKmUzm9DsZhPXVi/XVi/UNR+SB/zQ8Bb5SCEHBtn4m1XN3FLLZbGSvHQbrqxfrqxfrGw7jA38qpkjEYsxnEjxu8eBJm1TP3VEolUqRvXYYrK9erK9erG84jA/8PnGWZ5Ik4rEjlRzHVfFxnCwtLUX22mGwvnqxvnqxvuEwPvAr5VNqdvjWJy8c03P37BUfx0m1Wo3stcNgffViffVifcMRdTrnqaRisJBN8MGHSjxlJTcw+JvUc9eURgvDYn31Yn31Yn3DYfyIv61iRmTrDIspebrDYn31Yn31Yn3DYXzgT4sffI04W2dYTMnTHRbrqxfrqxfrGw7jA7/fLdEWdbbOsJiSrjUs1lcv1lcv1jcc5gd+hRHZOsNiSqOFYbG+erG+erG+4TA+8MdFGZGtMyzlsrm9AgZhffViffVifcNhfFbPcj7Da7/GzEqcg1heNr89ZD/WVy/WVy/WNxzGj/g9z4taYSRM+Ys+LNZXL9ZXL9Y3HMYH/ij7BYTBdd2oFUbC+urF+urF+obD+MCfTCajVhgJU/J0h8X66sX66sX6hsP4wG/KX8hhMSVPd1isr16sr16sbziMD/w7TY+fft9DkTZXGYVcLhe1wkhYX71YX71Y33AYH/gFjOisNSzxeDxqhZGwvnqxvnqxvuGYgsDvs9Nw6Xj+VNTqqVQqUSuMhPXVi/XVi/UNh/F5/C1P6Pg+ey0f12tGrXMqKysrUSuMhPXVi/XVi/UNh/Ej/nQMYiIogjaMplMsFqNWGAnrqxfrqxfrGw7jA78Q1OtBQfJw010DmbZ1B9ZXL9ZXL9Y3HMZP9TR9IRETcpk4N82a0aH+JEz5KDcs1lcv1lcv1jccxo/48wkV9NyNHe25ayKbm5tRK4yE9dWL9dWL9Q2H8YG/5XFsz10TyefzUSuMhPXVi/XVi/UNh/GBPxmT/Z6705DHb7FYLKZjfOCPi5qqnru1Wi1qhZGwvnqxvnqxvuEwPvDXOsLlcpuO509Fz93V1dWoFUbC+urF+urF+obD+MCfjfl0fJ+tustM0vx0zu3t7agVRsL66sX66sX6hiPywC8i8yLyThH5nIh8VkS+tn+/QqDbcB0xP/DLFDj2Y331Yn31Yn3DYUIe/+8BdymlXiYiKWCmf2erm8c/P5Og4fjRGI7A4uJi1AojYX31Yn31Yn3DEemIX0TmgG8A/hBAKeUopfb675NPKG6eS5OIxVgrmNGh/iRM+Sg3LNZXL9ZXL9Y3HFGP+B8PbAP/Q0SeDnwc+AmlVL13h3qlzId/9cdo+cJiJs7vPPjd3HnnnWxsbJDL5YjH41QqFVZWVigWiyilWFlZYXNzcz9ntlarsbq6yvb2NiLC4uIi29vbzM7O4nke9XqdtbU1NjY2SCaTzM3NsbOzw9zcHI7j0Gw29/enUikKhQK7u7ssLCzQbDZptVr7+z3Po1KpUCqVWFpaolqt4jjO/v5sNksqlaJcLrO8vEy5XMZ13f39kz6mVqvF1atXTzymTCZDNps14piy2Szr6+tn/jlN6pharRatVmsi771xHFMsFmN9fd2Y36fTjsn3ffb29oz5fTrtmFqtFpubmxN5752ERFk7QkRuA/4eeJ5S6mMi8ntARSn173v3eedf/JW6a7fAHbeem4oFXDs7OywvL0etMTTWVy/WVy/W93juu+++j1+6dOm2Qfuivrh7GbislPpY9/t3As/qv8NyNs5rX/zkqQj6APV6/fQ7GYT11Yv11Yv1DUekgV8ptQE8KiJP6W66BHym/z622bperK9erK9erG84oh7xA/wb4C0icj/wDODX+3faZut6sb56sb56sb7hiDzwK6U+qZS6TSl1q1Lqu5RSpf79e3t7xz3USN797ndHrTAS1lcv1lcv1jcckQf+05i2wP+ud70raoWRsL56sb56sb7hMD7wm9KxZlg6nU7UCiNhffViffVifcMRaTrnMLz//e+vptPpB6P2GJZisbi8uLi4E7XHsFhfvVhfvVjfE7l46dKlgS2/jA/8FovFYhkvxk/1WCwWi2W82MBvsVgsNxhGB34ReYGIPCgiXxCRn4vaZxAi8iUR+ZSIfFJE/rG7bVFEPigiD3W/LkTo93oR2RKRB/q2DfSTgP/SPd/3i8izjn/mifr+kohc6Z7jT4rIi/r2vbrr+6CIfHsEvhdE5EMi8hkR+bSI/ER3u3Hn+ARXI8+viGRE5F4R+aeu7y93tz9eRD7W9Xp7t6ovIpLufv+F7v7HGeL7BhH5577z+4zu9uh+35RSRv4D4sDDwBOAFPBPwNOi9hrg+SVg+dC23wR+rnv754DfiNDvGwjKYDxwmh/wIuAvCBogPAf4mCG+vwT81ID7Pq37vkgTFPx7GIhP2Pc88Kzu7QLw+a6Xcef4BFcjz2/3HOW7t5PAx7rn7E+A7+1u/wPgld3bPwb8Qff29wJvn/B74TjfNwAvG3D/yN4LJo/4nw18QSn1RaWUA7wNeEnETsPyEuCPurf/CPiuqESUUvcAxUObj/N7CfBGFfD3wLyInJ+MacAxvsfxEuBtSqm2UuqfgS8QvG8mhlLqqlLqvu7tKvBZ4CYMPMcnuB5HpOe3e456TWqT3X8K+GaCul5w9Nz2zvk7gUsywc4nJ/geR2TvBZMD/03Ao33fX+bkN2lUKOADIvJxEfnX3W2rSqmr3dsbgBmNNq9xnJ/J5/xV3Y/Dr++bOjPKtzu18EyCkZ7R5/iQKxh6fkUkLiKfBLaADxJ86thTSvUS4vud9n27+8vAUpS+6loByl/rnt/fFZH0Yd8uEzu/Jgf+aeHrlFLPAl4I3Cki39C/UwWf6YzNmTXdr8v/AzyRoJbTVeC3o9U5iojkgf8P+LdKqUr/PtPO8QBXY8+vUspTSj0DuJng08ZTI1Y6kcO+InIL8GoC768GFoGfjVARMDvwXwEu9H1/c3ebUSilrnS/bgF/SvDm3Ox9ZOt+3YrOcCDH+Rl5zpVSm91fKB/471ybbjDCV0SSBIH0LUqp3pp8I8/xIFfTzy+ACjrzfQj4WoIpkV4TqX6nfd/u/jlgd8KqwAHfF3Sn2JRSqg38Dww4vyYH/n8Anty9gp8iuFjznoidDiAiOREp9G4D3wY8QOD5g927/SDwZ9EYHstxfu8BfqCbbfAcoNw3XREZh+Y9X0pwjiHw/d5uNsfjgScD907YTQhah35WKfU7fbuMO8fHuZp6fkVkRUTmu7ezwLcSXJf4EPCy7t0On9veOX8Z8NfdT1tR+n6ubwAgBNcj+s9vNL9vk7qKHOYfwVXvzxPM6/1C1D4D/J5AkPXwT8Cne44E84p/BTwE/CWwGKHjWwk+vrsEc4g/fJwfQXbB73fP96eA2wzxfVPX536CX5bzfff/ha7vg8ALI/D9OoJpnPuBT3b/vcjEc3yCq5HnF7gV+ETX6wHgF7vbn0DwB+gLwDuAdHd7pvv9F7r7n2CI7193z+8DwJu5lvkT2XvBlmywWCyWGwyTp3osFovFogEb+C0Wi+UGwwZ+i8ViucGwgd9isVhuMGzgt1gslhsMG/gtNwQi8koR2RSRmogsicjzJKicWROR7xKRu0Xk/4ja02KZBDbwW4ylWxL4Lw5te+iYbd97wvMkgd8Bvk0plVdK7QK/Aryu+/27R/RSIvKkQ9t+SUTePMrzWCxRYQO/xWTuAZ4rInHYX2GaBJ55aNuTuvc9jlWCxT2f7tt28dD3FssNgw38FpP5B4JA/4zu919PsFz/wUPbHga+XUQ+KyJVEfmiiPwIgIh8Rff+AHsi8tci0uvz8OfdqZ5etcR9ROSHus9XEpH/KSIXRxEXkeeKyD+ISLn79bl9+74kIt/S9/3+pwUJmnm8WUR2RWSv+9jV7r45EflDEbkqQeOU/9j3B/BJIvLh7uvtiMjbR/G13FjYwG8xFhX0YfgYQXMWul//BvjbQ9vuISiC9h3ALPCvgN8VkWcppT4PfGX3vvNKqW9WSj0ReAT4zu5UT7v/dUXkJcDPA7cDK93XfOuw3iKyCLwP+C8EpRt+B3ifiAxTIvgHCYqLXeg+kNL9rQAAAuBJREFU9keBZnffG4AOwSecZxLUhupdl/hV4APAAkGxr/97WF/LjYcN/BbT+TDXgvzXEwThvzm07cNKqfcppR5WAR8mCIJfH/I1fxT4T0qpz6qgrvuvA884NOq/rzsi3xORPYIuWz1eDDyklHqTUqqjlHor8DngO4d4bZcg4D9JBRUzP66UqnRH/S8iKKVcV0E12N8lKF7Ye9xF4DFKqZZS6m9DHrvlBsAGfovp3AN8XXcUvaKUegj4KMHc/yJwC3CPiLxQRP5eRIrdQPwiYDnka14Efq8vqBcJCmr1N8l4llJqvvcPeE3fvscA64eec53hmmy8CfifwNtE5Msi8pvdi9MXCaa9rvZ5/b/Aue7jfqbreK8E/V5/aKQjttxQJE6/i8USKX9HMPXxfwIfAeiOgL/c3fbl7r9PAz8A/JlSyhWRdxMEwjA8CvyaUuotIR//ZYJA3c9jgbu6t+vATN++td4NpZQL/DLwyxJ0yXo/wTWK9wNtgv7OHQ6hlNogOB+IyNcBfyki9yilvhDyGCzXMXbEbzEapVQT+Efg/yKY4unxt91t9wApgobg20BHRF5IMP8dlj8AXi0iXwn7F1XvGOHx7we+QkS+T0QSIvIvCRqXv7e7/5MEde6TInIb12rLIyLPF5Gv6l60rRBM4fgqqNP+AeC3RWRWRGIi8kQR+cbu4+4QkZu7T1MiKL/shz0BlusbG/gt08CHCaY0+uet/6a77R4VNA7/ceBPCILe93GGpj1KqT8FfoNguqVCUEf9hSM8fpfgQvO/I+gA9TPAdyildrp3+fcErQ5LBKP7P+57+BpBo/AKQdORDxNM/0DwiSYFfKb72HcCvSYqXw18TERqBMf+E0qpLw5/1JYbCVuP32KxWG4w7IjfYrFYbjBs4LdYLJYbDBv4LRaL5QbDBn6LxWK5wbCB32KxWG4wbOC3WCyWGwwb+C0Wi+UGwwZ+i8ViucGwgd9isVhuMP5/prM5K0y7v1gAAAAASUVORK5CYII=\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def plot_regression(x, y_mean, y_hpdi):\n", - " # Sort values for plotting by x axis\n", - " idx = jnp.argsort(x)\n", - " marriage = x[idx]\n", - " mean = y_mean[idx]\n", - " hpdi = y_hpdi[:, idx]\n", - " divorce = dset.DivorceScaled.values[idx]\n", - "\n", - " # Plot\n", - " fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 6))\n", - " ax.plot(marriage, mean)\n", - " ax.plot(marriage, divorce, 'o')\n", - " ax.fill_between(marriage, hpdi[0], hpdi[1], alpha=0.3, interpolate=True)\n", - " return ax\n", - "\n", - "# Compute empirical posterior distribution over mu\n", - "posterior_mu = jnp.expand_dims(samples_1['a'], -1) + \\\n", - " jnp.expand_dims(samples_1['bM'], -1) * dset.MarriageScaled.values\n", - "\n", - "mean_mu = jnp.mean(posterior_mu, axis=0)\n", - "hpdi_mu = hpdi(posterior_mu, 0.9)\n", - "ax = plot_regression(dset.MarriageScaled.values, mean_mu, hpdi_mu)\n", - "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Regression line with 90% CI');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can see from the plot, that the CI broadens towards the tails where the data is relatively sparse, as can be expected.\n", - "\n", - "#### Posterior Predictive Distribution\n", - "\n", - "Let us now look at the posterior predictive distribution to see how our predictive distribution looks with respect to the observed divorce rates. To get samples from the posterior predictive distribution, we need to run the model by substituting the latent parameters with samples from the posterior. NumPyro provides a handy [Predictive](http://num.pyro.ai/en/latest/utilities.html#numpyro.infer.util.Predictive) utility for this purpose. Note that by default we generate a single prediction for each sample from the joint posterior distribution, but this can be controlled using the `num_samples` argument." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + }, { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    LocationMean Predictions
    0Alabama0.003563
    1Alaska0.559501
    2Arizona0.007107
    3Arkansas0.539909
    4California-0.077508
    \n", - "
    " + "cell_type": "markdown", + "metadata": { + "id": "Kc4rautdN7l9" + }, + "source": [ + "This is an example of a spurious association. We do not expect the number of Waffle Houses in a state to affect the divorce rate, but it is likely correlated with other factors that have an effect on the divorce rate. We will not delve into this spurious association in this tutorial, but the interested reader is encouraged to read Chapters 5 and 6 of [[1](#References)] which explores the problem of causal association in the presence of multiple predictors. \n", + "\n", + "For simplicity, we will primarily focus on marriage rate and the median age of marriage as our predictors for divorce rate throughout the remaining tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mQuCSnFLN7l9" + }, + "source": [ + "## Regression Model to Predict Divorce Rate\n", + "\n", + "Let us now write a regressionn model in *NumPyro* to predict the divorce rate as a linear function of marriage rate and median age of marriage in each of the states. \n", + "\n", + "First, note that our predictor variables have somewhat different scales. It is a good practice to standardize our predictors and response variables to mean `0` and standard deviation `1`, which should result in [faster inference](https://mc-stan.org/docs/2_19/stan-users-guide/standardizing-predictors-and-outputs.html)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "CPtcs7a6N7l-" + }, + "source": [ + "standardize = lambda x: (x - x.mean()) / x.std()\n", + "\n", + "dset['AgeScaled'] = dset.MedianAgeMarriage.pipe(standardize)\n", + "dset['MarriageScaled'] = dset.Marriage.pipe(standardize)\n", + "dset['DivorceScaled'] = dset.Divorce.pipe(standardize)" ], - "text/plain": [ - " Location Mean Predictions\n", - "0 Alabama 0.003563\n", - "1 Alaska 0.559501\n", - "2 Arizona 0.007107\n", - "3 Arkansas 0.539909\n", - "4 California -0.077508" + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "olBAKjb1N7l-" + }, + "source": [ + "We write the NumPyro model as follows. While the code should largely be self-explanatory, take note of the following:\n", + "\n", + " - In NumPyro, *model* code is any Python callable which can optionally accept additional arguments and keywords. For HMC which we will be using for this tutorial, these arguments and keywords remain static during inference, but we can reuse the same model to generate [predictions](#Posterior-Predictive-Distribution) on new data.\n", + " - In addition to regular Python statements, the model code also contains primitives like `sample`. These primitives can be interpreted with various side-effects using effect handlers. For more on effect handlers, refer to [[3](#References)], [[4](#References)]. For now, just remember that a `sample` statement makes this a stochastic function that samples some latent parameters from a *prior distribution*. Our goal is to infer the *posterior distribution* of these parameters conditioned on observed data.\n", + " - The reason why we have kept our predictors as optional keyword arguments is to be able to reuse the same model as we vary the set of predictors. Likewise, the reason why the response variable is optional is that we would like to reuse this model to sample from the posterior predictive distribution. See the [section](#Posterior-Predictive-Distribution) on plotting the posterior predictive distribution, as an example." ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from numpyro.infer import Predictive\n", - "\n", - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictive = Predictive(model, samples_1)\n", - "predictions = predictive(rng_key_, marriage=dset.MarriageScaled.values)['obs']\n", - "df = dset.filter(['Location'])\n", - "df['Mean Predictions'] = jnp.mean(predictions, axis=0)\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "#### Predictive Utility With Effect Handlers\n", - "\n", - "To remove the magic behind `Predictive`, let us see how we can combine [effect handlers](https://numpyro.readthedocs.io/en/latest/handlers.html) with the [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) JAX primitive to implement our own simplified predictive utility function that can do vectorized predictions." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "def predict(rng_key, post_samples, model, *args, **kwargs):\n", - " model = handlers.seed(handlers.condition(model, post_samples), rng_key)\n", - " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", - " return model_trace['obs']['value']\n", - "\n", - "# vectorize predictions via vmap\n", - "predict_fn = vmap(lambda rng_key, samples: predict(rng_key, samples, model, marriage=dset.MarriageScaled.values))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note the use of the `condition`, `seed` and `trace` effect handlers in the `predict` function.\n", - "\n", - " - The `seed` effect-handler is used to wrap a stochastic function with an initial `PRNGKey` seed. When a sample statement inside the model is called, it uses the existing seed to sample from a distribution but this effect-handler also splits the existing key to ensure that future `sample` calls in the model use the newly split key instead. This is to prevent us from having to explicitly pass in a `PRNGKey` to each `sample` statement in the model.\n", - " - The `condition` effect handler conditions the latent sample sites to certain values. In our case, we are conditioning on values from the posterior distribution returned by MCMC.\n", - " - The `trace` effect handler runs the model and records the execution trace within an `OrderedDict`. This trace object contains execution metadata that is useful for computing quantities such as the log joint density.\n", - " \n", - "It should be clear now that the `predict` function simply runs the model by substituting the latent parameters with samples from the posterior (generated by the `mcmc` function) to generate predictions. Note the use of JAX's auto-vectorization transform called [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) to vectorize predictions. Note that if we didn't use `vmap`, we would have to use a native for loop which for each sample which is much slower. Each draw from the posterior can be used to get predictions over all the 50 states. When we vectorize this over all the samples from the posterior using `vmap`, we will get a `predictions_1` array of shape `(num_samples, 50)`. We can then compute the mean and 90% CI of these samples to plot the posterior predictive distribution. We note that our mean predictions match those obtained from the `Predictive` utility class." - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ + }, { - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    LocationMean Predictions
    0Alabama0.003563
    1Alaska0.559501
    2Arizona0.007107
    3Arkansas0.539909
    4California-0.077508
    \n", - "
    " + "cell_type": "code", + "metadata": { + "id": "hVzAKfmnN7l-" + }, + "source": [ + "def model(marriage=None, age=None, divorce=None):\n", + " a = numpyro.sample('a', dist.Normal(0., 0.2))\n", + " M, A = 0., 0.\n", + " if marriage is not None:\n", + " bM = numpyro.sample('bM', dist.Normal(0., 0.5))\n", + " M = bM * marriage\n", + " if age is not None:\n", + " bA = numpyro.sample('bA', dist.Normal(0., 0.5))\n", + " A = bA * age\n", + " sigma = numpyro.sample('sigma', dist.Exponential(1.))\n", + " mu = a + M + A\n", + " numpyro.sample('obs', dist.Normal(mu, sigma), obs=divorce)" ], - "text/plain": [ - " Location Mean Predictions\n", - "0 Alabama 0.003563\n", - "1 Alaska 0.559501\n", - "2 Arizona 0.007107\n", - "3 Arkansas 0.539909\n", - "4 California -0.077508" + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tsUGIXf4N7l_" + }, + "source": [ + "### Model 1: Predictor - Marriage Rate\n", + "\n", + "We first try to model the divorce rate as depending on a single variable, marriage rate. As mentioned above, we can use the same `model` code as earlier, but only pass values for `marriage` and `divorce` keyword arguments. We will use the No U-Turn Sampler (see [[5](#References)] for more details on the NUTS algorithm) to run inference on this simple model.\n", + "\n", + "The Hamiltonian Monte Carlo (or, the NUTS) implementation in NumPyro takes in a potential energy function. This is the negative log joint density for the model. Therefore, for our model description above, we need to construct a function which given the parameter values returns the potential energy (or negative log joint density). Additionally, the verlet integrator in HMC (or, NUTS) returns sample values simulated using Hamiltonian dynamics in the unconstrained space. As such, continuous variables with bounded support need to be transformed into unconstrained space using bijective transforms. We also need to transform these samples back to their constrained support before returning these values to the user. Thankfully, this is handled on the backend for us, within a convenience class for doing [MCMC inference](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.MCMC) that has the following methods:\n", + "\n", + " - `run(...)`: runs warmup, adapts steps size and mass matrix, and does sampling using the sample from the warmup phase.\n", + " - `print_summary()`: print diagnostic information like quantiles, effective sample size, and the Gelman-Rubin diagnostic.\n", + " - `get_samples()`: gets samples from the posterior distribution.\n", + "\n", + "Note the following:\n", + "\n", + " - JAX uses functional PRNGs. Unlike other languages / frameworks which maintain a global random state, in JAX, every call to a sampler requires an [explicit PRNGKey](https://github.com/google/jax#random-numbers-are-different). We will split our initial random seed for subsequent operations, so that we do not accidentally reuse the same seed.\n", + " - We run inference with the `NUTS` sampler. To run vanilla HMC, we can instead use the [HMC](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.HMC) class." ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# Using the same key as we used for Predictive - note that the results are identical.\n", - "\n", - "predictions_1 = predict_fn(random.split(rng_key_, num_samples), samples_1)\n", - "\n", - "mean_pred = jnp.mean(predictions_1, axis=0)\n", - "df = dset.filter(['Location'])\n", - "df['Mean Predictions'] = mean_pred\n", - "df.head()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "er7-QqEhN7l_", + "outputId": "d52e722b-0061-49a1-d9df-d977a311b88d" + }, + "source": [ + "# Start from this source of randomness. We will split keys for subsequent operations.\n", + "rng_key = random.PRNGKey(0)\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "# Run NUTS.\n", + "kernel = NUTS(model)\n", + "num_samples = 2000\n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=num_samples)\n", + "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values, divorce=dset.DivorceScaled.values)\n", + "mcmc.print_summary()\n", + "samples_1 = mcmc.get_samples()" + ], + "execution_count": 8, + "outputs": [ + { + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 3000/3000 [00:04<00:00, 748.14it/s, 7 steps of size 7.41e-01. acc. prob=0.92]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a 0.00 0.11 0.00 -0.16 0.20 1510.96 1.00\n", + " bM 0.35 0.13 0.35 0.14 0.57 2043.12 1.00\n", + " sigma 0.95 0.10 0.94 0.78 1.10 1565.40 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hpdi_pred = hpdi(predictions_1, 0.9)\n", - "\n", - "ax = plot_regression(dset.MarriageScaled.values, mean_pred, hpdi_pred)\n", - "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Predictions with 90% CI');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We have used the same `plot_regression` function as earlier. We notice that our CI for the predictive distribution is much broader as compared to the last plot due to the additional noise introduced by the `sigma` parameter. Most data points lie well within the 90% CI, which indicates a good fit.\n", - "\n", - "#### Posterior Predictive Density\n", - "\n", - "Likewise, making use of effect-handlers and `vmap`, we can also compute the log likelihood for this model given the dataset, and the log posterior predictive density [[6](#References)] which is given by \n", - "$$ log \\prod_{i=1}^{n} \\int p(y_i | \\theta) p_{post}(\\theta) d\\theta \n", - "\\approx \\sum_{i=1}^n log \\frac{\\sum_s p(\\theta^{s})}{S} \\\\\n", - "= \\sum_{i=1}^n (log \\sum_s p(\\theta^{s}) - log(S))\n", - "$$.\n", - "\n", - "Here, $i$ indexes the observed data points $y$ and $s$ indexes the posterior samples over the latent parameters $\\theta$. If the posterior predictive density for a model has a comparatively high value, it indicates that the observed data-points have higher probability under the given model." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "def log_likelihood(rng_key, params, model, *args, **kwargs):\n", - " model = handlers.condition(model, params)\n", - " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", - " obs_node = model_trace['obs']\n", - " return obs_node['fn'].log_prob(obs_node['value'])\n", - " \n", - "def log_pred_density(rng_key, params, model, *args, **kwargs):\n", - " n = list(params.values())[0].shape[0]\n", - " log_lk_fn = vmap(lambda rng_key, params: log_likelihood(rng_key, params, model, *args, **kwargs))\n", - " log_lk_vals = log_lk_fn(random.split(rng_key, n), params)\n", - " return (logsumexp(log_lk_vals, 0) - jnp.log(n)).sum()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note that NumPyro provides the [log_likelihood](http://num.pyro.ai/en/latest/utilities.html#log-likelihood) utility function that can be used directly for computing `log likelihood` as in the first function for any general model. In this tutorial, we would like to emphasize that there is nothing magical about such utility functions, and you can roll out your own inference utilities using NumPyro's effect handling stack." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Log posterior predictive density: -66.65252685546875\n" - ] - } - ], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "print('Log posterior predictive density: {}'.format(log_pred_density(rng_key_,\n", - " samples_1, \n", - " model,\n", - " marriage=dset.MarriageScaled.values,\n", - " divorce=dset.DivorceScaled.values)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Model 2: Predictor - Median Age of Marriage\n", - "\n", - "We will now model the divorce rate as a function of the median age of marriage. The computations are mostly a reproduction of what we did for Model 1. Notice the following:\n", - "\n", - " - Divorce rate is inversely related to the age of marriage. Hence states where the median age of marriage is low will likely have a higher divorce rate.\n", - " - We get a higher log likelihood as compared to Model 2, indicating that median age of marriage is likely a much better predictor of divorce rate. " - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "id": "0IfifzKHN7mA" + }, + "source": [ + "#### Posterior Distribution over the Regression Parameters\n", + "\n", + "We notice that the progress bar gives us online statistics on the acceptance probability, step size and number of steps taken per sample while running NUTS. In particular, during warmup, we adapt the step size and mass matrix to achieve a certain target acceptance probability which is 0.8, by default. We were able to successfully adapt our step size to achieve this target in the warmup phase.\n", + "\n", + "During warmup, the aim is to adapt hyper-parameters such as step size and mass matrix (the HMC algorithm is very sensitive to these hyper-parameters), and to reach the typical set (see [[6](#References)] for more details). If there are any issues in the model specification, the first signal to notice would be low acceptance probabilities or very high number of steps. We use the sample from the end of the warmup phase to seed the MCMC chain (denoted by the second `sample` progress bar) from which we generate the desired number of samples from our target distribution.\n", + "\n", + "At the end of inference, NumPyro prints the mean, std and 90% CI values for each of the latent parameters. Note that since we standardized our predictors and response variable, we would expect the intercept to have mean 0, as can be seen here. It also prints other convergence diagnostics on the latent parameters in the model, including [effective sample size](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.effective_sample_size) and the [gelman rubin diagnostic](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.gelman_rubin) ($\\hat{R}$). The value for these diagnostics indicates that the chain has converged to the target distribution. In our case, the \"target distribution\" is the posterior distribution over the latent parameters that we are interested in. Note that this is often worth verifying with multiple chains for more complicated models. In the end, `samples_1` is a collection (in our case, a `dict` since `init_samples` was a `dict`) containing samples from the posterior distribution for each of the latent parameters in the model.\n", + "\n", + "To look at our regression fit, let us plot the regression line using our posterior estimates for the regression parameters, along with the 90% Credibility Interval (CI). Note that the [hpdi](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.hpdi) function in NumPyro's diagnostics module can be used to compute CI. In the functions below, note that the collected samples from the posterior are all along the leading axis." + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 3000/3000 [00:07<00:00, 425.30it/s, 3 steps of size 7.68e-01. acc. prob=0.92]" - ] + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "id": "UX-DbOtsN7mA", + "outputId": "163ad2c9-7567-490f-9535-f6834f457c8a" + }, + "source": [ + "def plot_regression(x, y_mean, y_hpdi):\n", + " # Sort values for plotting by x axis\n", + " idx = jnp.argsort(x)\n", + " marriage = x[idx]\n", + " mean = y_mean[idx]\n", + " hpdi = y_hpdi[:, idx]\n", + " divorce = dset.DivorceScaled.values[idx]\n", + "\n", + " # Plot\n", + " fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 6))\n", + " ax.plot(marriage, mean)\n", + " ax.plot(marriage, divorce, 'o')\n", + " ax.fill_between(marriage, hpdi[0], hpdi[1], alpha=0.3, interpolate=True)\n", + " return ax\n", + "\n", + "# Compute empirical posterior distribution over mu\n", + "posterior_mu = jnp.expand_dims(samples_1['a'], -1) + \\\n", + " jnp.expand_dims(samples_1['bM'], -1) * dset.MarriageScaled.values\n", + "\n", + "mean_mu = jnp.mean(posterior_mu, axis=0)\n", + "hpdi_mu = hpdi(posterior_mu, 0.9)\n", + "ax = plot_regression(dset.MarriageScaled.values, mean_mu, hpdi_mu)\n", + "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Regression line with 90% CI');" + ], + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a -0.00 0.10 -0.00 -0.16 0.16 1862.10 1.00\n", - " bA -0.57 0.11 -0.57 -0.75 -0.39 1962.83 1.00\n", - " sigma 0.82 0.08 0.81 0.68 0.95 1544.86 1.00\n", - "\n", - "Number of divergences: 0\n" - ] + "cell_type": "markdown", + "metadata": { + "id": "sndvig_RQi0s" + }, + "source": [ + "We can see from the plot, that the CI broadens towards the tails where the data is relatively sparse, as can be expected.\n", + "\n", + "#### Prior Predictive Distribution\n", + "\n", + "Let us check that we have set sensible priors by sampling from the prior predictive distribution. NumPyro provides a handy [Predictive](http://num.pyro.ai/en/latest/utilities.html#numpyro.infer.util.Predictive) utility for this purpose." + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "mcmc.run(rng_key_, age=dset.AgeScaled.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_2 = mcmc.get_samples()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "id": "vSfDasR7Q5Be", + "outputId": "a11554aa-96b7-4298-9456-d44e0d63d8af" + }, + "source": [ + "from numpyro.infer import Predictive\n", + "\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "prior_predictive = Predictive(model, num_samples=100)\n", + "prior_predictions = prior_predictive(rng_key_, marriage=dset.MarriageScaled.values)['obs']\n", + "mean_prior_pred = jnp.mean(prior_predictions, axis=0)\n", + "hpdi_prior_pred = hpdi(prior_predictions, 0.9)\n", + "\n", + "ax = plot_regression(dset.MarriageScaled.values, mean_prior_pred, hpdi_prior_pred)\n", + "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Predictions with 90% CI');" + ], + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "markdown", + "metadata": { + "id": "Q1ojeyHpN7mB" + }, + "source": [ + "#### Posterior Predictive Distribution\n", + "\n", + "Let us now look at the posterior predictive distribution to see how our predictive distribution looks with respect to the observed divorce rates. To get samples from the posterior predictive distribution, we need to run the model by substituting the latent parameters with samples from the posterior. Note that by default we generate a single prediction for each sample from the joint posterior distribution, but this can be controlled using the `num_samples` argument." ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "posterior_mu = jnp.expand_dims(samples_2['a'], -1) + \\\n", - " jnp.expand_dims(samples_2['bA'], -1) * dset.AgeScaled.values\n", - "mean_mu = jnp.mean(posterior_mu, axis=0)\n", - "hpdi_mu = hpdi(posterior_mu, 0.9)\n", - "ax = plot_regression(dset.AgeScaled.values, mean_mu, hpdi_mu)\n", - "ax.set(xlabel='Median marriage age', ylabel='Divorce rate', title='Regression line with 90% CI');" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "XzzsqL7jN7mB", + "outputId": "00bb95d0-8be6-4686-f9d9-bc8a8891aa2c" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictive = Predictive(model, samples_1)\n", + "predictions = predictive(rng_key_, marriage=dset.MarriageScaled.values)['obs']\n", + "df = dset.filter(['Location'])\n", + "df['Mean Predictions'] = jnp.mean(predictions, axis=0)\n", + "df.head()" + ], + "execution_count": 11, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    LocationMean Predictions
    0Alabama0.016434
    1Alaska0.501293
    2Arizona0.025105
    3Arkansas0.600058
    4California-0.082887
    \n", + "
    " + ], + "text/plain": [ + " Location Mean Predictions\n", + "0 Alabama 0.016434\n", + "1 Alaska 0.501293\n", + "2 Arizona 0.025105\n", + "3 Arkansas 0.600058\n", + "4 California -0.082887" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 11 + } ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictions_2 = Predictive(model, samples_2)(rng_key_,\n", - " age=dset.AgeScaled.values)['obs']\n", - "\n", - "mean_pred = jnp.mean(predictions_2, axis=0)\n", - "hpdi_pred = hpdi(predictions_2, 0.9)\n", - "\n", - "ax = plot_regression(dset.AgeScaled.values, mean_pred, hpdi_pred)\n", - "ax.set(xlabel='Median Age', ylabel='Divorce rate', title='Predictions with 90% CI');" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Log posterior predictive density: -59.238067626953125\n" - ] - } - ], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "print('Log posterior predictive density: {}'.format(log_pred_density(rng_key_,\n", - " samples_2, \n", - " model,\n", - " age=dset.AgeScaled.values,\n", - " divorce=dset.DivorceScaled.values)))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Model 3: Predictor - Marriage Rate and Median Age of Marriage\n", - "\n", - "Finally, we will also model divorce rate as depending on both marriage rate as well as the median age of marriage. Note that the model's posterior predictive density is similar to Model 2 which likely indicates that the marginal information from marriage rate in predicting divorce rate is low when the median age of marriage is already known." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "id": "n-Sm_5H8N7mC" + }, + "source": [ + "#### Predictive Utility With Effect Handlers\n", + "\n", + "To remove the magic behind `Predictive`, let us see how we can combine [effect handlers](https://numpyro.readthedocs.io/en/latest/handlers.html) with the [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) JAX primitive to implement our own simplified predictive utility function that can do vectorized predictions." + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 3000/3000 [00:07<00:00, 389.02it/s, 7 steps of size 5.15e-01. acc. prob=0.92]\n" - ] + "cell_type": "code", + "metadata": { + "id": "gSKilj8dN7mC" + }, + "source": [ + "def predict(rng_key, post_samples, model, *args, **kwargs):\n", + " model = handlers.seed(handlers.condition(model, post_samples), rng_key)\n", + " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", + " return model_trace['obs']['value']\n", + "\n", + "# vectorize predictions via vmap\n", + "predict_fn = vmap(lambda rng_key, samples: predict(rng_key, samples, model, marriage=dset.MarriageScaled.values))" + ], + "execution_count": 12, + "outputs": [] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a 0.00 0.10 0.00 -0.17 0.16 1731.49 1.00\n", - " bA -0.61 0.16 -0.61 -0.88 -0.36 1446.05 1.00\n", - " bM -0.06 0.16 -0.07 -0.32 0.20 1432.76 1.00\n", - " sigma 0.82 0.08 0.82 0.69 0.96 1654.31 1.00\n", - "\n", - "Number of divergences: 0\n" - ] - } - ], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_3 = mcmc.get_samples()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "id": "hGB12J3-N7mC" + }, + "source": [ + "Note the use of the `condition`, `seed` and `trace` effect handlers in the `predict` function.\n", + "\n", + " - The `seed` effect-handler is used to wrap a stochastic function with an initial `PRNGKey` seed. When a sample statement inside the model is called, it uses the existing seed to sample from a distribution but this effect-handler also splits the existing key to ensure that future `sample` calls in the model use the newly split key instead. This is to prevent us from having to explicitly pass in a `PRNGKey` to each `sample` statement in the model.\n", + " - The `condition` effect handler conditions the latent sample sites to certain values. In our case, we are conditioning on values from the posterior distribution returned by MCMC.\n", + " - The `trace` effect handler runs the model and records the execution trace within an `OrderedDict`. This trace object contains execution metadata that is useful for computing quantities such as the log joint density.\n", + " \n", + "It should be clear now that the `predict` function simply runs the model by substituting the latent parameters with samples from the posterior (generated by the `mcmc` function) to generate predictions. Note the use of JAX's auto-vectorization transform called [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) to vectorize predictions. Note that if we didn't use `vmap`, we would have to use a native for loop which for each sample which is much slower. Each draw from the posterior can be used to get predictions over all the 50 states. When we vectorize this over all the samples from the posterior using `vmap`, we will get a `predictions_1` array of shape `(num_samples, 50)`. We can then compute the mean and 90% CI of these samples to plot the posterior predictive distribution. We note that our mean predictions match those obtained from the `Predictive` utility class." + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Log posterior predictive density: -59.06075668334961\n" - ] - } - ], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "print('Log posterior predictive density: {}'.format(\n", - " log_pred_density(rng_key_,\n", - " samples_3,\n", - " model,\n", - " marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values,\n", - " divorce=dset.DivorceScaled.values)\n", - "))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Divorce Rate Residuals by State\n", - "\n", - "The regression plots above shows that the observed divorce rates for many states differs considerably from the mean regression line. To dig deeper into how the last model (Model 3) under-predicts or over-predicts for each of the states, we will plot the posterior predictive and residuals (`Observed divorce rate - Predicted divorce rate`) for each of the states." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "Hbo0AzmSN7mD", + "outputId": "9183ecd2-bb3b-473b-e912-09188806573e" + }, + "source": [ + "# Using the same key as we used for Predictive - note that the results are identical.\n", + "\n", + "predictions_1 = predict_fn(random.split(rng_key_, num_samples), samples_1)\n", + "\n", + "mean_pred = jnp.mean(predictions_1, axis=0)\n", + "df = dset.filter(['Location'])\n", + "df['Mean Predictions'] = mean_pred\n", + "df.head()" + ], + "execution_count": 13, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    LocationMean Predictions
    0Alabama0.016434
    1Alaska0.501293
    2Arizona0.025105
    3Arkansas0.600058
    4California-0.082887
    \n", + "
    " + ], + "text/plain": [ + " Location Mean Predictions\n", + "0 Alabama 0.016434\n", + "1 Alaska 0.501293\n", + "2 Arizona 0.025105\n", + "3 Arkansas 0.600058\n", + "4 California -0.082887" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 13 + } + ] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "id": "x57YjUCLN7mD", + "outputId": "19ed4248-f852-40d1-da61-f06faa6c4cbd" + }, + "source": [ + "hpdi_pred = hpdi(predictions_1, 0.9)\n", + "\n", + "ax = plot_regression(dset.MarriageScaled.values, mean_pred, hpdi_pred)\n", + "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Predictions with 90% CI');" + ], + "execution_count": 14, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Predictions for Model 3.\n", - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictions_3 = Predictive(model, samples_3)(rng_key_,\n", - " marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values)['obs']\n", - "y = jnp.arange(50)\n", - "\n", - "\n", - "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 16))\n", - "pred_mean = jnp.mean(predictions_3, axis=0)\n", - "pred_hpdi = hpdi(predictions_3, 0.9)\n", - "residuals_3 = dset.DivorceScaled.values - predictions_3\n", - "residuals_mean = jnp.mean(residuals_3, axis=0)\n", - "residuals_hpdi = hpdi(residuals_3, 0.9)\n", - "idx = jnp.argsort(residuals_mean)\n", - "\n", - "# Plot posterior predictive\n", - "ax[0].plot(jnp.zeros(50), y, '--')\n", - "ax[0].errorbar(pred_mean[idx], y, xerr=pred_hpdi[1, idx] - pred_mean[idx], \n", - " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", - "ax[0].plot(dset.DivorceScaled.values[idx], y, marker='o', \n", - " ls='none', color='gray')\n", - "ax[0].set(xlabel='Posterior Predictive (red) vs. Actuals (gray)', ylabel='State', \n", - " title='Posterior Predictive with 90% CI')\n", - "ax[0].set_yticks(y)\n", - "ax[0].set_yticklabels(dset.Loc.values[idx], fontsize=10);\n", - "\n", - "# Plot residuals\n", - "residuals_3 = dset.DivorceScaled.values - predictions_3\n", - "residuals_mean = jnp.mean(residuals_3, axis=0)\n", - "residuals_hpdi = hpdi(residuals_3, 0.9)\n", - "err = residuals_hpdi[1] - residuals_mean\n", - "\n", - "ax[1].plot(jnp.zeros(50), y, '--')\n", - "ax[1].errorbar(residuals_mean[idx], y, xerr=err[idx], \n", - " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", - "ax[1].set(xlabel='Residuals', ylabel='State', title='Residuals with 90% CI')\n", - "ax[1].set_yticks(y)\n", - "ax[1].set_yticklabels(dset.Loc.values[idx], fontsize=10);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The plot on the left shows the mean predictions with 90% CI for each of the states using Model 3. The gray markers indicate the actual observed divorce rates. The right plot shows the residuals for each of the states, and both these plots are sorted by the residuals, i.e. at the bottom, we are looking at states where the model predictions are higher than the observed rates, whereas at the top, the reverse is true.\n", - "\n", - "Overall, the model fit seems good because most observed data points like within a 90% CI around the mean predictions. However, notice how the model over-predicts by a large margin for states like Idaho (bottom left), and on the other end under-predicts for states like Maine (top right). This is likely indicative of other factors that we are missing out in our model that affect divorce rate across different states. Even ignoring other socio-political variables, one such factor that we have not yet modeled is the measurement noise given by `Divorce SE` in the dataset. We will explore this in the next section." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Regression Model with Measurement Error\n", - "\n", - "Note that in our previous models, each data point influences the regression line equally. Is this well justified? We will build on the previous model to incorporate measurement error given by `Divorce SE` variable in the dataset. Incorporating measurement noise will be useful in ensuring that observations that have higher confidence (i.e. lower measurement noise) have a greater impact on the regression line. On the other hand, this will also help us better model outliers with high measurement errors. For more details on modeling errors due to measurement noise, refer to Chapter 14 of [[1](#References)].\n", - "\n", - "To do this, we will reuse Model 3, with the only change that the final observed value has a measurement error given by `divorce_sd` (notice that this has to be standardized since the `divorce` variable itself has been standardized to mean 0 and std 1)." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "def model_se(marriage, age, divorce_sd, divorce=None):\n", - " a = numpyro.sample('a', dist.Normal(0., 0.2))\n", - " bM = numpyro.sample('bM', dist.Normal(0., 0.5))\n", - " M = bM * marriage\n", - " bA = numpyro.sample('bA', dist.Normal(0., 0.5))\n", - " A = bA * age\n", - " sigma = numpyro.sample('sigma', dist.Exponential(1.))\n", - " mu = a + M + A\n", - " divorce_rate = numpyro.sample('divorce_rate', dist.Normal(mu, sigma))\n", - " numpyro.sample('obs', dist.Normal(divorce_rate, divorce_sd), obs=divorce)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# Standardize\n", - "dset['DivorceScaledSD'] = dset['Divorce SE'] / jnp.std(dset.Divorce.values)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:09<00:00, 408.70it/s, 15 steps of size 3.00e-01. acc. prob=0.91] \n" - ] + "cell_type": "markdown", + "metadata": { + "id": "b5i71NCFN7mE" + }, + "source": [ + "We have used the same `plot_regression` function as earlier. We notice that our CI for the predictive distribution is much broader as compared to the last plot due to the additional noise introduced by the `sigma` parameter. Most data points lie well within the 90% CI, which indicates a good fit.\n", + "\n", + "#### Posterior Predictive Density\n", + "\n", + "Likewise, making use of effect-handlers and `vmap`, we can also compute the log likelihood for this model given the dataset, and the log posterior predictive density [[6](#References)] which is given by \n", + "$$ log \\prod_{i=1}^{n} \\int p(y_i | \\theta) p_{post}(\\theta) d\\theta \n", + "\\approx \\sum_{i=1}^n log \\frac{\\sum_s p(\\theta^{s})}{S} \\\\\n", + "= \\sum_{i=1}^n (log \\sum_s p(\\theta^{s}) - log(S))\n", + "$$.\n", + "\n", + "Here, $i$ indexes the observed data points $y$ and $s$ indexes the posterior samples over the latent parameters $\\theta$. If the posterior predictive density for a model has a comparatively high value, it indicates that the observed data-points have higher probability under the given model." + ] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a -0.06 0.09 -0.06 -0.21 0.10 3381.24 1.00\n", - " bA -0.61 0.16 -0.61 -0.86 -0.32 2457.71 1.00\n", - " bM 0.06 0.17 0.06 -0.19 0.35 2384.97 1.00\n", - " divorce_rate[0] 1.14 0.37 1.14 0.54 1.74 4196.29 1.00\n", - " divorce_rate[1] 0.69 0.55 0.68 -0.24 1.54 4457.97 1.00\n", - " divorce_rate[2] 0.43 0.34 0.43 -0.12 0.97 4692.82 1.00\n", - " divorce_rate[3] 1.41 0.47 1.41 0.71 2.21 5338.40 1.00\n", - " divorce_rate[4] -0.90 0.13 -0.90 -1.12 -0.69 6373.86 1.00\n", - " divorce_rate[5] 0.65 0.39 0.64 0.00 1.29 5890.75 1.00\n", - " divorce_rate[6] -1.36 0.35 -1.35 -1.90 -0.74 6029.70 1.00\n", - " divorce_rate[7] -0.33 0.48 -0.32 -1.13 0.42 6226.93 1.00\n", - " divorce_rate[8] -1.88 0.61 -1.89 -2.84 -0.86 3797.97 1.00\n", - " divorce_rate[9] -0.62 0.16 -0.62 -0.88 -0.33 7313.05 1.00\n", - "divorce_rate[10] 0.76 0.28 0.75 0.31 1.24 5122.44 1.00\n", - "divorce_rate[11] -0.54 0.47 -0.55 -1.32 0.22 4301.37 1.00\n", - "divorce_rate[12] 0.20 0.51 0.21 -0.60 1.07 2646.56 1.00\n", - "divorce_rate[13] -0.87 0.23 -0.86 -1.24 -0.49 6676.11 1.00\n", - "divorce_rate[14] 0.55 0.31 0.55 0.04 1.03 5340.67 1.00\n", - "divorce_rate[15] 0.29 0.38 0.29 -0.35 0.89 7546.96 1.00\n", - "divorce_rate[16] 0.51 0.43 0.50 -0.23 1.17 4965.65 1.00\n", - "divorce_rate[17] 1.24 0.34 1.25 0.69 1.82 4936.42 1.00\n", - "divorce_rate[18] 0.42 0.38 0.42 -0.15 1.11 5954.93 1.00\n", - "divorce_rate[19] 0.38 0.56 0.37 -0.53 1.28 2854.65 1.00\n", - "divorce_rate[20] -0.56 0.32 -0.55 -1.09 -0.05 5861.17 1.00\n", - "divorce_rate[21] -1.10 0.26 -1.10 -1.53 -0.66 5929.05 1.00\n", - "divorce_rate[22] -0.28 0.27 -0.28 -0.70 0.16 6215.17 1.00\n", - "divorce_rate[23] -0.99 0.30 -1.00 -1.44 -0.45 4756.94 1.00\n", - "divorce_rate[24] 0.42 0.42 0.41 -0.25 1.10 6284.63 1.00\n", - "divorce_rate[25] -0.03 0.32 -0.03 -0.53 0.53 6587.60 1.00\n", - "divorce_rate[26] -0.02 0.50 -0.02 -0.88 0.75 5119.31 1.00\n", - "divorce_rate[27] -0.15 0.38 -0.14 -0.78 0.44 4868.48 1.00\n", - "divorce_rate[28] -0.26 0.50 -0.27 -1.06 0.61 4898.44 1.00\n", - "divorce_rate[29] -1.79 0.24 -1.80 -2.19 -1.40 5940.81 1.00\n", - "divorce_rate[30] 0.18 0.43 0.17 -0.60 0.80 6070.03 1.00\n", - "divorce_rate[31] -1.66 0.16 -1.66 -1.92 -1.38 7048.38 1.00\n", - "divorce_rate[32] 0.12 0.24 0.11 -0.24 0.52 6550.93 1.00\n", - "divorce_rate[33] -0.03 0.53 -0.01 -0.92 0.81 4108.95 1.00\n", - "divorce_rate[34] -0.13 0.22 -0.13 -0.51 0.21 7752.43 1.00\n", - "divorce_rate[35] 1.27 0.40 1.27 0.66 1.99 5621.12 1.00\n", - "divorce_rate[36] 0.23 0.36 0.22 -0.36 0.81 7705.96 1.00\n", - "divorce_rate[37] -1.02 0.22 -1.02 -1.40 -0.68 5115.13 1.00\n", - "divorce_rate[38] -0.93 0.54 -0.93 -1.84 -0.10 3426.71 1.00\n", - "divorce_rate[39] -0.67 0.32 -0.67 -1.23 -0.17 6310.21 1.00\n", - "divorce_rate[40] 0.25 0.54 0.25 -0.60 1.15 4844.06 1.00\n", - "divorce_rate[41] 0.73 0.35 0.74 0.12 1.27 5814.62 1.00\n", - "divorce_rate[42] 0.20 0.18 0.20 -0.12 0.48 8983.24 1.00\n", - "divorce_rate[43] 0.82 0.42 0.84 0.13 1.52 3795.81 1.00\n", - "divorce_rate[44] -0.42 0.52 -0.43 -1.25 0.48 4979.32 1.00\n", - "divorce_rate[45] -0.38 0.25 -0.38 -0.80 0.02 6811.34 1.00\n", - "divorce_rate[46] 0.13 0.31 0.14 -0.38 0.64 6527.01 1.00\n", - "divorce_rate[47] 0.57 0.48 0.56 -0.22 1.33 6760.92 1.00\n", - "divorce_rate[48] -0.63 0.27 -0.63 -1.08 -0.20 6560.02 1.00\n", - "divorce_rate[49] 0.86 0.59 0.87 -0.13 1.78 4066.94 1.00\n", - " sigma 0.58 0.11 0.57 0.41 0.76 1067.58 1.00\n", - "\n", - "Number of divergences: 0\n" - ] - } - ], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "kernel = NUTS(model_se, target_accept_prob=0.9) \n", - "mcmc = MCMC(kernel, num_warmup=1000, num_samples=3000)\n", - "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values, age=dset.AgeScaled.values,\n", - " divorce_sd=dset.DivorceScaledSD.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_4 = mcmc.get_samples()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Effect of Incorporating Measurement Noise on Residuals\n", - "\n", - "Notice that our values for the regression coefficients is very similar to Model 3. However, introducing measurement noise allows us to more closely match our predictive distribution to the observed values. We can see this if we plot the residuals as earlier. " - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictions_4 = Predictive(model_se, samples_4)(rng_key_,\n", - " marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values,\n", - " divorce_sd=dset.DivorceScaledSD.values)['obs']" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "metadata": { + "id": "ZpNwpvk_N7mE" + }, + "source": [ + "def log_likelihood(rng_key, params, model, *args, **kwargs):\n", + " model = handlers.condition(model, params)\n", + " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", + " obs_node = model_trace['obs']\n", + " return obs_node['fn'].log_prob(obs_node['value'])\n", + " \n", + "def log_pred_density(rng_key, params, model, *args, **kwargs):\n", + " n = list(params.values())[0].shape[0]\n", + " log_lk_fn = vmap(lambda rng_key, params: log_likelihood(rng_key, params, model, *args, **kwargs))\n", + " log_lk_vals = log_lk_fn(random.split(rng_key, n), params)\n", + " return (logsumexp(log_lk_vals, 0) - jnp.log(n)).sum()" + ], + "execution_count": 15, + "outputs": [] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "markdown", + "metadata": { + "id": "dXu_hzcDN7mE" + }, + "source": [ + "Note that NumPyro provides the [log_likelihood](http://num.pyro.ai/en/latest/utilities.html#log-likelihood) utility function that can be used directly for computing `log likelihood` as in the first function for any general model. In this tutorial, we would like to emphasize that there is nothing magical about such utility functions, and you can roll out your own inference utilities using NumPyro's effect handling stack." ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sd = dset.DivorceScaledSD.values\n", - "residuals_4 = dset.DivorceScaled.values - predictions_4\n", - "residuals_mean = jnp.mean(residuals_4, axis=0)\n", - "residuals_hpdi = hpdi(residuals_4, 0.9)\n", - "err = residuals_hpdi[1] - residuals_mean\n", - "idx = jnp.argsort(residuals_mean)\n", - "y = jnp.arange(50)\n", - "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 16))\n", - "\n", - "\n", - "# Plot Residuals\n", - "ax.plot(jnp.zeros(50), y, '--')\n", - "ax.errorbar(residuals_mean[idx], y, xerr=err[idx], \n", - " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", - "\n", - "# Plot SD \n", - "ax.errorbar(residuals_mean[idx], y, xerr=sd[idx], \n", - " ls='none', color='orange', alpha=0.9)\n", - "\n", - "# Plot earlier mean residual\n", - "ax.plot(jnp.mean(dset.DivorceScaled.values - predictions_3, 0)[idx], y,\n", - " ls='none', marker='o', ms=6, color='black', alpha=0.6)\n", - "\n", - "ax.set(xlabel='Residuals', ylabel='State', title='Residuals with 90% CI')\n", - "ax.set_yticks(y)\n", - "ax.set_yticklabels(dset.Loc.values[idx], fontsize=10);\n", - "ax.text(-2.8, -7, 'Residuals (with error-bars) from current model (in red). '\n", - " 'Black marker \\nshows residuals from the previous model (Model 3). '\n", - " 'Measurement \\nerror is indicated by orange bar.');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The plot above shows the residuals for each of the states, along with the measurement noise given by inner error bar. The gray dots are the mean residuals from our earlier Model 3. Notice how having an additional degree of freedom to model the measurement noise has shrunk the residuals. In particular, for Idaho and Maine, our predictions are now much closer to the observed values after incorporating measurement noise in the model.\n", - "\n", - "To better see how measurement noise affects the movement of the regression line, let us plot the residuals with respect to the measurement noise." - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dZxKq_ETN7mF", + "outputId": "9574a5f7-56aa-404a-e491-f7dc2a1c6636" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "print('Log posterior predictive density: {}'.format(log_pred_density(rng_key_,\n", + " samples_1, \n", + " model,\n", + " marriage=dset.MarriageScaled.values,\n", + " divorce=dset.DivorceScaled.values)))" + ], + "execution_count": 16, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Log posterior predictive density: -66.70008087158203\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wbxnyQazN7mF" + }, + "source": [ + "### Model 2: Predictor - Median Age of Marriage\n", + "\n", + "We will now model the divorce rate as a function of the median age of marriage. The computations are mostly a reproduction of what we did for Model 1. Notice the following:\n", + "\n", + " - Divorce rate is inversely related to the age of marriage. Hence states where the median age of marriage is low will likely have a higher divorce rate.\n", + " - We get a higher log likelihood as compared to Model 2, indicating that median age of marriage is likely a much better predictor of divorce rate. " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ZBdf-6NEN7mF", + "outputId": "128e3a0b-1742-44a3-f3d1-43b0cc4c5eef" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "mcmc.run(rng_key_, age=dset.AgeScaled.values, divorce=dset.DivorceScaled.values)\n", + "mcmc.print_summary()\n", + "samples_2 = mcmc.get_samples()" + ], + "execution_count": 17, + "outputs": [ + { + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 3000/3000 [00:04<00:00, 722.23it/s, 7 steps of size 7.58e-01. acc. prob=0.92]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a -0.00 0.10 -0.00 -0.17 0.16 1942.82 1.00\n", + " bA -0.57 0.12 -0.57 -0.75 -0.38 1995.70 1.00\n", + " sigma 0.82 0.08 0.82 0.69 0.96 1865.82 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "id": "6udy6d7_N7mG", + "outputId": "28a2e4af-81be-4229-b944-1af4d64ddd98" + }, + "source": [ + "posterior_mu = jnp.expand_dims(samples_2['a'], -1) + \\\n", + " jnp.expand_dims(samples_2['bA'], -1) * dset.AgeScaled.values\n", + "mean_mu = jnp.mean(posterior_mu, axis=0)\n", + "hpdi_mu = hpdi(posterior_mu, 0.9)\n", + "ax = plot_regression(dset.AgeScaled.values, mean_mu, hpdi_mu)\n", + "ax.set(xlabel='Median marriage age', ylabel='Divorce rate', title='Regression line with 90% CI');" + ], + "execution_count": 18, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "id": "DYGHPBueN7mG", + "outputId": "7646a234-b1ee-44f2-8510-02b76654d582" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictions_2 = Predictive(model, samples_2)(rng_key_,\n", + " age=dset.AgeScaled.values)['obs']\n", + "\n", + "mean_pred = jnp.mean(predictions_2, axis=0)\n", + "hpdi_pred = hpdi(predictions_2, 0.9)\n", + "\n", + "ax = plot_regression(dset.AgeScaled.values, mean_pred, hpdi_pred)\n", + "ax.set(xlabel='Median Age', ylabel='Divorce rate', title='Predictions with 90% CI');" + ], + "execution_count": 19, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "FbKMD13UN7mH", + "outputId": "b271e24a-b880-4e2c-97e9-15ea3a671610" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "print('Log posterior predictive density: {}'.format(log_pred_density(rng_key_,\n", + " samples_2, \n", + " model,\n", + " age=dset.AgeScaled.values,\n", + " divorce=dset.DivorceScaled.values)))" + ], + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Log posterior predictive density: -59.251956939697266\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xVss4FJNN7mH" + }, + "source": [ + "### Model 3: Predictor - Marriage Rate and Median Age of Marriage\n", + "\n", + "Finally, we will also model divorce rate as depending on both marriage rate as well as the median age of marriage. Note that the model's posterior predictive density is similar to Model 2 which likely indicates that the marginal information from marriage rate in predicting divorce rate is low when the median age of marriage is already known." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "18Qm4F2_N7mH", + "outputId": "2ce7fc1d-48bb-4c7f-bad6-f0b929f3ac6b" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values, divorce=dset.DivorceScaled.values)\n", + "mcmc.print_summary()\n", + "samples_3 = mcmc.get_samples()" + ], + "execution_count": 21, + "outputs": [ + { + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 3000/3000 [00:04<00:00, 644.48it/s, 7 steps of size 4.65e-01. acc. prob=0.94]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a 0.00 0.10 0.00 -0.17 0.16 2007.41 1.00\n", + " bA -0.61 0.16 -0.61 -0.89 -0.37 1225.02 1.00\n", + " bM -0.07 0.16 -0.07 -0.34 0.19 1275.37 1.00\n", + " sigma 0.83 0.08 0.82 0.69 0.96 1820.77 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XfW5xgpwN7mI", + "outputId": "0561ac6d-ae08-4f60-a5a2-13c81f13ce3f" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "print('Log posterior predictive density: {}'.format(\n", + " log_pred_density(rng_key_,\n", + " samples_3,\n", + " model,\n", + " marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values,\n", + " divorce=dset.DivorceScaled.values)\n", + "))" + ], + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Log posterior predictive density: -59.06374740600586\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nptmx2OaN7mI" + }, + "source": [ + "### Divorce Rate Residuals by State\n", + "\n", + "The regression plots above shows that the observed divorce rates for many states differs considerably from the mean regression line. To dig deeper into how the last model (Model 3) under-predicts or over-predicts for each of the states, we will plot the posterior predictive and residuals (`Observed divorce rate - Predicted divorce rate`) for each of the states." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 948 + }, + "id": "3vEDRtFON7mI", + "outputId": "a11368d2-222d-484d-9529-10ae11cc042a" + }, + "source": [ + "# Predictions for Model 3.\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictions_3 = Predictive(model, samples_3)(rng_key_,\n", + " marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values)['obs']\n", + "y = jnp.arange(50)\n", + "\n", + "\n", + "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 16))\n", + "pred_mean = jnp.mean(predictions_3, axis=0)\n", + "pred_hpdi = hpdi(predictions_3, 0.9)\n", + "residuals_3 = dset.DivorceScaled.values - predictions_3\n", + "residuals_mean = jnp.mean(residuals_3, axis=0)\n", + "residuals_hpdi = hpdi(residuals_3, 0.9)\n", + "idx = jnp.argsort(residuals_mean)\n", + "\n", + "# Plot posterior predictive\n", + "ax[0].plot(jnp.zeros(50), y, '--')\n", + "ax[0].errorbar(pred_mean[idx], y, xerr=pred_hpdi[1, idx] - pred_mean[idx], \n", + " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", + "ax[0].plot(dset.DivorceScaled.values[idx], y, marker='o', \n", + " ls='none', color='gray')\n", + "ax[0].set(xlabel='Posterior Predictive (red) vs. Actuals (gray)', ylabel='State', \n", + " title='Posterior Predictive with 90% CI')\n", + "ax[0].set_yticks(y)\n", + "ax[0].set_yticklabels(dset.Loc.values[idx], fontsize=10);\n", + "\n", + "# Plot residuals\n", + "residuals_3 = dset.DivorceScaled.values - predictions_3\n", + "residuals_mean = jnp.mean(residuals_3, axis=0)\n", + "residuals_hpdi = hpdi(residuals_3, 0.9)\n", + "err = residuals_hpdi[1] - residuals_mean\n", + "\n", + "ax[1].plot(jnp.zeros(50), y, '--')\n", + "ax[1].errorbar(residuals_mean[idx], y, xerr=err[idx], \n", + " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", + "ax[1].set(xlabel='Residuals', ylabel='State', title='Residuals with 90% CI')\n", + "ax[1].set_yticks(y)\n", + "ax[1].set_yticklabels(dset.Loc.values[idx], fontsize=10);" + ], + "execution_count": 23, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_gtKVD5jN7mJ" + }, + "source": [ + "The plot on the left shows the mean predictions with 90% CI for each of the states using Model 3. The gray markers indicate the actual observed divorce rates. The right plot shows the residuals for each of the states, and both these plots are sorted by the residuals, i.e. at the bottom, we are looking at states where the model predictions are higher than the observed rates, whereas at the top, the reverse is true.\n", + "\n", + "Overall, the model fit seems good because most observed data points like within a 90% CI around the mean predictions. However, notice how the model over-predicts by a large margin for states like Idaho (bottom left), and on the other end under-predicts for states like Maine (top right). This is likely indicative of other factors that we are missing out in our model that affect divorce rate across different states. Even ignoring other socio-political variables, one such factor that we have not yet modeled is the measurement noise given by `Divorce SE` in the dataset. We will explore this in the next section." + ] + }, { - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " + "cell_type": "markdown", + "metadata": { + "id": "ZB2I6FAhN7mJ" + }, + "source": [ + "## Regression Model with Measurement Error\n", + "\n", + "Note that in our previous models, each data point influences the regression line equally. Is this well justified? We will build on the previous model to incorporate measurement error given by `Divorce SE` variable in the dataset. Incorporating measurement noise will be useful in ensuring that observations that have higher confidence (i.e. lower measurement noise) have a greater impact on the regression line. On the other hand, this will also help us better model outliers with high measurement errors. For more details on modeling errors due to measurement noise, refer to Chapter 14 of [[1](#References)].\n", + "\n", + "To do this, we will reuse Model 3, with the only change that the final observed value has a measurement error given by `divorce_sd` (notice that this has to be standardized since the `divorce` variable itself has been standardized to mean 0 and std 1)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ue9-HyWuN7mJ" + }, + "source": [ + "def model_se(marriage, age, divorce_sd, divorce=None):\n", + " a = numpyro.sample('a', dist.Normal(0., 0.2))\n", + " bM = numpyro.sample('bM', dist.Normal(0., 0.5))\n", + " M = bM * marriage\n", + " bA = numpyro.sample('bA', dist.Normal(0., 0.5))\n", + " A = bA * age\n", + " sigma = numpyro.sample('sigma', dist.Exponential(1.))\n", + " mu = a + M + A\n", + " divorce_rate = numpyro.sample('divorce_rate', dist.Normal(mu, sigma))\n", + " numpyro.sample('obs', dist.Normal(divorce_rate, divorce_sd), obs=divorce)" + ], + "execution_count": 24, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "BFm91doZN7mJ" + }, + "source": [ + "# Standardize\n", + "dset['DivorceScaledSD'] = dset['Divorce SE'] / jnp.std(dset.Divorce.values)" + ], + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "twtxSbBpN7mJ", + "outputId": "1eb4cd42-3b0d-4ae8-bb65-335b6faf205a" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "kernel = NUTS(model_se, target_accept_prob=0.9) \n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=3000)\n", + "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values, age=dset.AgeScaled.values,\n", + " divorce_sd=dset.DivorceScaledSD.values, divorce=dset.DivorceScaled.values)\n", + "mcmc.print_summary()\n", + "samples_4 = mcmc.get_samples()" + ], + "execution_count": 26, + "outputs": [ + { + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 4000/4000 [00:06<00:00, 578.19it/s, 15 steps of size 2.58e-01. acc. prob=0.93]\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a -0.06 0.10 -0.06 -0.20 0.11 3203.01 1.00\n", + " bA -0.61 0.16 -0.61 -0.87 -0.35 2156.51 1.00\n", + " bM 0.06 0.17 0.06 -0.21 0.33 1943.15 1.00\n", + " divorce_rate[0] 1.16 0.36 1.15 0.53 1.72 2488.98 1.00\n", + " divorce_rate[1] 0.69 0.55 0.68 -0.15 1.65 4832.63 1.00\n", + " divorce_rate[2] 0.42 0.34 0.42 -0.16 0.96 4419.13 1.00\n", + " divorce_rate[3] 1.41 0.46 1.40 0.63 2.11 4782.86 1.00\n", + " divorce_rate[4] -0.90 0.13 -0.90 -1.12 -0.71 4269.33 1.00\n", + " divorce_rate[5] 0.65 0.39 0.65 0.01 1.31 4139.51 1.00\n", + " divorce_rate[6] -1.36 0.35 -1.36 -1.96 -0.82 5180.21 1.00\n", + " divorce_rate[7] -0.33 0.49 -0.33 -1.15 0.45 4089.39 1.00\n", + " divorce_rate[8] -1.88 0.59 -1.88 -2.89 -0.93 3305.68 1.00\n", + " divorce_rate[9] -0.62 0.17 -0.61 -0.90 -0.34 4936.95 1.00\n", + "divorce_rate[10] 0.76 0.29 0.76 0.28 1.24 3627.89 1.00\n", + "divorce_rate[11] -0.55 0.50 -0.55 -1.38 0.26 3822.80 1.00\n", + "divorce_rate[12] 0.20 0.53 0.20 -0.74 0.99 1476.70 1.00\n", + "divorce_rate[13] -0.86 0.23 -0.87 -1.24 -0.48 5333.10 1.00\n", + "divorce_rate[14] 0.55 0.30 0.55 0.09 1.05 5533.56 1.00\n", + "divorce_rate[15] 0.28 0.38 0.28 -0.35 0.92 5179.68 1.00\n", + "divorce_rate[16] 0.49 0.43 0.49 -0.23 1.16 5134.56 1.00\n", + "divorce_rate[17] 1.25 0.35 1.24 0.69 1.84 4571.21 1.00\n", + "divorce_rate[18] 0.42 0.38 0.41 -0.15 1.10 4946.86 1.00\n", + "divorce_rate[19] 0.38 0.55 0.36 -0.50 1.29 2145.11 1.00\n", + "divorce_rate[20] -0.56 0.34 -0.56 -1.12 -0.02 5219.59 1.00\n", + "divorce_rate[21] -1.11 0.27 -1.11 -1.53 -0.65 3778.88 1.00\n", + "divorce_rate[22] -0.28 0.26 -0.28 -0.71 0.13 5751.65 1.00\n", + "divorce_rate[23] -0.99 0.30 -0.99 -1.46 -0.49 4385.57 1.00\n", + "divorce_rate[24] 0.43 0.41 0.42 -0.26 1.08 3868.84 1.00\n", + "divorce_rate[25] -0.03 0.32 -0.03 -0.57 0.48 5927.41 1.00\n", + "divorce_rate[26] -0.01 0.49 -0.01 -0.79 0.81 4581.29 1.00\n", + "divorce_rate[27] -0.16 0.39 -0.15 -0.79 0.49 4522.45 1.00\n", + "divorce_rate[28] -0.27 0.50 -0.29 -1.08 0.53 3824.97 1.00\n", + "divorce_rate[29] -1.79 0.24 -1.78 -2.18 -1.39 5134.14 1.00\n", + "divorce_rate[30] 0.17 0.42 0.16 -0.55 0.82 5978.21 1.00\n", + "divorce_rate[31] -1.66 0.16 -1.66 -1.93 -1.41 5976.18 1.00\n", + "divorce_rate[32] 0.12 0.25 0.12 -0.27 0.52 5759.99 1.00\n", + "divorce_rate[33] -0.04 0.52 -0.04 -0.91 0.82 2926.68 1.00\n", + "divorce_rate[34] -0.13 0.22 -0.13 -0.50 0.23 4390.05 1.00\n", + "divorce_rate[35] 1.27 0.43 1.27 0.53 1.94 4659.54 1.00\n", + "divorce_rate[36] 0.22 0.36 0.22 -0.36 0.84 3758.16 1.00\n", + "divorce_rate[37] -1.02 0.23 -1.02 -1.38 -0.64 5954.84 1.00\n", + "divorce_rate[38] -0.93 0.54 -0.94 -1.84 -0.06 3289.66 1.00\n", + "divorce_rate[39] -0.67 0.33 -0.67 -1.18 -0.09 4787.55 1.00\n", + "divorce_rate[40] 0.25 0.55 0.24 -0.67 1.16 4526.98 1.00\n", + "divorce_rate[41] 0.73 0.34 0.73 0.17 1.29 4237.28 1.00\n", + "divorce_rate[42] 0.20 0.18 0.20 -0.10 0.48 5156.91 1.00\n", + "divorce_rate[43] 0.81 0.43 0.81 0.14 1.50 2067.24 1.00\n", + "divorce_rate[44] -0.42 0.51 -0.43 -1.23 0.45 3844.29 1.00\n", + "divorce_rate[45] -0.39 0.25 -0.39 -0.78 0.04 4611.94 1.00\n", + "divorce_rate[46] 0.13 0.31 0.13 -0.36 0.64 5879.70 1.00\n", + "divorce_rate[47] 0.56 0.47 0.56 -0.15 1.37 4319.38 1.00\n", + "divorce_rate[48] -0.63 0.28 -0.63 -1.11 -0.18 5820.05 1.00\n", + "divorce_rate[49] 0.86 0.59 0.88 -0.10 1.79 2460.53 1.00\n", + " sigma 0.58 0.11 0.57 0.40 0.76 735.02 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "puqL7TzPN7mJ" + }, + "source": [ + "### Effect of Incorporating Measurement Noise on Residuals\n", + "\n", + "Notice that our values for the regression coefficients is very similar to Model 3. However, introducing measurement noise allows us to more closely match our predictive distribution to the observed values. We can see this if we plot the residuals as earlier. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XKnLI7__N7mJ" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictions_4 = Predictive(model_se, samples_4)(rng_key_,\n", + " marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values,\n", + " divorce_sd=dset.DivorceScaledSD.values)['obs']" + ], + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 993 + }, + "id": "a7aC5dgdN7mJ", + "outputId": "e6878a39-dbb8-485c-bd56-79a66155f8a5" + }, + "source": [ + "sd = dset.DivorceScaledSD.values\n", + "residuals_4 = dset.DivorceScaled.values - predictions_4\n", + "residuals_mean = jnp.mean(residuals_4, axis=0)\n", + "residuals_hpdi = hpdi(residuals_4, 0.9)\n", + "err = residuals_hpdi[1] - residuals_mean\n", + "idx = jnp.argsort(residuals_mean)\n", + "y = jnp.arange(50)\n", + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 16))\n", + "\n", + "\n", + "# Plot Residuals\n", + "ax.plot(jnp.zeros(50), y, '--')\n", + "ax.errorbar(residuals_mean[idx], y, xerr=err[idx], \n", + " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", + "\n", + "# Plot SD \n", + "ax.errorbar(residuals_mean[idx], y, xerr=sd[idx], \n", + " ls='none', color='orange', alpha=0.9)\n", + "\n", + "# Plot earlier mean residual\n", + "ax.plot(jnp.mean(dset.DivorceScaled.values - predictions_3, 0)[idx], y,\n", + " ls='none', marker='o', ms=6, color='black', alpha=0.6)\n", + "\n", + "ax.set(xlabel='Residuals', ylabel='State', title='Residuals with 90% CI')\n", + "ax.set_yticks(y)\n", + "ax.set_yticklabels(dset.Loc.values[idx], fontsize=10);\n", + "ax.text(-2.8, -7, 'Residuals (with error-bars) from current model (in red). '\n", + " 'Black marker \\nshows residuals from the previous model (Model 3). '\n", + " 'Measurement \\nerror is indicated by orange bar.');" + ], + "execution_count": 28, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "05vX0drHN7mK" + }, + "source": [ + "The plot above shows the residuals for each of the states, along with the measurement noise given by inner error bar. The gray dots are the mean residuals from our earlier Model 3. Notice how having an additional degree of freedom to model the measurement noise has shrunk the residuals. In particular, for Idaho and Maine, our predictions are now much closer to the observed values after incorporating measurement noise in the model.\n", + "\n", + "To better see how measurement noise affects the movement of the regression line, let us plot the residuals with respect to the measurement noise." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + }, + "id": "lmvXOBAsN7mK", + "outputId": "12aba4b5-d974-4887-8be1-b223f73d0ad0" + }, + "source": [ + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n", + "x = dset.DivorceScaledSD.values\n", + "y1 = jnp.mean(residuals_3, 0)\n", + "y2 = jnp.mean(residuals_4, 0)\n", + "ax.plot(x, y1, ls='none', marker='o')\n", + "ax.plot(x, y2, ls='none', marker='o')\n", + "for i, (j, k) in enumerate(zip(y1, y2)):\n", + " ax.plot([x[i], x[i]], [j, k], '--', color='gray');\n", + "\n", + "ax.set(xlabel='Measurement Noise', ylabel='Residual', title='Mean residuals (Model 4: red, Model 3: blue)');" + ], + "execution_count": 29, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YzFlMShkN7mL" + }, + "source": [ + "The plot above shows what has happend in more detail - the regression line itself has moved to ensure a better fit for observations with low measurement noise (left of the plot) where the residuals have shrunk very close to 0. That is to say that data points with low measurement error have a concomitantly higher contribution in determining the regression line. On the other hand, for states with high measurement error (right of the plot), incorporating measurement noise allows us to move our posterior distribution mass closer to the observations resulting in a shrinkage of residuals as well." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1NmiOj_fN7mL" + }, + "source": [ + "## References\n", + "\n", + "1. McElreath, R. (2016). Statistical Rethinking: A Bayesian Course with Examples in R and Stan CRC Press.\n", + "2. Stan Development Team. [Stan User's Guide](https://mc-stan.org/docs/2_19/stan-users-guide/index.html)\n", + "3. Goodman, N.D., and StuhlMueller, A. (2014). [The Design and Implementation of Probabilistic Programming Languages](http://dippl.org/)\n", + "4. Pyro Development Team. [Poutine: A Guide to Programming with Effect Handlers in Pyro](http://pyro.ai/examples/effect_handlers.html)\n", + "5. Hoffman, M.D., Gelman, A. (2011). The No-U-Turn Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo.\n", + "6. Betancourt, M. (2017). A Conceptual Introduction to Hamiltonian Monte Carlo.\n", + "7. JAX Development Team (2018). [Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more](https://github.com/google/jax)\n", + "8. Gelman, A., Hwang, J., and Vehtari A. [Understanding predictive information criteria for Bayesian models](https://arxiv.org/pdf/1307.5928.pdf)" ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } - ], - "source": [ - "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n", - "x = dset.DivorceScaledSD.values\n", - "y1 = jnp.mean(residuals_3, 0)\n", - "y2 = jnp.mean(residuals_4, 0)\n", - "ax.plot(x, y1, ls='none', marker='o')\n", - "ax.plot(x, y2, ls='none', marker='o')\n", - "for i, (j, k) in enumerate(zip(y1, y2)):\n", - " ax.plot([x[i], x[i]], [j, k], '--', color='gray');\n", - "\n", - "ax.set(xlabel='Measurement Noise', ylabel='Residual', title='Mean residuals (Model 4: red, Model 3: blue)');" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The plot above shows what has happend in more detail - the regression line itself has moved to ensure a better fit for observations with low measurement noise (left of the plot) where the residuals have shrunk very close to 0. That is to say that data points with low measurement error have a concomitantly higher contribution in determining the regression line. On the other hand, for states with high measurement error (right of the plot), incorporating measurement noise allows us to move our posterior distribution mass closer to the observations resulting in a shrinkage of residuals as well." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## References\n", - "\n", - "1. McElreath, R. (2016). Statistical Rethinking: A Bayesian Course with Examples in R and Stan CRC Press.\n", - "2. Stan Development Team. [Stan User's Guide](https://mc-stan.org/docs/2_19/stan-users-guide/index.html)\n", - "3. Goodman, N.D., and StuhlMueller, A. (2014). [The Design and Implementation of Probabilistic Programming Languages](http://dippl.org/)\n", - "4. Pyro Development Team. [Poutine: A Guide to Programming with Effect Handlers in Pyro](http://pyro.ai/examples/effect_handlers.html)\n", - "5. Hoffman, M.D., Gelman, A. (2011). The No-U-Turn Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo.\n", - "6. Betancourt, M. (2017). A Conceptual Introduction to Hamiltonian Monte Carlo.\n", - "7. JAX Development Team (2018). [Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more](https://github.com/google/jax)\n", - "8. Gelman, A., Hwang, J., and Vehtari A. [Understanding predictive information criteria for Bayesian models](https://arxiv.org/pdf/1307.5928.pdf)" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.8" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} + ] +} \ No newline at end of file From ab18282d6fe0a297fe6367b1231a9ce06f5164f7 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Mon, 28 Jun 2021 14:57:28 +0100 Subject: [PATCH 130/222] Fix chain detection in progress bar (#1077) * fixup progress bars with multiple chains * add noteabout ipywidgets to docstring, add underscore to regex * make CHAIN_RE private --- numpyro/infer/mcmc.py | 5 +++++ numpyro/util.py | 9 +++++++-- 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 58d5eaf39..3b9afb185 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -204,6 +204,11 @@ class MCMC(object): .. note:: Setting `progress_bar=False` will improve the speed for many cases. But it might require more memory than the other option. + .. note:: If setting `num_chains` greater than `1` in a Jupyter Notebook, then you will need to + have installed `ipywidgets `_ + in the environment from which you launced Jupyter in order for the progress bars to render + correctly. + :param MCMCKernel sampler: an instance of :class:`~numpyro.infer.mcmc.MCMCKernel` that determines the sampler for running MCMC. Currently, only :class:`~numpyro.infer.hmc.HMC` and :class:`~numpyro.infer.hmc.NUTS` are available. diff --git a/numpyro/util.py b/numpyro/util.py index 9405caa86..26b751ae6 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -21,6 +21,7 @@ from jax.tree_util import tree_flatten, tree_map _DISABLE_CONTROL_FLOW_PRIM = False +_CHAIN_RE = re.compile(r"(?<=_)\d+$") # e.g. get '3' from 'TFRT_CPU_3' def set_rng_seed(rng_seed): @@ -189,12 +190,16 @@ def progress_bar_factory(num_samples, num_chains): tqdm_bars[chain].set_description("Compiling.. ", refresh=True) def _update_tqdm(arg, transform, device): - chain = int(str(device)[4:]) + chain_match = _CHAIN_RE.search(str(device)) + assert chain_match + chain = int(chain_match.group()) tqdm_bars[chain].set_description(f"Running chain {chain}", refresh=False) tqdm_bars[chain].update(arg) def _close_tqdm(arg, transform, device): - chain = int(str(device)[4:]) + chain_match = _CHAIN_RE.search(str(device)) + assert chain_match + chain = int(chain_match.group()) tqdm_bars[chain].update(arg) finished_chains.append(chain) if len(finished_chains) == num_chains: From f8f482ad7b2f3f658d198c99f76fdda12cff84ca Mon Sep 17 00:00:00 2001 From: Indrayana Rustandi <468296+irustandi@users.noreply.github.com> Date: Tue, 29 Jun 2021 01:45:15 -0400 Subject: [PATCH 131/222] Port LKJ example from Pyro (#1065) * port LKJ example from Pyro * add code samples in docstring for LKJ and LKJCholesky * delete LKJ example * change sample name for correlation matrix from L_omega to corr_mat * incorporate review comments --- numpyro/distributions/continuous.py | 43 +++++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 53119ca5b..75b727872 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -545,6 +545,27 @@ class LKJ(TransformedDistribution): When ``concentration < 1``, the distribution favors samples with small determinent. This is useful when we know a priori that some underlying variables are correlated. + Sample code for using LKJ in the context of multivariate normal sample:: + + def model(y): # y has dimension N x d + d = y.shape[1] + N = y.shape[0] + # Vector of variances for each of the d variables + theta = numpyro.sample("theta", dist.HalfCauchy(jnp.ones(d))) + + concentration = jnp.ones(1) # Implies a uniform distribution over correlation matrices + corr_mat = numpyro.sample("corr_mat", dist.LKJ(d, concentration)) + sigma = jnp.sqrt(theta) + # we can also use a faster formula `cov_mat = jnp.outer(theta, theta) * corr_mat` + cov_mat = jnp.matmul(jnp.matmul(jnp.diag(sigma), corr_mat), jnp.diag(sigma)) + + # Vector of expectations + mu = jnp.zeros(d) + + with numpyro.plate("observations", N): + obs = numpyro.sample("obs", dist.MultivariateNormal(mu, covariance_matrix=cov_mat), obs=y) + return obs + :param int dimension: dimension of the matrices :param ndarray concentration: concentration/shape parameter of the distribution (often referred to as eta) @@ -606,6 +627,28 @@ class LKJCholesky(Distribution): (hence small determinent). This is useful when we know a priori that some underlying variables are correlated. + Sample code for using LKJCholesky in the context of multivariate normal sample:: + + def model(y): # y has dimension N x d + d = y.shape[1] + N = y.shape[0] + # Vector of variances for each of the d variables + theta = numpyro.sample("theta", dist.HalfCauchy(jnp.ones(d))) + # Lower cholesky factor of a correlation matrix + concentration = jnp.ones(1) # Implies a uniform distribution over correlation matrices + L_omega = numpyro.sample("L_omega", dist.LKJCholesky(d, concentration)) + # Lower cholesky factor of the covariance matrix + sigma = jnp.sqrt(theta) + # we can also use a faster formula `L_Omega = sigma[..., None] * L_omega` + L_Omega = jnp.matmul(jnp.diag(sigma), L_omega) + + # Vector of expectations + mu = jnp.zeros(d) + + with numpyro.plate("observations", N): + obs = numpyro.sample("obs", dist.MultivariateNormal(mu, scale_tril=L_Omega), obs=y) + return obs + :param int dimension: dimension of the matrices :param ndarray concentration: concentration/shape parameter of the distribution (often referred to as eta) From f368d98a62cf4afab302cbf1ce07bff8798588a6 Mon Sep 17 00:00:00 2001 From: Lukas Prediger Date: Mon, 5 Jul 2021 16:23:55 +0300 Subject: [PATCH 132/222] Easier installation for GPU/TPU (#1079) * Added optional installation target for GPU jaxlib. * Code review fixes to new installation options. Bumped jax version to 0.2.13 because jax isntall targets are not available before that. * Adding separate installation option for pinned jaxlib. * Simplifying TPU install instructions. * PR review fixes. --- README.md | 22 +++++++++++++++++++--- setup.py | 21 ++++++++++++++++++--- 2 files changed, 37 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 3f982eae5..62d5e591a 100644 --- a/README.md +++ b/README.md @@ -184,15 +184,31 @@ Pyro users will note that the API for model specification and inference is large > **Limited Windows Support:** Note that NumPyro is untested on Windows, and might require building jaxlib from source. See this [JAX issue](https://github.com/google/jax/issues/438) for more details. Alternatively, you can install [Windows Subsystem for Linux](https://docs.microsoft.com/en-us/windows/wsl/) and use NumPyro on it as on a Linux system. See also [CUDA on Windows Subsystem for Linux](https://developer.nvidia.com/cuda/wsl) and [this forum post](https://forum.pyro.ai/t/numpyro-with-gpu-works-on-windows/2690) if you want to use GPUs on Windows. -To install NumPyro with a CPU version of JAX, you can use pip: +To install NumPyro with the latest CPU version of JAX, you can use pip: ``` pip install numpyro ``` -To use NumPyro on the GPU, you will need to first [install](https://github.com/google/jax#installation) `jax` and `jaxlib` with CUDA support. +In case of compatibility issues arise during execution of the above command, you can instead force the installation of a known +compatible CPU version of JAX with -To run NumPyro on Cloud TPUs, you can use pip to install NumPyro as above and setup the TPU backend as detailed [here](https://github.com/google/jax/tree/master/cloud_tpu_colabs). +``` +pip install numpyro[cpu] +``` + +To use **NumPyro on the GPU**, you need to install CUDA first and then use the following pip command: +``` +# change `cuda111` to your CUDA version number, e.g. for CUDA 10.2 use `cuda102` +pip install numpyro[cuda111] -f https://storage.googleapis.com/jax-releases/jax_releases.html +``` +If you need further guidance, please have a look at the [JAX GPU installation instructions](https://github.com/google/jax#pip-installation-gpu-cuda). + +To run **NumPyro on Cloud TPUs**, you can look at some [JAX on Cloud TPU examples](https://github.com/google/jax/tree/master/cloud_tpu_colabs). + +For Cloud TPU VM, you need to setup the TPU backend as detailed in the [Cloud TPU VM JAX Quickstart Guide](https://cloud.google.com/tpu/docs/jax-quickstart-tpu-vm). +After you have verified that the TPU backend is properly set up, +you can install NumPyro using the `pip install numpyro` command. > **Default Platform:** JAX will use GPU by default if CUDA-supported `jaxlib` package is installed. You can use [set_platform](http://num.pyro.ai/en/stable/utilities.html#set-platform) utility `numpyro.set_platform("cpu")` to switch to CPU at the beginning of your program. diff --git a/setup.py b/setup.py index 0342cddd4..169fd9bae 100644 --- a/setup.py +++ b/setup.py @@ -9,6 +9,14 @@ from setuptools import find_packages, setup PROJECT_PATH = os.path.dirname(os.path.abspath(__file__)) +_available_cuda_versions = [ + "101", + "102", + "110", + "111", +] # TODO: align these with what's available in JAX before release +_jax_version_constraints = ">=0.2.13" +_jaxlib_version_constraints = ">=0.1.65" # Find version for line in open(os.path.join(PROJECT_PATH, "numpyro", "version.py")): @@ -23,7 +31,6 @@ sys.stderr.flush() long_description = "" - setup( name="numpyro", version=version, @@ -32,8 +39,8 @@ url="https://github.com/pyro-ppl/numpyro", author="Uber AI Labs", install_requires=[ - "jax>=0.2.11", - "jaxlib>=0.1.62", + f"jax{_jax_version_constraints}", + f"jaxlib{_jaxlib_version_constraints}", "tqdm", ], extras_require={ @@ -66,6 +73,14 @@ "tfp-nightly<=0.14.0.dev20210608", ], "examples": ["arviz", "jupyter", "matplotlib", "pandas", "seaborn"], + "cpu": f"jax[cpu]{_jax_version_constraints}", + # TPU and CUDA installations, currently require to add package repository URL, i.e., + # pip install numpyro[cuda101] -f https://storage.googleapis.com/jax-releases/jax_releases.html + "tpu": f"jax[tpu]{_jax_version_constraints}", + **{ + f"cuda{version}": f"jax[cuda{version}]{_jax_version_constraints}" + for version in _available_cuda_versions + }, }, long_description=long_description, long_description_content_type="text/markdown", From 1b517b03854cbdfde03dc18b75b4dcea02256347 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Mon, 5 Jul 2021 17:00:32 +0100 Subject: [PATCH 133/222] ProdLDA example with Haiku + Flax (#1056) * Add ProdLDA example * Format source * Fix docs build and add local image * Fixes * Add command line configuration * Add Flax * Address further comments * Add prodLDA to docs and tests * Explicitly set momentum / decay_rate in batch norm layers * Add wordcloud dependency to examples requirements * Fix tests * Test specification * Use Dirichlet distribution * Minor fixes * Add dirichlet-dirichlet KL test * Fix test >_< --- docs/source/_static/img/examples/prodlda.png | Bin 0 -> 375581 bytes docs/source/index.rst | 1 + examples/prodlda.py | 348 +++++++++++++++++++ numpyro/distributions/kl.py | 15 +- setup.py | 10 +- test/test_distributions.py | 10 + test/test_examples.py | 2 + 7 files changed, 384 insertions(+), 2 deletions(-) create mode 100644 docs/source/_static/img/examples/prodlda.png create mode 100644 examples/prodlda.py diff --git a/docs/source/_static/img/examples/prodlda.png b/docs/source/_static/img/examples/prodlda.png new file mode 100644 index 0000000000000000000000000000000000000000..b9136b9f8ff3cfd1cfdcb86b58c0f1ca0eccca9d GIT binary patch literal 375581 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

    ?yWJ~m22S;4Xd{xCvOXGa;?>e1_u*3ZDYWl752 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%0D$4 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%0DwE<rAPFOsn6b?hcZU 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

    G0D!^ZhAv|GzF$QKmGf2`Dlsp)qL0-Lzic(&R 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 *Lkg-Yi08 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 U)B^iMIbXfJ)>mryDP$#M3^P)d9U3`h+$uv^ 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�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 XbPHp;*onBK2Ldibw6R_}$~p2sPnxLi literal 0 HcmV?d00001 diff --git a/docs/source/index.rst b/docs/source/index.rst index 99d0e08e2..a93f70e0e 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -59,6 +59,7 @@ NumPyro documentation examples/neutra examples/covtype examples/thompson_sampling + examples/prodlda Indices and tables diff --git a/examples/prodlda.py b/examples/prodlda.py new file mode 100644 index 000000000..d7b2ae5c3 --- /dev/null +++ b/examples/prodlda.py @@ -0,0 +1,348 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +""" +Example: ProdLDA +================ +In this example, we will follow [1] to implement the ProdLDA topic model from +Autoencoding Variational Inference For Topic Models by Akash Srivastava and Charles +Sutton [2]. This model returns consistently better topics than vanilla LDA and trains +much more quickly. Furthermore, it does not require a custom inference algorithm that +relies on complex mathematical derivations. This example also serves as an +introduction to Flax and Haiku modules in NumPyro. + +Note that unlike [1, 2], this implementation uses a Dirichlet prior directly rather +than approximating it with a softmax-normal distribution. + +For the interested reader, a nice extension of this model is the CombinedTM model [3] +which utilizes a pre-trained sentence transformer (like https://www.sbert.net/) to +generate a better representation of the encoded latent vector. + +**References:** + 1. http://pyro.ai/examples/prodlda.html + 2. Akash Srivastava, & Charles Sutton. (2017). Autoencoding Variational Inference + For Topic Models. + 3. Federico Bianchi, Silvia Terragni, and Dirk Hovy (2021), "Pre-training is a Hot + Topic: Contextualized Document Embeddings Improve Topic Coherence" + (https://arxiv.org/abs/2004.03974) + +.. image:: ../_static/img/examples/prodlda.png + :align: center +""" +import argparse + +import matplotlib.pyplot as plt +import pandas as pd +from sklearn.datasets import fetch_20newsgroups +from sklearn.feature_extraction.text import CountVectorizer +from wordcloud import WordCloud + +import flax.linen as nn +import haiku as hk +import jax +from jax import device_put, random +import jax.numpy as jnp + +import numpyro +from numpyro.contrib.module import flax_module, haiku_module +import numpyro.distributions as dist +from numpyro.infer import SVI, TraceMeanField_ELBO + + +class HaikuEncoder: + def __init__(self, vocab_size, num_topics, hidden, dropout_rate): + self._vocab_size = vocab_size + self._num_topics = num_topics + self._hidden = hidden + self._dropout_rate = dropout_rate + + def __call__(self, inputs, is_training): + dropout_rate = self._dropout_rate if is_training else 0.0 + + h = jax.nn.softplus(hk.Linear(self._hidden)(inputs)) + h = jax.nn.softplus(hk.Linear(self._hidden)(h)) + h = hk.dropout(hk.next_rng_key(), dropout_rate, h) + h = hk.Linear(self._num_topics)(h) + + # NB: here we set `create_scale=False` and `create_offset=False` to reduce + # the number of learning parameters + log_concentration = hk.BatchNorm( + create_scale=False, create_offset=False, decay_rate=0.9 + )(h, is_training) + return jnp.exp(log_concentration) + + +class HaikuDecoder: + def __init__(self, vocab_size, dropout_rate): + self._vocab_size = vocab_size + self._dropout_rate = dropout_rate + + def __call__(self, inputs, is_training): + dropout_rate = self._dropout_rate if is_training else 0.0 + h = hk.dropout(hk.next_rng_key(), dropout_rate, inputs) + h = hk.Linear(self._vocab_size, with_bias=False)(h) + return hk.BatchNorm(create_scale=False, create_offset=False, decay_rate=0.9)( + h, is_training + ) + + +class FlaxEncoder(nn.Module): + vocab_size: int + num_topics: int + hidden: int + dropout_rate: float + + @nn.compact + def __call__(self, inputs, is_training): + h = nn.softplus(nn.Dense(self.hidden)(inputs)) + h = nn.softplus(nn.Dense(self.hidden)(h)) + h = nn.Dropout(self.dropout_rate, deterministic=not is_training)(h) + h = nn.Dense(self.num_topics)(h) + + log_concentration = nn.BatchNorm( + use_bias=False, + use_scale=False, + momentum=0.9, + use_running_average=not is_training, + )(h) + return jnp.exp(log_concentration) + + +class FlaxDecoder(nn.Module): + vocab_size: int + dropout_rate: float + + @nn.compact + def __call__(self, inputs, is_training): + h = nn.Dropout(self.dropout_rate, deterministic=not is_training)(inputs) + h = nn.Dense(self.vocab_size, use_bias=False)(h) + return nn.BatchNorm( + use_bias=False, + use_scale=False, + momentum=0.9, + use_running_average=not is_training, + )(h) + + +def model(docs, hyperparams, is_training=False, nn_framework="flax"): + if nn_framework == "flax": + decoder = flax_module( + "decoder", + FlaxDecoder(hyperparams["vocab_size"], hyperparams["dropout_rate"]), + input_shape=(1, hyperparams["num_topics"]), + # ensure PRNGKey is made available to dropout layers + apply_rng=["dropout"], + # indicate mutable state due to BatchNorm layers + mutable=["batch_stats"], + # to ensure proper initialisation of BatchNorm we must + # initialise with is_training=True + is_training=True, + ) + elif nn_framework == "haiku": + decoder = haiku_module( + "decoder", + # use `transform_with_state` for BatchNorm + hk.transform_with_state( + HaikuDecoder(hyperparams["vocab_size"], hyperparams["dropout_rate"]) + ), + input_shape=(1, hyperparams["num_topics"]), + apply_rng=True, + # to ensure proper initialisation of BatchNorm we must + # initialise with is_training=True + is_training=True, + ) + else: + raise ValueError(f"Invalid choice {nn_framework} for argument nn_framework") + + with numpyro.plate( + "documents", docs.shape[0], subsample_size=hyperparams["batch_size"] + ): + batch_docs = numpyro.subsample(docs, event_dim=1) + theta = numpyro.sample( + "theta", dist.Dirichlet(jnp.ones(hyperparams["num_topics"])) + ) + + if nn_framework == "flax": + logits = decoder(theta, is_training, rngs={"dropout": numpyro.prng_key()}) + elif nn_framework == "haiku": + logits = decoder(numpyro.prng_key(), theta, is_training) + + total_count = batch_docs.sum(-1) + numpyro.sample( + "obs", dist.Multinomial(total_count, logits=logits), obs=batch_docs + ) + + +def guide(docs, hyperparams, is_training=False, nn_framework="flax"): + if nn_framework == "flax": + encoder = flax_module( + "encoder", + FlaxEncoder( + hyperparams["vocab_size"], + hyperparams["num_topics"], + hyperparams["hidden"], + hyperparams["dropout_rate"], + ), + input_shape=(1, hyperparams["vocab_size"]), + # ensure PRNGKey is made available to dropout layers + apply_rng=["dropout"], + # indicate mutable state due to BatchNorm layers + mutable=["batch_stats"], + # to ensure proper initialisation of BatchNorm we must + # initialise with is_training=True + is_training=True, + ) + elif nn_framework == "haiku": + encoder = haiku_module( + "encoder", + # use `transform_with_state` for BatchNorm + hk.transform_with_state( + HaikuEncoder( + hyperparams["vocab_size"], + hyperparams["num_topics"], + hyperparams["hidden"], + hyperparams["dropout_rate"], + ) + ), + input_shape=(1, hyperparams["vocab_size"]), + apply_rng=True, + # to ensure proper initialisation of BatchNorm we must + # initialise with is_training=True + is_training=True, + ) + else: + raise ValueError(f"Invalid choice {nn_framework} for argument nn_framework") + + with numpyro.plate( + "documents", docs.shape[0], subsample_size=hyperparams["batch_size"] + ): + batch_docs = numpyro.subsample(docs, event_dim=1) + + if nn_framework == "flax": + concentration = encoder( + batch_docs, is_training, rngs={"dropout": numpyro.prng_key()} + ) + elif nn_framework == "haiku": + concentration = encoder(numpyro.prng_key(), batch_docs, is_training) + + numpyro.sample("theta", dist.Dirichlet(concentration)) + + +def load_data(): + news = fetch_20newsgroups(subset="all") + vectorizer = CountVectorizer(max_df=0.5, min_df=20, stop_words="english") + docs = jnp.array(vectorizer.fit_transform(news["data"]).toarray()) + + vocab = pd.DataFrame(columns=["word", "index"]) + vocab["word"] = vectorizer.get_feature_names() + vocab["index"] = vocab.index + + return docs, vocab + + +def run_inference(docs, args): + rng_key = random.PRNGKey(0) + docs = device_put(docs) + + hyperparams = dict( + vocab_size=docs.shape[1], + num_topics=args.num_topics, + hidden=args.hidden, + dropout_rate=args.dropout_rate, + batch_size=args.batch_size, + ) + + optimizer = numpyro.optim.Adam(args.learning_rate) + svi = SVI(model, guide, optimizer, loss=TraceMeanField_ELBO()) + + return svi.run( + rng_key, + args.num_steps, + docs, + hyperparams, + is_training=True, + progress_bar=not args.disable_progbar, + nn_framework=args.nn_framework, + ) + + +def plot_word_cloud(b, ax, vocab, n): + indices = jnp.argsort(b)[::-1] + top20 = indices[:20] + df = pd.DataFrame(top20, columns=["index"]) + words = pd.merge(df, vocab[["index", "word"]], how="left", on="index")[ + "word" + ].values.tolist() + sizes = b[top20].tolist() + freqs = {words[i]: sizes[i] for i in range(len(words))} + wc = WordCloud(background_color="white", width=800, height=500) + wc = wc.generate_from_frequencies(freqs) + ax.set_title(f"Topic {n + 1}") + ax.imshow(wc, interpolation="bilinear") + ax.axis("off") + + +def main(args): + docs, vocab = load_data() + print(f"Dictionary size: {len(vocab)}") + print(f"Corpus size: {docs.shape}") + + svi_result = run_inference(docs, args) + + if args.nn_framework == "flax": + beta = svi_result.params["decoder$params"]["Dense_0"]["kernel"] + elif args.nn_framework == "haiku": + beta = svi_result.params["decoder$params"]["linear"]["w"] + + beta = jax.nn.softmax(beta) + + # the number of plots depends on the chosen number of topics. + # add 2 to num topics to ensure we create a row for any remainder after division + nrows = (args.num_topics + 2) // 3 + fig, axs = plt.subplots(nrows, 3, figsize=(14, 3 + 3 * nrows)) + axs = axs.flatten() + + for n in range(beta.shape[0]): + plot_word_cloud(beta[n], axs[n], vocab, n) + + # hide any unused axes + for i in range(n, len(axs)): + axs[i].axis("off") + + fig.savefig("wordclouds.png") + + +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.6.0") + parser = argparse.ArgumentParser( + description="Probabilistic topic modelling with Flax and Haiku" + ) + parser.add_argument("-n", "--num-steps", nargs="?", default=30_000, type=int) + parser.add_argument("-t", "--num-topics", nargs="?", default=12, type=int) + parser.add_argument("--batch-size", nargs="?", default=32, type=int) + parser.add_argument("--learning-rate", nargs="?", default=1e-3, type=float) + parser.add_argument("--hidden", nargs="?", default=200, type=int) + parser.add_argument("--dropout-rate", nargs="?", default=0.2, type=float) + parser.add_argument( + "-dp", + "--disable-progbar", + action="store_true", + default=False, + help="Whether to disable progress bar", + ) + parser.add_argument( + "--device", default="cpu", type=str, help='use "cpu", "gpu" or "tpu".' + ) + parser.add_argument( + "--nn-framework", + nargs="?", + default="flax", + help=( + "The framework to use for constructing encoder / decoder. Options are " + '"flax" or "haiku".' + ), + ) + args = parser.parse_args() + + numpyro.set_platform(args.device) + main(args) diff --git a/numpyro/distributions/kl.py b/numpyro/distributions/kl.py index c97bbeb63..ba30068f2 100644 --- a/numpyro/distributions/kl.py +++ b/numpyro/distributions/kl.py @@ -30,8 +30,9 @@ from jax import lax import jax.numpy as jnp +from jax.scipy.special import digamma, gammaln -from numpyro.distributions.continuous import Normal +from numpyro.distributions.continuous import Dirichlet, Normal from numpyro.distributions.distribution import ( Delta, Distribution, @@ -196,3 +197,15 @@ def _kl_normal_normal(p, q): var_ratio = jnp.square(p.scale / q.scale) t1 = jnp.square((p.loc - q.loc) / q.scale) return 0.5 * (var_ratio + t1 - 1 - jnp.log(var_ratio)) + + +@register_kl(Dirichlet, Dirichlet) +def _kl_dirichlet_dirichlet(p, q): + # From http://bariskurt.com/kullback-leibler-divergence-between-two-dirichlet-and-beta-distributions/ + sum_p_concentration = p.concentration.sum(-1) + sum_q_concentration = q.concentration.sum(-1) + t1 = gammaln(sum_p_concentration) - gammaln(sum_q_concentration) + t2 = (gammaln(p.concentration) - gammaln(q.concentration)).sum(-1) + t3 = p.concentration - q.concentration + t4 = digamma(p.concentration) - digamma(sum_p_concentration)[..., None] + return t1 - t2 + (t3 * t4).sum(-1) diff --git a/setup.py b/setup.py index 169fd9bae..e8ccd3a95 100644 --- a/setup.py +++ b/setup.py @@ -72,7 +72,15 @@ # TODO: relax this restriction when we revise tfp wrapper "tfp-nightly<=0.14.0.dev20210608", ], - "examples": ["arviz", "jupyter", "matplotlib", "pandas", "seaborn"], + "examples": [ + "arviz", + "jupyter", + "matplotlib", + "pandas", + "seaborn", + "scikit-learn", + "wordcloud", + ], "cpu": f"jax[cpu]{_jax_version_constraints}", # TPU and CUDA installations, currently require to add package repository URL, i.e., # pip install numpyro[cuda101] -f https://storage.googleapis.com/jax-releases/jax_releases.html diff --git a/test/test_distributions.py b/test/test_distributions.py index bbaa0c6ac..9fbdf97fa 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -2033,3 +2033,13 @@ def test_kl_normal_normal(shape): x = p.sample(random.PRNGKey(0), (10000,)).copy() expected = jnp.mean((p.log_prob(x) - q.log_prob(x)), 0) assert_allclose(actual, expected, rtol=0.05) + + +@pytest.mark.parametrize("shape", [(4,), (2, 3)], ids=str) +def test_kl_dirichlet_dirichlet(shape): + p = dist.Dirichlet(np.exp(np.random.normal(size=shape))) + q = dist.Dirichlet(np.exp(np.random.normal(size=shape))) + actual = kl_divergence(p, q) + x = p.sample(random.PRNGKey(0), (10_000,)).copy() + expected = jnp.mean((p.log_prob(x) - q.log_prob(x)), 0) + assert_allclose(actual, expected, rtol=0.05) diff --git a/test/test_examples.py b/test/test_examples.py index 436110e73..dcb35677c 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -37,6 +37,8 @@ "minipyro.py", "neutra.py --num-samples 100 --num-warmup 100", "ode.py --num-samples 100 --num-warmup 100 --num-chains 1", + "prodlda.py --num-steps 10 --hidden 10 --nn-framework flax", + "prodlda.py --num-steps 10 --hidden 10 --nn-framework haiku", "sparse_regression.py --num-samples 10 --num-warmup 10 --num-data 10 --num-dimensions 10", "stochastic_volatility.py --num-samples 100 --num-warmup 100", "ucbadmit.py --num-chains 2", From 003424bb3c57e44b433991cc73ddbb557bf31f3c Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 10 Jul 2021 15:35:14 -0400 Subject: [PATCH 134/222] Support infer_discrete for Predictive (#1086) * support infer_discrete for Predictive * revise docs * use infer_discrete_temperature * use temperature=1 by default --- examples/annotation.py | 22 ++---------- numpyro/contrib/funsor/discrete.py | 15 +++++--- numpyro/infer/util.py | 55 +++++++++++++++++++++++++----- 3 files changed, 60 insertions(+), 32 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index 6b7ada33e..264d14ac7 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -42,10 +42,9 @@ import numpyro from numpyro import handlers -from numpyro.contrib.funsor import config_enumerate, infer_discrete from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist -from numpyro.infer import MCMC, NUTS +from numpyro.infer import MCMC, NUTS, Predictive from numpyro.infer.reparam import LocScaleReparam @@ -313,24 +312,9 @@ def main(args): mcmc.run(random.PRNGKey(0), *data) mcmc.print_summary() - def infer_discrete_model(rng_key, samples): - conditioned_model = handlers.condition(model, data=samples) - infer_discrete_model = infer_discrete( - config_enumerate(conditioned_model), rng_key=rng_key - ) - with handlers.trace() as tr: - infer_discrete_model(*data) - - return { - name: site["value"] - for name, site in tr.items() - if site["type"] == "sample" and site["infer"].get("enumerate") == "parallel" - } - posterior_samples = mcmc.get_samples() - discrete_samples = vmap(infer_discrete_model)( - random.split(random.PRNGKey(1), args.num_samples), posterior_samples - ) + predictive = Predictive(model, posterior_samples, infer_discrete=True) + discrete_samples = predictive(random.PRNGKey(1), *data) item_class = vmap(lambda x: jnp.bincount(x, length=4), in_axes=1)( discrete_samples["c"].squeeze(-1) diff --git a/numpyro/contrib/funsor/discrete.py b/numpyro/contrib/funsor/discrete.py index 72767ff84..36462e28a 100644 --- a/numpyro/contrib/funsor/discrete.py +++ b/numpyro/contrib/funsor/discrete.py @@ -118,8 +118,7 @@ def _sample_posterior( values = [v.reshape((-1,) + prototype_shape[1:]) for v in values] data[root_name] = jnp.concatenate(values) - with substitute(data=data): - return model(*args, **kwargs) + return data def infer_discrete(fn=None, first_available_dim=None, temperature=1, rng_key=None): @@ -169,6 +168,12 @@ def viterbi_decoder(data, hidden_dim=10): temperature=temperature, rng_key=rng_key, ) - return functools.partial( - _sample_posterior, fn, first_available_dim, temperature, rng_key - ) + + def wrap_fn(*args, **kwargs): + samples = _sample_posterior( + fn, first_available_dim, temperature, rng_key, *args, **kwargs + ) + with substitute(data=samples): + return fn(*args, **kwargs) + + return wrap_fn diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index b4aee6ad5..d3c41187a 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -11,12 +11,13 @@ from jax import device_get, jacfwd, lax, random, value_and_grad from jax.flatten_util import ravel_pytree import jax.numpy as jnp +from jax.tree_util import tree_map import numpyro from numpyro.distributions import constraints from numpyro.distributions.transforms import biject_to from numpyro.distributions.util import is_identically_one, sum_rightmost -from numpyro.handlers import replay, seed, substitute, trace +from numpyro.handlers import condition, replay, seed, substitute, trace from numpyro.infer.initialization import init_to_uniform, init_to_value from numpyro.util import not_jax_tracer, soft_vmap, while_loop @@ -673,17 +674,47 @@ def _predictive( posterior_samples, batch_shape, return_sites=None, + infer_discrete=False, parallel=True, model_args=(), model_kwargs={}, ): - model = numpyro.handlers.mask(model, mask=False) + masked_model = numpyro.handlers.mask(model, mask=False) + if infer_discrete: + # inspect the model to get some structure + rng_key, subkey = random.split(rng_key) + batch_ndim = len(batch_shape) + prototype_sample = tree_map( + lambda x: jnp.reshape(x, (-1,) + jnp.shape(x)[batch_ndim:])[0], + posterior_samples, + ) + prototype_trace = trace( + seed(substitute(masked_model, prototype_sample), subkey) + ).get_trace(*model_args, **model_kwargs) + first_available_dim = -_guess_max_plate_nesting(prototype_trace) - 1 def single_prediction(val): rng_key, samples = val - model_trace = trace(seed(substitute(model, samples), rng_key)).get_trace( - *model_args, **model_kwargs - ) + if infer_discrete: + from numpyro.contrib.funsor import config_enumerate + from numpyro.contrib.funsor.discrete import _sample_posterior + + model_trace = prototype_trace + temperature = 1 + pred_samples = _sample_posterior( + config_enumerate(condition(model, samples)), + first_available_dim, + temperature, + rng_key, + *model_args, + **model_kwargs, + ) + else: + model_trace = trace( + seed(substitute(masked_model, samples), rng_key) + ).get_trace(*model_args, **model_kwargs) + pred_samples = {name: site["value"] for name, site in model_trace.items()} + if return_sites is not None: if return_sites == "": sites = { @@ -698,9 +729,7 @@ def single_prediction(val): if (site["type"] == "sample" and k not in samples) or (site["type"] == "deterministic") } - return { - name: site["value"] for name, site in model_trace.items() if name in sites - } + return {name: value for name, value in pred_samples.items() if name in sites} num_samples = int(np.prod(batch_shape)) if num_samples > 1: @@ -729,6 +758,12 @@ class Predictive(object): :param int num_samples: number of samples :param list return_sites: sites to return; by default only sample sites not present in `posterior_samples` are returned. + :param bool infer_discrete: whether or not to sample discrete sites from the + posterior, conditioned on observations and other latent values in + ``posterior_samples``. Under the hood, those sites will be marked with + ``site["infer"]["enumerate"] = "parallel"``. See how `infer_discrete` works at + the `Pyro enumeration tutorial `_. + Note that this requires ``funsor`` installation. :param bool parallel: whether to predict in parallel using JAX vectorized map :func:`jax.vmap`. Defaults to False. :param batch_ndims: the number of batch dimensions in posterior samples. Some usages: @@ -749,10 +784,12 @@ def __init__( self, model, posterior_samples=None, + *, guide=None, params=None, num_samples=None, return_sites=None, + infer_discrete=False, parallel=False, batch_ndims=1, ): @@ -801,6 +838,7 @@ def __init__( self.num_samples = num_samples self.guide = guide self.params = {} if params is None else params + self.infer_discrete = infer_discrete self.return_sites = return_sites self.parallel = parallel self.batch_ndims = batch_ndims @@ -838,6 +876,7 @@ def __call__(self, rng_key, *args, **kwargs): posterior_samples, self._batch_shape, return_sites=self.return_sites, + infer_discrete=self.infer_discrete, parallel=self.parallel, model_args=args, model_kwargs=kwargs, From e398f19c3ec21c9924b7971f25308fa9b4c13902 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 10 Jul 2021 22:02:09 -0400 Subject: [PATCH 135/222] Checklist for 0.7 release (#1082) * bump versions to 0.7.0 * Bump dependency * bump funsor version * an attempt to fix rtd rendering * update Docker file * update prodlda version * fix update_version use wrong version in tutorials * revise docs * add kernerls to sidebar * revert the change at getting started * move prodlda to intro * pin funsor and jaxns versions --- README.md | 24 +- docker/dev/Dockerfile | 2 +- docker/release/Dockerfile | 13 +- docs/requirements.txt | 12 +- docs/source/api.rst | 48 ---- docs/source/contrib.rst | 3 + docs/source/distributions.rst | 257 +++++++++--------- docs/source/index.rst | 8 +- docs/source/infer.rst | 15 + docs/source/mcmc.rst | 18 ++ examples/annotation.py | 2 +- examples/baseball.py | 2 +- examples/bnn.py | 2 +- examples/covtype.py | 2 +- examples/funnel.py | 2 +- examples/gaussian_shells.py | 2 +- examples/gp.py | 2 +- examples/hmm.py | 2 +- examples/minipyro.py | 2 +- examples/neutra.py | 2 +- examples/ode.py | 2 +- examples/prodlda.py | 7 +- examples/proportion_test.py | 2 +- examples/sparse_regression.py | 2 +- examples/stochastic_volatility.py | 2 +- examples/thompson_sampling.py | 2 +- examples/ucbadmit.py | 2 +- examples/vae.py | 2 +- ...esian_hierarchical_linear_regression.ipynb | 2 +- notebooks/source/bayesian_imputation.ipynb | 2 +- notebooks/source/bayesian_regression.ipynb | 2 +- notebooks/source/logistic_regression.ipynb | 2 +- notebooks/source/model_rendering.ipynb | 2 +- notebooks/source/ordinal_regression.ipynb | 2 +- numpyro/contrib/nested_sampling.py | 3 +- numpyro/infer/hmc.py | 2 +- numpyro/version.py | 2 +- scripts/update_version.py | 7 +- setup.py | 10 +- 39 files changed, 231 insertions(+), 246 deletions(-) delete mode 100644 docs/source/api.rst create mode 100644 docs/source/infer.rst diff --git a/README.md b/README.md index 62d5e591a..475afde89 100644 --- a/README.md +++ b/README.md @@ -237,22 +237,22 @@ conda install -c conda-forge numpyro - Provide the `rng_key` argument to `numpyro.sample`. e.g. `numpyro.sample('x', dist.Normal(0, 1), rng_key=PRNGKey(0))`. - Wrap the code in a `seed` handler, used either as a context manager or as a function that wraps over the original callable. e.g. - ```python - with handlers.seed(rng_seed=0): # random.PRNGKey(0) is used - x = numpyro.sample('x', dist.Beta(1, 1)) # uses a PRNGKey split from random.PRNGKey(0) - y = numpyro.sample('y', dist.Bernoulli(x)) # uses different PRNGKey split from the last one - ``` + ```python + with handlers.seed(rng_seed=0): # random.PRNGKey(0) is used + x = numpyro.sample('x', dist.Beta(1, 1)) # uses a PRNGKey split from random.PRNGKey(0) + y = numpyro.sample('y', dist.Bernoulli(x)) # uses different PRNGKey split from the last one + ``` , or as a higher order function: - ```python - def fn(): - x = numpyro.sample('x', dist.Beta(1, 1)) - y = numpyro.sample('y', dist.Bernoulli(x)) - return y + ```python + def fn(): + x = numpyro.sample('x', dist.Beta(1, 1)) + y = numpyro.sample('y', dist.Bernoulli(x)) + return y - print(handlers.seed(fn, rng_seed=0)()) - ``` + print(handlers.seed(fn, rng_seed=0)()) + ``` 2. Can I use the same Pyro model for doing inference in NumPyro? diff --git a/docker/dev/Dockerfile b/docker/dev/Dockerfile index 2cf3c62a1..f15611d74 100644 --- a/docker/dev/Dockerfile +++ b/docker/dev/Dockerfile @@ -10,7 +10,7 @@ FROM nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04 # note that this image uses Python 3.8 ENV IMG_NAME=11.2.2-cudnn8-devel-ubuntu20.04 \ # declare the cuda version for pulling appropriate jaxlib wheel - JAXLIB_CUDA=112 + JAXLIB_CUDA=111 # install python3 and pip on top of the base Ubuntu image # unlike for release, we need to install git and setuptools too diff --git a/docker/release/Dockerfile b/docker/release/Dockerfile index 14fa65023..2ad632b10 100644 --- a/docker/release/Dockerfile +++ b/docker/release/Dockerfile @@ -8,14 +8,7 @@ FROM nvidia/cuda:11.2.2-cudnn8-devel-ubuntu20.04 # declare the image name # note that this image uses Python 3.8 ENV IMG_NAME=11.2.2-cudnn8-devel-ubuntu20.04 \ - # declare what jaxlib, jax, and numpyro versions to use - # right now this is a manual process - in the future it should be automated - # if a CI/CD system is expected to pass in these arguments - # the dockerfile should be modified accordingly - JAXLIB_CUDA=112 \ - JAXLIB_VERSION=0.1.62 \ - JAX_VERSION=0.2.10 \ - NUMPYRO_VERSION=0.6.0 + JAXLIB_CUDA=111 # install python3 and pip on top of the base Ubuntu image RUN apt update && \ @@ -26,8 +19,6 @@ ENV PATH=/root/.local/bin:$PATH # install python packages via pip RUN pip3 install --user \ - numpyro==${NUMPYRO_VERSION} \ - jax==${JAX_VERSION} \ # we pull wheels from google's api as per https://github.com/google/jax#installation # the pre-compiled wheels that google provides work for now. This may change in the future (and necessitate building from source) - jaxlib==${JAXLIB_VERSION}+cuda${JAXLIB_CUDA} -f https://storage.googleapis.com/jax-releases/jax_releases.html \ No newline at end of file + numpyro[cuda${JAXLIB_CUDA}] -f https://storage.googleapis.com/jax-releases/jax_releases.html diff --git a/docs/requirements.txt b/docs/requirements.txt index 56c361b0f..567c3b922 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,11 +1,11 @@ dm-haiku flax -funsor -jax>=0.1.65 -jaxlib>=0.1.45 -jaxns==0.0.7 -optax==0.0.6 +funsor>=0.4.1 +jax>=0.2.11 +jaxlib>=0.1.62 +jaxns>=0.0.7 +optax>=0.0.6 nbsphinx>=0.8.5 sphinx-gallery -tfp-nightly<=0.14.0.dev20210608 # TODO: change this to tensorflow-probability when it is stable +tensorflow_probability>=0.13 tqdm diff --git a/docs/source/api.rst b/docs/source/api.rst deleted file mode 100644 index 9478f6663..000000000 --- a/docs/source/api.rst +++ /dev/null @@ -1,48 +0,0 @@ -.. currentmodule:: api - -API Reference -============= - -Modeling --------- - -.. toctree:: - :glob: - :maxdepth: 1 - - primitives - handlers - -Distributions -------------- - -.. toctree:: - :glob: - :maxdepth: 1 - - distributions - -Inference ---------- - -.. toctree:: - :glob: - :maxdepth: 1 - - mcmc - svi - autoguide - reparam - funsor - optimizers - diagnostics - utilities - -Contributed Code ----------------- - -.. toctree:: - :glob: - :maxdepth: 1 - - contrib diff --git a/docs/source/contrib.rst b/docs/source/contrib.rst index acb050a94..741417163 100644 --- a/docs/source/contrib.rst +++ b/docs/source/contrib.rst @@ -1,3 +1,6 @@ +Contributed Code +================ + Nested Sampling ~~~~~~~~~~~~~~~ diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 845d22282..3174115f8 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -1,8 +1,11 @@ +Distributions +============= + Base Distribution -================= +----------------- Distribution ------------- +^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.distribution.Distribution :members: :undoc-members: @@ -10,7 +13,7 @@ Distribution :member-order: bysource ExpandedDistribution --------------------- +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.distribution.ExpandedDistribution :members: :undoc-members: @@ -18,7 +21,7 @@ ExpandedDistribution :member-order: bysource FoldedDistribution ------------------- +^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.distribution.FoldedDistribution :members: :undoc-members: @@ -26,7 +29,7 @@ FoldedDistribution :member-order: bysource ImproperUniform ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.distribution.ImproperUniform :members: :undoc-members: @@ -34,7 +37,7 @@ ImproperUniform :member-order: bysource Independent ------------ +^^^^^^^^^^^ .. autoclass:: numpyro.distributions.distribution.Independent :members: :undoc-members: @@ -42,7 +45,7 @@ Independent :member-order: bysource MaskedDistribution ------------------- +^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.distribution.MaskedDistribution :members: :undoc-members: @@ -50,7 +53,7 @@ MaskedDistribution :member-order: bysource TransformedDistribution ------------------------ +^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.distribution.TransformedDistribution :members: :undoc-members: @@ -58,7 +61,7 @@ TransformedDistribution :member-order: bysource Delta ------ +^^^^^ .. autoclass:: numpyro.distributions.distribution.Delta :members: :undoc-members: @@ -66,7 +69,7 @@ Delta :member-order: bysource Unit ----- +^^^^ .. autoclass:: numpyro.distributions.distribution.Unit :members: :undoc-members: @@ -75,10 +78,10 @@ Unit Continuous Distributions -======================== +------------------------ Beta ----- +^^^^ .. autoclass:: numpyro.distributions.continuous.Beta :members: :undoc-members: @@ -86,7 +89,7 @@ Beta :member-order: bysource BetaProportion --------------- +^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.BetaProportion :members: :undoc-members: @@ -95,7 +98,7 @@ BetaProportion Cauchy ------- +^^^^^^ .. autoclass:: numpyro.distributions.continuous.Cauchy :members: :undoc-members: @@ -103,7 +106,7 @@ Cauchy :member-order: bysource Chi2 ----- +^^^^ .. autoclass:: numpyro.distributions.continuous.Chi2 :members: :undoc-members: @@ -111,7 +114,7 @@ Chi2 :member-order: bysource Dirichlet ---------- +^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.Dirichlet :members: :undoc-members: @@ -119,7 +122,7 @@ Dirichlet :member-order: bysource Exponential ------------ +^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.Exponential :members: :undoc-members: @@ -127,7 +130,7 @@ Exponential :member-order: bysource Gamma ------ +^^^^^ .. autoclass:: numpyro.distributions.continuous.Gamma :members: :undoc-members: @@ -135,7 +138,7 @@ Gamma :member-order: bysource Gumbel ------- +^^^^^^ .. autoclass:: numpyro.distributions.continuous.Gumbel :members: :undoc-members: @@ -143,7 +146,7 @@ Gumbel :member-order: bysource GaussianRandomWalk ------------------- +^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.GaussianRandomWalk :members: :undoc-members: @@ -151,7 +154,7 @@ GaussianRandomWalk :member-order: bysource HalfCauchy ----------- +^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.HalfCauchy :members: :undoc-members: @@ -159,7 +162,7 @@ HalfCauchy :member-order: bysource HalfNormal ----------- +^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.HalfNormal :members: :undoc-members: @@ -167,7 +170,7 @@ HalfNormal :member-order: bysource InverseGamma ------------- +^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.InverseGamma :members: :undoc-members: @@ -175,7 +178,7 @@ InverseGamma :member-order: bysource Laplace -------- +^^^^^^^ .. autoclass:: numpyro.distributions.continuous.Laplace :members: :undoc-members: @@ -183,7 +186,7 @@ Laplace :member-order: bysource LKJ ---- +^^^ .. autoclass:: numpyro.distributions.continuous.LKJ :members: :undoc-members: @@ -191,7 +194,7 @@ LKJ :member-order: bysource LKJCholesky ------------ +^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.LKJCholesky :members: :undoc-members: @@ -199,7 +202,7 @@ LKJCholesky :member-order: bysource LogNormal ---------- +^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.LogNormal :members: :undoc-members: @@ -207,7 +210,7 @@ LogNormal :member-order: bysource Logistic --------- +^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.Logistic :members: :undoc-members: @@ -215,7 +218,7 @@ Logistic :member-order: bysource MultivariateNormal ------------------- +^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.MultivariateNormal :members: :undoc-members: @@ -223,7 +226,7 @@ MultivariateNormal :member-order: bysource LowRankMultivariateNormal -------------------------- +^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.LowRankMultivariateNormal :members: :undoc-members: @@ -231,7 +234,7 @@ LowRankMultivariateNormal :member-order: bysource Normal ------- +^^^^^^ .. autoclass:: numpyro.distributions.continuous.Normal :members: :undoc-members: @@ -239,7 +242,7 @@ Normal :member-order: bysource Pareto ------- +^^^^^^ .. autoclass:: numpyro.distributions.continuous.Pareto :members: :undoc-members: @@ -247,7 +250,7 @@ Pareto :member-order: bysource SoftLaplace ------------ +^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.SoftLaplace :members: :undoc-members: @@ -255,7 +258,7 @@ SoftLaplace :member-order: bysource StudentT --------- +^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.StudentT :members: :undoc-members: @@ -263,7 +266,7 @@ StudentT :member-order: bysource Uniform -------- +^^^^^^^ .. autoclass:: numpyro.distributions.continuous.Uniform :members: :undoc-members: @@ -271,7 +274,7 @@ Uniform :member-order: bysource Weibull -------- +^^^^^^^ .. autoclass:: numpyro.distributions.continuous.Weibull :members: :undoc-members: @@ -280,14 +283,14 @@ Weibull Discrete Distributions -====================== +---------------------- Bernoulli ---------- +^^^^^^^^^ .. autofunction:: numpyro.distributions.discrete.Bernoulli BernoulliLogits ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.BernoulliLogits :members: :undoc-members: @@ -295,7 +298,7 @@ BernoulliLogits :member-order: bysource BernoulliProbs --------------- +^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.BernoulliProbs :members: :undoc-members: @@ -303,7 +306,7 @@ BernoulliProbs :member-order: bysource BetaBinomial ------------- +^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.conjugate.BetaBinomial :members: :undoc-members: @@ -311,11 +314,11 @@ BetaBinomial :member-order: bysource Binomial ---------- +^^^^^^^^^ .. autofunction:: numpyro.distributions.discrete.Binomial BinomialLogits --------------- +^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.BinomialLogits :members: :undoc-members: @@ -323,7 +326,7 @@ BinomialLogits :member-order: bysource BinomialProbs -------------- +^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.BinomialProbs :members: :undoc-members: @@ -331,11 +334,11 @@ BinomialProbs :member-order: bysource Categorical ------------ +^^^^^^^^^^^ .. autofunction:: numpyro.distributions.discrete.Categorical CategoricalLogits ------------------ +^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.CategoricalLogits :members: :undoc-members: @@ -343,7 +346,7 @@ CategoricalLogits :member-order: bysource CategoricalProbs ----------------- +^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.CategoricalProbs :members: :undoc-members: @@ -351,7 +354,7 @@ CategoricalProbs :member-order: bysource DirichletMultinomial --------------------- +^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.conjugate.DirichletMultinomial :members: :undoc-members: @@ -359,7 +362,7 @@ DirichletMultinomial :member-order: bysource GammaPoisson ------------- +^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.conjugate.GammaPoisson :members: :undoc-members: @@ -367,11 +370,11 @@ GammaPoisson :member-order: bysource Geometric ---------- +^^^^^^^^^ .. autofunction:: numpyro.distributions.discrete.Geometric GeometricLogits ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.GeometricLogits :members: :undoc-members: @@ -379,7 +382,7 @@ GeometricLogits :member-order: bysource GeometricProbs --------------- +^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.GeometricProbs :members: :undoc-members: @@ -387,11 +390,11 @@ GeometricProbs :member-order: bysource Multinomial ------------ +^^^^^^^^^^^ .. autofunction:: numpyro.distributions.discrete.Multinomial MultinomialLogits ------------------ +^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.MultinomialLogits :members: :undoc-members: @@ -399,7 +402,7 @@ MultinomialLogits :member-order: bysource MultinomialProbs ----------------- +^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.MultinomialProbs :members: :undoc-members: @@ -407,7 +410,7 @@ MultinomialProbs :member-order: bysource OrderedLogistic ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.OrderedLogistic :members: :undoc-members: @@ -415,11 +418,11 @@ OrderedLogistic :member-order: bysource NegativeBinomial ----------------- +^^^^^^^^^^^^^^^^ .. autofunction:: numpyro.distributions.conjugate.NegativeBinomial NegativeBinomialLogits ----------------------- +^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.conjugate.NegativeBinomialLogits :members: :undoc-members: @@ -427,7 +430,7 @@ NegativeBinomialLogits :member-order: bysource NegativeBinomialProbs ---------------------- +^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.conjugate.NegativeBinomialProbs :members: :undoc-members: @@ -435,7 +438,7 @@ NegativeBinomialProbs :member-order: bysource NegativeBinomial2 ------------------ +^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.conjugate.NegativeBinomial2 :members: :undoc-members: @@ -443,7 +446,7 @@ NegativeBinomial2 :member-order: bysource Poisson -------- +^^^^^^^ .. autoclass:: numpyro.distributions.discrete.Poisson :members: :undoc-members: @@ -451,7 +454,7 @@ Poisson :member-order: bysource PRNGIdentity ------------- +^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.PRNGIdentity :members: :undoc-members: @@ -459,11 +462,11 @@ PRNGIdentity :member-order: bysource ZeroInflatedDistribution ------------------------- +^^^^^^^^^^^^^^^^^^^^^^^^ .. autofunction:: numpyro.distributions.discrete.ZeroInflatedDistribution ZeroInflatedPoisson -------------------- +^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.discrete.ZeroInflatedPoisson :members: :undoc-members: @@ -471,15 +474,15 @@ ZeroInflatedPoisson :member-order: bysource ZeroInflatedNegativeBinomial2 ------------------------------ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autofunction:: numpyro.distributions.conjugate.ZeroInflatedNegativeBinomial2 Directional Distributions -========================= +------------------------- ProjectedNormal ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.directional.ProjectedNormal :members: :undoc-members: @@ -487,7 +490,7 @@ ProjectedNormal :member-order: bysource VonMises --------- +^^^^^^^^ .. autoclass:: numpyro.distributions.directional.VonMises :members: :undoc-members: @@ -496,10 +499,10 @@ VonMises Truncated Distributions -======================= +----------------------- LeftTruncatedDistribution -------------------------- +^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.truncated.LeftTruncatedDistribution :members: :undoc-members: @@ -507,7 +510,7 @@ LeftTruncatedDistribution :member-order: bysource RightTruncatedDistribution --------------------------- +^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.truncated.RightTruncatedDistribution :members: :undoc-members: @@ -515,7 +518,7 @@ RightTruncatedDistribution :member-order: bysource TruncatedCauchy ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.truncated.TruncatedCauchy :members: :undoc-members: @@ -523,11 +526,11 @@ TruncatedCauchy :member-order: bysource TruncatedDistribution ---------------------- +^^^^^^^^^^^^^^^^^^^^^ .. autofunction:: numpyro.distributions.truncated.TruncatedDistribution TruncatedNormal ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.truncated.TruncatedNormal :members: :undoc-members: @@ -535,7 +538,7 @@ TruncatedNormal :member-order: bysource TruncatedPolyaGamma -------------------- +^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.truncated.TruncatedPolyaGamma :members: :undoc-members: @@ -543,7 +546,7 @@ TruncatedPolyaGamma :member-order: bysource TwoSidedTruncatedDistribution ------------------------------ +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.truncated.TwoSidedTruncatedDistribution :members: :undoc-members: @@ -552,7 +555,7 @@ TwoSidedTruncatedDistribution TensorFlow Distributions -======================== +------------------------ Thin wrappers around TensorFlow Probability (TFP) distributions. For details on the TFP distribution interface, see `its Distribution docs `_. @@ -561,10 +564,10 @@ see `its Distribution docs .. nbgallery:: @@ -39,6 +43,7 @@ NumPyro documentation examples/capture_recapture examples/gaussian_shells tutorials/discrete_imputation + examples/prodlda .. nbgallery:: :maxdepth: 1 @@ -59,7 +64,6 @@ NumPyro documentation examples/neutra examples/covtype examples/thompson_sampling - examples/prodlda Indices and tables diff --git a/docs/source/infer.rst b/docs/source/infer.rst new file mode 100644 index 000000000..4d44d68de --- /dev/null +++ b/docs/source/infer.rst @@ -0,0 +1,15 @@ +Inference +========= + +.. toctree:: + :glob: + :maxdepth: 1 + + mcmc + svi + autoguide + reparam + funsor + optimizers + diagnostics + utilities diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index 416e0a3a6..10b477931 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -10,54 +10,72 @@ Markov Chain Monte Carlo (MCMC) MCMC Kernels ------------ +MCMCKernel +^^^^^^^^^^ .. autoclass:: numpyro.infer.mcmc.MCMCKernel :members: :undoc-members: :show-inheritance: :member-order: bysource +BarkerMH +^^^^^^^^ .. autoclass:: numpyro.infer.barker.BarkerMH :members: :undoc-members: :show-inheritance: :member-order: bysource +HMC +^^^ .. autoclass:: numpyro.infer.hmc.HMC :members: :undoc-members: :show-inheritance: :member-order: bysource +NUTS +^^^^ .. autoclass:: numpyro.infer.hmc.NUTS :members: :undoc-members: :show-inheritance: :member-order: bysource +HMCGibbs +^^^^^^^^ .. autoclass:: numpyro.infer.hmc_gibbs.HMCGibbs :members: :undoc-members: :show-inheritance: :member-order: bysource +DiscreteHMCGibbs +^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.infer.hmc_gibbs.DiscreteHMCGibbs :members: :undoc-members: :show-inheritance: :member-order: bysource +MixedHMC +^^^^^^^^ .. autoclass:: numpyro.infer.mixed_hmc.MixedHMC :members: :undoc-members: :show-inheritance: :member-order: bysource +HMCECS +^^^^^^ .. autoclass:: numpyro.infer.hmc_gibbs.HMCECS :members: :undoc-members: :show-inheritance: :member-order: bysource +SA +^^ .. autoclass:: numpyro.infer.sa.SA :members: :undoc-members: diff --git a/examples/annotation.py b/examples/annotation.py index 264d14ac7..a84f896e5 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -327,7 +327,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Bayesian Models of Annotation") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/baseball.py b/examples/baseball.py index 463c54203..549ddae72 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -210,7 +210,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Baseball batting average using MCMC") parser.add_argument("-n", "--num-samples", nargs="?", default=3000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/bnn.py b/examples/bnn.py index 333ef1c6c..393908de5 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -156,7 +156,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Bayesian neural network example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/covtype.py b/examples/covtype.py index e62867ea1..f9dd88322 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -206,7 +206,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-samples", default=1000, type=int, help="number of samples" diff --git a/examples/funnel.py b/examples/funnel.py index 16897f06f..16cefdf5d 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -108,7 +108,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser( description="Non-centered reparameterization example" ) diff --git a/examples/gaussian_shells.py b/examples/gaussian_shells.py index 262c6dd7d..b3851143b 100644 --- a/examples/gaussian_shells.py +++ b/examples/gaussian_shells.py @@ -120,7 +120,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Nested sampler for Gaussian shells") parser.add_argument("-n", "--num-samples", nargs="?", default=10000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/gp.py b/examples/gp.py index 11b7a4d3a..c7952c984 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -170,7 +170,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/hmm.py b/examples/hmm.py index f57e6dffd..47a3c4025 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -263,7 +263,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Semi-supervised Hidden Markov Model") parser.add_argument("--num-categories", default=3, type=int) parser.add_argument("--num-words", default=10, type=int) diff --git a/examples/minipyro.py b/examples/minipyro.py index b54c5f08e..4d9e57800 100644 --- a/examples/minipyro.py +++ b/examples/minipyro.py @@ -58,7 +58,7 @@ def body_fn(i, val): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Mini Pyro demo") parser.add_argument("-f", "--full-pyro", action="store_true", default=False) parser.add_argument("-n", "--num-steps", default=1001, type=int) diff --git a/examples/neutra.py b/examples/neutra.py index 4a30c87ab..e8348ac8c 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -197,7 +197,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="NeuTra HMC") parser.add_argument("-n", "--num-samples", nargs="?", default=4000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/ode.py b/examples/ode.py index 6b9f241df..d00dca624 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -116,7 +116,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Predator-Prey Model") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/prodlda.py b/examples/prodlda.py index d7b2ae5c3..ac6b802d3 100644 --- a/examples/prodlda.py +++ b/examples/prodlda.py @@ -2,8 +2,9 @@ # SPDX-License-Identifier: Apache-2.0 """ -Example: ProdLDA -================ +Example: ProdLDA with Flax and Haiku +==================================== + In this example, we will follow [1] to implement the ProdLDA topic model from Autoencoding Variational Inference For Topic Models by Akash Srivastava and Charles Sutton [2]. This model returns consistently better topics than vanilla LDA and trains @@ -313,7 +314,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser( description="Probabilistic topic modelling with Flax and Haiku" ) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index b02e9aeb5..164e9147d 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -160,7 +160,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Testing whether ") parser.add_argument("-n", "--num-samples", nargs="?", default=500, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index f94cfac48..338adbc4f 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -401,7 +401,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=500, type=int) diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index ad4b1c64c..ec094b306 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -122,7 +122,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Stochastic Volatility Model") parser.add_argument("-n", "--num-samples", nargs="?", default=600, type=int) parser.add_argument("--num-warmup", nargs="?", default=600, type=int) diff --git a/examples/thompson_sampling.py b/examples/thompson_sampling.py index 0c15f6bf4..d78d58a4a 100644 --- a/examples/thompson_sampling.py +++ b/examples/thompson_sampling.py @@ -294,7 +294,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="Thompson sampling example") parser.add_argument( "--num-random", nargs="?", default=2, type=int, help="number of random draws" diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index a7523a787..9bf99b9b5 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -151,7 +151,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser( description="UCBadmit gender discrimination using HMC" ) diff --git a/examples/vae.py b/examples/vae.py index c82a7cfdc..20ab6881e 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -159,7 +159,7 @@ def reconstruct_img(epoch, rng_key): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.6.0") + assert numpyro.__version__.startswith("0.7.0") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-epochs", default=15, type=int, help="number of training epochs" diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index 49670aef3..3ab89d034 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -242,7 +242,7 @@ "import numpyro.distributions as dist\n", "from jax import random\n", "\n", - "assert numpyro.__version__.startswith('0.6.0')" + "assert numpyro.__version__.startswith('0.7.0')" ] }, { diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index e7a03197e..da83bcc74 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -55,7 +55,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith('0.6.0')" + "assert numpyro.__version__.startswith('0.7.0')" ] }, { diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 9a72853c3..40b008d27 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -95,7 +95,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats('svg')\n", "\n", - "assert numpyro.__version__.startswith('0.6.0')" + "assert numpyro.__version__.startswith('0.7.0')" ], "execution_count": 2, "outputs": [] diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index bea5eecbd..22cfa561c 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -40,7 +40,7 @@ "import numpyro.distributions as dist\n", "from numpyro.examples.datasets import COVTYPE, load_dataset\n", "from numpyro.infer import HMC, MCMC, NUTS\n", - "assert numpyro.__version__.startswith('0.6.0')\n", + "assert numpyro.__version__.startswith('0.7.0')\n", "\n", "# NB: replace gpu by cpu to run this notebook in cpu\n", "numpyro.set_platform(\"gpu\")" diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index 17d46747a..abf29442b 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -33,7 +33,7 @@ "import numpyro\n", "import numpyro.distributions as dist\n", "\n", - "assert numpyro.__version__.startswith('0.6.0')" + "assert numpyro.__version__.startswith('0.7.0')" ] }, { diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 1787786fe..d0f3a76d2 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -39,7 +39,7 @@ "from numpyro.infer import MCMC, NUTS\n", "import pandas as pd\n", "import seaborn as sns\n", - "assert numpyro.__version__.startswith('0.6.0')" + "assert numpyro.__version__.startswith('0.7.0')" ] }, { diff --git a/numpyro/contrib/nested_sampling.py b/numpyro/contrib/nested_sampling.py index 6ca9ce7cc..c90590534 100644 --- a/numpyro/contrib/nested_sampling.py +++ b/numpyro/contrib/nested_sampling.py @@ -124,7 +124,8 @@ def __call__(self, name, fn, obs): class NestedSampler: """ - (EXPERIMENTAL) A wrapper for `jaxns`, a nested sampling package based on JAX. + (EXPERIMENTAL) A wrapper for `jaxns `_ , + a nested sampling package based on JAX. See reference [1] for details on the meaning of each parameter. Please consider citing this reference if you use the nested sampler in your research. diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index aff4493f5..f424e0b63 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -136,7 +136,7 @@ def hmc(potential_fn=None, potential_fn_gen=None, kinetic_fn=None, algo="NUTS"): .. warning:: Instead of using this interface directly, we would highly recommend you - to use the higher level :class:`numpyro.infer.MCMC` API instead. + to use the higher level :class:`~numpyro.infer.mcmc.MCMC` API instead. **Example** diff --git a/numpyro/version.py b/numpyro/version.py index 3720decc6..0eba22b6c 100644 --- a/numpyro/version.py +++ b/numpyro/version.py @@ -1,4 +1,4 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -__version__ = "0.6.0" +__version__ = "0.7.0" diff --git a/scripts/update_version.py b/scripts/update_version.py index ed9e38fd9..e3e0bbcbf 100644 --- a/scripts/update_version.py +++ b/scripts/update_version.py @@ -23,12 +23,13 @@ # Update version string. pattern1 = re.compile('assert numpyro.__version__.startswith\\("[^"]*"\\)') pattern2 = re.compile("assert numpyro.__version__.startswith\\('[^']*'\\)") -text = f"assert numpyro.__version__.startswith({new_version})" +text1 = f"assert numpyro.__version__.startswith({new_version})" +text2 = text1.replace('"', "'") for filename in filenames: with open(filename) as f: old_text = f.read() - new_text = pattern1.sub(text, old_text) - new_text = pattern2.sub(text, new_text) + new_text = pattern1.sub(text1, old_text) + new_text = pattern2.sub(text2, new_text) if new_text != old_text: print("updating {}".format(filename)) with open(filename, "w") as f: diff --git a/setup.py b/setup.py index e8ccd3a95..5c63a7c02 100644 --- a/setup.py +++ b/setup.py @@ -62,15 +62,11 @@ "dev": [ "dm-haiku", "flax", - # TODO: bump funsor version before the release - "funsor @ git+https://github.com/pyro-ppl/funsor.git@d5574988665dd822ec64e41f2b54b9dc929959dc", + "funsor==0.4.1", "graphviz", "jaxns==0.0.7", - "optax==0.0.6", - # TODO: change this to tensorflow_probability>0.12.1 when the next version - # of tfp is released. The current release is not compatible with jax>=0.2.12. - # TODO: relax this restriction when we revise tfp wrapper - "tfp-nightly<=0.14.0.dev20210608", + "optax>=0.0.6", + "tensorflow_probability>=0.13", ], "examples": [ "arviz", From ed4e95640ee0a7e614ba6c237d2532d5b443d272 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 11 Jul 2021 15:28:05 -0400 Subject: [PATCH 136/222] bump version to 0.7.1 (#1093) --- examples/annotation.py | 2 +- examples/baseball.py | 2 +- examples/bnn.py | 2 +- examples/covtype.py | 2 +- examples/funnel.py | 2 +- examples/gaussian_shells.py | 2 +- examples/gp.py | 2 +- examples/hmm.py | 2 +- examples/minipyro.py | 2 +- examples/neutra.py | 2 +- examples/ode.py | 2 +- examples/prodlda.py | 2 +- examples/proportion_test.py | 2 +- examples/sparse_regression.py | 2 +- examples/stochastic_volatility.py | 2 +- examples/thompson_sampling.py | 2 +- examples/ucbadmit.py | 2 +- examples/vae.py | 2 +- notebooks/source/bayesian_hierarchical_linear_regression.ipynb | 2 +- notebooks/source/bayesian_imputation.ipynb | 2 +- notebooks/source/bayesian_regression.ipynb | 2 +- notebooks/source/logistic_regression.ipynb | 2 +- notebooks/source/model_rendering.ipynb | 2 +- notebooks/source/ordinal_regression.ipynb | 2 +- numpyro/version.py | 2 +- 25 files changed, 25 insertions(+), 25 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index a84f896e5..9760a2c94 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -327,7 +327,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Bayesian Models of Annotation") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/baseball.py b/examples/baseball.py index 549ddae72..1484af1ce 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -210,7 +210,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Baseball batting average using MCMC") parser.add_argument("-n", "--num-samples", nargs="?", default=3000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/bnn.py b/examples/bnn.py index 393908de5..314b2ba84 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -156,7 +156,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Bayesian neural network example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/covtype.py b/examples/covtype.py index f9dd88322..961dec00b 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -206,7 +206,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-samples", default=1000, type=int, help="number of samples" diff --git a/examples/funnel.py b/examples/funnel.py index 16cefdf5d..69eab07a6 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -108,7 +108,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser( description="Non-centered reparameterization example" ) diff --git a/examples/gaussian_shells.py b/examples/gaussian_shells.py index b3851143b..f959c35de 100644 --- a/examples/gaussian_shells.py +++ b/examples/gaussian_shells.py @@ -120,7 +120,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Nested sampler for Gaussian shells") parser.add_argument("-n", "--num-samples", nargs="?", default=10000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/gp.py b/examples/gp.py index c7952c984..5d2e0f548 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -170,7 +170,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/hmm.py b/examples/hmm.py index 47a3c4025..a9ca1a719 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -263,7 +263,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Semi-supervised Hidden Markov Model") parser.add_argument("--num-categories", default=3, type=int) parser.add_argument("--num-words", default=10, type=int) diff --git a/examples/minipyro.py b/examples/minipyro.py index 4d9e57800..62d1c213e 100644 --- a/examples/minipyro.py +++ b/examples/minipyro.py @@ -58,7 +58,7 @@ def body_fn(i, val): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Mini Pyro demo") parser.add_argument("-f", "--full-pyro", action="store_true", default=False) parser.add_argument("-n", "--num-steps", default=1001, type=int) diff --git a/examples/neutra.py b/examples/neutra.py index e8348ac8c..83ab5c0c9 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -197,7 +197,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="NeuTra HMC") parser.add_argument("-n", "--num-samples", nargs="?", default=4000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/ode.py b/examples/ode.py index d00dca624..126db1418 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -116,7 +116,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Predator-Prey Model") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/prodlda.py b/examples/prodlda.py index ac6b802d3..d8d7a9d88 100644 --- a/examples/prodlda.py +++ b/examples/prodlda.py @@ -314,7 +314,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser( description="Probabilistic topic modelling with Flax and Haiku" ) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index 164e9147d..bf37b7675 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -160,7 +160,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Testing whether ") parser.add_argument("-n", "--num-samples", nargs="?", default=500, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index 338adbc4f..77591b1aa 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -401,7 +401,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=500, type=int) diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index ec094b306..be1a9129e 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -122,7 +122,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Stochastic Volatility Model") parser.add_argument("-n", "--num-samples", nargs="?", default=600, type=int) parser.add_argument("--num-warmup", nargs="?", default=600, type=int) diff --git a/examples/thompson_sampling.py b/examples/thompson_sampling.py index d78d58a4a..00cd339f9 100644 --- a/examples/thompson_sampling.py +++ b/examples/thompson_sampling.py @@ -294,7 +294,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="Thompson sampling example") parser.add_argument( "--num-random", nargs="?", default=2, type=int, help="number of random draws" diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index 9bf99b9b5..89a201281 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -151,7 +151,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser( description="UCBadmit gender discrimination using HMC" ) diff --git a/examples/vae.py b/examples/vae.py index 20ab6881e..4ae5b9cd4 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -159,7 +159,7 @@ def reconstruct_img(epoch, rng_key): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.0") + assert numpyro.__version__.startswith("0.7.1") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-epochs", default=15, type=int, help="number of training epochs" diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index 3ab89d034..394e07ba8 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -242,7 +242,7 @@ "import numpyro.distributions as dist\n", "from jax import random\n", "\n", - "assert numpyro.__version__.startswith('0.7.0')" + "assert numpyro.__version__.startswith('0.7.1')" ] }, { diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index da83bcc74..2c6500088 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -55,7 +55,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith('0.7.0')" + "assert numpyro.__version__.startswith('0.7.1')" ] }, { diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 40b008d27..5e1d7c718 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -95,7 +95,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats('svg')\n", "\n", - "assert numpyro.__version__.startswith('0.7.0')" + "assert numpyro.__version__.startswith('0.7.1')" ], "execution_count": 2, "outputs": [] diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index 22cfa561c..f1667a8db 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -40,7 +40,7 @@ "import numpyro.distributions as dist\n", "from numpyro.examples.datasets import COVTYPE, load_dataset\n", "from numpyro.infer import HMC, MCMC, NUTS\n", - "assert numpyro.__version__.startswith('0.7.0')\n", + "assert numpyro.__version__.startswith('0.7.1')\n", "\n", "# NB: replace gpu by cpu to run this notebook in cpu\n", "numpyro.set_platform(\"gpu\")" diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index abf29442b..676526c7e 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -33,7 +33,7 @@ "import numpyro\n", "import numpyro.distributions as dist\n", "\n", - "assert numpyro.__version__.startswith('0.7.0')" + "assert numpyro.__version__.startswith('0.7.1')" ] }, { diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index d0f3a76d2..536eb1cde 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -39,7 +39,7 @@ "from numpyro.infer import MCMC, NUTS\n", "import pandas as pd\n", "import seaborn as sns\n", - "assert numpyro.__version__.startswith('0.7.0')" + "assert numpyro.__version__.startswith('0.7.1')" ] }, { diff --git a/numpyro/version.py b/numpyro/version.py index 0eba22b6c..db37c4aee 100644 --- a/numpyro/version.py +++ b/numpyro/version.py @@ -1,4 +1,4 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -__version__ = "0.7.0" +__version__ = "0.7.1" From cf85229edab08144108623338f31c78a1a16d5d5 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Sun, 11 Jul 2021 22:15:35 +0100 Subject: [PATCH 137/222] DOC Add Predictive examples (#1084) * document Predictive * import Predictive in docstring * remove non-guide argument * clarify * fix lint error * escape asterisk * put in code block --- numpyro/infer/mcmc.py | 11 ++++++++++- numpyro/infer/svi.py | 5 ++++- numpyro/infer/util.py | 21 +++++++++++++++++++++ 3 files changed, 35 insertions(+), 2 deletions(-) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 3b9afb185..5a1b0d994 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -64,7 +64,7 @@ class MCMCKernel(ABC): >>> kernel = MetropolisHastings(f) >>> mcmc = MCMC(kernel, num_warmup=1000, num_samples=1000) >>> mcmc.run(random.PRNGKey(0), init_params=jnp.array([1., 2.])) - >>> samples = mcmc.get_samples() + >>> posterior_samples = mcmc.get_samples() >>> mcmc.print_summary() # doctest: +SKIP """ @@ -593,6 +593,15 @@ def get_samples(self, group_by_chain=False): `dict` keyed on site names if a model containing Pyro primitives is used, but can be any :func:`jaxlib.pytree`, more generally (e.g. when defining a `potential_fn` for HMC that takes `list` args). + + **Example:** + + You can then pass those samples to :class:`~numpyro.infer.util.Predictive`:: + + posterior_samples = mcmc.get_samples() + predictive = Predictive(model, posterior_samples=posterior_samples) + samples = predictive(rng_key1, *model_args, **model_kwargs) + """ return ( self._states[self._sample_field] diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 7df085062..a8f4a3d5e 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -83,7 +83,7 @@ class SVI(object): >>> import numpyro >>> import numpyro.distributions as dist >>> from numpyro.distributions import constraints - >>> from numpyro.infer import SVI, Trace_ELBO + >>> from numpyro.infer import Predictive, SVI, Trace_ELBO >>> def model(data): ... f = numpyro.sample("latent_fairness", dist.Beta(10, 10)) @@ -102,6 +102,9 @@ class SVI(object): >>> svi_result = svi.run(random.PRNGKey(0), 2000, data) >>> params = svi_result.params >>> inferred_mean = params["alpha_q"] / (params["alpha_q"] + params["beta_q"]) + >>> # get posterior samples + >>> predictive = Predictive(guide, params=params, num_samples=1000) + >>> samples = predictive(random.PRNGKey(1), data) :param model: Python callable with Pyro primitives for the model. :param guide: Python callable with Pyro primitives for the guide diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index d3c41187a..fd145a9f4 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -778,6 +778,27 @@ class Predictive(object): argument is not None, its value should be equal to `num_chains x N`. :return: dict of samples from the predictive distribution. + + **Example:** + + Given a model + + def model(X, y=None): + ... + return numpyro.sample("obs", likelihood, obs=y) + + you can sample from the prior predictive: + + predictive = Predictive(model, num_samples=1000) + y_pred = predictive(rng_key, X)["obs"] + + If you also have posterior samples, you can sample from the posterior predictive: + + predictive = Predictive(model, posterior_samples=posterior_samples) + y_pred = predictive(rng_key, X)["obs"] + + See docstrings for :class:`~numpyro.infer.svi.SVI` and :class:`~numpyro.infer.mcmc.MCMCKernel` + to see example code of this in context. """ def __init__( From d121cff5dfdba51ace605a3c34448ccb41ec21af Mon Sep 17 00:00:00 2001 From: Benjamin Datko Date: Thu, 15 Jul 2021 07:54:02 -0400 Subject: [PATCH 138/222] add fix and testt for model rendering of only discrete variables (#1099) --- numpyro/contrib/render.py | 5 ++++- test/test_model_rendering.py | 16 ++++++++++++++++ 2 files changed, 20 insertions(+), 1 deletion(-) diff --git a/numpyro/contrib/render.py b/numpyro/contrib/render.py index 91d422504..f4cbb3018 100644 --- a/numpyro/contrib/render.py +++ b/numpyro/contrib/render.py @@ -117,7 +117,10 @@ def get_log_probs(sample, seed=0): and not site["is_observed"] and not site["fn"].is_discrete } - log_prob_grads = jax.jacobian(get_log_probs)(samples) + if samples: + log_prob_grads = jax.jacobian(get_log_probs)(samples) + else: + log_prob_grads = {k: {} for k in get_log_probs(samples)} sample_deps = {} for name, grads in log_prob_grads.items(): sample_deps[name] = {n for n in grads if n != name and (grads[n] != 0).any()} diff --git a/test/test_model_rendering.py b/test/test_model_rendering.py index c9dbb97ff..9db9f2ef2 100644 --- a/test/test_model_rendering.py +++ b/test/test_model_rendering.py @@ -39,6 +39,10 @@ def discrete_to_continuous(probs, locs): numpyro.sample("x", dist.Normal(locs[c], 0.5)) +def discrete(prob): + numpyro.sample("x", dist.Bernoulli(prob)) + + @pytest.mark.parametrize( "test_model,model_kwargs,expected_graph_spec", [ @@ -104,6 +108,18 @@ def discrete_to_continuous(probs, locs): "edge_list": [("c", "x")], }, ), + ( + discrete, + dict(prob=0.5), + { + "plate_groups": {None: ["x"]}, + "plate_data": {}, + "node_data": { + "x": {"is_observed": False, "distribution": "BernoulliProbs"} + }, + "edge_list": [], + }, + ), ], ) def test_model_transformation(test_model, model_kwargs, expected_graph_spec): From 313301dd07d9f145ebc9a4f19d6b2e6bf8d6544d Mon Sep 17 00:00:00 2001 From: Benjamin Datko Date: Sat, 17 Jul 2021 20:56:41 -0400 Subject: [PATCH 139/222] fix typo in docs for dim param of plate (#1102) --- numpyro/contrib/funsor/enum_messenger.py | 2 +- numpyro/primitives.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/numpyro/contrib/funsor/enum_messenger.py b/numpyro/contrib/funsor/enum_messenger.py index c84f25b05..af4bb61d1 100644 --- a/numpyro/contrib/funsor/enum_messenger.py +++ b/numpyro/contrib/funsor/enum_messenger.py @@ -476,7 +476,7 @@ class plate(GlobalNamedMessenger): This can be used to apply a scaling factor by inference algorithms. e.g. when computing ELBO using a mini-batch. :param int dim: Optional argument to specify which dimension in the tensor - is used as the plate dim. If `None` (default), the leftmost available dim + is used as the plate dim. If `None` (default), the rightmost available dim is allocated. """ diff --git a/numpyro/primitives.py b/numpyro/primitives.py index f5be24bb4..d10c93d1e 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -390,7 +390,7 @@ class plate(Messenger): This can be used to apply a scaling factor by inference algorithms. e.g. when computing ELBO using a mini-batch. :param int dim: Optional argument to specify which dimension in the tensor - is used as the plate dim. If `None` (default), the leftmost available dim + is used as the plate dim. If `None` (default), the rightmost available dim is allocated. """ From 339e0c0fb914656ebec06e17cabff3be7cb277a8 Mon Sep 17 00:00:00 2001 From: omarfsosa <32113591+omarfsosa@users.noreply.github.com> Date: Sun, 18 Jul 2021 15:31:23 -0500 Subject: [PATCH 140/222] Example for Hilbert space approximation of Gaussian processes (#1097) * Cleanup * Added figure to repo * Fixed typos and minor fixes - no longer return the figure as part of main function * enable float64 using numpyro instead of jax * Add example/hsgp to index * Made license for hsgp example * Changed wording of the docstring to use 'We' instead of 'I' * Format hsgp for passing pipeline checks. Do not print mcmc summary nor progress bar if running as sphinx build. * Added test cases for example/hsgp models * When getting the day of week in pandas, use 'weekday' method instead of 'day_of_week' for compatibility with earlier versions of pandas --- docs/source/_static/img/examples/hsgp.png | Bin 0 -> 67283 bytes docs/source/index.rst | 1 + examples/hsgp.py | 717 ++++++++++++++++++++++ test/test_examples.py | 4 + 4 files changed, 722 insertions(+) create mode 100644 docs/source/_static/img/examples/hsgp.png create mode 100644 examples/hsgp.py diff --git a/docs/source/_static/img/examples/hsgp.png b/docs/source/_static/img/examples/hsgp.png new file mode 100644 index 0000000000000000000000000000000000000000..1c0ef2d2281444afdbbf56fa6799cb06b40ae43b GIT binary patch literal 67283 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 G|9=79*V4BD literal 0 HcmV?d00001 diff --git a/docs/source/index.rst b/docs/source/index.rst index 47eff654a..743fb1bb0 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -60,6 +60,7 @@ NumPyro documentation examples/ucbadmit examples/hmcecs examples/hmm + examples/hsgp examples/ode examples/neutra examples/covtype diff --git a/examples/hsgp.py b/examples/hsgp.py new file mode 100644 index 000000000..b24d25dc4 --- /dev/null +++ b/examples/hsgp.py @@ -0,0 +1,717 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +""" +Example: Hilbert space approximation for Gaussian processes. +============================================================ + +This example replicates a few of the models in the excellent case +study by Aki Vehtari [1] (originally written using R and Stan). +The case study uses approximate Gaussian processes [2] to model the +relative number of births per day in the US from 1969 to 1988. +The Hilbert space approximation is way faster than the exact Gaussian +processes because it circumvents the need for inverting the +covariance matrix. + +The original case study presented by Aki also emphasizes the iterative +process of building a Bayesian model, which is excellent as a pedagogical +resource. Here, however, we replicate only 4 out of all the models available in [1]. +There are a few minor differences in the mathematical details of our models, +which we had to make in order for the chains to mix properly. We have clearly +commented on the places where our models are different. + +**References:** + 1. Gelman, Vehtari, Simpson, et al (2020), `"Bayesian workflow book - Birthdays" + `. + 2. Riutort-Mayol G, Bürkner PC, Andersen MR, et al (2020), + "Practical hilbert space approximate bayesian gaussian processes for probabilistic programming". + +.. image:: ../_static/img/examples/hsgp.png + :align: center + + +""" +import argparse +import functools +import operator +import os + +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd + +import jax +import jax.numpy as jnp +from tensorflow_probability.substrates import jax as tfp + +import numpyro +from numpyro import deterministic, plate, sample +import numpyro.distributions as dist +from numpyro.infer import MCMC, NUTS + + +# --- utility functions +def load_data(): + URL = "https://raw.githubusercontent.com/avehtari/casestudies/master/Birthdays/data/births_usa_1969.csv" + data = pd.read_csv(URL, sep=",") + day0 = pd.to_datetime("31-Dec-1968") + dates = [day0 + pd.Timedelta(f"{i}d") for i in data["id"]] + data["date"] = dates + data["births_relative"] = data["births"] / data["births"].mean() + return data + + +def save_samples(out_path, samples): + """ + Save dictionary of arrays using numpys compressed binary format + Fast reading and writing and efficient storage + """ + np.savez_compressed(out_path, **samples) + + +class UnivariateScaler: + """ + Standardizes the data to have mean 0 and unit standard deviation. + """ + + def __init__(self): + self._mean = None + self._std = None + + def fit(self, x): + self._mean = np.mean(x) + self._std = np.std(x) + return self + + def transform(self, x): + return (x - self._mean) / self._std + + def inverse_transform(self, x): + return x * self._std + self._mean + + +def _agg(*args, scaler=None): + """ + Custom function for aggregating the samples + and transforming back to the desired scale. + """ + total = functools.reduce(operator.add, args) + return (100 * scaler.inverse_transform(total)).mean(axis=0) + + +# --- modelling functions +def modified_bessel_first_kind(v, z): + v = jnp.asarray(v, dtype=float) + return jnp.exp(jnp.abs(z)) * tfp.math.bessel_ive(v, z) + + +def spectral_density(w, alpha, length): + c = alpha * jnp.sqrt(2 * jnp.pi) * length + e = jnp.exp(-0.5 * (length ** 2) * (w ** 2)) + return c * e + + +def diag_spectral_density(alpha, length, L, M): + """spd for squared exponential kernel""" + sqrt_eigenvalues = jnp.arange(1, 1 + M) * jnp.pi / 2 / L + return spectral_density(sqrt_eigenvalues, alpha, length) + + +def phi(x, L, M): + """ + The first `M` eigenfunctions of the laplacian operator in `[-L, L]` + evaluated at `x`. These are used for the approximation of the + squared exponential kernel. + """ + m1 = (jnp.pi / (2 * L)) * jnp.tile(L + x[:, None], M) + m2 = jnp.diag(jnp.linspace(1, M, num=M)) + num = jnp.sin(m1 @ m2) + den = jnp.sqrt(L) + return num / den + + +def diag_spectral_density_periodic(alpha, length, M): + """ + Not actually a spectral density but these are used in the same + way. These are simply the first `M` coefficients of the Taylor + expansion approximation for the periodic kernel. + """ + a = length ** (-2) + J = jnp.arange(1, M + 1) + q2 = (2 * alpha ** 2 / jnp.exp(a)) * modified_bessel_first_kind(J, a) + return q2 + + +def phi_periodic(x, w0, M): + """ + Basis functions for the approximation of the periodic kernel. + """ + m1 = jnp.tile(w0 * x[:, None], M) + m2 = jnp.diag(jnp.linspace(1, M, num=M)) + mw0x = m1 @ m2 + return jnp.cos(mw0x), jnp.sin(mw0x) + + +# --- models +class GP1: + """ + Long term trend Gaussian process + """ + + def __init__(self): + self.x_scaler = UnivariateScaler() + self.y_scaler = UnivariateScaler() + + def model(self, x, L, M, y=None): + # intercept + intercept = sample("intercept", dist.Normal(0, 1)) + + # long term trend + ρ = sample("ρ", dist.LogNormal(-1.0, 1.0)) + α = sample("α", dist.HalfNormal(1.0)) + eigenfunctions = phi(x, L, M) + spd = jnp.sqrt(diag_spectral_density(α, ρ, L, M)) + + with plate("basis1", M): + β1 = sample("β1", dist.Normal(0, 1)) + + f1 = deterministic("f1", eigenfunctions @ (spd * β1)) + μ = deterministic("μ", intercept + f1) + σ = sample("σ", dist.HalfNormal(0.5)) + with plate("n_obs", x.shape[0]): + sample("y", dist.Normal(μ, σ), obs=y) + + def get_data(self): + data = load_data() + x = data["id"].values + y = data["births_relative"].values + self.x_scaler.fit(x) + self.y_scaler.fit(y) + xsd = jnp.array(self.x_scaler.transform(x)) + ysd = jnp.array(self.y_scaler.transform(y)) + return dict( + x=xsd, + y=ysd, + L=1.5 * max(xsd), + M=10, + ) + + def make_figure(self, samples): + data = load_data() + dates = data["date"] + y = 100 * data["births_relative"] + μ = 100 * self.y_scaler.inverse_transform(samples["μ"]).mean(axis=0) + + f = plt.figure(figsize=(15, 5)) + plt.axhline(100, color="k", lw=1, alpha=0.8) + plt.plot(dates, y, marker=".", lw=0, alpha=0.3) + plt.plot(dates, μ, color="r", lw=2) + plt.ylabel("Relative number of births") + plt.xlabel("") + return f + + +class GP2: + """ + Long term trend with year seasonality component. + """ + + def __init__(self): + self.x_scaler = UnivariateScaler() + self.y_scaler = UnivariateScaler() + + def model(self, x, w0, J, L, M, y=None): + intercept = sample("intercept", dist.Normal(0, 1)) + + # long term trend + ρ1 = sample("ρ1", dist.LogNormal(-1.0, 1.0)) + α1 = sample("α1", dist.HalfNormal(1.0)) + eigenfunctions = phi(x, L, M) + spd = jnp.sqrt(diag_spectral_density(α1, ρ1, L, M)) + with plate("basis", M): + β1 = sample("β1", dist.Normal(0, 1)) + + # year-periodic component + ρ2 = sample("ρ2", dist.HalfNormal(0.1)) + α2 = sample("α2", dist.HalfNormal(1.0)) + cosines, sines = phi_periodic(x, w0, J) + spd_periodic = jnp.sqrt(diag_spectral_density_periodic(α2, ρ2, J)) + with plate("periodic_basis", J): + β2_cos = sample("β2_cos", dist.Normal(0, 1)) + β2_sin = sample("β2_sin", dist.Normal(0, 1)) + + f1 = deterministic("f1", eigenfunctions @ (spd * β1)) + f2 = deterministic( + "f2", cosines @ (spd_periodic * β2_cos) + sines @ (spd_periodic * β2_sin) + ) + μ = deterministic("μ", intercept + f1 + f2) + σ = sample("σ", dist.HalfNormal(0.5)) + with plate("n_obs", x.shape[0]): + sample("y", dist.Normal(μ, σ), obs=y) + + def get_data(self): + data = load_data() + x = data["id"].values + y = data["births_relative"].values + self.x_scaler.fit(x) + self.y_scaler.fit(y) + xsd = jnp.array(self.x_scaler.transform(x)) + ysd = jnp.array(self.y_scaler.transform(y)) + w0 = 2 * jnp.pi / (365.25 / self.x_scaler._std) + return dict( + x=xsd, + y=ysd, + w0=w0, + J=20, + L=1.5 * max(xsd), + M=10, + ) + + def make_figure(self, samples): + data = load_data() + dates = data["date"] + y = 100 * data["births_relative"] + y_by_day_of_year = 100 * data.groupby("day_of_year2")["births_relative"].mean() + μ = 100 * self.y_scaler.inverse_transform(samples["μ"]).mean(axis=0) + f1 = 100 * self.y_scaler.inverse_transform(samples["f1"]).mean(axis=0) + f2 = 100 * self.y_scaler.inverse_transform(samples["f2"]).mean(axis=0) + + fig, axes = plt.subplots(1, 2, figsize=(15, 5)) + axes[0].plot(dates, y, marker=".", lw=0, alpha=0.3) + axes[0].plot(dates, μ, color="r", lw=2, alpha=1, label="Total") + axes[0].plot(dates, f1, color="C2", lw=3, alpha=1, label="Trend") + + axes[0].set_ylabel("Relative number of births") + axes[0].set_title("All time") + + axes[1].plot( + y_by_day_of_year.index, y_by_day_of_year, marker=".", lw=0, alpha=0.5 + ) + axes[1].plot( + y_by_day_of_year.index, f2[:366], color="r", lw=2, label="Year seaonality" + ) + axes[1].set_ylabel("Relative number of births") + axes[1].set_xlabel("Day of year") + for ax in axes: + ax.axhline(100, color="k", lw=1, alpha=0.8) + ax.legend() + + return fig + + +class GP3: + """ + Long term trend with yearly seasonaly and slowly varying day-of-week effect. + """ + + def __init__(self): + self.x_scaler = UnivariateScaler() + self.y_scaler = UnivariateScaler() + + def model(self, x, day_of_week, w0, J, L, M, L3, M3, y=None): + intercept = sample("intercept", dist.Normal(0, 1)) + + # long term trend + ρ1 = sample("ρ1", dist.LogNormal(-1.0, 1.0)) + α1 = sample("α1", dist.HalfNormal(1.0)) + eigenfunctions = phi(x, L, M) + spd = jnp.sqrt(diag_spectral_density(α1, ρ1, L, M)) + with plate("basis", M): + β1 = sample("β1", dist.Normal(0, 1)) + + # year-periodic component + ρ2 = sample("ρ2", dist.HalfNormal(0.1)) + α2 = sample("α2", dist.HalfNormal(1.0)) + cosines, sines = phi_periodic(x, w0, J) + spd_periodic = jnp.sqrt(diag_spectral_density_periodic(α2, ρ2, J)) + with plate("periodic_basis", J): + β2_cos = sample("β2_cos", dist.Normal(0, 1)) + β2_sin = sample("β2_sin", dist.Normal(0, 1)) + + # day of week effect + with plate("plate_day_of_week", 6): + β_week = sample("β_week", dist.Normal(0, 1)) + # next enforce sum-to-zero -- this is slightly different from Aki's model, + # which instead imposes Monday's effect to be zero. + β_week = jnp.concatenate([jnp.array([-jnp.sum(β_week)]), β_week]) + + # long term variation of week effect + α3 = sample("α3", dist.HalfNormal(0.1)) + ρ3 = sample("ρ3", dist.LogNormal(1.0, 1.0)) # prior: very long-term effect + eigenfunctions_3 = phi(x, L3, M3) + spd_3 = jnp.sqrt(diag_spectral_density(α3, ρ3, L3, M3)) + with plate("week_trend", M3): + β3 = sample("β3", dist.Normal(0, 1)) + + # combine + f1 = deterministic("f1", eigenfunctions @ (spd * β1)) + f2 = deterministic( + "f2", cosines @ (spd_periodic * β2_cos) + sines @ (spd_periodic * β2_sin) + ) + g3 = deterministic("g3", eigenfunctions_3 @ (spd_3 * β3)) + μ = deterministic("μ", intercept + f1 + f2 + jnp.exp(g3) * β_week[day_of_week]) + σ = sample("σ", dist.HalfNormal(0.5)) + with plate("n_obs", x.shape[0]): + sample("y", dist.Normal(μ, σ), obs=y) + + def get_data(self): + data = load_data() + x = data["id"].values + y = data["births_relative"].values + self.x_scaler.fit(x) + self.y_scaler.fit(y) + xsd = jnp.array(self.x_scaler.transform(x)) + ysd = jnp.array(self.y_scaler.transform(y)) + w0 = 2 * jnp.pi / (365.25 / self.x_scaler._std) + dow = jnp.array(data["day_of_week"].values) - 1 + return dict( + x=xsd, + day_of_week=dow, + w0=w0, + J=20, + L=1.5 * max(xsd), + M=10, + L3=1.5 * max(xsd), + M3=5, + y=ysd, + ) + + def make_figure(self, samples): + data = load_data() + dates = data["date"] + y = 100 * data["births_relative"] + y_by_day_of_year = 100 * ( + data.groupby("day_of_year2")["births_relative"].mean() + ) + year_days = y_by_day_of_year.index.values + + μ = samples["μ"] + intercept = samples["intercept"][:, None] + f1 = samples["f1"] + f2 = samples["f2"] + g3 = samples["g3"] + β_week = samples["β_week"] + β_week = np.concatenate([-β_week.sum(axis=1)[:, None], β_week], axis=1) + + fig, axes = plt.subplots(2, 2, figsize=(15, 8), sharey=False, sharex=False) + axes[0, 0].plot(dates, y, marker=".", lw=0, alpha=0.3) + axes[0, 0].plot( + dates, + _agg(μ, scaler=self.y_scaler), + color="r", + lw=0, + label="Total", + marker=".", + alpha=0.5, + ) + axes[0, 1].plot(dates, y, marker=".", lw=0, alpha=0.3) + axes[0, 1].plot( + dates, _agg(f1, scaler=self.y_scaler), color="r", lw=2, label="Trend" + ) + axes[1, 0].plot(year_days, y_by_day_of_year, marker=".", lw=0, alpha=0.3) + axes[1, 0].plot( + year_days, + _agg(f2[:, :366], scaler=self.y_scaler), + color="r", + lw=2, + label="Year seasonality", + ) + axes[1, 1].plot(dates, y, marker=".", lw=0, alpha=0.3) + for day in range(7): + dow_trend = (jnp.exp(g3).T * β_week[:, day]).T + fit = _agg(intercept, f1, dow_trend, scaler=self.y_scaler) + axes[1, 1].plot(dates, fit, lw=2, color="r") + + axes[0, 0].set_title("Total") + axes[0, 1].set_title("Long term trend") + axes[1, 0].set_title("Year seasonality") + axes[1, 1].set_title("Weekly effects with long term trend") + for ax in axes.flatten(): + ax.axhline(100, color="k", lw=1, alpha=0.8) + ax.legend() + + return fig + + +class GP4: + """ + Long term trend with yearly seasonaly, slowly varying day-of-week effect, + and special day effect including floating special days. + """ + + def __init__(self): + self.x_scaler = UnivariateScaler() + self.y_scaler = UnivariateScaler() + + def model( + self, + x, + day_of_week, + day_of_year, + memorial_days_indicator, + labour_days_indicator, + thanksgiving_days_indicator, + w0, + J, + L, + M, + L3, + M3, + y=None, + ): + intercept = sample("intercept", dist.Normal(0, 1)) + + # long term trend + ρ1 = sample("ρ1", dist.LogNormal(-1.0, 1.0)) + α1 = sample("α1", dist.HalfNormal(1.0)) + eigenfunctions = phi(x, L, M) + spd = jnp.sqrt(diag_spectral_density(α1, ρ1, L, M)) + with plate("basis", M): + β1 = sample("β1", dist.Normal(0, 1)) + + # year-periodic component + ρ2 = sample("ρ2", dist.HalfNormal(0.1)) + α2 = sample("α2", dist.HalfNormal(1.0)) + cosines, sines = phi_periodic(x, w0, J) + spd_periodic = jnp.sqrt(diag_spectral_density_periodic(α2, ρ2, J)) + with plate("periodic_basis", J): + β2_cos = sample("β2_cos", dist.Normal(0, 1)) + β2_sin = sample("β2_sin", dist.Normal(0, 1)) + + # day of week effect + with plate("plate_day_of_week", 6): + β_week = sample("β_week", dist.Normal(0, 1)) + # next enforce sum-to-zero -- this is slightly different from Aki's model, + # which instead imposes Monday's effect to be zero. + β_week = jnp.concatenate([jnp.array([-jnp.sum(β_week)]), β_week]) + + # long term separation of week effects + ρ3 = sample("ρ3", dist.LogNormal(1.0, 1.0)) + α3 = sample("α3", dist.HalfNormal(0.1)) + eigenfunctions_3 = phi(x, L3, M3) + spd_3 = jnp.sqrt(diag_spectral_density(α3, ρ3, L3, M3)) + with plate("week_trend", M3): + β3 = sample("β3", dist.Normal(0, 1)) + + # Finnish horseshoe prior on day of year effect + # Aki uses slab_df=100 instead, but chains didn't mix + # in our case for some reason, so we lowered it to 50. + slab_scale = 2 + slab_df = 50 + scale_global = 0.1 + τ = sample("τ", dist.HalfCauchy(scale=scale_global * 2)) + c_aux = sample("c_aux", dist.InverseGamma(0.5 * slab_df, 0.5 * slab_df)) + c = slab_scale * jnp.sqrt(c_aux) + with plate("plate_day_of_year", 366): + λ = sample("λ", dist.HalfCauchy(scale=1)) + λ_tilde = jnp.sqrt(c) * λ / jnp.sqrt(c + (τ * λ) ** 2) + β4 = sample("β4", dist.Normal(loc=0, scale=τ * λ_tilde)) + + # floating special days + β5_labour = sample("β5_labour", dist.Normal(0, 1)) + β5_memorial = sample("β5_memorial", dist.Normal(0, 1)) + β5_thanksgiving = sample("β5_thanksgiving", dist.Normal(0, 1)) + + # combine + f1 = deterministic("f1", eigenfunctions @ (spd * β1)) + f2 = deterministic( + "f2", cosines @ (spd_periodic * β2_cos) + sines @ (spd_periodic * β2_sin) + ) + g3 = deterministic("g3", eigenfunctions_3 @ (spd_3 * β3)) + μ = deterministic( + "μ", + intercept + + f1 + + f2 + + jnp.exp(g3) * β_week[day_of_week] + + β4[day_of_year] + + β5_labour * labour_days_indicator + + β5_memorial * memorial_days_indicator + + β5_thanksgiving * thanksgiving_days_indicator, + ) + σ = sample("σ", dist.HalfNormal(0.5)) + with plate("n_obs", x.shape[0]): + sample("y", dist.Normal(μ, σ), obs=y) + + def _get_floating_days(self, data): + x = data["id"].values + memorial_days = data.loc[ + data["date"].dt.month.eq(5) + & data["date"].dt.weekday.eq(0) + & data["date"].dt.day.ge(25), + "id", + ].values + + labour_days = data.loc[ + data["date"].dt.month.eq(9) + & data["date"].dt.weekday.eq(0) + & data["date"].dt.day.le(7), + "id", + ].values + labour_days = np.concatenate((labour_days, labour_days + 1)) + + thanksgiving_days = data.loc[ + data["date"].dt.month.eq(11) + & data["date"].dt.weekday.eq(3) + & data["date"].dt.day.ge(22) + & data["date"].dt.day.le(28), + "id", + ].values + thanksgiving_days = np.concatenate((thanksgiving_days, thanksgiving_days + 1)) + + md_indicators = np.zeros_like(x) + md_indicators[memorial_days - 1] = 1 + ld_indicators = np.zeros_like(x) + ld_indicators[labour_days - 1] = 1 + td_indicators = np.zeros_like(x) + td_indicators[thanksgiving_days - 1] = 1 + return { + "memorial_days_indicator": md_indicators, + "labour_days_indicator": ld_indicators, + "thanksgiving_days_indicator": td_indicators, + } + + def get_data(self): + data = load_data() + x = data["id"].values + y = data["births_relative"].values + self.x_scaler.fit(x) + self.y_scaler.fit(y) + xsd = jnp.array(self.x_scaler.transform(x)) + ysd = jnp.array(self.y_scaler.transform(y)) + w0 = 2 * jnp.pi / (365.25 / self.x_scaler._std) + dow = jnp.array(data["day_of_week"].values) - 1 + doy = jnp.array((data["day_of_year2"] - 1).values) + return dict( + x=xsd, + day_of_week=dow, + day_of_year=doy, + w0=w0, + J=20, + L=1.5 * max(xsd), + M=10, + L3=1.5 * max(xsd), + M3=5, + y=ysd, + **self._get_floating_days(data), + ) + + def make_figure(self, samples): + special_days = { + "Valentine's": pd.to_datetime("1988-02-14"), + "Leap day": pd.to_datetime("1988-02-29"), + "Halloween": pd.to_datetime("1988-10-31"), + "Christmas eve": pd.to_datetime("1988-12-24"), + "Christmas day": pd.to_datetime("1988-12-25"), + "New year": pd.to_datetime("1988-01-01"), + "New year's eve": pd.to_datetime("1988-12-31"), + "April 1st": pd.to_datetime("1988-04-01"), + "Independence day": pd.to_datetime("1988-07-04"), + "Labour day": pd.to_datetime("1988-09-05"), + "Memorial day": pd.to_datetime("1988-05-30"), + "Thanksgiving": pd.to_datetime("1988-11-24"), + } + β4 = samples["β4"] + β5_labour = samples["β5_labour"] + β5_memorial = samples["β5_memorial"] + β5_thanksgiving = samples["β5_thanksgiving"] + + day_effect = np.array(β4) + md_idx = special_days["Memorial day"].day_of_year - 1 + day_effect[:, md_idx] = day_effect[:, md_idx] + β5_memorial + ld_idx = special_days["Labour day"].day_of_year - 1 + day_effect[:, ld_idx] = day_effect[:, ld_idx] + β5_labour + td_idx = special_days["Thanksgiving"].day_of_year - 1 + day_effect[:, td_idx] = day_effect[:, td_idx] + β5_thanksgiving + day_effect = 100 * day_effect.mean(axis=0) + + fig = plt.figure(figsize=(12, 5)) + plt.plot(np.arange(1, 367), day_effect) + for name, day in special_days.items(): + xs = day.day_of_year + ys = day_effect[day.day_of_year - 1] + plt.plot(xs, ys, marker="o", mec="k", c="none", ms=10) + plt.text(xs - 3, ys, name, horizontalalignment="right") + plt.title("Special day effect") + plt.ylabel("Relative number of births") + plt.xlabel("Day of year") + plt.xlim([-40, None]) + return fig + + +def parse_arguments(): + parser = argparse.ArgumentParser(description="Hilbert space approx for GPs") + parser.add_argument("--num-samples", nargs="?", default=1000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument( + "--model", + nargs="?", + default="tywd", + help="one of" + '"t" (Long term trend),' + '"ty" (t + year seasonality),' + '"tyw" (t + y + slowly varying weekday effect),' + '"tywd" (t + y + w + special days effect)', + ) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') + parser.add_argument("--x64", action="store_true", help="Enable float64 precision") + parser.add_argument( + "--save-samples", + default="", + type=str, + help="Path where to store the samples. Must be '.npz' file.", + ) + parser.add_argument( + "--save-figure", + default="", + type=str, + help="Path where to save the plot with matplotlib.", + ) + args = parser.parse_args() + return args + + +NAME_TO_MODEL = { + "t": GP1, + "ty": GP2, + "tyw": GP3, + "tywd": GP4, +} + + +def main(args): + is_sphinxbuild = "NUMPYRO_SPHINXBUILD" in os.environ + model = NAME_TO_MODEL[args.model]() + data = model.get_data() + mcmc = MCMC( + NUTS(model.model), + num_warmup=args.num_warmup, + num_samples=args.num_samples, + num_chains=args.num_chains, + progress_bar=False if is_sphinxbuild else True, + ) + mcmc.run(jax.random.PRNGKey(0), **data) + if not is_sphinxbuild: + mcmc.print_summary() + posterior_samples = mcmc.get_samples() + if args.save_samples: + print(f"Saving samples at {args.save_samples}") + save_samples(args.save_samples, posterior_samples) + if args.save_figure: + print(f"Saving figure at {args.save_figure}") + fig = model.make_figure(posterior_samples) + fig.savefig(args.save_figure) + plt.close() + + return model, data, mcmc, posterior_samples + + +if __name__ == "__main__": + args = parse_arguments() + if args.x64: + numpyro.enable_x64() + + numpyro.set_platform(args.device) + numpyro.set_host_device_count(args.num_chains) + main(args) diff --git a/test/test_examples.py b/test/test_examples.py index dcb35677c..e35094f80 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -34,6 +34,10 @@ "hmm_enum.py -m 3 -t 3 -d 4 --num-warmup 1 -n 4", "hmm_enum.py -m 4 -t 3 -d 4 --num-warmup 1 -n 4", "hmm_enum.py -m 6 -t 4 -d 3 --num-warmup 1 -n 4", + "hsgp.py --model t --num-samples 10 --num-warmup 10 --num-chains 2", + "hsgp.py --model ty --num-samples 10 --num-warmup 10 --num-chains 2", + "hsgp.py --model tyw --num-samples 10 --num-warmup 10 --num-chains 2", + "hsgp.py --model tywd --num-samples 10 --num-warmup 10 --num-chains 2", "minipyro.py", "neutra.py --num-samples 100 --num-warmup 100", "ode.py --num-samples 100 --num-warmup 100 --num-chains 1", From b33f808baede1c7278dd74c13866c9c6c933fdc3 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 20 Jul 2021 23:00:54 -0400 Subject: [PATCH 141/222] fix cpu string (#1101) --- numpyro/util.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/numpyro/util.py b/numpyro/util.py index 26b751ae6..f7ad4059d 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -21,7 +21,7 @@ from jax.tree_util import tree_flatten, tree_map _DISABLE_CONTROL_FLOW_PRIM = False -_CHAIN_RE = re.compile(r"(?<=_)\d+$") # e.g. get '3' from 'TFRT_CPU_3' +_CHAIN_RE = re.compile(r"\d+$") # e.g. get '3' from 'TFRT_CPU_3' def set_rng_seed(rng_seed): From 4a51b5912ed63f57ff9146191163d33636a96d55 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 21 Jul 2021 01:22:05 -0400 Subject: [PATCH 142/222] bump to 0.7.2 (#1105) --- examples/annotation.py | 2 +- examples/baseball.py | 2 +- examples/bnn.py | 2 +- examples/covtype.py | 2 +- examples/funnel.py | 2 +- examples/gaussian_shells.py | 2 +- examples/gp.py | 2 +- examples/hmm.py | 2 +- examples/minipyro.py | 2 +- examples/neutra.py | 2 +- examples/ode.py | 2 +- examples/prodlda.py | 2 +- examples/proportion_test.py | 2 +- examples/sparse_regression.py | 2 +- examples/stochastic_volatility.py | 2 +- examples/thompson_sampling.py | 2 +- examples/ucbadmit.py | 2 +- examples/vae.py | 2 +- notebooks/source/bayesian_hierarchical_linear_regression.ipynb | 2 +- notebooks/source/bayesian_imputation.ipynb | 2 +- notebooks/source/bayesian_regression.ipynb | 2 +- notebooks/source/logistic_regression.ipynb | 2 +- notebooks/source/model_rendering.ipynb | 2 +- notebooks/source/ordinal_regression.ipynb | 2 +- numpyro/version.py | 2 +- 25 files changed, 25 insertions(+), 25 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index 9760a2c94..f7314cf1f 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -327,7 +327,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Bayesian Models of Annotation") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/baseball.py b/examples/baseball.py index 1484af1ce..09cb9f688 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -210,7 +210,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Baseball batting average using MCMC") parser.add_argument("-n", "--num-samples", nargs="?", default=3000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/bnn.py b/examples/bnn.py index 314b2ba84..ab404d86b 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -156,7 +156,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Bayesian neural network example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/covtype.py b/examples/covtype.py index 961dec00b..ff5c98cec 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -206,7 +206,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-samples", default=1000, type=int, help="number of samples" diff --git a/examples/funnel.py b/examples/funnel.py index 69eab07a6..281003ebf 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -108,7 +108,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser( description="Non-centered reparameterization example" ) diff --git a/examples/gaussian_shells.py b/examples/gaussian_shells.py index f959c35de..9224992ee 100644 --- a/examples/gaussian_shells.py +++ b/examples/gaussian_shells.py @@ -120,7 +120,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Nested sampler for Gaussian shells") parser.add_argument("-n", "--num-samples", nargs="?", default=10000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/gp.py b/examples/gp.py index 5d2e0f548..d31f3da2f 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -170,7 +170,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/hmm.py b/examples/hmm.py index a9ca1a719..17ff58eb5 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -263,7 +263,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Semi-supervised Hidden Markov Model") parser.add_argument("--num-categories", default=3, type=int) parser.add_argument("--num-words", default=10, type=int) diff --git a/examples/minipyro.py b/examples/minipyro.py index 62d1c213e..6b48dfdfc 100644 --- a/examples/minipyro.py +++ b/examples/minipyro.py @@ -58,7 +58,7 @@ def body_fn(i, val): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Mini Pyro demo") parser.add_argument("-f", "--full-pyro", action="store_true", default=False) parser.add_argument("-n", "--num-steps", default=1001, type=int) diff --git a/examples/neutra.py b/examples/neutra.py index 83ab5c0c9..15e81a130 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -197,7 +197,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="NeuTra HMC") parser.add_argument("-n", "--num-samples", nargs="?", default=4000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/ode.py b/examples/ode.py index 126db1418..b5f19ba9b 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -116,7 +116,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Predator-Prey Model") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/prodlda.py b/examples/prodlda.py index d8d7a9d88..65ca22e3b 100644 --- a/examples/prodlda.py +++ b/examples/prodlda.py @@ -314,7 +314,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser( description="Probabilistic topic modelling with Flax and Haiku" ) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index bf37b7675..6665fa539 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -160,7 +160,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Testing whether ") parser.add_argument("-n", "--num-samples", nargs="?", default=500, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index 77591b1aa..9f90ddefa 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -401,7 +401,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=500, type=int) diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index be1a9129e..39c8a1966 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -122,7 +122,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Stochastic Volatility Model") parser.add_argument("-n", "--num-samples", nargs="?", default=600, type=int) parser.add_argument("--num-warmup", nargs="?", default=600, type=int) diff --git a/examples/thompson_sampling.py b/examples/thompson_sampling.py index 00cd339f9..6a33734c3 100644 --- a/examples/thompson_sampling.py +++ b/examples/thompson_sampling.py @@ -294,7 +294,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="Thompson sampling example") parser.add_argument( "--num-random", nargs="?", default=2, type=int, help="number of random draws" diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index 89a201281..8898bb3d8 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -151,7 +151,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser( description="UCBadmit gender discrimination using HMC" ) diff --git a/examples/vae.py b/examples/vae.py index 4ae5b9cd4..913017f53 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -159,7 +159,7 @@ def reconstruct_img(epoch, rng_key): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.1") + assert numpyro.__version__.startswith("0.7.2") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-epochs", default=15, type=int, help="number of training epochs" diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index 394e07ba8..e858ffd9a 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -242,7 +242,7 @@ "import numpyro.distributions as dist\n", "from jax import random\n", "\n", - "assert numpyro.__version__.startswith('0.7.1')" + "assert numpyro.__version__.startswith('0.7.2')" ] }, { diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index 2c6500088..611ffbc52 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -55,7 +55,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith('0.7.1')" + "assert numpyro.__version__.startswith('0.7.2')" ] }, { diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 5e1d7c718..8cc1fb567 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -95,7 +95,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats('svg')\n", "\n", - "assert numpyro.__version__.startswith('0.7.1')" + "assert numpyro.__version__.startswith('0.7.2')" ], "execution_count": 2, "outputs": [] diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index f1667a8db..b355d62c5 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -40,7 +40,7 @@ "import numpyro.distributions as dist\n", "from numpyro.examples.datasets import COVTYPE, load_dataset\n", "from numpyro.infer import HMC, MCMC, NUTS\n", - "assert numpyro.__version__.startswith('0.7.1')\n", + "assert numpyro.__version__.startswith('0.7.2')\n", "\n", "# NB: replace gpu by cpu to run this notebook in cpu\n", "numpyro.set_platform(\"gpu\")" diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index 676526c7e..22b66b689 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -33,7 +33,7 @@ "import numpyro\n", "import numpyro.distributions as dist\n", "\n", - "assert numpyro.__version__.startswith('0.7.1')" + "assert numpyro.__version__.startswith('0.7.2')" ] }, { diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 536eb1cde..7d6b4d4cc 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -39,7 +39,7 @@ "from numpyro.infer import MCMC, NUTS\n", "import pandas as pd\n", "import seaborn as sns\n", - "assert numpyro.__version__.startswith('0.7.1')" + "assert numpyro.__version__.startswith('0.7.2')" ] }, { diff --git a/numpyro/version.py b/numpyro/version.py index db37c4aee..5483712f8 100644 --- a/numpyro/version.py +++ b/numpyro/version.py @@ -1,4 +1,4 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -__version__ = "0.7.1" +__version__ = "0.7.2" From e55f0d41c9eba48a10e88fb403a5e016f18857e6 Mon Sep 17 00:00:00 2001 From: Alex Lyttle <43786145+alexlyttle@users.noreply.github.com> Date: Fri, 23 Jul 2021 04:58:49 +0100 Subject: [PATCH 143/222] Circular Reparameterization (#1080) * Add CircularReparam * Change to use jnp.remainder * Add circular constraint * Change Von Mises constraint to circular * Remove comment * Lint and format * Add helpful error for circular support * Add docstring to VonMises distribution * Remove trailing whitespace * Add circular constraint to gen_values functions * Review response * Circular now inherits from interval * Move to after _Interval definition * Replace Normal with ImproperUniform * Add `test_circular` and `get_circular_moments` * Lint and format * Update docstring * Add circular to all * Assert circular support and simplify * Change from error to warning * Revert changes to gen_values functions * Add CircularReparm docs * Add circular constraint * Change to autofunction * Change circular to autodata * Make circular instance of _Interval * Modify assert for changes to constraints.py * Warn if support is circular * Change back to remainder * Lint and format * Add raise_warnings flag to helpful_support_errors --- docs/source/distributions.rst | 4 ++ docs/source/reparam.rst | 9 +++++ numpyro/distributions/constraints.py | 4 ++ numpyro/distributions/directional.py | 19 ++++++++- numpyro/infer/reparam.py | 30 ++++++++++++++ numpyro/infer/util.py | 24 ++++++++++-- test/infer/test_reparam.py | 58 ++++++++++++++++++++++++++++ 7 files changed, 143 insertions(+), 5 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 3174115f8..170352e17 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -578,6 +578,10 @@ boolean ^^^^^^^ .. autodata:: numpyro.distributions.constraints.boolean +circular +-------- +.. autodata:: numpyro.distributions.constraints.circular + corr_cholesky ^^^^^^^^^^^^^ .. autodata:: numpyro.distributions.constraints.corr_cholesky diff --git a/docs/source/reparam.rst b/docs/source/reparam.rst index b809f9e56..7355b03c1 100644 --- a/docs/source/reparam.rst +++ b/docs/source/reparam.rst @@ -51,3 +51,12 @@ Projected Normal Distributions :show-inheritance: :member-order: bysource :special-members: __call__ + +Circular Distributions +---------------------- +.. autoclass:: numpyro.infer.reparam.CircularReparam + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + :special-members: __call__ diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 34a7727b0..a6f9ac5eb 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -28,6 +28,7 @@ __all__ = [ "boolean", + "circular", "corr_cholesky", "corr_matrix", "dependent", @@ -53,6 +54,8 @@ "Constraint", ] +import math + import numpy as np import jax.numpy @@ -454,6 +457,7 @@ def feasible_like(self, prototype): # See https://github.com/pytorch/pytorch/issues/50616 boolean = _Boolean() +circular = _Interval(-math.pi, math.pi) corr_cholesky = _CorrCholesky() corr_matrix = _CorrMatrix() dependent = _Dependent() diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index 50e60cdb8..48cef64dc 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -20,9 +20,26 @@ class VonMises(Distribution): + """ + The von Mises distribution, also known as the circular normal distribution. + + This distribution is supported by a circular constraint from -pi to +pi. By + default, the circular support behaves like + ``constraints.interval(-math.pi, math.pi)``. To avoid issues at the + boundaries of this interval during sampling, you should reparameterize this + distribution using ``handlers.reparam`` with a + :class:`~numpyro.infer.reparam.CircularReparam` reparametrizer in + the model, e.g.:: + + @handlers.reparam(config={"direction": CircularReparam()}) + def model(): + direction = numpyro.sample("direction", VonMises(0.0, 4.0)) + ... + """ + arg_constraints = {"loc": constraints.real, "concentration": constraints.positive} reparametrized_params = ["loc"] - support = constraints.interval(-math.pi, math.pi) + support = constraints.circular def __init__(self, loc, concentration, validate_args=None): """von Mises distribution for sampling directions. diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index 54bdb729d..290997465 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -2,6 +2,7 @@ # SPDX-License-Identifier: Apache-2.0 from abc import ABC, abstractmethod +import math import jax.numpy as jnp @@ -288,3 +289,32 @@ def transform_sample(self, latent): """ x_unconstrained = self.transform(latent) return self.guide._unpack_and_constrain(x_unconstrained, self.params) + + +class CircularReparam(Reparam): + """ + Reparametrizer for :class:`~numpyro.distributions.VonMises` latent + variables. + """ + + def __call__(self, name, fn, obs): + # Support must be circular + support = fn.support + if isinstance(support, constraints.independent): + support = fn.support.base_constraint + assert support is constraints.circular + + # Draw parameter-free noise. + new_fn = dist.ImproperUniform(constraints.real, fn.batch_shape, fn.event_shape) + value = numpyro.sample( + f"{name}_unwrapped", + new_fn, + obs=obs, + ) + + # Differentiably transform. + value = jnp.remainder(value + math.pi, 2 * math.pi) - math.pi + + # Simulate a pyro.deterministic() site. + numpyro.factor(f"{name}_factor", fn.log_prob(value)) + return None, value diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index fd145a9f4..9f1079ed1 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -397,7 +397,7 @@ def _get_model_transforms(model, model_args=(), model_kwargs=None): ) else: support = v["fn"].support - with helpful_support_errors(v): + with helpful_support_errors(v, raise_warnings=True): inv_transforms[k] = biject_to(support) # XXX: the following code filters out most situations with dynamic supports args = () @@ -961,12 +961,28 @@ def single_loglik(samples): @contextmanager -def helpful_support_errors(site): +def helpful_support_errors(site, raise_warnings=False): + name = site["name"] + support = getattr(site["fn"], "support", None) + if isinstance(support, constraints.independent): + support = support.base_constraint + + # Warnings + if raise_warnings: + if support is constraints.circular: + msg = ( + f"Continuous inference poorly handles circular sample site '{name}'. " + + "Consider using VonMises distribution together with " + + "a reparameterizer, e.g. " + + f"numpyro.handlers.reparam(config={{'{name}': CircularReparam()}})." + ) + warnings.warn(msg, UserWarning) + + # Exceptions try: yield except NotImplementedError as e: - name = site["name"] - support_name = repr(site["fn"].support).lower() + support_name = repr(support).lower() if "integer" in support_name or "boolean" in support_name: # TODO: mention enumeration when it is supported in SVI raise ValueError( diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index 2f335bdfb..454243ce7 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -15,6 +15,7 @@ from numpyro.infer import MCMC, NUTS, SVI, Trace_ELBO from numpyro.infer.autoguide import AutoIAFNormal from numpyro.infer.reparam import ( + CircularReparam, LocScaleReparam, NeuTraReparam, ProjectedNormalReparam, @@ -37,6 +38,26 @@ def get_moments(x): return jnp.stack([m1, m2, m3, m4]) +# Helper functions to get central circular moments +def mean_vector(x, m, n): + s = jnp.mean(jnp.sin(n * (x - m)), axis=0) + c = jnp.mean(jnp.cos(n * (x - m)), axis=0) + return s, c + + +def circular_moment(x, n): + m = jnp.arctan2(*mean_vector(x, 0.0, n)) # circular mean + s, c = mean_vector(x, m, n) + # direction = jnp.arctan2(s, c) + length = jnp.hypot(s, c) + return length + # return jnp.array([direction, length]) + + +def get_circular_moments(x): + return jnp.stack([circular_moment(x, i) for i in range(1, 5)]) + + def test_syntax(): loc = np.random.uniform(-1.0, 1.0, ()) scale = np.random.uniform(0.5, 1.5, ()) @@ -268,3 +289,40 @@ def get_actual_probe(concentration): expected_grad = jacobian(get_expected_probe)(concentration) actual_grad = jacobian(get_actual_probe)(concentration) assert_allclose(actual_grad, expected_grad, atol=0.05) + + +@pytest.mark.parametrize("shape", [(), (4,), (3, 2)], ids=str) +def test_circular(shape): + # Define two models which should return the same distributions + # This model is the expected distribution + def model_exp(loc, concentration): + with numpyro.plate_stack("plates", shape): + with numpyro.plate("particles", 10000): + numpyro.sample("x", dist.VonMises(loc, concentration)) + + # This model is for inference + reparam = CircularReparam() + + @numpyro.handlers.reparam(config={"x": reparam}) + def model_act(loc, concentration): + numpyro.sample("x", dist.VonMises(loc, concentration)) + + def get_expected_probe(loc, concentration): + with numpyro.handlers.trace() as trace: + with numpyro.handlers.seed(rng_seed=0): + model_exp(loc, concentration) + return get_circular_moments(trace["x"]["value"]) + + def get_actual_probe(loc, concentration): + kernel = NUTS(model_act) + mcmc = MCMC(kernel, num_warmup=1000, num_samples=10000, num_chains=1) + mcmc.run(random.PRNGKey(0), loc, concentration) + samples = mcmc.get_samples() + return get_circular_moments(samples["x"]) + + loc = np.random.uniform(-np.pi, np.pi, shape) + concentration = np.random.lognormal(1.0, 1.0, shape) + expected_probe = get_expected_probe(loc, concentration) + actual_probe = get_actual_probe(loc, concentration) + + assert_allclose(actual_probe, expected_probe, atol=0.1) From 507acedba02e1b47f3bc4d0d7d8ade129bb2516b Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Sat, 31 Jul 2021 13:32:09 +0100 Subject: [PATCH 144/222] Support direct use of TFP distributions in `numpyro.sample` (#1109) * Support tensorflow_probability distributions in NumPyro sample * Add tests * Relax test * Don't raise an error for funsor.Funsors * Move distribution wrapping logic into _TFPDistributionMeta * Simplify distribution wrapping * Issue FutureWarning if user instantiates TFPDistribution themselves * Expand testing * Fix tests * Remove redundant tests * Cache results of __getitem__ to prevent repeat pytree registrations * Add tree_flatten and tree_unflatten methods to TFPDistribution * Remove tfd_class attribute of TFPDistribution * Don't set signature on wrapped distributions * Distribution cache fix * Update docstring * Test nits --- numpyro/contrib/tfp/distributions.py | 127 +++++++++++++------------ numpyro/primitives.py | 38 ++++++++ test/contrib/test_tfp.py | 134 ++++++++++++++++++--------- 3 files changed, 196 insertions(+), 103 deletions(-) diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index b4ff3eb08..d7834da45 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -1,10 +1,12 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -import inspect +from functools import lru_cache +import warnings import numpy as np +import jax import jax.numpy as jnp from tensorflow_probability.substrates.jax import bijectors as tfb, distributions as tfd @@ -105,18 +107,68 @@ def _transform_to_bijector_constraint(constraint): return BijectorTransform(constraint.bijector) +def _onehot_enumerate_support(self, expand=True): + n = self.event_shape[-1] + values = jnp.identity(n, dtype=jnp.result_type(self.dtype)) + values = values.reshape((n,) + (1,) * len(self.batch_shape) + (n,)) + if expand: + values = jnp.broadcast_to(values, (n,) + self.batch_shape + (n,)) + return values + + class _TFPDistributionMeta(type(NumPyroDistribution)): + @lru_cache(maxsize=None) def __getitem__(cls, tfd_class): assert issubclass(tfd_class, tfd.Distribution) + tfd_class_name = tfd_class.__name__ + def init(self, *args, **kwargs): + warnings.warn( + "Importing distributions from numpyro.contrib.tfp.distributions is " + "deprecated. You should import distributions directly from " + "tensorflow_probability.substrates.jax.distributions instead.", + FutureWarning, + ) self.tfp_dist = tfd_class(*args, **kwargs) - init.__signature__ = inspect.signature(tfd_class.__init__) - - _PyroDist = type(tfd_class.__name__, (TFPDistribution,), {}) - _PyroDist.tfd_class = tfd_class + _PyroDist = type(tfd_class_name, (TFPDistribution,), {}) _PyroDist.__init__ = init + + if tfd_class is tfd.InverseGamma: + _PyroDist.arg_constraints = { + "concentration": constraints.positive, + "scale": constraints.positive, + } + elif tfd_class is tfd.OneHotCategorical: + _PyroDist.arg_constraints = {"logits": constraints.real_vector} + _PyroDist.has_enumerate_support = True + _PyroDist.support = constraints.simplex + _PyroDist.is_discrete = True + _PyroDist.enumerate_support = _onehot_enumerate_support + elif tfd_class is tfd.OrderedLogistic: + _PyroDist.arg_constraints = { + "cutpoints": constraints.ordered_vector, + "loc": constraints.real, + } + elif tfd_class is tfd.Pareto: + _PyroDist.arg_constraints = { + "concentration": constraints.positive, + "scale": constraints.positive, + } + else: + if hasattr(numpyro_dist, tfd_class_name): + numpyro_dist_class = getattr(numpyro_dist, tfd_class_name) + # resolve FooProbs/FooLogits namespaces + numpyro_dist_class = getattr( + numpyro_dist, f"{tfd_class_name}Logits", numpyro_dist_class + ) + _PyroDist.arg_constraints = numpyro_dist_class.arg_constraints + _PyroDist.has_enumerate_support = ( + numpyro_dist_class.has_enumerate_support + ) + _PyroDist.enumerate_support = numpyro_dist_class.enumerate_support + return _PyroDist @@ -132,8 +184,6 @@ class TFPDistribution(NumPyroDistribution, metaclass=_TFPDistributionMeta): """ - tfd_class = None - def __getattr__(self, name): # return parameters from the constructor if name in self.tfp_dist.parameters: @@ -187,41 +237,15 @@ def is_discrete(self): # XXX: this should cover most cases return self.support is None + def tree_flatten(self): + return jax.tree_util.tree_flatten(self.tfp_dist) -InverseGamma = TFPDistribution[tfd.InverseGamma] -InverseGamma.arg_constraints = { - "concentration": constraints.positive, - "scale": constraints.positive, -} - - -def _onehot_enumerate_support(self, expand=True): - n = self.event_shape[-1] - values = jnp.identity(n, dtype=jnp.result_type(self.dtype)) - values = values.reshape((n,) + (1,) * len(self.batch_shape) + (n,)) - if expand: - values = jnp.broadcast_to(values, (n,) + self.batch_shape + (n,)) - return values - - -OneHotCategorical = TFPDistribution[tfd.OneHotCategorical] -OneHotCategorical.arg_constraints = {"logits": constraints.real_vector} -OneHotCategorical.has_enumerate_support = True -OneHotCategorical.support = constraints.simplex -OneHotCategorical.is_discrete = True -OneHotCategorical.enumerate_support = _onehot_enumerate_support - -OrderedLogistic = TFPDistribution[tfd.OrderedLogistic] -OrderedLogistic.arg_constraints = { - "cutpoints": constraints.ordered_vector, - "loc": constraints.real, -} - -Pareto = TFPDistribution[tfd.Pareto] -Pareto.arg_constraints = { - "concentration": constraints.positive, - "scale": constraints.positive, -} + @classmethod + def tree_unflatten(cls, aux_data, params): + fn = jax.tree_util.tree_unflatten(aux_data, params) + with warnings.catch_warnings(): + warnings.simplefilter("ignore", category=FutureWarning) + return TFPDistribution[fn.__class__](**fn.parameters) __all__ = ["BijectorConstraint", "BijectorTransform", "TFPDistribution"] @@ -234,22 +258,9 @@ def _onehot_enumerate_support(self, expand=True): if _Dist is tfd.Distribution: continue - try: - _PyroDist = locals()[_name] - except KeyError: - _PyroDist = TFPDistribution[_Dist] - _PyroDist.__module__ = __name__ - if hasattr(numpyro_dist, _name): - numpyro_dist_class = getattr(numpyro_dist, _name) - # resolve FooProbs/FooLogits namespaces - if type(numpyro_dist_class).__name__ == "function": - if not hasattr(numpyro_dist, _name + "Logits"): - continue - numpyro_dist_class = getattr(numpyro_dist, _name + "Logits") - _PyroDist.arg_constraints = numpyro_dist_class.arg_constraints - _PyroDist.has_enumerate_support = numpyro_dist_class.has_enumerate_support - _PyroDist.enumerate_support = numpyro_dist_class.enumerate_support - locals()[_name] = _PyroDist + _PyroDist = TFPDistribution[_Dist] + _PyroDist.__module__ = __name__ + locals()[_name] = _PyroDist _PyroDist.__doc__ = """ Wraps `{}.{} `_ @@ -271,6 +282,6 @@ def _onehot_enumerate_support(self, expand=True): """.format( _name ) - for _name in __all__[:_len_all] + sorted(__all__[_len_all:]) + for _name in __all__[:_len_all] ] ) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index d10c93d1e..fb6632e47 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -131,6 +131,44 @@ def sample( + "_unobserved"`` which should be used by guides. :return: sample from the stochastic `fn`. """ + if not isinstance(fn, numpyro.distributions.Distribution): + type_error = TypeError( + "It looks like you tried to use a fn that isn't an instance of " + "numpyro.distributions.Distribution, funsor.Funsor or " + "tensorflow_probability.distributions.Distribution. If you're using " + "funsor or tensorflow_probability, make sure they are correctly installed." + ) + + # fn can be a funsor.Funsor, but this won't be installed for all users + try: + from funsor import Funsor + except ImportError: + Funsor = None + + # if Funsor import failed, or fn is not a Funsor it's also possible fn could be + # a tensorflow_probability distribution + if Funsor is None or not isinstance(fn, Funsor): + try: + from tensorflow_probability.substrates.jax import distributions as tfd + + from numpyro.contrib.tfp.distributions import TFPDistribution + except ImportError: + # if tensorflow_probability fails to import here, then fn is not a + # numpyro Distribution or a Funsor, and it can't have been a tfp + # distribution either, so raising TypeError is ok + raise type_error + + if isinstance(fn, tfd.Distribution): + with warnings.catch_warnings(): + # ignore FutureWarnings when instantiating TFPDistribution + warnings.simplefilter("ignore", category=FutureWarning) + # if fn is a tfp distribution we need to wrap it + fn = TFPDistribution[fn.__class__](**fn.parameters) + else: + # if tensorflow_probability imported, but fn is not tfd.Distribution we + # still need to raise a type error + raise type_error + # if there are no active Messengers, we just draw a sample and return it as expected: if not _PYRO_STACK: return fn(rng_key=rng_key, sample_shape=sample_shape) diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index aa6fc7dbe..1a323dcc0 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -1,7 +1,6 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -import inspect import os from numpy.testing import assert_allclose @@ -17,71 +16,49 @@ from numpyro.infer.reparam import TransformReparam -# XXX: for some reasons, pytest raises ImportWarning when we import tfp -@pytest.mark.filterwarnings("ignore:can't resolve package") -def test_api_consistent(): - from numpyro.contrib.tfp import distributions as tfd - - for name in tfd.__all__: - if name in numpyro.distributions.__all__: - tfp_dist = getattr(tfd, name) - numpyro_dist = getattr(numpyro.distributions, name) - if type(numpyro_dist).__name__ == "function": - numpyro_dist = getattr(numpyro.distributions, name + "Logits") - for p in tfp_dist.arg_constraints: - assert p in inspect.getfullargspec(tfp_dist.__init__)[0] - - def test_dist_pytree(): - from numpyro.contrib.tfp import distributions as tfd + from tensorflow_probability.substrates.jax import distributions as tfd - def f(x): - return tfd.Normal(x, 1) - - jit(f)(0) + from numpyro.contrib.tfp.distributions import TFPDistribution + @jit + def f(x): + with numpyro.handlers.seed(rng_seed=0), numpyro.handlers.trace() as tr: + numpyro.sample("x", tfd.Normal(x, 1)) + return tr["x"]["fn"] -@pytest.mark.filterwarnings("ignore:can't resolve package") -def test_independent(): - from numpyro.contrib.tfp import distributions as tfd + res = f(0.0) - d = tfd.Independent( - tfd.Normal(jnp.zeros(10), jnp.ones(10)), reinterpreted_batch_ndims=1 - ) - assert d.event_shape == (10,) - assert d.batch_shape == () + assert isinstance(res, TFPDistribution) + assert res.loc == 0 + assert res.scale == 1 @pytest.mark.filterwarnings("ignore:can't resolve package") def test_transformed_distributions(): - from tensorflow_probability.substrates.jax import bijectors as tfb - from tensorflow_probability.substrates.jax.distributions import Normal as TFPNormal - - from numpyro.contrib.tfp import distributions as tfd + from tensorflow_probability.substrates.jax import ( + bijectors as tfb, + distributions as tfd, + ) d = dist.TransformedDistribution(dist.Normal(0, 1), dist.transforms.ExpTransform()) - d1 = tfd.TransformedDistribution(TFPNormal(0, 1), tfb.Exp()) - d2 = dist.TransformedDistribution( - dist.Normal(0, 1), tfd.BijectorTransform(tfb.Exp()) - ) + d1 = tfd.TransformedDistribution(tfd.Normal(0, 1), tfb.Exp()) x = random.normal(random.PRNGKey(0), (1000,)) d_x = d.log_prob(x).sum() d1_x = d1.log_prob(x).sum() - d2_x = d2.log_prob(x).sum() assert_allclose(d_x, d1_x) - assert_allclose(d_x, d2_x) @pytest.mark.filterwarnings("ignore:can't resolve package") def test_logistic_regression(): - from numpyro.contrib.tfp import distributions as tfd + from tensorflow_probability.substrates.jax import distributions as tfd N, dim = 3000, 3 num_warmup, num_samples = (1000, 1000) data = random.normal(random.PRNGKey(0), (N, dim)) true_coefs = jnp.arange(1.0, dim + 1.0) logits = jnp.sum(true_coefs * data, axis=-1) - labels = tfd.Bernoulli(logits=logits)(rng_key=random.PRNGKey(1)) + labels = tfd.Bernoulli(logits=logits).sample(seed=random.PRNGKey(1)) def model(labels): coefs = numpyro.sample("coefs", tfd.Normal(jnp.zeros(dim), jnp.ones(dim))) @@ -102,7 +79,7 @@ def model(labels): # TODO: remove after https://github.com/tensorflow/probability/issues/1072 is resolved @pytest.mark.filterwarnings("ignore:Explicitly requested dtype") def test_beta_bernoulli(): - from numpyro.contrib.tfp import distributions as tfd + from tensorflow_probability.substrates.jax import distributions as tfd num_warmup, num_samples = (500, 2000) @@ -114,7 +91,9 @@ def model(data): return p_latent true_probs = jnp.array([0.9, 0.1]) - data = tfd.Bernoulli(true_probs)(rng_key=random.PRNGKey(1), sample_shape=(1000, 2)) + data = tfd.Bernoulli(true_probs).sample( + seed=random.PRNGKey(1), sample_shape=(1000, 2) + ) kernel = NUTS(model=model, trajectory_length=0.1) mcmc = MCMC(kernel, num_warmup=num_warmup, num_samples=num_samples) mcmc.run(random.PRNGKey(2), data) @@ -240,14 +219,79 @@ def potential_fn(z): # test if sampling from tfp distributions works as expected using # numpyro sample function: numpyro.sample("name", dist) (bug) @pytest.mark.filterwarnings("ignore:can't resolve package") +@pytest.mark.filterwarnings("ignore:Importing distributions") def test_sample_tfp_distributions(): - from numpyro.contrib.tfp import distributions as tfd + from tensorflow_probability.substrates.jax import distributions as tfd + + from numpyro.contrib.tfp.distributions import TFPDistribution # test no error raised - d = tfd.Normal(0, 1) + d = TFPDistribution[tfd.Normal](0, 1) with numpyro.handlers.seed(rng_seed=random.PRNGKey(0)): numpyro.sample("normal", d) # test intermediates are [] value, intermediates = d(sample_intermediates=True, rng_key=random.PRNGKey(0)) assert intermediates == [] + + +# test that sampling from unwrapped tensorflow_probability distributions works as +# expected using numpyro.sample primitive +@pytest.mark.parametrize( + "dist,args", + [ + ["Bernoulli", (0,)], + ["Beta", (1, 1)], + ["Binomial", (10, 0)], + ["Categorical", ([0, 1, -1],)], + ["Cauchy", (0, 1)], + ["Dirichlet", ([1, 2, 0.5],)], + ["Exponential", (1,)], + ["InverseGamma", (1, 1)], + ["Normal", (0, 1)], + ["OrderedLogistic", ([0, 1], 0.5)], + ["Pareto", (1,)], + ], +) +def test_sample_unwrapped_tfp_distributions(dist, args): + from tensorflow_probability.substrates.jax import distributions as tfd + + # test no error is raised + with numpyro.handlers.seed(rng_seed=random.PRNGKey(0)): + # since we import tfd inside the test, distributions have to be parametrized as + # strings, which is why we use getattr here + numpyro.sample("sample", getattr(tfd, dist)(*args)) + + +# test mixture distributions +def test_sample_unwrapped_mixture_same_family(): + from tensorflow_probability.substrates.jax import distributions as tfd + + # test no error is raised + with numpyro.handlers.seed(rng_seed=random.PRNGKey(0)): + numpyro.sample( + "sample", + tfd.MixtureSameFamily( + mixture_distribution=tfd.Categorical(probs=[0.3, 0.7]), + components_distribution=tfd.Normal( + loc=[-1.0, 1], scale=[0.1, 0.5] # One for each component. + ), + ), + ) + + +# test that MCMC works with unwrapped tensorflow_probability distributions +def test_mcmc_unwrapped_tfp_distributions(): + from tensorflow_probability.substrates.jax import distributions as tfd + + def model(y): + theta = numpyro.sample("p", tfd.Beta(1, 1)) + + with numpyro.plate("plate", y.size): + numpyro.sample("y", tfd.Bernoulli(probs=theta), obs=y) + + mcmc = MCMC(NUTS(model), num_warmup=1000, num_samples=1000) + mcmc.run(random.PRNGKey(0), jnp.array([0, 0, 1, 1, 1])) + samples = mcmc.get_samples() + + assert_allclose(jnp.mean(samples["p"]), 4 / 7, atol=0.05) From 8e7439ef39c7a72ea229d75d1d40ee8bd8f7090e Mon Sep 17 00:00:00 2001 From: Julian Stastny <33601631+julianstastny@users.noreply.github.com> Date: Sat, 31 Jul 2021 21:18:58 +0200 Subject: [PATCH 145/222] Avoid numerical problems when using BernoulliProbs (#1108) * Avoid numerical problems when using BernoulliProbs Solving the issue described here: https://forum.pyro.ai/t/cannot-find-valid-initial-parameters-when-using-nuts-and-bernoulliprobs/3185?u=julianstastny * Remove whitespace I think that this is the reason for the linter fail. * Cast probs to float --- numpyro/distributions/discrete.py | 3 ++- numpyro/distributions/util.py | 2 +- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 8596f71b9..618d4cdea 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -91,7 +91,8 @@ def sample(self, key, sample_shape=()): @validate_sample def log_prob(self, value): - return xlogy(value, self.probs) + xlog1py(1 - value, -self.probs) + ps_clamped = clamp_probs(self.probs) + return xlogy(value, ps_clamped) + xlog1py(1 - value, -ps_clamped) @lazy_property def logits(self): diff --git a/numpyro/distributions/util.py b/numpyro/distributions/util.py index c66b0b2d8..c24c6bd96 100644 --- a/numpyro/distributions/util.py +++ b/numpyro/distributions/util.py @@ -395,7 +395,7 @@ def logmatmulexp(x, y): def clamp_probs(probs): - finfo = jnp.finfo(jnp.result_type(probs)) + finfo = jnp.finfo(jnp.result_type(probs, float)) return jnp.clip(probs, a_min=finfo.tiny, a_max=1.0 - finfo.eps) From 672c33f1ae4a1e2108980a69f9f3823b867778dc Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Sun, 1 Aug 2021 18:32:06 +0100 Subject: [PATCH 146/222] Add sphinx-search to docs and pin version numbers (#1113) * Add sphinx-search to docs and pin version numbers * Black --- docs/requirements.txt | 6 +++++- docs/source/conf.py | 1 + setup.py | 1 + 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 567c3b922..1255b6335 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -1,11 +1,15 @@ dm-haiku flax funsor>=0.4.1 +ipython jax>=0.2.11 jaxlib>=0.1.62 jaxns>=0.0.7 optax>=0.0.6 -nbsphinx>=0.8.5 +nbsphinx==0.8.6 +readthedocs-sphinx-search==0.1.0 +sphinx==4.1.2 sphinx-gallery +sphinx_rtd_theme==0.5.2 tensorflow_probability>=0.13 tqdm diff --git a/docs/source/conf.py b/docs/source/conf.py index 66b6a6d73..48c6e836c 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -73,6 +73,7 @@ "sphinx.ext.mathjax", "sphinx.ext.viewcode", "sphinx_gallery.gen_gallery", + "sphinx_search.extension", ] # Enable documentation inheritance diff --git a/setup.py b/setup.py index 5c63a7c02..79e8873e9 100644 --- a/setup.py +++ b/setup.py @@ -47,6 +47,7 @@ "doc": [ "ipython", # sphinx needs this to render codes "nbsphinx>=0.8.5", + "readthedocs-sphinx-search==0.1.0", "sphinx", "sphinx_rtd_theme", "sphinx-gallery", From c0b351f6614b4710640ee5d41695895acf7b50f8 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Sun, 1 Aug 2021 23:28:52 +0100 Subject: [PATCH 147/222] Pin Sphinx for readthedocs (#1114) --- docs/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 1255b6335..e4a250672 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -8,7 +8,7 @@ jaxns>=0.0.7 optax>=0.0.6 nbsphinx==0.8.6 readthedocs-sphinx-search==0.1.0 -sphinx==4.1.2 +sphinx==4.0.3 sphinx-gallery sphinx_rtd_theme==0.5.2 tensorflow_probability>=0.13 From 58a7beb383f7c233a7d9edfd8312b5011c0a6c90 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 3 Aug 2021 10:02:23 -0400 Subject: [PATCH 148/222] fix docs of scan (#1110) --- docs/source/index.rst | 2 +- numpyro/contrib/control_flow/scan.py | 12 ++++++------ 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/docs/source/index.rst b/docs/source/index.rst index 743fb1bb0..8f09b0404 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -31,6 +31,7 @@ NumPyro documentation examples/vae examples/funnel examples/stochastic_volatility + examples/prodlda tutorials/model_rendering .. nbgallery:: @@ -43,7 +44,6 @@ NumPyro documentation examples/capture_recapture examples/gaussian_shells tutorials/discrete_imputation - examples/prodlda .. nbgallery:: :maxdepth: 1 diff --git a/numpyro/contrib/control_flow/scan.py b/numpyro/contrib/control_flow/scan.py index 57165b834..883b15efe 100644 --- a/numpyro/contrib/control_flow/scan.py +++ b/numpyro/contrib/control_flow/scan.py @@ -378,19 +378,19 @@ def g(*args, **kwargs): variables will contain the following sites: + init sites: those sites belong to the first `history` traces of `f`. - Sites at the `i`-th trace will have name prefixed with - `'_PREV_' * (2 * history - 1 - i)`. + Sites at the `i`-th trace will have name prefixed with + `'_PREV_' * (2 * history - 1 - i)`. + scanned sites: those sites collect the values of the remaining scan - loop over `f`. An addition time dimension `_time_foo` will be - added to those sites, where `foo` is the name of the first site - appeared in `f`. + loop over `f`. An addition time dimension `_time_foo` will be + added to those sites, where `foo` is the name of the first site + appeared in `f`. Not all transition functions `f` are supported. All of the restrictions from Pyro's enumeration tutorial [2] still apply here. In addition, there should not have any site outside of `scan` depend on the first output of `scan` (the last carry value). - ** References ** + **References** 1. *Temporal Parallelization of Bayesian Smoothers*, Simo Sarkka, Angel F. Garcia-Fernandez From d90b335544767890c33aa0f7ec11e000ffa14394 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 12 Aug 2021 01:22:56 -0400 Subject: [PATCH 149/222] Add L1 ball constraint and its corresponding L1BallTransform bijective (#1090) * add L1 ball constraints * remove unused import * only apply clip in needed places --- docs/source/distributions.rst | 8 ++++ numpyro/distributions/constraints.py | 19 ++++++++++ numpyro/distributions/transforms.py | 57 ++++++++++++++++++++++++++-- test/test_distributions.py | 2 + 4 files changed, 83 insertions(+), 3 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 170352e17..861ef22fe 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -762,6 +762,14 @@ InvCholeskyTransform :show-inheritance: :member-order: bysource +L1BallTransform +--------------- +.. autoclass:: numpyro.distributions.transforms.L1BallTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + LowerCholeskyAffine ^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.transforms.LowerCholeskyAffine diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index a6f9ac5eb..7b81b64cf 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -37,6 +37,7 @@ "integer_greater_than", "interval", "is_dependent", + "l1_ball", "less_than", "lower_cholesky", "multinomial", @@ -353,6 +354,23 @@ def feasible_like(self, prototype): return jax.numpy.broadcast_to(value, prototype.shape) +class _L1Ball(Constraint): + """ + Constrain to the L1 ball of any dimension. + """ + + event_dim = 1 + reltol = 10.0 # Relative to finfo.eps. + + def __call__(self, x): + jnp = np if isinstance(x, (np.ndarray, np.generic)) else jax.numpy + eps = jnp.finfo(x.dtype).eps + return jnp.abs(x).sum(axis=-1) < 1 + self.reltol * eps + + def feasible_like(self, prototype): + return jax.numpy.zeros_like(prototype) + + class _OrderedVector(Constraint): event_dim = 1 @@ -467,6 +485,7 @@ def feasible_like(self, prototype): integer_interval = _IntegerInterval integer_greater_than = _IntegerGreaterThan interval = _Interval +l1_ball = _L1Ball() lower_cholesky = _LowerCholesky() multinomial = _Multinomial nonnegative_integer = _IntegerGreaterThan(0) diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 636e15b2d..e4a0c4463 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -33,9 +33,9 @@ "CorrCholeskyTransform", "CorrMatrixCholeskyTransform", "ExpTransform", - "SoftplusTransform", "IdentityTransform", "InvCholeskyTransform", + "L1BallTransform", "LowerCholeskyTransform", "LowerCholeskyAffine", "PermuteTransform", @@ -404,8 +404,7 @@ def _inverse(self, y): matrix_to_tril_vec(z1m_cumprod_shifted, diagonal=-1) ) # inverse of tanh - x = jnp.log((1 + t) / (1 - t)) / 2 - return x + return jnp.arctanh(t) def log_abs_det_jacobian(self, x, y, intermediates=None): # NB: because domain and codomain are two spaces with different dimensions, determinant of @@ -583,6 +582,53 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): ) +class L1BallTransform(Transform): + r""" + Transforms a uncontrained real vector :math:`x` into the unit L1 ball. + """ + domain = constraints.real_vector + codomain = constraints.l1_ball + + def __call__(self, x): + # transform to (-1, 1) interval + t = jnp.tanh(x) + + # apply stick-breaking transform + remainder = jnp.cumprod(1 - jnp.abs(t[..., :-1]), axis=-1) + pad_width = [(0, 0)] * (t.ndim - 1) + [(1, 0)] + remainder = jnp.pad(remainder, pad_width, mode="constant", constant_values=1.0) + return t * remainder + + def _inverse(self, y): + # inverse stick-breaking + remainder = 1 - jnp.cumsum(jnp.abs(y[..., :-1]), axis=-1) + pad_width = [(0, 0)] * (y.ndim - 1) + [(1, 0)] + remainder = jnp.pad(remainder, pad_width, mode="constant", constant_values=1.0) + finfo = jnp.finfo(y.dtype) + remainder = jnp.clip(remainder, a_min=finfo.tiny) + t = y / remainder + + # inverse of tanh + t = jnp.clip(t, a_min=-1 + finfo.eps, a_max=1 - finfo.eps) + return jnp.arctanh(t) + + def log_abs_det_jacobian(self, x, y, intermediates=None): + # compute stick-breaking logdet + # t1 -> t1 + # t2 -> t2 * (1 - abs(t1)) + # t3 -> t3 * (1 - abs(t1)) * (1 - abs(t2)) + # hence jacobian is triangular and logdet is the sum of the log + # of the diagonal part of the jacobian + one_minus_remainder = jnp.cumsum(jnp.abs(y[..., :-1]), axis=-1) + eps = jnp.finfo(y.dtype).eps + one_minus_remainder = jnp.clip(one_minus_remainder, a_max=1 - eps) + # log(remainder) = log1p(remainder - 1) + stick_breaking_logdet = jnp.sum(jnp.log1p(-one_minus_remainder), axis=-1) + + tanh_logdet = -2 * jnp.sum(x + softplus(-2 * x) - jnp.log(2.0), axis=-1) + return stick_breaking_logdet + tanh_logdet + + class LowerCholeskyAffine(Transform): r""" Transform via the mapping :math:`y = loc + scale\_tril\ @\ x`. @@ -981,6 +1027,11 @@ def _transform_to_interval(constraint): ) +@biject_to.register(constraints.l1_ball) +def _transform_to_l1_ball(constraint): + return L1BallTransform() + + @biject_to.register(constraints.lower_cholesky) def _transform_to_lower_cholesky(constraint): return LowerCholeskyTransform() diff --git a/test/test_distributions.py b/test/test_distributions.py index 9fbdf97fa..5bcdbd242 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1471,6 +1471,7 @@ def test_constraints(constraint, x, expected): constraints.corr_matrix, constraints.greater_than(2), constraints.interval(-3, 5), + constraints.l1_ball, constraints.less_than(1), constraints.lower_cholesky, constraints.ordered_vector, @@ -1533,6 +1534,7 @@ def test_biject_to(constraint, shape): constraints.real_vector, constraints.ordered_vector, constraints.positive_ordered_vector, + constraints.l1_ball, ]: expected = np.linalg.slogdet(jax.jacobian(transform)(x))[1] inv_expected = np.linalg.slogdet(jax.jacobian(transform.inv)(y))[1] From c21570d4989df45ae0cd0740292859096282aa81 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 16 Aug 2021 08:43:24 -0400 Subject: [PATCH 150/222] Fix intersphinx links at various places (#1122) * improve and fix docs at various places * fix indent of hmc_gibbs example --- numpyro/infer/hmc_gibbs.py | 14 +++++++++----- numpyro/infer/mcmc.py | 7 ++++--- numpyro/infer/sa.py | 8 ++++---- numpyro/infer/util.py | 6 +++--- 4 files changed, 20 insertions(+), 15 deletions(-) diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index 1c1fab8a0..f458bfe5c 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -34,7 +34,7 @@ HMCGibbsState = namedtuple("HMCGibbsState", "z, hmc_state, rng_key") """ - **z** - a dict of the current latent values (both HMC and Gibbs sites) - - **hmc_state** - current hmc_state + - **hmc_state** - current :data:`~numpyro.infer.hmc.HMCState` - **rng_key** - random key for the current step """ @@ -80,9 +80,9 @@ class HMCGibbs(MCMCKernel): ... numpyro.sample("obs", dist.Normal(x + y, 1.0), obs=jnp.array([1.0])) ... >>> def gibbs_fn(rng_key, gibbs_sites, hmc_sites): - ... y = hmc_sites['y'] - ... new_x = dist.Normal(0.8 * (1-y), jnp.sqrt(0.8)).sample(rng_key) - ... return {'x': new_x} + ... y = hmc_sites['y'] + ... new_x = dist.Normal(0.8 * (1-y), jnp.sqrt(0.8)).sample(rng_key) + ... return {'x': new_x} ... >>> hmc_kernel = NUTS(model) >>> kernel = HMCGibbs(hmc_kernel, gibbs_fn=gibbs_fn, gibbs_sites=['x']) @@ -701,6 +701,10 @@ def potential_fn(z_gibbs, gibbs_state, z_hmc): @staticmethod def taylor_proxy(reference_params): + """ + This is just a convenient static method which calls + :func:`~numpyro.infer.hmc_gibbs.taylor_proxy`. + """ return taylor_proxy(reference_params) @@ -740,7 +744,7 @@ def taylor_proxy(reference_params): :param dict reference_params: Model parameterization at MLE or MAP-estimate. - ** References: ** + **References:** [1] Towards scaling up Markov chainMonte Carlo: an adaptive subsampling approach Bardenet., R., Doucet, A., Holmes, C. (2014) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 5a1b0d994..f617e274d 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -514,9 +514,10 @@ def run(self, rng_key, *args, extra_fields=(), init_params=None, **kwargs): does not have batch_size, it will be split in to a batch of `num_chains` keys. :param args: Arguments to be provided to the :meth:`numpyro.infer.mcmc.MCMCKernel.init` method. These are typically the arguments needed by the `model`. - :param extra_fields: Extra fields (aside from `z`, `diverging`) from :data:`numpyro.infer.mcmc.HMCState` - to collect during the MCMC run. - :type extra_fields: tuple or list + :param extra_fields: Extra fields (aside from `"z"`, `"diverging"`) to be collected + during the MCMC run. Note that subfields can be accessed using dots, e.g. + `"adapt_state.step_size"` can be used to collect step sizes at each step. + :type extra_fields: tuple or list of str :param init_params: Initial parameters to begin sampling. The type must be consistent with the input type to `potential_fn`. :param kwargs: Keyword arguments to be provided to the :meth:`numpyro.infer.mcmc.MCMCKernel.init` diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index a64aef9ec..999aa4b50 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -260,8 +260,8 @@ class SA(MCMCKernel): subset of approximate posterior samples of size num_chains x num_samples instead of num_chains x num_samples x adapt_state_size. - .. note:: We recommend to use this kernel with `progress_bar=False` in :class:`MCMC` - to reduce JAX's dispatch overhead. + .. note:: We recommend to use this kernel with `progress_bar=False` in + :class:`~numpyro.infer.mcmc.MCMC` to reduce JAX's dispatch overhead. **References:** @@ -383,8 +383,8 @@ def postprocess_fn(self, args, kwargs): def sample(self, state, model_args, model_kwargs): """ - Run SA from the given :data:`~numpyro.infer.mcmc.SAState` and return the resulting - :data:`~numpyro.infer.mcmc.SAState`. + Run SA from the given :data:`~numpyro.infer.sa.SAState` and return the resulting + :data:`~numpyro.infer.sa.SAState`. :param SAState state: Represents the current state. :param model_args: Arguments provided to the model. diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 9f1079ed1..03000ad4d 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -781,18 +781,18 @@ class Predictive(object): **Example:** - Given a model + Given a model:: def model(X, y=None): ... return numpyro.sample("obs", likelihood, obs=y) - you can sample from the prior predictive: + you can sample from the prior predictive:: predictive = Predictive(model, num_samples=1000) y_pred = predictive(rng_key, X)["obs"] - If you also have posterior samples, you can sample from the posterior predictive: + If you also have posterior samples, you can sample from the posterior predictive:: predictive = Predictive(model, posterior_samples=posterior_samples) y_pred = predictive(rng_key, X)["obs"] From 935d4f5b0d7a9759c44caf3409be9b95e407d956 Mon Sep 17 00:00:00 2001 From: Tom Begley Date: Mon, 16 Aug 2021 13:58:25 +0100 Subject: [PATCH 151/222] Add format_shapes utility (#1116) * Add format_trace_shapes utility * Rename function, enforce keyword arguments * Add support for plates * Add tests * Add docstring * Clearer formatting of target strings in test * Test event_shape formatting * Allow compute_log_prob to be callable, add to docs --- docs/source/utilities.rst | 4 ++ numpyro/util.py | 140 ++++++++++++++++++++++++++++++++++++++ test/test_util.py | 67 +++++++++++++++++- 3 files changed, 210 insertions(+), 1 deletion(-) diff --git a/docs/source/utilities.rst b/docs/source/utilities.rst index b40a04fc2..9a531c8b3 100644 --- a/docs/source/utilities.rst +++ b/docs/source/utilities.rst @@ -104,3 +104,7 @@ Visualization Utilities render_model ------------ .. autofunction:: numpyro.contrib.render.render_model + +Trace inspection +---------------- +.. autofunction:: numpyro.util.format_shapes diff --git a/numpyro/util.py b/numpyro/util.py index f7ad4059d..f26933b93 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -408,3 +408,143 @@ def soft_vmap(fn, xs, batch_ndims=1, chunk_size=None): lambda y: jnp.reshape(y, (-1,) + jnp.shape(y)[map_ndims:])[:batch_size], ys ) return tree_map(lambda y: jnp.reshape(y, batch_shape + jnp.shape(y)[1:]), ys) + + +def format_shapes( + trace, + *, + compute_log_prob=False, + title="Trace Shapes:", + last_site=None, +): + """ + Given the trace of a function, returns a string showing a table of the shapes of + all sites in the trace. + + Use :class:`~numpyro.handlers.trace` handler (or funsor + :class:`~numpyro.contrib.funsor.enum_messenger.trace` handler for enumeration) to + produce the trace. + + :param dict trace: The model trace to format. + :param compute_log_prob: Compute log probabilities and display the shapes in the + table. Accepts True / False or a function which when given a dictionary + containing site-level metadata returns whether the log probability should be + calculated and included in the table. + :param str title: Title for the table of shapes. + :param str last_site: Name of a site in the model. If supplied, subsequent sites + are not displayed in the table. + + Usage:: + + def model(*args, **kwargs): + ... + + trace = numpyro.handlers.trace(model).get_trace(*args, **kwargs) + numpyro.util.format_shapes(trace) + """ + if not trace.keys(): + return title + rows = [[title]] + + rows.append(["Param Sites:"]) + for name, site in trace.items(): + if site["type"] == "param": + rows.append( + [name, None] + + [str(size) for size in getattr(site["value"], "shape", ())] + ) + if name == last_site: + break + + rows.append(["Sample Sites:"]) + for name, site in trace.items(): + if site["type"] == "sample": + # param shape + batch_shape = getattr(site["fn"], "batch_shape", ()) + event_shape = getattr(site["fn"], "event_shape", ()) + rows.append( + [f"{name} dist", None] + + [str(size) for size in batch_shape] + + ["|", None] + + [str(size) for size in event_shape] + ) + + # value shape + event_dim = len(event_shape) + shape = getattr(site["value"], "shape", ()) + batch_shape = shape[: len(shape) - event_dim] + event_shape = shape[len(shape) - event_dim :] + rows.append( + ["value", None] + + [str(size) for size in batch_shape] + + ["|", None] + + [str(size) for size in event_shape] + ) + + # log_prob shape + if (not callable(compute_log_prob) and compute_log_prob) or ( + callable(compute_log_prob) and compute_log_prob(site) + ): + batch_shape = getattr(site["fn"].log_prob(site["value"]), "shape", ()) + rows.append( + ["log_prob", None] + + [str(size) for size in batch_shape] + + ["|", None] + ) + elif site["type"] == "plate": + shape = getattr(site["value"], "shape", ()) + rows.append( + [f"{name} plate", None] + [str(size) for size in shape] + ["|", None] + ) + + if name == last_site: + break + + return _format_table(rows) + + +def _format_table(rows): + """ + Formats a right justified table using None as column separator. + """ + # compute column widths + column_widths = [0, 0, 0] + for row in rows: + widths = [0, 0, 0] + j = 0 + for cell in row: + if cell is None: + j += 1 + else: + widths[j] += 1 + for j in range(3): + column_widths[j] = max(column_widths[j], widths[j]) + + # justify columns + for i, row in enumerate(rows): + cols = [[], [], []] + j = 0 + for cell in row: + if cell is None: + j += 1 + else: + cols[j].append(cell) + cols = [ + [""] * (width - len(col)) + col + if direction == "r" + else col + [""] * (width - len(col)) + for width, col, direction in zip(column_widths, cols, "rrl") + ] + rows[i] = sum(cols, []) + + # compute cell widths + cell_widths = [0] * len(rows[0]) + for row in rows: + for j, cell in enumerate(row): + cell_widths[j] = max(cell_widths[j], len(cell)) + + # justify cells + return "\n".join( + " ".join(cell.rjust(width) for cell, width in zip(row, cell_widths)) + for row in rows + ) diff --git a/test/test_util.py b/test/test_util.py index 7ee8ae9aa..9152aa145 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -9,7 +9,9 @@ from jax.test_util import check_eq from jax.tree_util import tree_flatten, tree_multimap -from numpyro.util import fori_collect, soft_vmap +import numpyro +import numpyro.distributions as dist +from numpyro.util import fori_collect, format_shapes, soft_vmap def test_fori_collect_thinning(): @@ -101,3 +103,66 @@ def f(x): assert set(ys.keys()) == {"a", "b"} assert_allclose(ys["a"], xs["a"][..., None] * jnp.ones(4)) assert_allclose(ys["b"], ~xs["b"]) + + +def test_format_shapes(): + data = jnp.arange(100) + + def model_test(): + mean = numpyro.param("mean", jnp.zeros(len(data))) + scale = numpyro.sample("scale", dist.Normal(0, 1).expand([3]).to_event(1)) + scale = scale.sum() + with numpyro.plate("data", len(data), subsample_size=10) as ind: + batch = data[ind] + mean_batch = mean[ind] + numpyro.sample("x", dist.Normal(mean_batch, scale), obs=batch) + + with numpyro.handlers.seed(rng_seed=0), numpyro.handlers.trace() as t: + model_test() + + assert ( + format_shapes(t) == "Trace Shapes: \n" + " Param Sites: \n" + " mean 100 \n" + "Sample Sites: \n" + " scale dist | 3\n" + " value | 3\n" + " data plate 10 | \n" + " x dist 10 | \n" + " value 10 | " + ) + assert ( + format_shapes(t, compute_log_prob=True) == "Trace Shapes: \n" + " Param Sites: \n" + " mean 100 \n" + "Sample Sites: \n" + " scale dist | 3\n" + " value | 3\n" + " log_prob | \n" + " data plate 10 | \n" + " x dist 10 | \n" + " value 10 | \n" + " log_prob 10 | " + ) + assert ( + format_shapes(t, compute_log_prob=lambda site: site["name"] == "scale") + == "Trace Shapes: \n" + " Param Sites: \n" + " mean 100 \n" + "Sample Sites: \n" + " scale dist | 3\n" + " value | 3\n" + " log_prob | \n" + " data plate 10 | \n" + " x dist 10 | \n" + " value 10 | " + ) + assert ( + format_shapes(t, last_site="data") == "Trace Shapes: \n" + " Param Sites: \n" + " mean 100 \n" + "Sample Sites: \n" + " scale dist | 3\n" + " value | 3\n" + " data plate 10 | " + ) From ed1aac3189d0aa864bc5b9e263b626cd4fd9b227 Mon Sep 17 00:00:00 2001 From: Nicholas Mancuso Date: Fri, 20 Aug 2021 12:42:46 -0700 Subject: [PATCH 152/222] smarter warning about discrete inference in SVI models (#1124) (#1126) * smarter warning about discrete inference in SVI models (#1124) * lint/flake8 * moved discrete check to member variable and updated tests * flake8 * fixed tests for SVI warning * isort warning --- numpyro/infer/elbo.py | 9 +++++++++ numpyro/infer/svi.py | 8 +++++--- test/infer/test_svi.py | 15 ++++++++++++--- test/pyroapi/test_pyroapi.py | 13 ++++++++++++- 4 files changed, 38 insertions(+), 7 deletions(-) diff --git a/numpyro/infer/elbo.py b/numpyro/infer/elbo.py index 8f3e58585..879778a57 100644 --- a/numpyro/infer/elbo.py +++ b/numpyro/infer/elbo.py @@ -25,6 +25,13 @@ class ELBO: (gradient) estimators. """ + """ + Determines whether the ELBO objective can support inference of discrete latent variables. + + Subclasses that are capable of inferring discrete latent variables should override to `True` + """ + can_infer_discrete = False + def __init__(self, num_particles=1): self.num_particles = num_particles @@ -531,6 +538,8 @@ class TraceGraph_ELBO(ELBO): John Schulman, Nicolas Heess, Theophane Weber, Pieter Abbeel """ + can_infer_discrete = True + def __init__(self, num_particles=1): super().__init__(num_particles=num_particles) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index a8f4a3d5e..d37d08299 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -192,9 +192,11 @@ def init(self, rng_key, *args, **kwargs): site["type"] == "sample" and (not site["is_observed"]) and site["fn"].support.is_discrete + and not self.loss.can_infer_discrete ): + s_name = type(self.loss).__name__ warnings.warn( - "Currently, SVI does not support models with discrete latent variables" + f"Currently, SVI with {s_name} loss does not support models with discrete latent variables" ) if not mutable_state: @@ -283,7 +285,7 @@ def run( *args, progress_bar=True, stable_update=False, - **kwargs + **kwargs, ): """ (EXPERIMENTAL INTERFACE) Run SVI with `num_steps` iterations, then return @@ -369,5 +371,5 @@ def evaluate(self, svi_state, *args, **kwargs): self.guide, *args, **kwargs, - **self.static_kwargs + **self.static_kwargs, ) diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index 6f890db98..90a679738 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -231,6 +231,12 @@ def guide(): def test_svi_discrete_latent(): + cont_inf_only_cls = [RenyiELBO(), Trace_ELBO(), TraceMeanField_ELBO()] + mixed_inf_cls = [TraceGraph_ELBO()] + + assert not any([c.can_infer_discrete for c in cont_inf_only_cls]) + assert all([c.can_infer_discrete for c in mixed_inf_cls]) + def model(): numpyro.sample("x", dist.Bernoulli(0.5)) @@ -238,9 +244,12 @@ def guide(): probs = numpyro.param("probs", 0.2) numpyro.sample("x", dist.Bernoulli(probs)) - svi = SVI(model, guide, optim.Adam(1), Trace_ELBO()) - with pytest.warns(UserWarning, match="SVI does not support models with discrete"): - svi.run(random.PRNGKey(0), 10) + for elbo in cont_inf_only_cls: + svi = SVI(model, guide, optim.Adam(1), elbo) + s_name = type(elbo).__name__ + w_msg = f"Currently, SVI with {s_name} loss does not support models with discrete latent variables" + with pytest.warns(UserWarning, match=w_msg): + svi.run(random.PRNGKey(0), 10) @pytest.mark.parametrize("stable_update", [True, False]) diff --git a/test/pyroapi/test_pyroapi.py b/test/pyroapi/test_pyroapi.py index 2ce443d63..1454e496a 100644 --- a/test/pyroapi/test_pyroapi.py +++ b/test/pyroapi/test_pyroapi.py @@ -5,9 +5,20 @@ from pyroapi.tests import * # noqa F401 import pytest +from numpyro.infer import RenyiELBO, Trace_ELBO, TraceMeanField_ELBO + +cont_inf_only_cls_names = [ + RenyiELBO.__name__, + Trace_ELBO.__name__, + TraceMeanField_ELBO.__name__, +] + pytestmark = pytest.mark.filterwarnings( "ignore::numpyro.compat.util.UnsupportedAPIWarning", - "ignore:Currently, SVI does not support models with discrete", + *( + f"ignore:Currently, SVI with {s_name} loss does not support models with discrete latent variables" + for s_name in cont_inf_only_cls_names + ), ) From c9eb769383341f81b768bc67e44de87198f577a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Fri, 20 Aug 2021 21:52:53 +0200 Subject: [PATCH 153/222] Porting Sine Bivaraite von Mises from Pyro (#1063) * Added BvM. * Added BvM tests. * Added comment with tests that need to be fixed. * Added tests. * Ran black * fixed license * Added BvM to docs * Fixed docstring * Added math envs to docstring for `SineBivariateVonMises`. * Fixed `test_distribution_constraints` failures for `SineBivariateVonMises`. * Added circular mean to `test_mean_var` * Fixed lint. * Added test cases with inconsistent size * Moved `SineVBivariateVonMises` in docs. * Fixed docstring paths, removed lax and fixed `SineBivariateVonMises` placement in docs. * Fixed broadcasting for mean. * Fixed lint. * updated docstring param type to `jnp.ndarray` for `SineBivariateVonMises`. * `jnp.ndarray` -> `np.ndarray` * `jnp.ndarray` -> `np.ndarray` * removed numpy import from directional.py * Fixed scalar params * Changed `SineBivariateVonMises` support to circular Co-authored-by: Ola --- docs/source/distributions.rst | 8 + numpyro/distributions/__init__.py | 7 +- numpyro/distributions/directional.py | 310 ++++++++++++++++++++++++++- test/test_distributions.py | 54 ++++- 4 files changed, 376 insertions(+), 3 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 861ef22fe..f7c71daed 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -489,6 +489,14 @@ ProjectedNormal :show-inheritance: :member-order: bysource +SineBivariateVonMises +--------------------- +.. autoclass:: numpyro.distributions.directional.SineBivariateVonMises + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + VonMises ^^^^^^^^ .. autoclass:: numpyro.distributions.directional.VonMises diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 65e9d7bb9..428b40508 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -37,7 +37,11 @@ Uniform, Weibull, ) -from numpyro.distributions.directional import ProjectedNormal, VonMises +from numpyro.distributions.directional import ( + ProjectedNormal, + SineBivariateVonMises, + VonMises, +) from numpyro.distributions.discrete import ( Bernoulli, BernoulliLogits, @@ -145,6 +149,7 @@ "ProjectedNormal", "PRNGIdentity", "RightTruncatedDistribution", + "SineBivariateVonMises", "SoftLaplace", "StudentT", "TransformedDistribution", diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index 48cef64dc..f27126587 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -1,22 +1,80 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +from collections import namedtuple +import functools import math +from math import pi +import operator from jax import lax import jax.numpy as jnp import jax.random as random -from jax.scipy.special import erf, i0e, i1e +from jax.scipy import special +from jax.scipy.special import erf, i0e, i1e, logsumexp from numpyro.distributions import constraints from numpyro.distributions.distribution import Distribution from numpyro.distributions.util import ( is_prng_key, + lazy_property, promote_shapes, safe_normalize, validate_sample, von_mises_centered, ) +from numpyro.util import while_loop + + +def _numel(shape): + return functools.reduce(operator.mul, shape, 1) + + +def log_I1(orders: int, value, terms=250): + r"""Compute first n log modified bessel function of first kind + .. math :: + \log(I_v(z)) = v*\log(z/2) + \log(\sum_{k=0}^\inf \exp\left[2*k*\log(z/2) - \sum_kk^k log(kk) + - \lgamma(v + k + 1)\right]) + :param orders: orders of the log modified bessel function. + :param value: values to compute modified bessel function for + :param terms: truncation of summation + :return: 0 to orders modified bessel function + """ + orders = orders + 1 + if value.ndim == 0: + vshape = jnp.shape([1]) + else: + vshape = value.shape + value = value.reshape(-1, 1) + flat_vshape = _numel(vshape) + + k = jnp.arange(terms) + lgammas_all = special.gammaln(jnp.arange(1.0, terms + orders + 1)) + assert lgammas_all.shape == (orders + terms,) # lgamma(0) = inf => start from 1 + + lvalues = jnp.log(value / 2) * k.reshape(1, -1) + assert lvalues.shape == (flat_vshape, terms) + + lfactorials = lgammas_all[:terms] + assert lfactorials.shape == (terms,) + + lgammas = lgammas_all.tile(orders).reshape((orders, -1)) + assert lgammas.shape == (orders, terms + orders) # lgamma(0) = inf => start from 1 + + indices = k[:orders].reshape(-1, 1) + k.reshape(1, -1) + assert indices.shape == (orders, terms) + + seqs = logsumexp( + 2 * lvalues[None, :, :] + - lfactorials[None, None, :] + - jnp.take_along_axis(lgammas, indices, axis=1)[:, None, :], + -1, + ) + assert seqs.shape == (orders, flat_vshape) + + i1s = lvalues[..., :orders].T + seqs + assert i1s.shape == (orders, flat_vshape) + return i1s.reshape(-1, *vshape) class VonMises(Distribution): @@ -92,6 +150,256 @@ def variance(self): ) +PhiMarginalState = namedtuple("PhiMarginalState", ["i", "done", "phi", "key"]) + + +class SineBivariateVonMises(Distribution): + r"""Unimodal distribution of two dependent angles on the 2-torus (S^1 ⨂ S^1) given by + + .. math:: + C^{-1}\exp(\kappa_1\cos(x_1-\mu_1) + \kappa_2\cos(x_2 -\mu_2) + \rho\sin(x_1 - \mu_1)\sin(x_2 - \mu_2)) + + and + + .. math:: + C = (2\pi)^2 \sum_{i=0} {2i \choose i} + \left(\frac{\rho^2}{4\kappa_1\kappa_2}\right)^i I_i(\kappa_1)I_i(\kappa_2), + + where :math:`I_i(\cdot)` is the modified bessel function of first kind, mu's are the locations of the distribution, + kappa's are the concentration and rho gives the correlation between angles :math:`x_1` and :math:`x_2`. + This distribution is helpful for modeling coupled angles such as torsion angles in peptide chains. + + To infer parameters, use :class:`~numpyro.infer.hmc.NUTS` or :class:`~numpyro.infer.hmc.HMC` with priors that + avoid parameterizations where the distribution becomes bimodal; see note below. + + .. note:: Sample efficiency drops as + + .. math:: + \frac{\rho}{\kappa_1\kappa_2} \rightarrow 1 + + because the distribution becomes increasingly bimodal. + + .. note:: The correlation and weighted_correlation params are mutually exclusive. + + .. note:: In the context of :class:`~numpyro.infer.svi.SVI`, this distribution can be used as a likelihood but not + for latent variables. + + ** References: ** + 1. Probabilistic model for two dependent circular variables Singh, H., Hnizdo, V., and Demchuck, E. (2002) + + :param np.ndarray phi_loc: location of first angle + :param np.ndarray psi_loc: location of second angle + :param np.ndarray phi_concentration: concentration of first angle + :param np.ndarray psi_concentration: concentration of second angle + :param np.ndarray correlation: correlation between the two angles + :param np.ndarray weighted_correlation: set correlation to weigthed_corr * sqrt(phi_conc*psi_conc) + to avoid bimodality (see note). + """ + + arg_constraints = { + "phi_loc": constraints.circular, + "psi_loc": constraints.circular, + "phi_concentration": constraints.positive, + "psi_concentration": constraints.positive, + "correlation": constraints.real, + } + support = constraints.independent(constraints.circular, 1) + max_sample_iter = 1000 + + def __init__( + self, + phi_loc, + psi_loc, + phi_concentration, + psi_concentration, + correlation=None, + weighted_correlation=None, + validate_args=None, + ): + assert (correlation is None) != (weighted_correlation is None) + + if weighted_correlation is not None: + correlation = ( + weighted_correlation * jnp.sqrt(phi_concentration * psi_concentration) + + 1e-8 + ) + + ( + self.phi_loc, + self.psi_loc, + self.phi_concentration, + self.psi_concentration, + self.correlation, + ) = promote_shapes( + phi_loc, psi_loc, phi_concentration, psi_concentration, correlation + ) + batch_shape = lax.broadcast_shapes( + jnp.shape(phi_loc), + jnp.shape(psi_loc), + jnp.shape(phi_concentration), + jnp.shape(psi_concentration), + jnp.shape(correlation), + ) + super().__init__(batch_shape, (2,), validate_args) + + @lazy_property + def norm_const(self): + corr = jnp.reshape(self.correlation, (1, -1)) + 1e-8 + conc = jnp.stack( + (self.phi_concentration, self.psi_concentration), axis=-1 + ).reshape(-1, 2) + m = jnp.arange(50).reshape(-1, 1) + num = special.gammaln(2 * m + 1.0) + den = special.gammaln(m + 1.0) + lbinoms = num - 2 * den + + fs = ( + lbinoms.reshape(-1, 1) + + 2 * m * jnp.log(corr) + - m * jnp.log(4 * jnp.prod(conc, axis=-1)) + ) + fs += log_I1(49, conc, terms=51).sum(-1) + mfs = fs.max() + norm_const = 2 * jnp.log(jnp.array(2 * pi)) + mfs + logsumexp(fs - mfs, 0) + return norm_const.reshape(jnp.shape(self.phi_loc)) + + @validate_sample + def log_prob(self, value): + indv = self.phi_concentration * jnp.cos( + value[..., 0] - self.phi_loc + ) + self.psi_concentration * jnp.cos(value[..., 1] - self.psi_loc) + corr = ( + self.correlation + * jnp.sin(value[..., 0] - self.phi_loc) + * jnp.sin(value[..., 1] - self.psi_loc) + ) + return indv + corr - self.norm_const + + def sample(self, key, sample_shape=()): + """ + ** References: ** + 1. A New Unified Approach for the Simulation of aWide Class of Directional Distributions + John T. Kent, Asaad M. Ganeiber & Kanti V. Mardia (2018) + """ + assert is_prng_key(key) + phi_key, psi_key = random.split(key) + + corr = self.correlation + conc = jnp.stack((self.phi_concentration, self.psi_concentration)) + + eig = 0.5 * (conc[0] - corr ** 2 / conc[1]) + eig = jnp.stack((jnp.zeros_like(eig), eig)) + eigmin = jnp.where(eig[1] < 0, eig[1], jnp.zeros_like(eig[1], dtype=eig.dtype)) + eig = eig - eigmin + b0 = self._bfind(eig) + + total = _numel(sample_shape) + phi_den = log_I1(0, conc[1]).squeeze(0) + batch_size = _numel(self.batch_shape) + phi_shape = (total, 2, batch_size) + phi_state = SineBivariateVonMises._phi_marginal( + phi_shape, + phi_key, + jnp.reshape(conc, (2, batch_size)), + jnp.reshape(corr, (batch_size,)), + jnp.reshape(eig, (2, batch_size)), + jnp.reshape(b0, (batch_size,)), + jnp.reshape(eigmin, (batch_size,)), + jnp.reshape(phi_den, (batch_size,)), + ) + + phi = jnp.arctan2(phi_state.phi[:, 1:], phi_state.phi[:, :1]) + + alpha = jnp.sqrt(conc[1] ** 2 + (corr * jnp.sin(phi)) ** 2) + beta = jnp.arctan(corr / conc[1] * jnp.sin(phi)) + + psi = VonMises(beta, alpha).sample(psi_key) + + phi_psi = jnp.concatenate( + ( + (phi + self.phi_loc + pi) % (2 * pi) - pi, + (psi + self.psi_loc + pi) % (2 * pi) - pi, + ), + axis=1, + ) + phi_psi = jnp.transpose(phi_psi, (0, 2, 1)) + return phi_psi.reshape(*sample_shape, *self.batch_shape, *self.event_shape) + + @staticmethod + def _phi_marginal(shape, rng_key, conc, corr, eig, b0, eigmin, phi_den): + conc = jnp.broadcast_to(conc, shape) + eig = jnp.broadcast_to(eig, shape) + b0 = jnp.broadcast_to(b0, shape) + eigmin = jnp.broadcast_to(eigmin, shape) + phi_den = jnp.broadcast_to(phi_den, shape) + + def update_fn(curr): + i, done, phi, key = curr + phi_key, key = random.split(key) + accept_key, acg_key, phi_key = random.split(phi_key, 3) + + x = jnp.sqrt(1 + 2 * eig / b0) * random.normal(acg_key, shape) + x /= jnp.linalg.norm( + x, axis=1, keepdims=True + ) # Angular Central Gaussian distribution + + lf = ( + conc[:, :1] * (x[:, :1] - 1) + + eigmin + + log_I1( + 0, jnp.sqrt(conc[:, 1:] ** 2 + (corr * x[:, 1:]) ** 2) + ).squeeze(0) + - phi_den + ) + assert lf.shape == shape + + lg_inv = ( + 1.0 - b0 / 2 + jnp.log(b0 / 2 + (eig * x ** 2).sum(1, keepdims=True)) + ) + assert lg_inv.shape == lf.shape + + accepted = random.uniform(accept_key, shape) < jnp.exp(lf + lg_inv) + + phi = jnp.where(accepted, x, phi) + return PhiMarginalState(i + 1, done | accepted, phi, key) + + def cond_fn(curr): + return jnp.bitwise_and( + curr.i < SineBivariateVonMises.max_sample_iter, + jnp.logical_not(jnp.all(curr.done)), + ) + + phi_state = while_loop( + cond_fn, + update_fn, + PhiMarginalState( + i=jnp.array(0), + done=jnp.zeros(shape, dtype=bool), + phi=jnp.empty(shape, dtype=float), + key=rng_key, + ), + ) + return PhiMarginalState( + phi_state.i, phi_state.done, phi_state.phi, phi_state.key + ) + + @property + def mean(self): + """Computes circular mean of distribution. Note: same as location when mapped to support [-pi, pi]""" + mean = (jnp.stack((self.phi_loc, self.psi_loc), axis=-1) + jnp.pi) % ( + 2.0 * jnp.pi + ) - jnp.pi + print(mean.shape) + print(self.batch_shape) + return jnp.broadcast_to(mean, (*self.batch_shape, 2)) + + def _bfind(self, eig): + b = eig.shape[0] / 2 * jnp.ones(self.batch_shape, dtype=eig.dtype) + g1 = jnp.sum(1 / (b + 2 * eig) ** 2, axis=0) + g2 = jnp.sum(-2 / (b + 2 * eig) ** 3, axis=0) + return jnp.where(jnp.linalg.norm(eig, axis=0) != 0, b - g1 / g2, b) + + class ProjectedNormal(Distribution): """ Projected isotropic normal distribution of arbitrary dimension. diff --git a/test/test_distributions.py b/test/test_distributions.py index 5bcdbd242..5a827ba84 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -4,6 +4,7 @@ from collections import namedtuple from functools import partial import inspect +import math import os import numpy as np @@ -19,6 +20,7 @@ import numpyro.distributions as dist from numpyro.distributions import constraints, kl_divergence, transforms +from numpyro.distributions.directional import SineBivariateVonMises from numpyro.distributions.discrete import _to_probs_bernoulli, _to_probs_multinom from numpyro.distributions.flows import InverseAutoregressiveTransform from numpyro.distributions.gof import InvalidTest, auto_goodness_of_fit @@ -45,6 +47,12 @@ def _identity(x): return x +def _circ_mean(angles): + return jnp.arctan2( + jnp.mean(jnp.sin(angles), axis=0), jnp.mean(jnp.cos(angles), axis=0) + ) + + class T(namedtuple("TestCase", ["jax_dist", "sp_dist", "params"])): def __new__(cls, jax_dist, *params): sp_dist = get_sp_dist(jax_dist) @@ -333,6 +341,39 @@ def get_sp_dist(jax_dist): T(dist.VonMises, 2.0, 10.0), T(dist.VonMises, 2.0, jnp.array([150.0, 10.0])), T(dist.VonMises, jnp.array([1 / 3 * jnp.pi, -1.0]), jnp.array([20.0, 30.0])), + T( + SineBivariateVonMises, + jnp.array([0.0]), + jnp.array([0.0]), + jnp.array([5.0]), + jnp.array([6.0]), + jnp.array([2.0]), + ), + T( + SineBivariateVonMises, + jnp.array([3.003]), + jnp.array([-1.3430]), + jnp.array(5.0), + jnp.array([6.0]), + jnp.array([2.0]), + ), + T( + SineBivariateVonMises, + jnp.array(-1.232), + jnp.array(-1.3430), + jnp.array(3.4), + jnp.array(2.0), + jnp.array(1.0), + ), + T( + SineBivariateVonMises, + jnp.array([math.pi - 0.2, 1.0]), + jnp.array([0.0, 1.0]), + jnp.array([2.123, 20.0]), + jnp.array([7.0, 0.5]), + None, + jnp.array([0.2, 0.5]), + ), T(dist.ProjectedNormal, jnp.array([0.0, 0.0])), T(dist.ProjectedNormal, jnp.array([[2.0, 3.0]])), T(dist.ProjectedNormal, jnp.array([0.0, 0.0, 0.0])), @@ -1186,6 +1227,13 @@ def test_mean_var(jax_dist, sp_dist, params): expected_variance = 1 - jnp.sqrt(x ** 2 + y ** 2) assert_allclose(d_jax.variance, expected_variance, rtol=0.05, atol=1e-2) + elif jax_dist in [dist.SineBivariateVonMises]: + phi_loc = _circ_mean(samples[..., 0]) + psi_loc = _circ_mean(samples[..., 1]) + + assert_allclose( + d_jax.mean, jnp.stack((phi_loc, psi_loc), axis=-1), rtol=0.05, atol=1e-2 + ) else: if jnp.all(jnp.isfinite(d_jax.mean)): assert_allclose(jnp.mean(samples, 0), d_jax.mean, rtol=0.05, atol=1e-2) @@ -1220,6 +1268,11 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): continue if jax_dist is dist.GaussianRandomWalk and dist_args[i] == "num_steps": continue + if ( + jax_dist is dist.SineBivariateVonMises + and dist_args[i] == "weighted_correlation" + ): + continue if params[i] is None: oob_params[i] = None valid_params[i] = None @@ -1489,7 +1542,6 @@ def test_constraints(constraint, x, expected): ) @pytest.mark.parametrize("shape", [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) def test_biject_to(constraint, shape): - transform = biject_to(constraint) event_dim = transform.domain.event_dim if isinstance(constraint, constraints._Interval): From 9da69d2653a2dee77487e613046a7904c99fd29e Mon Sep 17 00:00:00 2001 From: Freddy Boulton Date: Fri, 20 Aug 2021 15:54:40 -0400 Subject: [PATCH 154/222] Recommend AutoNormal guide when hessian in AutoLaplace is singular (#1118) * Modify get_transform for Laplace guide * Recommend AutoNormal guide * Revert changes to imports * Lint * Revert change to test name --- numpyro/infer/autoguide.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 89bcf8349..24156b9fc 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -889,7 +889,7 @@ def loss_fn(z): warnings.warn( "Hessian of log posterior at the MAP point is singular. Posterior" " samples from AutoLaplaceApproxmiation will be constant (equal to" - " the MAP point)." + " the MAP point). Please consider using an AutoNormal guide." ) scale_tril = jnp.where(jnp.isnan(scale_tril), 0.0, scale_tril) return LowerCholeskyAffine(loc, scale_tril) From 5b34f22794fd0f555691a91c3ef0d238a4ecc079 Mon Sep 17 00:00:00 2001 From: Peter Roelants Date: Tue, 24 Aug 2021 04:04:35 +0200 Subject: [PATCH 155/222] Add MixtureSameFamily mixture distribution (#1123) --- docs/source/distributions.rst | 12 ++ numpyro/distributions/__init__.py | 2 + numpyro/distributions/mixtures.py | 211 +++++++++++++++++++++++++++++ test/test_distributions.py | 62 ++++++++- test/test_distributions_mixture.py | 130 ++++++++++++++++++ 5 files changed, 413 insertions(+), 4 deletions(-) create mode 100644 numpyro/distributions/mixtures.py create mode 100644 test/test_distributions_mixture.py diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index f7c71daed..71986741b 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -478,6 +478,18 @@ ZeroInflatedNegativeBinomial2 .. autofunction:: numpyro.distributions.conjugate.ZeroInflatedNegativeBinomial2 +Mixture Distributions +--------------------- + +MixtureSameFamily +^^^^^^^^^^^^^^^^^ +.. autoclass:: numpyro.distributions.mixtures.MixtureSameFamily + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + + Directional Distributions ------------------------- diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 428b40508..4a24d2880 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -76,6 +76,7 @@ Unit, ) from numpyro.distributions.kl import kl_divergence +from numpyro.distributions.mixtures import MixtureSameFamily from numpyro.distributions.transforms import biject_to from numpyro.distributions.truncated import ( LeftTruncatedDistribution, @@ -134,6 +135,7 @@ "Logistic", "LogNormal", "MaskedDistribution", + "MixtureSameFamily", "Multinomial", "MultinomialLogits", "MultinomialProbs", diff --git a/numpyro/distributions/mixtures.py b/numpyro/distributions/mixtures.py new file mode 100644 index 000000000..99b3b82ed --- /dev/null +++ b/numpyro/distributions/mixtures.py @@ -0,0 +1,211 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import jax +from jax import lax +import jax.numpy as jnp + +from numpyro.distributions import Distribution, constraints +from numpyro.distributions.discrete import CategoricalLogits, CategoricalProbs +from numpyro.distributions.util import is_prng_key, validate_sample + + +class MixtureSameFamily(Distribution): + """ + Marginalized Finite Mixture distribution of vectorized components. + + The components being a vectorized distribution implies that all components are from the same family, + represented by a single Distribution object. + + :param numpyro.distribution.Distribution mixing_distribution: + The mixing distribution to select the components. Needs to be a categorical. + :param numpyro.distribution.Distribution component_distribution: + Vectorized component distribution. + + As an example: + + .. doctest:: + + >>> import jax + >>> import jax.numpy as jnp + >>> import numpyro.distributions as dist + >>> mixing_dist = dist.Categorical(probs=jnp.ones(3) / 3.) + >>> component_dist = dist.Normal(loc=jnp.zeros(3), scale=jnp.ones(3)) + >>> mixture = dist.MixtureSameFamily(mixing_dist, component_dist) + >>> mixture.sample(jax.random.PRNGKey(42)).shape + () + """ + + def __init__(self, mixing_distribution, component_distribution, validate_args=None): + # Check arguments + if not isinstance(mixing_distribution, (CategoricalLogits, CategoricalProbs)): + raise ValueError( + "The mixing distribution need to be a numpyro.distributions.Categorical. " + f"However, it is of type {type(mixing_distribution)}" + ) + mixture_size = mixing_distribution.probs.shape[-1] + if not isinstance(component_distribution, Distribution): + raise ValueError( + "The component distribution need to be a numpyro.distributions.Distribution. " + f"However, it is of type {type(component_distribution)}" + ) + assert component_distribution.batch_shape[-1] == mixture_size, ( + "Component distribution batch shape last dimension " + f"(size={component_distribution.batch_shape[-1]}) " + "needs to correspond to the mixture_size={mixture_size}!" + ) + # Assign checked arguments + self._mixing_distribution = mixing_distribution + self._component_distribution = component_distribution + self._mixture_size = mixture_size + batch_shape = lax.broadcast_shapes( + mixing_distribution.batch_shape, + component_distribution.batch_shape[:-1], # Without probabilities + ) + super().__init__( + batch_shape=batch_shape, + event_shape=component_distribution.event_shape, + validate_args=validate_args, + ) + + @property + def mixture_size(self): + """ + Returns the number of distributions in the mixture + + :return: number of mixtures. + :rtype: int + """ + return self._mixture_size + + @property + def mixing_distribution(self): + """ + Returns the mixing distribution + + :return: Categorical distribution + :rtype: Categorical + """ + return self._mixing_distribution + + @property + def mixture_dim(self): + return -self.event_dim - 1 + + @property + def component_distribution(self): + """ + Return the vectorized distribution of components being mixed. + + :return: Component distribution + :rtype: Distribution + """ + return self._component_distribution + + @constraints.dependent_property + def support(self): + return self.component_distribution.support + + @property + def is_discrete(self): + return self.component_distribution.is_discrete + + def tree_flatten(self): + mixing_flat, mixing_aux = self.mixing_distribution.tree_flatten() + component_flat, component_aux = self.component_distribution.tree_flatten() + params = (mixing_flat, component_flat) + aux_data = ( + (type(self.mixing_distribution), type(self.component_distribution)), + (mixing_aux, component_aux), + ) + return params, aux_data + + @classmethod + def tree_unflatten(cls, aux_data, params): + mixing_params, component_params = params + child_clss, child_aux = aux_data + mixing_cls, component_cls = child_clss + mixing_aux, component_aux = child_aux + mixing_dist = mixing_cls.tree_unflatten(mixing_aux, mixing_params) + component_dist = component_cls.tree_unflatten(component_aux, component_params) + return cls( + mixing_distribution=mixing_dist, component_distribution=component_dist + ) + + @property + def mean(self): + probs = self.mixing_distribution.probs + probs = probs.reshape(probs.shape + (1,) * self.event_dim) + weighted_component_means = probs * self.component_distribution.mean + return jnp.sum(weighted_component_means, axis=self.mixture_dim) + + @property + def variance(self): + probs = self.mixing_distribution.probs + probs = probs.reshape(probs.shape + (1,) * self.event_dim) + # E[Var(Y|X)] + mean_cond_var = jnp.sum( + probs * self.component_distribution.variance, axis=self.mixture_dim + ) + # Variance is the expectation of the squared deviation of a random variable from its mean + sq_deviation = ( + self.component_distribution.mean + - jnp.expand_dims(self.mean, axis=self.mixture_dim) + ) ** 2 + # Var(E[Y|X]) + var_cond_mean = jnp.sum(probs * sq_deviation, axis=self.mixture_dim) + # Law of total variance: Var(Y) = E[Var(Y|X)] + Var(E[Y|X]) + return mean_cond_var + var_cond_mean + + def cdf(self, samples): + """ + The cumulative distribution function of this mixture distribution. + + :param value: samples from this distribution. + :return: output of the cummulative distribution function evaluated at `value`. + :raises: NotImplementedError if the component distribution does not implement the cdf method. + """ + cdf_components = self.component_distribution.cdf( + jnp.expand_dims(samples, axis=self.mixture_dim) + ) + return jnp.sum(cdf_components * self.mixing_distribution.probs, axis=-1) + + def sample_with_intermediates(self, key, sample_shape=()): + """ + Same as ``sample`` except that the sampled mixture components are also returned. + + :param jax.random.PRNGKey key: the rng_key key to be used for the distribution. + :param tuple sample_shape: the sample shape for the distribution. + :return: Tuple (samples, indices) + :rtype: tuple + """ + assert is_prng_key(key) + key_comp, key_ind = jax.random.split(key) + # Samples from component distribution will have shape: + # (*sample_shape, *batch_shape, mixture_size, *event_shape) + samples = self.component_distribution.expand( + sample_shape + self.batch_shape + (self.mixture_size,) + ).sample(key_comp) + # Sample selection indices from the categorical (shape will be sample_shape) + indices = self.mixing_distribution.expand( + sample_shape + self.batch_shape + ).sample(key_ind) + n_expand = self.event_dim + 1 + indices_expanded = indices.reshape(indices.shape + (1,) * n_expand) + # Select samples according to indices samples from categorical + samples_selected = jnp.take_along_axis( + samples, indices=indices_expanded, axis=self.mixture_dim + ) + # Final sample shape (*sample_shape, *batch_shape, *event_shape) + return jnp.squeeze(samples_selected, axis=self.mixture_dim), indices + + def sample(self, key, sample_shape=()): + return self.sample_with_intermediates(key=key, sample_shape=sample_shape)[0] + + @validate_sample + def log_prob(self, value, intermediates=None): + del intermediates + value = jnp.expand_dims(value, self.mixture_dim) + component_log_probs = self.component_distribution.log_prob(value) + sum_log_probs = self.mixing_distribution.logits + component_log_probs + return jax.nn.logsumexp(sum_log_probs, axis=-1) diff --git a/test/test_distributions.py b/test/test_distributions.py index 5a827ba84..5aa9d2fbe 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -94,6 +94,34 @@ def _TruncatedNormal(loc, scale, low, high): _TruncatedNormal.infer_shapes = lambda *args: (lax.broadcast_shapes(*args), ()) +def _GaussianMixture(mixing_probs, loc, scale): + component_dist = dist.Normal(loc=loc, scale=scale) + mixing_distribution = dist.Categorical(probs=mixing_probs) + return dist.MixtureSameFamily( + mixing_distribution=mixing_distribution, + component_distribution=component_dist, + ) + + +_GaussianMixture.arg_constraints = {} +_GaussianMixture.reparametrized_params = [] +_GaussianMixture.infer_shapes = lambda *args: (lax.broadcast_shapes(*args), ()) + + +def _Gaussian2DMixture(mixing_probs, loc, cov_matrix): + component_dist = dist.MultivariateNormal(loc=loc, covariance_matrix=cov_matrix) + mixing_distribution = dist.Categorical(probs=mixing_probs) + return dist.MixtureSameFamily( + mixing_distribution=mixing_distribution, + component_distribution=component_dist, + ) + + +_Gaussian2DMixture.arg_constraints = {} +_Gaussian2DMixture.reparametrized_params = [] +_Gaussian2DMixture.infer_shapes = lambda *args: (lax.broadcast_shapes(*args), ()) + + class _ImproperWrapper(dist.ImproperUniform): def sample(self, key, sample_shape=()): transform = biject_to(self.support) @@ -335,6 +363,33 @@ def get_sp_dist(jax_dist): T(dist.Weibull, 0.2, 1.1), T(dist.Weibull, 2.8, jnp.array([2.0, 2.0])), T(dist.Weibull, 1.8, jnp.array([[1.0, 1.0], [2.0, 2.0]])), + T( + _GaussianMixture, + jnp.ones(3) / 3.0, + jnp.array([0.0, 7.7, 2.1]), + jnp.array([4.2, 7.7, 2.1]), + ), + T( + _Gaussian2DMixture, + jnp.array([0.2, 0.5, 0.3]), + jnp.array([[-1.2, 1.5], [2.0, 2.0], [-1, 4.0]]), # Mean + jnp.array( + [ + [ + [0.1, -0.2], + [-0.2, 1.0], + ], + [ + [0.75, 0.0], + [0.0, 0.75], + ], + [ + [1.0, 0.5], + [0.5, 0.27], + ], + ] + ), # Covariance + ), ] DIRECTIONAL = [ @@ -594,11 +649,10 @@ def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): ) -@pytest.mark.parametrize("prepend_shape", [(), (2,), (2, 3)], ids=str) @pytest.mark.parametrize( "jax_dist, sp_dist, params", CONTINUOUS + DISCRETE + DIRECTIONAL ) -def test_infer_shapes(jax_dist, sp_dist, params, prepend_shape): +def test_infer_shapes(jax_dist, sp_dist, params): shapes = tuple(getattr(p, "shape", ()) for p in params) shapes = tuple(x() if callable(x) else x for x in shapes) jax_dist = jax_dist(*params) @@ -1248,8 +1302,8 @@ def test_mean_var(jax_dist, sp_dist, params): ) @pytest.mark.parametrize("prepend_shape", [(), (2,), (2, 3)]) def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): - if jax_dist is _TruncatedNormal: - pytest.skip("_TruncatedNormal is a function, not a class") + if jax_dist in (_TruncatedNormal, _GaussianMixture, _Gaussian2DMixture): + pytest.skip(f"{jax_dist.__name__} is a function, not a class") dist_args = [p for p in inspect.getfullargspec(jax_dist.__init__)[0][1:]] valid_params, oob_params = list(params), list(params) diff --git a/test/test_distributions_mixture.py b/test/test_distributions_mixture.py new file mode 100644 index 000000000..c9621f0fa --- /dev/null +++ b/test/test_distributions_mixture.py @@ -0,0 +1,130 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import pytest + +import jax +import jax.numpy as jnp + +import numpyro.distributions as dist + +rng_key = jax.random.PRNGKey(42) + + +def get_normal(nb_mixtures, batch_shape): + """Get parameterized Normal with given batch shape.""" + loc = jnp.zeros(nb_mixtures) + scale = jnp.ones(nb_mixtures) + for i, s in enumerate(batch_shape): + loc = jnp.repeat(jnp.expand_dims(loc, i), s, axis=i) + scale = jnp.repeat(jnp.expand_dims(scale, i), s, axis=i) + batch_shape = (*batch_shape, nb_mixtures) + normal = dist.Normal(loc=loc, scale=scale) + assert normal.batch_shape == batch_shape + return normal + + +def get_mvn(nb_mixtures, batch_shape): + """Get parameterized MultivariateNormal with given batch shape.""" + dimensions = 2 + loc = jnp.zeros((nb_mixtures, dimensions)) + cov_matrix = jnp.repeat( + jnp.expand_dims(jnp.eye(dimensions, dimensions), 0), nb_mixtures, axis=0 + ) + for i, s in enumerate(batch_shape): + loc = jnp.repeat(jnp.expand_dims(loc, i), s, axis=i) + cov_matrix = jnp.repeat(jnp.expand_dims(cov_matrix, i), s, axis=i) + batch_shape = (*batch_shape, nb_mixtures) + mvn = dist.MultivariateNormal(loc=loc, covariance_matrix=cov_matrix) + assert mvn.batch_shape == batch_shape + return mvn + + +@pytest.mark.parametrize("jax_dist_getter", [get_normal, get_mvn]) +@pytest.mark.parametrize("nb_mixtures", [1, 3]) +@pytest.mark.parametrize("batch_shape", [(), (1,), (7,), (2, 5)]) +def test_mixture_same_family_same_batch_shape( + jax_dist_getter, nb_mixtures, batch_shape +): + # Create mixture + mixing_probabilities = jnp.ones(nb_mixtures) / nb_mixtures + for i, s in enumerate(batch_shape): + mixing_probabilities = jnp.repeat( + jnp.expand_dims(mixing_probabilities, i), s, axis=i + ) + assert jnp.allclose(mixing_probabilities.sum(axis=-1), 1.0) + component_distribution = jax_dist_getter( + nb_mixtures=nb_mixtures, batch_shape=batch_shape + ) + mixing_distribution = dist.Categorical(probs=mixing_probabilities) + _test_mixture_same_family(mixing_distribution, component_distribution) + + +@pytest.mark.parametrize("jax_dist_getter", [get_normal, get_mvn]) +@pytest.mark.parametrize("nb_mixtures", [3]) +@pytest.mark.parametrize("mixing_batch_shape, component_batch_shape", [[(2,), (7, 2)]]) +def test_mixture_same_family_broadcast_batch_shape( + jax_dist_getter, nb_mixtures, mixing_batch_shape, component_batch_shape +): + # Create mixture + mixing_probabilities = jnp.ones(nb_mixtures) / nb_mixtures + for i, s in enumerate(mixing_batch_shape): + mixing_probabilities = jnp.repeat( + jnp.expand_dims(mixing_probabilities, i), s, axis=i + ) + assert jnp.allclose(mixing_probabilities.sum(axis=-1), 1.0) + component_distribution = jax_dist_getter( + nb_mixtures=nb_mixtures, batch_shape=component_batch_shape + ) + mixing_distribution = dist.Categorical(probs=mixing_probabilities) + _test_mixture_same_family(mixing_distribution, component_distribution) + + +def _test_mixture_same_family(mixing_distribution, component_distribution): + # Create mixture + mixture = dist.MixtureSameFamily( + mixing_distribution=mixing_distribution, + component_distribution=component_distribution, + ) + assert ( + mixture.mixture_size == mixing_distribution.probs.shape[-1] + ), "Mixture size needs to be the size of the probability vector" + assert ( + mixture.batch_shape == component_distribution.batch_shape[:-1] + ), "Mixture batch shape needs to be the component batch shape without the mixture dimension." + # Test samples + sample_shape = (11,) + # Samples from component distribution + component_samples = mixture.component_distribution.sample(rng_key, sample_shape) + assert component_samples.shape == ( + *sample_shape, + *mixture.batch_shape, + mixture.mixture_size, + *mixture.event_shape, + ) + # Samples from mixture + samples = mixture.sample(rng_key, sample_shape=sample_shape) + assert samples.shape == (*sample_shape, *mixture.batch_shape, *mixture.event_shape) + # Check log_prob + lp = mixture.log_prob(samples) + nb_value_dims = len(samples.shape) - mixture.event_dim + expected_shape = samples.shape[:nb_value_dims] + assert lp.shape == expected_shape + # Samples with indices + samples_, indices = mixture.sample_with_intermediates( + rng_key, sample_shape=sample_shape + ) + assert samples_.shape == samples.shape + assert indices.shape == (*sample_shape, *mixture.batch_shape) + assert jnp.issubdtype(indices.dtype, jnp.integer) + assert (indices >= 0).all() and (indices < mixture.mixture_size).all() + # Check mean + mean = mixture.mean + assert mean.shape == mixture.shape() + # Check variance + var = mixture.variance + assert var.shape == mixture.shape() + # Check cdf + if isinstance(mixture.component_distribution, dist.Normal): + cdf = mixture.cdf(samples) + assert cdf.shape == (*sample_shape, *mixture.shape()) From e18ec045222e97421bcee934be6181dac5466aec Mon Sep 17 00:00:00 2001 From: Prashin Jethwa <34376548+prashjet@users.noreply.github.com> Date: Tue, 24 Aug 2021 15:56:55 +0200 Subject: [PATCH 156/222] Docsting note for `MCMCKernel.postprocess_fn` (#1128) * Docsting note for `MCMCKernel.postprocess_fn` * Move note from `MCMCKernel.postprocess_fn` to `HMC` and `NUTS`. --- numpyro/infer/hmc.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index f424e0b63..4be8cb645 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -511,6 +511,8 @@ class HMC(MCMCKernel): Hamiltonian Monte Carlo inference, using fixed trajectory length, with provision for step size and mass matrix adaptation. + .. note:: until the kernel is used in an MCMC run, `postprocess_fn` will return the identity + **References:** 1. *MCMC Using Hamiltonian Dynamics*, @@ -766,6 +768,8 @@ class NUTS(HMC): Hamiltonian Monte Carlo inference, using the No U-Turn Sampler (NUTS) with adaptive path length and mass matrix adaptation. + .. note:: until the kernel is used in an MCMC run, `postprocess_fn` will return the identity + **References:** 1. *MCMC Using Hamiltonian Dynamics*, From 91b830f71259602a1b6dd0fdee476744f7ffae59 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Wed, 25 Aug 2021 19:52:53 -0700 Subject: [PATCH 157/222] add AutoDAIS guide (#1132) * initial commit of autodais.py * add a prototype for autodais * make beta bernoulli test pass * add more args * fix bug at soft_vmap for empty tensor * support arbitrary sample_shape * lint * remove unnecessary momentum sample * add betas to autodais * expand docstring * add subsample error * convert np.prod result to int * add test_autodais_subsampling_error * lint * add dais_demo.py * tweak dais_demo * lint * add dais_demo.png * add to test_examples.py * update png * lint * add to rst * tweaks * fix path * address review * try to appease sphinx Co-authored-by: Du Phan --- docs/source/_static/img/dais_demo.png | Bin 0 -> 83898 bytes docs/source/autoguide.rst | 8 ++ docs/source/index.rst | 1 + examples/dais_demo.py | 174 ++++++++++++++++++++++++ numpyro/infer/autoguide.py | 189 +++++++++++++++++++++++++- numpyro/infer/elbo.py | 2 +- numpyro/util.py | 7 +- test/infer/test_autoguide.py | 29 +++- test/test_examples.py | 1 + 9 files changed, 403 insertions(+), 8 deletions(-) create mode 100644 docs/source/_static/img/dais_demo.png create mode 100644 examples/dais_demo.py diff --git a/docs/source/_static/img/dais_demo.png b/docs/source/_static/img/dais_demo.png new file mode 100644 index 0000000000000000000000000000000000000000..aaaabbfcd73f174499a2d68943f581f5ac72d243 GIT binary patch literal 83898 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    )e7=CxAHeEB%m6{n&Rn95z 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 hjqkbt<5ATf= 1000: + sns.set_style("white") + + coord1, coord2 = 0, 1 + + fig, axes = plt.subplots( + 2, 2, sharex=True, figsize=(6, 6), constrained_layout=True + ) + + xlim = (-3, 3) + ylim = (-3, 3) + + def add_fig(samples, title, ax): + sns.kdeplot(x=samples["f"][:, coord1], y=samples["f"][:, coord2], ax=ax) + ax.set(title=title, xlim=xlim, ylim=ylim) + + add_fig(dais8_samples, "AutoDAIS (K=8)", axes[0][0]) + add_fig(dais128_samples, "AutoDAIS (K=128)", axes[0][1]) + add_fig(meanfield_samples, "AutoDiagonalNormal", axes[1][0]) + add_fig(nuts_samples, "NUTS", axes[1][1]) + + plt.savefig("dais_demo.png") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser("Usage example for AutoDAIS guide.") + parser.add_argument("--num-svi-steps", type=int, default=80 * 1000) + parser.add_argument("--num-warmup", type=int, default=2000) + parser.add_argument("--num-samples", type=int, default=10 * 1000) + parser.add_argument("--device", default="cpu", type=str, choices=["cpu", "gpu"]) + + args = parser.parse_args() + + enable_x64() + numpyro.set_platform(args.device) + + main(args) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 24156b9fc..96f631c8b 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -8,7 +8,8 @@ import numpy as np -from jax import hessian, lax, random, tree_map +import jax +from jax import grad, hessian, lax, random, tree_map from jax.experimental import stax from jax.flatten_util import ravel_pytree import jax.numpy as jnp @@ -45,6 +46,7 @@ __all__ = [ "AutoContinuous", "AutoGuide", + "AutoDAIS", "AutoDiagonalNormal", "AutoLaplaceApproximation", "AutoLowRankMultivariateNormal", @@ -133,7 +135,7 @@ def _setup_prototype(self, *args, **kwargs): with handlers.block(): ( init_params, - _, + self._potential_fn, self._postprocess_fn, self.prototype_trace, ) = initialize_model( @@ -608,6 +610,189 @@ def sample_posterior(self, rng_key, params, sample_shape=()): return self._unpack_and_constrain(latent_sample, params) +class AutoDAIS(AutoContinuous): + """ + This implementation of :class:`AutoDAIS` uses Differentiable Annealed + Importance Sampling (DAIS) [1, 2] to construct a guide over the entire + latent space. Samples from the variational distribution (i.e. guide) + are generated using a combination of (uncorrected) Hamiltonian Monte Carlo + and Annealed Importance Sampling. The same algorithm is called Uncorrected + Hamiltonian Annealing in [1]. + + Note that AutoDAIS cannot be used in conjuction with data subsampling. + + **Reference:** + + 1. *MCMC Variational Inference via Uncorrected Hamiltonian Annealing*, + Tomas Geffner, Justin Domke + 2. *Differentiable Annealed Importance Sampling and the Perils of Gradient Noise*, + Guodong Zhang, Kyle Hsu, Jianing Li, Chelsea Finn, Roger Grosse + + Usage:: + + guide = AutoDAIS(model) + svi = SVI(model, guide, ...) + + :param callable model: A NumPyro model. + :param str prefix: A prefix that will be prefixed to all param internal sites. + :param int K: A positive integer that controls the number of HMC steps used. + Defaults to 8. + :param float eta_init: The initial value of the step size used in HMC. Defaults + to 0.01. + :param float eta_max: The maximum value of the learnable step size used in HMC. + Defaults to 0.1. + :param float gamma_init: The initial value of the learnable damping factor used + during partial momentum refreshments in HMC. Defaults to 0.9. + :param callable init_loc_fn: A per-site initialization function. + See :ref:`init_strategy` section for available functions. + :param float init_scale: Initial scale for the standard deviation of + the base variational distribution for each (unconstrained transformed) + latent variable. Defaults to 0.1. + """ + + def __init__( + self, + model, + *, + K=8, + eta_init=0.01, + eta_max=0.1, + gamma_init=0.9, + prefix="auto", + init_loc_fn=init_to_uniform, + init_scale=0.1, + ): + if K < 1: + raise ValueError("K must satisfy K >= 1 (got K = {})".format(K)) + if eta_init <= 0.0 or eta_init >= eta_max: + raise ValueError( + "eta_init must be positive and satisfy eta_init < eta_max." + ) + if eta_max <= 0.0: + raise ValueError("eta_max must be positive.") + if gamma_init <= 0.0 or gamma_init >= 1.0: + raise ValueError("gamma_init must be in the open interval (0, 1).") + if init_scale <= 0.0: + raise ValueError("init_scale must be positive.") + + self.eta_init = eta_init + self.eta_max = eta_max + self.gamma_init = gamma_init + self.K = K + self._init_scale = init_scale + super().__init__(model, prefix=prefix, init_loc_fn=init_loc_fn) + + def _setup_prototype(self, *args, **kwargs): + super()._setup_prototype(*args, **kwargs) + + for name, site in self.prototype_trace.items(): + if ( + site["type"] == "plate" + and isinstance(site["args"][1], int) + and site["args"][0] > site["args"][1] + ): + raise NotImplementedError( + "AutoDAIS cannot be used in conjuction with data subsampling." + ) + + def _get_posterior(self): + raise NotImplementedError + + def _sample_latent(self, *args, **kwargs): + def log_density(x): + x_unpack = self._unpack_latent(x) + with numpyro.handlers.block(): + return -self._potential_fn(x_unpack) + + eta0 = numpyro.param( + "{}_eta0".format(self.prefix), + self.eta_init, + constraint=constraints.interval(0, self.eta_max), + ) + eta_coeff = numpyro.param("{}_eta_coeff".format(self.prefix), 0.00) + + gamma = numpyro.param( + "{}_gamma".format(self.prefix), + self.gamma_init, + constraint=constraints.interval(0, 1), + ) + betas = numpyro.param( + "{}_beta_increments".format(self.prefix), + jnp.ones(self.K), + constraint=constraints.positive, + ) + betas = jnp.cumsum(betas) + betas = betas / betas[-1] # K-dimensional with betas[-1] = 1 + + mass_matrix = numpyro.param( + "{}_mass_matrix".format(self.prefix), + jnp.ones(self.latent_dim), + constraint=constraints.positive, + ) + inv_mass_matrix = 0.5 / mass_matrix + + init_z_loc = numpyro.param( + "{}_z_0_loc".format(self.prefix), jnp.zeros(self.latent_dim) + ) + init_z_scale = numpyro.param( + "{}_z_0_scale".format(self.prefix), + jnp.full(self.latent_dim, self._init_scale), + constraint=constraints.positive, + ) + + base_z_dist = dist.Normal(init_z_loc, init_z_scale).to_event() + z_0 = numpyro.sample( + "{}_z_0".format(self.prefix), + base_z_dist, + infer={"is_auxiliary": True}, + ) + momentum_dist = dist.Normal(0, mass_matrix).to_event() + eps = numpyro.sample( + "{}_momentum".format(self.prefix), + momentum_dist.expand((self.K,)).to_event().mask(False), + infer={"is_auxiliary": True}, + ) + + def scan_body(carry, eps_beta): + eps, beta = eps_beta + eta = eta0 + eta_coeff * beta + eta = jnp.clip(eta, a_min=0.0, a_max=self.eta_max) + z_prev, v_prev, log_factor = carry + z_half = z_prev + v_prev * eta * inv_mass_matrix + q_grad = (1.0 - beta) * grad(base_z_dist.log_prob)(z_half) + p_grad = beta * grad(log_density)(z_half) + v_hat = v_prev + eta * (q_grad + p_grad) + z = z_half + v_hat * eta * inv_mass_matrix + v = gamma * v_hat + jnp.sqrt(1 - gamma ** 2) * eps + delta_ke = momentum_dist.log_prob(v_prev) - momentum_dist.log_prob(v_hat) + log_factor = log_factor + delta_ke + return (z, v, log_factor), None + + v_0 = eps[-1] # note the return value of scan doesn't depend on eps[-1] + (z, _, log_factor), _ = jax.lax.scan(scan_body, (z_0, v_0, 0.0), (eps, betas)) + + numpyro.factor("{}_factor".format(self.prefix), log_factor) + + return z + + def sample_posterior(self, rng_key, params, sample_shape=()): + def _single_sample(_rng_key): + latent_sample = handlers.substitute( + handlers.seed(self._sample_latent, _rng_key), params + )(sample_shape=()) + return self._unpack_and_constrain(latent_sample, params) + + if sample_shape: + rng_key = random.split(rng_key, int(np.prod(sample_shape))) + samples = lax.map(_single_sample, rng_key) + return tree_map( + lambda x: jnp.reshape(x, sample_shape + jnp.shape(x)[1:]), + samples, + ) + else: + return _single_sample(rng_key) + + class AutoDiagonalNormal(AutoContinuous): """ This implementation of :class:`AutoContinuous` uses a Normal distribution diff --git a/numpyro/infer/elbo.py b/numpyro/infer/elbo.py index 879778a57..34ae516e9 100644 --- a/numpyro/infer/elbo.py +++ b/numpyro/infer/elbo.py @@ -258,7 +258,7 @@ def single_particle_elbo(rng_key): # handle auxiliary sites in the guide for name, site in guide_trace.items(): if site["type"] == "sample" and name not in model_trace: - assert site["infer"].get("is_auxiliary") + assert site["infer"].get("is_auxiliary") or site["is_observed"] elbo_particle = elbo_particle - _get_log_prob_sum(site) if mutable_params: diff --git a/numpyro/util.py b/numpyro/util.py index f26933b93..d635101b9 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -382,7 +382,7 @@ def soft_vmap(fn, xs, batch_ndims=1, chunk_size=None): # we'll do map(vmap(fn), xs) and make xs.shape = (num_chunks, chunk_size, ...) num_chunks = batch_size = int(np.prod(batch_shape)) - prepend_shape = (-1,) if batch_size > 1 else () + prepend_shape = (batch_size,) if batch_size > 1 else () xs = tree_map( lambda x: jnp.reshape(x, prepend_shape + jnp.shape(x)[batch_ndims:]), xs ) @@ -405,7 +405,10 @@ def soft_vmap(fn, xs, batch_ndims=1, chunk_size=None): ys = lax.map(fn, xs) if num_chunks > 1 else fn(xs) map_ndims = int(num_chunks > 1) + int(chunk_size > 1) ys = tree_map( - lambda y: jnp.reshape(y, (-1,) + jnp.shape(y)[map_ndims:])[:batch_size], ys + lambda y: jnp.reshape( + y, (int(np.prod(jnp.shape(y)[:map_ndims])),) + jnp.shape(y)[map_ndims:] + )[:batch_size], + ys, ) return tree_map(lambda y: jnp.reshape(y, batch_shape + jnp.shape(y)[1:]), ys) diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 5f162d5e6..d27553219 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -21,6 +21,7 @@ from numpyro.infer import SVI, Trace_ELBO, TraceMeanField_ELBO from numpyro.infer.autoguide import ( AutoBNAFNormal, + AutoDAIS, AutoDelta, AutoDiagonalNormal, AutoIAFNormal, @@ -47,6 +48,7 @@ "auto_class", [ AutoDiagonalNormal, + AutoDAIS, AutoIAFNormal, AutoBNAFNormal, AutoMultivariateNormal, @@ -74,14 +76,16 @@ def body_fn(i, val): svi_state = fori_loop(0, 3000, body_fn, svi_state) params = svi.get_params(svi_state) + true_coefs = (jnp.sum(data, axis=0) + 1) / (data.shape[0] + 2) # test .sample_posterior method posterior_samples = guide.sample_posterior( random.PRNGKey(1), params, sample_shape=(1000,) ) - assert_allclose(jnp.mean(posterior_samples["beta"], 0), true_coefs, atol=0.05) + posterior_mean = jnp.mean(posterior_samples["beta"], 0) + assert_allclose(posterior_mean, true_coefs, atol=0.05) - if auto_class not in [AutoDelta, AutoIAFNormal, AutoBNAFNormal]: + if auto_class not in [AutoDAIS, AutoDelta, AutoIAFNormal, AutoBNAFNormal]: quantiles = guide.quantiles(params, [0.2, 0.5, 0.8]) assert quantiles["beta"].shape == (3, 2) @@ -101,6 +105,7 @@ def body_fn(i, val): [ AutoDiagonalNormal, AutoIAFNormal, + AutoDAIS, AutoBNAFNormal, AutoMultivariateNormal, AutoLaplaceApproximation, @@ -142,7 +147,7 @@ def body_fn(i, val): svi_state = fori_loop(0, 2000, body_fn, svi_state) params = svi.get_params(svi_state) - if auto_class not in (AutoIAFNormal, AutoBNAFNormal): + if auto_class not in (AutoDAIS, AutoIAFNormal, AutoBNAFNormal): median = guide.median(params) assert_allclose(median["coefs"], true_coefs, rtol=0.1) # test .quantile method @@ -570,3 +575,21 @@ def model(): guide = auto_class(model, init_loc_fn=init_loc_fn) with pytest.raises(ValueError, match=".*ProjectedNormalReparam.*"): handlers.seed(guide, 0)() + + +def test_autodais_subsampling_error(): + data = jnp.array([1.0] * 8 + [0.0] * 2) + + def model(data): + with numpyro.plate("plate", 20, 10, dim=-1): + f = numpyro.sample( + "beta", dist.Beta(jnp.ones(data.shape), jnp.ones(data.shape)) + ) + numpyro.sample("obs", dist.Bernoulli(f), obs=data) + + adam = optim.Adam(0.01) + guide = AutoDAIS(model) + svi = SVI(model, guide, adam, Trace_ELBO()) + + with pytest.raises(NotImplementedError, match=".*data subsampling.*"): + svi.init(random.PRNGKey(1), data) diff --git a/test/test_examples.py b/test/test_examples.py index e35094f80..11c8dd96a 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -22,6 +22,7 @@ "capture_recapture.py --num-samples 4 --num-warmup 1 -m 3", "capture_recapture.py --num-samples 4 --num-warmup 1 -m 5", "covtype.py --algo HMC --num-samples 10 --num-warmup 10", + "dais_demo.py --num-svi-steps 10 --num-samples 10 --num-warmup 10", "gaussian_shells.py --num-samples 100", "gaussian_shells.py --num-samples 100 --enum", "gp.py --num-samples 10 --num-warmup 10 --num-chains 2", From f6f178d12483126021196bf87a4095e504e15d87 Mon Sep 17 00:00:00 2001 From: David Diaz Date: Wed, 25 Aug 2021 19:53:08 -0700 Subject: [PATCH 158/222] Adds model paramter to SA (#1136) --- numpyro/infer/sa.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/numpyro/infer/sa.py b/numpyro/infer/sa.py index 999aa4b50..15fd03f1f 100644 --- a/numpyro/infer/sa.py +++ b/numpyro/infer/sa.py @@ -365,6 +365,10 @@ def init( self._sample_fn = sample_fn return init_state + @property + def model(self): + return self._model + @property def sample_field(self): return "z" From 752fda237eaf0b5d3e10d56d27135053ec30ac3a Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Sun, 29 Aug 2021 08:01:47 -0700 Subject: [PATCH 159/222] add base_dist arg to AutoDAIS (#1138) * add base_dist arg to AutoDAIS * address review --- numpyro/infer/autoguide.py | 28 ++++++++++++++++++++++------ test/infer/test_autoguide.py | 5 ++++- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 96f631c8b..8a03163f0 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -637,6 +637,9 @@ class AutoDAIS(AutoContinuous): :param str prefix: A prefix that will be prefixed to all param internal sites. :param int K: A positive integer that controls the number of HMC steps used. Defaults to 8. + :param str base_dist: Controls whether the base Normal variational distribution + is parameterized by a "diagonal" covariance matrix or a full-rank covariance + matrix parameterized by a lower-diagonal "cholesky" factor. Defaults to "diagonal". :param float eta_init: The initial value of the step size used in HMC. Defaults to 0.01. :param float eta_max: The maximum value of the learnable step size used in HMC. @@ -655,6 +658,7 @@ def __init__( model, *, K=8, + base_dist="diagonal", eta_init=0.01, eta_max=0.1, gamma_init=0.9, @@ -664,6 +668,8 @@ def __init__( ): if K < 1: raise ValueError("K must satisfy K >= 1 (got K = {})".format(K)) + if base_dist not in ["diagonal", "cholesky"]: + raise ValueError('base_dist must be one of "diagonal" or "cholesky".') if eta_init <= 0.0 or eta_init >= eta_max: raise ValueError( "eta_init must be positive and satisfy eta_init < eta_max." @@ -679,6 +685,7 @@ def __init__( self.eta_max = eta_max self.gamma_init = gamma_init self.K = K + self.base_dist = base_dist self._init_scale = init_scale super().__init__(model, prefix=prefix, init_loc_fn=init_loc_fn) @@ -734,13 +741,22 @@ def log_density(x): init_z_loc = numpyro.param( "{}_z_0_loc".format(self.prefix), jnp.zeros(self.latent_dim) ) - init_z_scale = numpyro.param( - "{}_z_0_scale".format(self.prefix), - jnp.full(self.latent_dim, self._init_scale), - constraint=constraints.positive, - ) - base_z_dist = dist.Normal(init_z_loc, init_z_scale).to_event() + if self.base_dist == "diagonal": + init_z_scale = numpyro.param( + "{}_z_0_scale".format(self.prefix), + jnp.full(self.latent_dim, self._init_scale), + constraint=constraints.positive, + ) + base_z_dist = dist.Normal(init_z_loc, init_z_scale).to_event() + elif self.base_dist == "cholesky": + scale_tril = numpyro.param( + "{}_z_0_scale_tril".format(self.prefix), + jnp.identity(self.latent_dim) * self._init_scale, + constraint=constraints.lower_cholesky, + ) + base_z_dist = dist.MultivariateNormal(init_z_loc, scale_tril=scale_tril) + z_0 = numpyro.sample( "{}_z_0".format(self.prefix), base_z_dist, diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index d27553219..49255d13a 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -66,7 +66,10 @@ def model(data): numpyro.sample("obs", dist.Bernoulli(f), obs=data) adam = optim.Adam(0.01) - guide = auto_class(model, init_loc_fn=init_strategy) + if auto_class == AutoDAIS: + guide = auto_class(model, init_loc_fn=init_strategy, base_dist="cholesky") + else: + guide = auto_class(model, init_loc_fn=init_strategy) svi = SVI(model, guide, adam, Trace_ELBO()) svi_state = svi.init(random.PRNGKey(1), data) From f4c010dc1072d2c9aaf1be58061aa04a20f16953 Mon Sep 17 00:00:00 2001 From: Peter Roelants Date: Mon, 30 Aug 2021 12:24:06 +0200 Subject: [PATCH 160/222] Document Poisson is_sparse (#1139) --- numpyro/distributions/discrete.py | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 618d4cdea..149ded57b 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -597,6 +597,18 @@ def Multinomial(total_count=1, probs=None, logits=None, validate_args=None): class Poisson(Distribution): + r""" + Creates a Poisson distribution parameterized by rate, the rate parameter. + + Samples are nonnegative integers, with a pmf given by + + .. math:: + \mathrm{rate}^k \frac{e^{-\mathrm{rate}}}{k!} + + :param numpy.ndarray rate: The rate parameter + :param bool is_sparse: Whether to assume value is mostly zero when computing + :meth:`log_prob`, which can speed up computation when data is sparse. + """ arg_constraints = {"rate": constraints.positive} support = constraints.nonnegative_integer From 87ff265a0845fef194b230906081d8509376902a Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 30 Aug 2021 15:58:20 -0400 Subject: [PATCH 161/222] make Sigmoid and StickBreaking more stable (#1140) --- numpyro/distributions/transforms.py | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index e4a0c4463..09402118e 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -9,7 +9,7 @@ from jax import lax, ops, vmap from jax.flatten_util import ravel_pytree -from jax.nn import softplus +from jax.nn import log_sigmoid, softplus import jax.numpy as jnp from jax.scipy.linalg import solve_triangular from jax.scipy.special import expit, logit @@ -787,8 +787,7 @@ def _inverse(self, y): return logit(y) def log_abs_det_jacobian(self, x, y, intermediates=None): - x_abs = jnp.abs(x) - return -x_abs - 2 * jnp.log1p(jnp.exp(-x_abs)) + return -softplus(x) - softplus(-x) def _softplus_inv(y): @@ -877,12 +876,10 @@ def _inverse(self, y): def log_abs_det_jacobian(self, x, y, intermediates=None): # Ref: https://mc-stan.org/docs/2_19/reference-manual/simplex-transform-section.html - # |det|(J) = Product(y * (1 - z)) + # |det|(J) = Product(y * (1 - sigmoid(x))) + # = Product(y * sigmoid(x) * exp(-x)) x = x - jnp.log(x.shape[-1] - jnp.arange(x.shape[-1])) - z = jnp.clip(expit(x), a_min=jnp.finfo(x.dtype).tiny) - # XXX we use the identity 1 - z = z * exp(-x) to not worry about - # the case z ~ 1 - return jnp.sum(jnp.log(y[..., :-1] * z) - x, axis=-1) + return jnp.sum(jnp.log(y[..., :-1]) + (log_sigmoid(x) - x), axis=-1) def forward_shape(self, shape): if len(shape) < 1: From 1e2b2b2f1c7c61f61f8dcb0987dfb8c2b29b2b08 Mon Sep 17 00:00:00 2001 From: Jan Siml <49557684+svilupp@users.noreply.github.com> Date: Tue, 31 Aug 2021 18:33:46 +0100 Subject: [PATCH 162/222] Adding Dirichlet prior for Ordinal Regression case study (#1130) * added transform + example * updated transform to handle batch dimensions in forward and inverse direction. log det not ready yet * fixed a typo that has snuck in * added support in log_abs_det for batch dimensions * updated notebook with case study + added 1 test with xfail condition * updated transform name to SimplexToOrderedTransform + formatting updates * added reference to original case study in docs + fixed docs formatting * added reference to original case study in docs + fixed docs formatting * updated transform with jax tricks and added analytic Jacobian * aligned OrderedLogistic with SimplexToOrdered * re-run examples --- docs/source/distributions.rst | 8 ++ notebooks/source/ordinal_regression.ipynb | 167 +++++++++++++++++----- numpyro/distributions/discrete.py | 8 +- numpyro/distributions/transforms.py | 45 ++++++ test/test_distributions.py | 26 +++- 5 files changed, 211 insertions(+), 43 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 71986741b..2ad8ad534 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -838,6 +838,14 @@ SigmoidTransform :show-inheritance: :member-order: bysource +SimplexToOrderedTransform +^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: numpyro.distributions.transforms.SimplexToOrderedTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + SoftplusLowerCholeskyTransform ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.transforms.SoftplusLowerCholeskyTransform diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 7d6b4d4cc..578fbf2f6 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -11,37 +11,49 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Some data are discrete but instrinsically **ordered**, these are called [**ordinal**](https://en.wikipedia.org/wiki/Ordinal_data) data. One example is the [likert scale](https://en.wikipedia.org/wiki/Likert_scale) for questionairs (\"this is an informative tutorial\": 1. strongly disagree / 2. disagree / 3. neither agree nor disagree / 4. agree / 5. strongly agree). Ordinal data is also ubiquitous in the medical world (e.g. the [Glasgow Coma Scale](https://en.wikipedia.org/wiki/Glasgow_Coma_Scale) for measuring neurological disfunctioning). \n", + "Some data are discrete but intrinsically **ordered**, these are called [**ordinal**](https://en.wikipedia.org/wiki/Ordinal_data) data. One example is the [likert scale](https://en.wikipedia.org/wiki/Likert_scale) for questionairs (\"this is an informative tutorial\": 1. strongly disagree / 2. disagree / 3. neither agree nor disagree / 4. agree / 5. strongly agree). Ordinal data is also ubiquitous in the medical world (e.g. the [Glasgow Coma Scale](https://en.wikipedia.org/wiki/Glasgow_Coma_Scale) for measuring neurological disfunctioning). \n", "\n", - "This poses a challenge for statistical modeling as the data do not fit the most well known modelling approaches (e.g. linear regression). Modeling the data as [categorical](https://en.wikipedia.org/wiki/Categorical_distribution) is one possibility, but it disregards the inherent ordering in the data, and may be less statistically efficient. There are multiple appoaches for modeling ordered data. Here we will show how to use the OrderedLogistic distribution using cutpoints that are sampled from a Normal distribution with as additional constrain that the cutpoints they are ordered. For a more in-depth discussion of Bayesian modeling of ordinal data, see e.g. [Michael Betancour's blog](https://betanalpha.github.io/assets/case_studies/ordinal_regression.html)" + "This poses a challenge for statistical modeling as the data do not fit the most well known modelling approaches (e.g. linear regression). Modeling the data as [categorical](https://en.wikipedia.org/wiki/Categorical_distribution) is one possibility, but it disregards the inherent ordering in the data, and may be less statistically efficient. There are multiple appoaches for modeling ordered data. Here we will show how to use the OrderedLogistic distribution using cutpoints that are sampled from Improper priors, from a Normal distribution and induced via categories' probabilities from Dirichlet distribution. For a more in-depth discussion of Bayesian modeling of ordinal data, see e.g. [Michael Betancourt's Ordinal Regression case study](https://betanalpha.github.io/assets/case_studies/ordinal_regression.html) \n", + "\n", + "**References:**\n", + " 1. Betancourt, M. (2019), “Ordinal Regression”, (https://betanalpha.github.io/assets/case_studies/ordinal_regression.html)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ - "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + "# !pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from jax import numpy as np, random\n", "import numpyro\n", - "from numpyro import sample\n", - "from numpyro.distributions import (Categorical, ImproperUniform, Normal, OrderedLogistic,\n", + "from numpyro import sample,handlers\n", + "from numpyro.distributions import (Categorical, Dirichlet, ImproperUniform, Normal, OrderedLogistic,\n", " TransformedDistribution, constraints, transforms)\n", "from numpyro.infer import MCMC, NUTS\n", + "from numpyro.infer.reparam import TransformReparam\n", + "\n", "import pandas as pd\n", "import seaborn as sns\n", "assert numpyro.__version__.startswith('0.7.2')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Generation" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -51,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -87,12 +99,12 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "

    " ] @@ -107,6 +119,13 @@ "sns.violinplot(x='Y', y='X', data=df);" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Improper Prior" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -116,14 +135,14 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 1000/1000 [00:07<00:00, 126.55it/s, 7 steps of size 4.34e-01. acc. prob=0.95]\n" + "sample: 100%|██████████| 1000/1000 [00:03<00:00, 258.56it/s, 7 steps of size 5.02e-01. acc. prob=0.94]\n" ] }, { @@ -132,9 +151,9 @@ "text": [ "\n", " mean std median 5.0% 95.0% n_eff r_hat\n", - " b_X_eta 1.43 0.35 1.42 0.82 1.96 352.72 1.00\n", - " c_y[0] -0.11 0.41 -0.11 -0.78 0.55 505.85 1.00\n", - " c_y[1] 2.18 0.52 2.15 1.35 2.95 415.22 1.00\n", + " b_X_eta 1.44 0.37 1.42 0.83 2.05 349.38 1.01\n", + " c_y[0] -0.10 0.38 -0.10 -0.71 0.51 365.63 1.00\n", + " c_y[1] 2.15 0.49 2.13 1.38 2.99 376.45 1.01\n", "\n", "Number of divergences: 0\n" ] @@ -168,14 +187,14 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 1000/1000 [00:03<00:00, 315.02it/s, 7 steps of size 4.80e-01. acc. prob=0.94]\n" + "sample: 100%|██████████| 1000/1000 [00:03<00:00, 256.41it/s, 7 steps of size 5.31e-01. acc. prob=0.92]\n" ] }, { @@ -184,9 +203,9 @@ "text": [ "\n", " mean std median 5.0% 95.0% n_eff r_hat\n", - " b_X_eta 1.23 0.30 1.23 0.69 1.65 535.41 1.00\n", - " c_y[0] -0.25 0.33 -0.25 -0.82 0.27 461.96 1.00\n", - " c_y[1] 1.76 0.38 1.75 1.10 2.33 588.10 1.00\n", + " b_X_eta 1.23 0.31 1.23 0.64 1.68 501.31 1.01\n", + " c_y[0] -0.24 0.34 -0.23 -0.76 0.38 492.91 1.00\n", + " c_y[1] 1.77 0.40 1.76 1.11 2.42 628.46 1.00\n", "\n", "Number of divergences: 0\n" ] @@ -209,6 +228,13 @@ "mcmc.print_summary()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Proper Prior" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -218,14 +244,14 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 1000/1000 [00:03<00:00, 282.20it/s, 7 steps of size 4.84e-01. acc. prob=0.94]" + "sample: 100%|██████████| 1000/1000 [00:04<00:00, 244.78it/s, 7 steps of size 5.54e-01. acc. prob=0.93]\n" ] }, { @@ -234,19 +260,12 @@ "text": [ "\n", " mean std median 5.0% 95.0% n_eff r_hat\n", - " b_X_eta 1.41 0.34 1.40 0.88 2.00 444.42 1.00\n", - " c_y[0] -0.05 0.36 -0.05 -0.58 0.54 591.60 1.00\n", - " c_y[1] 2.08 0.47 2.07 1.37 2.87 429.27 1.00\n", + " b_X_eta 1.40 0.34 1.41 0.86 1.98 300.30 1.03\n", + " c_y[0] -0.03 0.35 -0.03 -0.57 0.54 395.98 1.00\n", + " c_y[1] 2.06 0.47 2.04 1.26 2.83 475.16 1.01\n", "\n", "Number of divergences: 0\n" ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] } ], "source": [ @@ -263,13 +282,91 @@ "mcmc.run(mcmc_key, X,Y, nclasses)\n", "mcmc.print_summary()" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Principled prior with Dirichlet Distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It is non-trivial to apply our expertise over the cutpoints in latent space (even more so when we are having to provide a prior before applying the OrderedTransform). \n", + "\n", + "Natural inclination would be to apply Dirichlet prior model to the ordinal probabilities. We will follow proposal by M.Betancourt ([1], Section 2.2) and use [Dirichlet](http://num.pyro.ai/en/stable/distributions.html#dirichlet) prior model to induce cutpoints indirectly via [SimplexToOrderedTransform](http://num.pyro.ai/en/stable/distributions.html#simplextoorderedtransform). \n", + "This approach should be advantageous when there is a need for strong prior knowledge to be added to our Ordinal model, eg, when one of the categories is missing in our dataset or when some categories are strongly separated (leading to non-identifiability of the cutpoints). Moreover, such parametrization allows us to sample our model and conduct prior predictive checks (unlike `model1` with `ImproperUniform`).\n", + "\n", + "We can sample cutpoints directly from `TransformedDistribution(Dirichlet(concentration),transforms.SimplexToOrderedTransform(anchor_point))`. However, if we use the Transform within the `reparam handler` context, we can capture not only the induced cutpoints, but also the sampled Ordinal probabilities implied by the `concentration` parameter. `anchor_point` is a nuisance parameter to improve identifiability of our transformation (for details please see [1], Section 2.2)\n", + "\n", + "Please note that we cannot compare latent cutpoints or b_X_eta separately across the various models as they are inherently linked." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# We will apply a nudge towards equal probability for each category (corresponds to equal logits of the true data generating process)\n", + "concentration=np.ones((nclasses,))*10.0" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 1000/1000 [00:05<00:00, 193.88it/s, 7 steps of size 7.00e-01. acc. prob=0.93]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " b_X_eta 1.01 0.26 1.01 0.59 1.42 388.46 1.00\n", + " c_y[0] -0.42 0.26 -0.42 -0.88 -0.05 491.73 1.00\n", + " c_y[1] 1.34 0.29 1.34 0.86 1.80 617.53 1.00\n", + "c_y_base[0] 0.40 0.06 0.40 0.29 0.49 488.71 1.00\n", + "c_y_base[1] 0.39 0.06 0.39 0.29 0.48 523.65 1.00\n", + "c_y_base[2] 0.21 0.05 0.21 0.13 0.29 610.33 1.00\n", + "\n", + "Number of divergences: 0\n" + ] + } + ], + "source": [ + "def model4(X, Y, nclasses,concentration,anchor_point=0.0):\n", + " b_X_eta = sample('b_X_eta', Normal(0, 5)) \n", + " \n", + " with handlers.reparam(config={'c_y': TransformReparam()}):\n", + " c_y=sample(\"c_y\", TransformedDistribution(Dirichlet(concentration), \n", + " transforms.SimplexToOrderedTransform(anchor_point)))\n", + " with numpyro.plate('obs', X.shape[0]):\n", + " eta = X * b_X_eta\n", + " sample('Y', OrderedLogistic(eta, c_y), obs=Y)\n", + "\n", + "kernel = NUTS(model4)\n", + "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", + "mcmc.run(mcmc_key, X,Y, nclasses,concentration)\n", + "# with exclude_deterministic=False, we will also show the ordinal probabilities sampled from Dirichlet (vis. `c_y_base`)\n", + "mcmc.print_summary(exclude_deterministic=False)" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "conda_env_my", "language": "python", - "name": "python3" + "name": "conda_env_my" }, "language_info": { "codemirror_mode": { @@ -281,7 +378,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.7.8" } }, "nbformat": 4, diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 149ded57b..305ea83c1 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -37,7 +37,7 @@ import jax.random as random from jax.scipy.special import expit, gammaincc, gammaln, logsumexp, xlog1py, xlogy -from numpyro.distributions import constraints +from numpyro.distributions import constraints, transforms from numpyro.distributions.distribution import Distribution from numpyro.distributions.util import ( binary_cross_entropy_with_logits, @@ -432,11 +432,7 @@ def __init__(self, predictor, cutpoints, validate_args=None): predictor = predictor[..., None] predictor, self.cutpoints = promote_shapes(predictor, cutpoints) self.predictor = predictor[..., 0] - cumulative_probs = expit(cutpoints - predictor) - # add two boundary points 0 and 1 - pad_width = [(0, 0)] * (jnp.ndim(cumulative_probs) - 1) + [(1, 1)] - cumulative_probs = jnp.pad(cumulative_probs, pad_width, constant_values=(0, 1)) - probs = cumulative_probs[..., 1:] - cumulative_probs[..., :-1] + probs = transforms.SimplexToOrderedTransform(self.predictor).inv(self.cutpoints) super(OrderedLogistic, self).__init__(probs, validate_args=validate_args) @staticmethod diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 09402118e..9932b14b4 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -41,6 +41,7 @@ "PermuteTransform", "PowerTransform", "SigmoidTransform", + "SimplexToOrderedTransform", "SoftplusTransform", "SoftplusLowerCholeskyTransform", "StickBreakingTransform", @@ -790,6 +791,50 @@ def log_abs_det_jacobian(self, x, y, intermediates=None): return -softplus(x) - softplus(-x) +class SimplexToOrderedTransform(Transform): + """ + Transform a simplex into an ordered vector (via difference in Logistic CDF between cutpoints) + Used in [1] to induce a prior on latent cutpoints via transforming ordered category probabilities. + + :param anchor_point: Anchor point is a nuisance parameter to improve the identifiability of the transform. + For simplicity, we assume it is a scalar value, but it is broadcastable x.shape[:-1]. + For more details please refer to Section 2.2 in [1] + + **References:** + + 1. *Ordinal Regression Case Study, section 2.2*, + M. Betancourt, https://betanalpha.github.io/assets/case_studies/ordinal_regression.html + + """ + + domain = constraints.simplex + codomain = constraints.ordered_vector + + def __init__(self, anchor_point=0.0): + self.anchor_point = anchor_point + + def __call__(self, x): + s = jnp.cumsum(x[..., :-1], axis=-1) + y = logit(s) + jnp.expand_dims(self.anchor_point, -1) + return y + + def _inverse(self, y): + y = y - jnp.expand_dims(self.anchor_point, -1) + s = expit(y) + # x0 = s0, x1 = s1 - s0, x2 = s2 - s1,..., xn = 1 - s[n-1] + # add two boundary points 0 and 1 + pad_width = [(0, 0)] * (jnp.ndim(s) - 1) + [(1, 1)] + s = jnp.pad(s, pad_width, constant_values=(0, 1)) + x = s[..., 1:] - s[..., :-1] + return x + + def log_abs_det_jacobian(self, x, y, intermediates=None): + # |dp/dc| = |dx/dy| = prod(ds/dy) = prod(expit'(y)) + # we know log derivative of expit(y) is `-softplus(y) - softplus(-y)` + J_logdet = (softplus(y) + softplus(-y)).sum(-1) + return J_logdet + + def _softplus_inv(y): return jnp.log(-jnp.expm1(-y)) + y diff --git a/test/test_distributions.py b/test/test_distributions.py index 5aa9d2fbe..496d242b2 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -28,6 +28,7 @@ LowerCholeskyAffine, PermuteTransform, PowerTransform, + SimplexToOrderedTransform, SoftplusTransform, biject_to, ) @@ -1705,9 +1706,30 @@ def inv_vec_transform(y): ), (2,), ), + ( + transforms.ComposeTransform( + [ + biject_to(constraints.simplex), + SimplexToOrderedTransform(0.0), + biject_to(constraints.ordered_vector).inv, + ] + ), + (5,), + ), + ], +) +@pytest.mark.parametrize( + "batch_shape", + [ + (), + (1,), + (3,), + (6,), + (3, 1), + (1, 3), + (5, 3), ], ) -@pytest.mark.parametrize("batch_shape", [(), (1,), (3,), (6,), (3, 1), (1, 3), (5, 3)]) def test_bijective_transforms(transform, event_shape, batch_shape): shape = batch_shape + event_shape rng_key = random.PRNGKey(0) @@ -1719,7 +1741,7 @@ def test_bijective_transforms(transform, event_shape, batch_shape): # test inv z = transform.inv(y) - assert_allclose(x, z, atol=1e-6, rtol=1e-6) + assert_allclose(x, z, atol=1e-6, rtol=1e-4) assert transform.inv.inv is transform assert transform.inv is transform.inv assert transform.domain is transform.inv.codomain From b0416e2dc3ccca89ffe06cb9203d496d3d03434e Mon Sep 17 00:00:00 2001 From: Nicholas Mancuso Date: Thu, 2 Sep 2021 12:00:20 -0700 Subject: [PATCH 163/222] updated format_shape example doc (#1144) --- numpyro/util.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/numpyro/util.py b/numpyro/util.py index d635101b9..84c5f6e55 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -442,7 +442,8 @@ def format_shapes( def model(*args, **kwargs): ... - trace = numpyro.handlers.trace(model).get_trace(*args, **kwargs) + with numpyro.handlers.seed(rng_key=1): + trace = numpyro.handlers.trace(model).get_trace(*args, **kwargs) numpyro.util.format_shapes(trace) """ if not trace.keys(): From db571f85bbb210ae958ad896c0d69e28e90abf9a Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Fri, 3 Sep 2021 04:09:23 -0700 Subject: [PATCH 164/222] fix bnaf docstring (#1145) * fix bnaf docstring * tweak --- numpyro/infer/autoguide.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 8a03163f0..a21d3e3cf 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -1226,7 +1226,7 @@ class AutoBNAFNormal(AutoContinuous): :param callable model: a generative model. :param str prefix: a prefix that will be prefixed to all param internal sites. :param callable init_loc_fn: A per-site initialization function. - :param int num_flows: the number of flows to be used, defaults to 3. + :param int num_flows: the number of flows to be used, defaults to 1. :param list hidden_factors: Hidden layer i has ``hidden_factors[i]`` hidden units per input dimension. This corresponds to both :math:`a` and :math:`b` in reference [1]. The elements of hidden_factors must be integers. From f787ff946413338890fb67e941e5daef48b51d70 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Fri, 3 Sep 2021 11:54:15 -0700 Subject: [PATCH 165/222] add basic horseshoe regression example (#1141) * add to test * tweak * add binary response example * cleanup * isort * fix test --- docs/source/index.rst | 1 + examples/horseshoe_regression.py | 174 +++++++++++++++++++++++++++++++ test/test_examples.py | 1 + 3 files changed, 176 insertions(+) create mode 100644 examples/horseshoe_regression.py diff --git a/docs/source/index.rst b/docs/source/index.rst index c7e4a8047..73cb655f9 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -57,6 +57,7 @@ NumPyro documentation examples/bnn examples/dais_demo examples/sparse_regression + examples/horseshoe_regression examples/proportion_test examples/ucbadmit examples/hmcecs diff --git a/examples/horseshoe_regression.py b/examples/horseshoe_regression.py new file mode 100644 index 000000000..b24261a42 --- /dev/null +++ b/examples/horseshoe_regression.py @@ -0,0 +1,174 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +""" +Example: Horseshoe Regression +============================= + +We demonstrate how to use NUTS to do sparse regression using +the Horseshoe prior [1] for both continuous- and binary-valued +responses. For a more complex modeling and inference approach +that also supports quadratic interaction terms in a way that +is efficient in high dimensions see examples/sparse_regression.py. + +References: + +[1] "Handling Sparsity via the Horseshoe," + Carlos M. Carvalho, Nicholas G. Polson, James G. Scott. +""" + +import argparse +import os +import time + +import numpy as np +from scipy.special import expit + +import jax.numpy as jnp +import jax.random as random + +import numpyro +from numpyro.diagnostics import summary +import numpyro.distributions as dist +from numpyro.infer import MCMC, NUTS + + +# regression model with continuous-valued outputs/responses +def model_normal_likelihood(X, Y): + D_X = X.shape[1] + + # sample from horseshoe prior + lambdas = numpyro.sample("lambdas", dist.HalfCauchy(jnp.ones(D_X))) + tau = numpyro.sample("tau", dist.HalfCauchy(jnp.ones(1))) + + # note that in practice for a normal likelihood we would probably want to + # integrate out the coefficients (as is done for example in sparse_regression.py). + # however, this trick wouldn't be applicable to other likelihoods + # (e.g. bernoulli, see below) so we don't make use of it here. + unscaled_betas = numpyro.sample("unscaled_betas", dist.Normal(jnp.ones(D_X))) + scaled_betas = numpyro.deterministic("betas", tau * lambdas * unscaled_betas) + + # compute mean function using linear coefficients + mean_function = jnp.dot(X, scaled_betas) + + prec_obs = numpyro.sample("prec_obs", dist.Gamma(3.0, 1.0)) + sigma_obs = 1.0 / jnp.sqrt(prec_obs) + + # observe data + numpyro.sample("Y", dist.Normal(mean_function, sigma_obs), obs=Y) + + +# regression model with binary-valued outputs/responses +def model_bernoulli_likelihood(X, Y): + D_X = X.shape[1] + + # sample from horseshoe prior + lambdas = numpyro.sample("lambdas", dist.HalfCauchy(jnp.ones(D_X))) + tau = numpyro.sample("tau", dist.HalfCauchy(jnp.ones(1))) + + # note that this reparameterization (i.e. coordinate transformation) improves + # posterior geometry and makes NUTS sampling more efficient + unscaled_betas = numpyro.sample("unscaled_betas", dist.Normal(jnp.ones(D_X))) + scaled_betas = numpyro.deterministic("betas", tau * lambdas * unscaled_betas) + + # compute mean function using linear coefficients + mean_function = jnp.dot(X, scaled_betas) + + # observe data + numpyro.sample("Y", dist.Bernoulli(logits=mean_function), obs=Y) + + +# helper function for HMC inference +def run_inference(model, args, rng_key, X, Y): + start = time.time() + kernel = NUTS(model) + mcmc = MCMC( + kernel, + num_warmup=args.num_warmup, + num_samples=args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) + + mcmc.run(rng_key, X, Y) + mcmc.print_summary(exclude_deterministic=False) + + samples = mcmc.get_samples() + summary_dict = summary(samples, group_by_chain=False) + + print("\nMCMC elapsed time:", time.time() - start) + + return summary_dict + + +# create artificial regression dataset with 3 non-zero regression coefficients +def get_data(N=50, D_X=3, sigma_obs=0.05, response="continuous"): + assert response in ["continuous", "binary"] + assert D_X >= 3 + + np.random.seed(0) + X = np.random.randn(N, D_X) + + # the response only depends on X_0, X_1, and X_2 + W = np.array([2.0, -1.0, 0.50]) + Y = jnp.dot(X[:, :3], W) + Y -= jnp.mean(Y) + + if response == "continuous": + Y += sigma_obs * np.random.randn(N) + Y /= Y.std() + elif response == "binary": + Y = np.random.binomial(1, expit(Y)) + + assert X.shape == (N, D_X) + assert Y.shape == (N,) + + return X, Y + + +def main(args): + N, D_X = args.num_data, 32 + + print("[Experiment with continuous-valued responses]") + # first generate and analyze data with continuous-valued responses + X, Y = get_data(N=N, D_X=D_X, response="continuous") + + # do inference + rng_key, rng_key_predict = random.split(random.PRNGKey(0)) + summary = run_inference(model_normal_likelihood, args, rng_key, X, Y) + + # lambda should only be large for the first 3 dimensions, which + # correspond to relevant covariates (see get_data) + print("Posterior median over lambdas (leading 5 dimensions):") + print(summary["lambdas"]["median"][:5]) + + print("[Experiment with binary-valued responses]") + # next generate and analyze data with binary-valued responses + # (note we use more data for the case of binary-valued responses, + # since each response carries less information than a real number) + X, Y = get_data(N=4 * N, D_X=D_X, response="binary") + + # do inference + rng_key, rng_key_predict = random.split(random.PRNGKey(0)) + summary = run_inference(model_bernoulli_likelihood, args, rng_key, X, Y) + + # lambda should only be large for the first 3 dimensions, which + # correspond to relevant covariates (see get_data) + print("Posterior median over lambdas (leading 5 dimensions):") + print(summary["lambdas"]["median"][:5]) + + +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.7.2") + parser = argparse.ArgumentParser(description="Horseshoe regression example") + parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--num-data", nargs="?", default=100, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') + args = parser.parse_args() + + numpyro.set_platform(args.device) + numpyro.set_host_device_count(args.num_chains) + + main(args) diff --git a/test/test_examples.py b/test/test_examples.py index 11c8dd96a..ba8bda327 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -35,6 +35,7 @@ "hmm_enum.py -m 3 -t 3 -d 4 --num-warmup 1 -n 4", "hmm_enum.py -m 4 -t 3 -d 4 --num-warmup 1 -n 4", "hmm_enum.py -m 6 -t 4 -d 3 --num-warmup 1 -n 4", + "horseshoe_regression.py --num-samples 10 --num-warmup 10 --num-data 5", "hsgp.py --model t --num-samples 10 --num-warmup 10 --num-chains 2", "hsgp.py --model ty --num-samples 10 --num-warmup 10 --num-chains 2", "hsgp.py --model tyw --num-samples 10 --num-warmup 10 --num-chains 2", From b9c4e19f6ee9efc43d88697dd29d0e23f8f6aae5 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 6 Sep 2021 10:05:55 -0400 Subject: [PATCH 166/222] Support autoguide subsample with deterministic sites (#1147) * support subsample with deterministic * black --- numpyro/infer/autoguide.py | 6 +++++- test/infer/test_autoguide.py | 14 ++++++++++++++ 2 files changed, 19 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index a21d3e3cf..dfd1a2d6f 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -136,7 +136,7 @@ def _setup_prototype(self, *args, **kwargs): ( init_params, self._potential_fn, - self._postprocess_fn, + postprocess_fn, self.prototype_trace, ) = initialize_model( rng_key, @@ -146,6 +146,10 @@ def _setup_prototype(self, *args, **kwargs): model_args=args, model_kwargs=kwargs, ) + # We apply a fixed seed just in case postprocess_fn requires + # a random key to generate subsample indices. It does not matter + # because we only collect deterministic sites. + self._postprocess_fn = handlers.seed(postprocess_fn, rng_seed=0) self._init_locs = init_params[0] self._prototype_frames = {} diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 49255d13a..3b779197e 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -596,3 +596,17 @@ def model(data): with pytest.raises(NotImplementedError, match=".*data subsampling.*"): svi.init(random.PRNGKey(1), data) + + +def test_subsample_model_with_deterministic(): + def model(): + x = numpyro.sample("x", dist.Normal(0, 1)) + numpyro.deterministic("x2", x * 2) + with numpyro.plate("N", 10, subsample_size=5): + numpyro.sample("obs", dist.Normal(x, 1), obs=jnp.ones(5)) + + guide = AutoNormal(model) + svi = SVI(model, guide, optim.Adam(1.0), Trace_ELBO()) + svi_result = svi.run(random.PRNGKey(0), 10) + samples = guide.sample_posterior(random.PRNGKey(1), svi_result.params) + assert "x2" in samples From 63e5eb5cb8799b5f58844625b09eae5145323165 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Mon, 6 Sep 2021 11:39:10 -0700 Subject: [PATCH 167/222] add notebook that explores bad posterior geometries and tips for dealing with them (#1142) * add to test * tweak * add geometry.ipynb * clenaup * add example * address some of fritzs comments * cleanup * add example * add transformreparam * populate rst * add LocScaleReparam * tweak * fix rst * fix scale= --- docs/source/index.rst | 1 + notebooks/source/bad_posterior_geometry.ipynb | 553 ++++++++++++++++++ 2 files changed, 554 insertions(+) create mode 100644 notebooks/source/bad_posterior_geometry.ipynb diff --git a/docs/source/index.rst b/docs/source/index.rst index 73cb655f9..2b08a382f 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -33,6 +33,7 @@ NumPyro documentation examples/stochastic_volatility examples/prodlda tutorials/model_rendering + tutorials/bad_posterior_geometry .. nbgallery:: :maxdepth: 1 diff --git a/notebooks/source/bad_posterior_geometry.ipynb b/notebooks/source/bad_posterior_geometry.ipynb new file mode 100644 index 000000000..3b72a6dca --- /dev/null +++ b/notebooks/source/bad_posterior_geometry.ipynb @@ -0,0 +1,553 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bad posterior geometry and how to deal with it" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "HMC and its variant NUTS use gradient information to draw (approximate) samples from a posterior distribution. \n", + "These gradients are computed in a *particular coordinate system*, and different choices of coordinate system can make HMC more or less efficient. \n", + "This is analogous to the situation in constrained optimization problems where, for example, parameterizing a positive quantity via an exponential versus softplus transformation results in distinct optimization dynamics.\n", + "\n", + "Consequently it is important to pay attention to the *geometry* of the posterior distribution. \n", + "Reparameterizing the model (i.e. changing the coordinate system) can make a big practical difference for many complex models. \n", + "For the most complex models it can be absolutely essential. For the same reason it can be important to pay attention to some of the hyperparameters that control HMC/NUTS (in particular the `max_tree_depth` and `dense_mass`). \n", + "\n", + "In this tutorial we explore models with bad posterior geometries---and what one can do to get achieve better performance---with a few concrete examples." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "import numpy as np\n", + "\n", + "import jax.numpy as jnp\n", + "from jax import random\n", + "\n", + "import numpyro\n", + "import numpyro.distributions as dist\n", + "from numpyro.diagnostics import summary\n", + "\n", + "from numpyro.infer import MCMC, NUTS\n", + "assert numpyro.__version__.startswith('0.7.2')\n", + "\n", + "# NB: replace cpu by gpu to run this notebook on gpu\n", + "numpyro.set_platform(\"cpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We begin by writing a helper function to do NUTS inference." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def run_inference(model, \n", + " num_warmup=1000, \n", + " num_samples=1000,\n", + " max_tree_depth=10, \n", + " dense_mass=False):\n", + " \n", + " kernel = NUTS(model, \n", + " max_tree_depth=max_tree_depth,\n", + " dense_mass=dense_mass)\n", + " mcmc = MCMC(\n", + " kernel,\n", + " num_warmup=num_warmup,\n", + " num_samples=num_samples,\n", + " num_chains=1,\n", + " progress_bar=False,\n", + " )\n", + " mcmc.run(random.PRNGKey(0))\n", + " summary_dict = summary(mcmc.get_samples(), group_by_chain=False) \n", + " \n", + " # print the largest r_hat for each variable\n", + " for k, v in summary_dict.items():\n", + " spaces = \" \" * max(12 - len(k), 0)\n", + " print(\"[{}] {} \\t max r_hat: {:.4f}\".format(k, spaces, np.max(v['r_hat'])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Evaluating HMC/NUTS\n", + "\n", + "In general it is difficult to assess whether the samples returned from HMC or NUTS represent accurate (approximate) samples from the posterior. \n", + "Two general rules of thumb, however, are to look at the effective sample size (ESS) and `r_hat` diagnostics returned by `mcmc.print_summary()`.\n", + "If we see values of `r_hat` in the range `(1.0, 1.05)` and effective sample sizes that are comparable to the total number of samples `num_samples` (assuming `thinning=1`) then we have good reason to believe that HMC is doing a good job. \n", + "If, however, we see low effective sample sizes or large `r_hat`s for some of the variables (e.g. `r_hat = 1.15`) then HMC is likely struggling with the posterior geometry. \n", + "In the following we will use `r_hat` as our primary diagnostic metric." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model reparameterization\n", + "\n", + "### Example #1\n", + "\n", + "We begin with an example (horseshoe regression; see [examples/horseshoe_regression.py](https://github.com/pyro-ppl/numpyro/blob/master/examples/horseshoe_regression.py) for a complete example script) where reparameterization helps a lot. \n", + "This particular example demonstrates a general reparameterization strategy that is useful in many models with hierarchical/multi-level structure. \n", + "For more discussion of some of the issues that can arise in hierarchical models see reference [1]." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# In this unreparameterized model some of the parameters of the distributions\n", + "# explicitly depend on other parameters (in particular beta depends on lambdas and tau).\n", + "# This kind of coordinate system can be a challenge for HMC.\n", + "def _unrep_hs_model(X, Y):\n", + " lambdas = numpyro.sample(\"lambdas\", dist.HalfCauchy(jnp.ones(X.shape[1])))\n", + " tau = numpyro.sample(\"tau\", dist.HalfCauchy(jnp.ones(1)))\n", + " betas = numpyro.sample(\"betas\", dist.Normal(scale=tau * lambdas))\n", + " mean_function = jnp.dot(X, betas)\n", + " numpyro.sample(\"Y\", dist.Normal(mean_function, 0.05), obs=Y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To deal with the bad geometry that results form this coordinate system we change coordinates using the following re-write logic.\n", + "Instead of \n", + "\n", + "$$ \\beta \\sim {\\rm Normal}(0, \\lambda \\tau) $$\n", + "we write\n", + "$$ \\beta^\\prime \\sim {\\rm Normal}(0, 1) $$\n", + "and\n", + "$$ \\beta \\equiv \\lambda \\tau \\beta^\\prime $$\n", + "\n", + "where $\\beta$ is now defined *deterministically* in terms of $\\lambda$, $\\tau$,\n", + "and $\\beta^\\prime$. \n", + "In effect we've changed to a coordinate system where the different\n", + "latent variables are less correlated with one another. \n", + "In this new coordinate system we can expect HMC with a diagonal mass matrix to behave much better than it would in the original coordinate system.\n", + "\n", + "There are basically two ways to implement this kind of reparameterization in NumPyro:\n", + "\n", + "- manually (i.e. by hand)\n", + "- using [`numpyro.infer.reparam`](http://num.pyro.ai/en/stable/reparam.html), which automates a few common reparameterization strategies\n", + "\n", + "To begin with let's do the reparameterization by hand." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# In this reparameterized model none of the parameters of the distributions\n", + "# explicitly depend on other parameters. This model is exactly equivalent \n", + "# to _unrep_hs_model but is expressed in a different coordinate system.\n", + "def _rep_hs_model1(X, Y):\n", + " lambdas = numpyro.sample(\"lambdas\", dist.HalfCauchy(jnp.ones(X.shape[1])))\n", + " tau = numpyro.sample(\"tau\", dist.HalfCauchy(jnp.ones(1)))\n", + " unscaled_betas = numpyro.sample(\"unscaled_betas\", dist.Normal(scale=jnp.ones(X.shape[1])))\n", + " scaled_betas = numpyro.deterministic(\"betas\", tau * lambdas * unscaled_betas)\n", + " mean_function = jnp.dot(X, scaled_betas)\n", + " numpyro.sample(\"Y\", dist.Normal(mean_function, 0.05), obs=Y) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we do the reparameterization using [`numpyro.infer.reparam`](http://num.pyro.ai/en/stable/reparam.html). \n", + "There are at least two ways to do this. \n", + "First let's use [`LocScaleReparam`](http://num.pyro.ai/en/stable/reparam.html#numpyro.infer.reparam.LocScaleReparam)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from numpyro.infer.reparam import LocScaleReparam \n", + "# LocScaleReparam with centered=0 fully \"decenters\" the prior over betas.\n", + "config = {\"betas\": LocScaleReparam(centered=0)}\n", + "# The coordinate system of this model is equivalent to that in _rep_hs_model1 above.\n", + "_rep_hs_model2 = numpyro.handlers.reparam(_unrep_hs_model, config=config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To show the versatility of the [`numpyro.infer.reparam`](http://num.pyro.ai/en/stable/reparam.html) library let's do the reparameterization using [`TransformReparam`](http://num.pyro.ai/en/stable/reparam.html#numpyro.infer.reparam.TransformReparam) instead." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from numpyro.distributions.transforms import AffineTransform\n", + "from numpyro.infer.reparam import TransformReparam \n", + "\n", + "# In this reparameterized model none of the parameters of the distributions\n", + "# explicitly depend on other parameters. This model is exactly equivalent \n", + "# to _unrep_hs_model but is expressed in a different coordinate system.\n", + "def _rep_hs_model3(X, Y):\n", + " lambdas = numpyro.sample(\"lambdas\", dist.HalfCauchy(jnp.ones(X.shape[1])))\n", + " tau = numpyro.sample(\"tau\", dist.HalfCauchy(jnp.ones(1)))\n", + " \n", + " # instruct NumPyro to do the reparameterization automatically.\n", + " reparam_config = {\"betas\": TransformReparam()}\n", + " with numpyro.handlers.reparam(config=reparam_config):\n", + " betas_root_variance = tau * lambdas\n", + " # in order to use TransformReparam we have to express the prior\n", + " # over betas as a TransformedDistribution\n", + " betas = numpyro.sample(\"betas\", \n", + " dist.TransformedDistribution(\n", + " dist.Normal(0., jnp.ones(X.shape[1])), \n", + " AffineTransform(0., betas_root_variance)\n", + " )\n", + " )\n", + " \n", + " mean_function = jnp.dot(X, betas)\n", + " numpyro.sample(\"Y\", dist.Normal(mean_function, 0.05), obs=Y) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally we verify that `_rep_hs_model1`, `_rep_hs_model2`, and `_rep_hs_model3` do indeed achieve better `r_hat`s than `_unrep_hs_model`." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "unreparameterized model (very bad r_hats)\n", + "[betas] \t max r_hat: 1.0775\n", + "[lambdas] \t max r_hat: 3.2450\n", + "[tau] \t max r_hat: 2.1926\n", + "\n", + "reparameterized model with manual reparameterization (good r_hats)\n", + "[betas] \t max r_hat: 1.0074\n", + "[lambdas] \t max r_hat: 1.0146\n", + "[tau] \t max r_hat: 1.0036\n", + "[unscaled_betas] \t max r_hat: 1.0059\n", + "\n", + "reparameterized model with LocScaleReparam (good r_hats)\n", + "[betas] \t max r_hat: 1.0103\n", + "[betas_decentered] \t max r_hat: 1.0060\n", + "[lambdas] \t max r_hat: 1.0124\n", + "[tau] \t max r_hat: 0.9998\n", + "\n", + "reparameterized model with TransformReparam (good r_hats)\n", + "[betas] \t max r_hat: 1.0087\n", + "[betas_base] \t max r_hat: 1.0080\n", + "[lambdas] \t max r_hat: 1.0114\n", + "[tau] \t max r_hat: 1.0029\n" + ] + } + ], + "source": [ + "# create fake dataset\n", + "X = np.random.RandomState(0).randn(100, 500)\n", + "Y = X[:, 0]\n", + "\n", + "print(\"unreparameterized model (very bad r_hats)\")\n", + "run_inference(partial(_unrep_hs_model, X, Y))\n", + "\n", + "print(\"\\nreparameterized model with manual reparameterization (good r_hats)\")\n", + "run_inference(partial(_rep_hs_model1, X, Y))\n", + "\n", + "print(\"\\nreparameterized model with LocScaleReparam (good r_hats)\")\n", + "run_inference(partial(_rep_hs_model2, X, Y))\n", + "\n", + "print(\"\\nreparameterized model with TransformReparam (good r_hats)\")\n", + "run_inference(partial(_rep_hs_model3, X, Y))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Aside: numpyro.deterministic\n", + "\n", + "In `_rep_hs_model1` above we used [`numpyro.deterministic`](http://num.pyro.ai/en/stable/primitives.html?highlight=deterministic#numpyro.primitives.deterministic) to define `scaled_betas`.\n", + "We note that using this primitive is not strictly necessary; however, it has the consequence that `scaled_betas` will appear in the trace and will thus appear in the summary reported by `mcmc.print_summary()`. \n", + "In other words we could also have written:\n", + "\n", + "```\n", + "scaled_betas = tau * lambdas * unscaled_betas\n", + "```\n", + "\n", + "without invoking the `deterministic` primitive." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mass matrices\n", + "By default HMC/NUTS use diagonal mass matrices. \n", + "For models with complex geometries it can pay to use a richer set of mass matrices.\n", + "\n", + "\n", + "### Example #2\n", + "In this first simple example we show that using a full-rank (i.e. dense) mass matrix leads to a better `r_hat`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dense_mass = False (bad r_hat)\n", + "[x] \t max r_hat: 1.3810\n", + "dense_mass = True (good r_hat)\n", + "[x] \t max r_hat: 0.9992\n" + ] + } + ], + "source": [ + "# Because rho is very close to 1.0 the posterior geometry \n", + "# is extremely skewed and using the \"diagonal\" coordinate system \n", + "# implied by dense_mass=False leads to bad results\n", + "rho = 0.9999\n", + "cov = jnp.array([[10.0, rho], [rho, 0.1]])\n", + "\n", + "def mvn_model():\n", + " numpyro.sample(\"x\", \n", + " dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", + " )\n", + " \n", + "print(\"dense_mass = False (bad r_hat)\")\n", + "run_inference(mvn_model, dense_mass=False, max_tree_depth=3)\n", + "\n", + "print(\"dense_mass = True (good r_hat)\")\n", + "run_inference(mvn_model, dense_mass=True, max_tree_depth=3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Example #3\n", + "\n", + "Using `dense_mass=True` can be very expensive when the dimension of the latent space `D` is very large. \n", + "In addition it can be difficult to estimate a full-rank mass matrix with `D^2` parameters using a moderate number of samples if `D` is large. In these cases `dense_mass=True` can be a poor choice. \n", + "Luckily, the argument `dense_mass` can also be used to specify structured mass matrices that are richer than a diagonal mass matrix but more constrained (i.e. have fewer parameters) than a full-rank mass matrix ([see the docs](http://num.pyro.ai/en/stable/mcmc.html#hmc)).\n", + "In this second example we show how we can use `dense_mass` to specify such a structured mass matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "rho = 0.9\n", + "cov = jnp.array([[10.0, rho], [rho, 0.1]])\n", + "\n", + "# In this model x1 and x2 are highly correlated with one another\n", + "# but not correlated with y at all.\n", + "def partially_correlated_model():\n", + " x1 = numpyro.sample(\"x1\", \n", + " dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", + " )\n", + " x2 = numpyro.sample(\"x2\", \n", + " dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", + " ) \n", + " y = numpyro.sample(\"y\", dist.Normal(jnp.zeros(100), 1.0))\n", + " numpyro.sample(\"obs\", dist.Normal(x1 - x2, 0.1), jnp.ones(2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's compare two choices of `dense_mass`." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dense_mass = False (very bad r_hats)\n", + "[x1] \t max r_hat: 1.5882\n", + "[x2] \t max r_hat: 1.5410\n", + "[y] \t max r_hat: 2.0179\n", + "\n", + "dense_mass = True (bad r_hats)\n", + "[x1] \t max r_hat: 1.0697\n", + "[x2] \t max r_hat: 1.0738\n", + "[y] \t max r_hat: 1.2746\n", + "\n", + "structured mass matrix (good r_hats)\n", + "[x1] \t max r_hat: 1.0023\n", + "[x2] \t max r_hat: 1.0024\n", + "[y] \t max r_hat: 1.0030\n" + ] + } + ], + "source": [ + "print(\"dense_mass = False (very bad r_hats)\")\n", + "run_inference(partially_correlated_model, dense_mass=False, max_tree_depth=3)\n", + "\n", + "print(\"\\ndense_mass = True (bad r_hats)\")\n", + "run_inference(partially_correlated_model, dense_mass=True, max_tree_depth=3)\n", + "\n", + "# We use dense_mass=[(\"x1\", \"x2\")] to specify\n", + "# a structured mass matrix in which the y-part of the mass matrix is diagonal\n", + "# and the (x1, x2) block of the mass matrix is full-rank.\n", + "\n", + "# Graphically:\n", + "#\n", + "# x1 x2 y\n", + "# x1 | * * 0 |\n", + "# x2 | * * 0 |\n", + "# y | 0 0 * |\n", + "\n", + "print(\"\\nstructured mass matrix (good r_hats)\")\n", + "run_inference(partially_correlated_model, dense_mass=[(\"x1\", \"x2\")], max_tree_depth=3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# `max_tree_depth`\n", + "\n", + "The hyperparameter `max_tree_depth` can play an important role in determining the quality of posterior samples generated by NUTS. The default value in NumPyro is `max_tree_depth=10`. In some models, in particular those with especially difficult geometries, it may be necessary to increase `max_tree_depth` above `10`. In other cases where computing the gradient of the model log density is particularly expensive, it may be necessary to decrease `max_tree_depth` below `10` to reduce compute. As an example where large `max_tree_depth` is essential, we return to a variant of example #2. (We note that in this particular case another way to improve performance would be to use `dense_mass=True`).\n", + "\n", + "### Example #4" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "max_tree_depth = 5 (bad r_hat)\n", + "[x] \t max r_hat: 1.1159\n", + "max_tree_depth = 10 (good r_hat)\n", + "[x] \t max r_hat: 1.0166\n" + ] + } + ], + "source": [ + "# Because rho is very close to 1.0 the posterior geometry is extremely \n", + "# skewed and using small max_tree_depth leads to bad results.\n", + "rho = 0.999\n", + "dim = 200\n", + "cov = rho * jnp.ones((dim, dim)) + (1 - rho) * jnp.eye(dim)\n", + "\n", + "def mvn_model():\n", + " x = numpyro.sample(\"x\", \n", + " dist.MultivariateNormal(jnp.zeros(dim), \n", + " covariance_matrix=cov)\n", + " )\n", + " \n", + "print(\"max_tree_depth = 5 (bad r_hat)\")\n", + "run_inference(mvn_model, max_tree_depth=5)\n", + "\n", + "print(\"max_tree_depth = 10 (good r_hat)\")\n", + "run_inference(mvn_model, max_tree_depth=10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Other strategies\n", + "\n", + "- In some cases it can make sense to use variational inference to *learn* a new coordinate system. For details see [examples/neutra.py](https://github.com/pyro-ppl/numpyro/blob/master/examples/neutra.py) and reference [2]." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# References\n", + "\n", + "[1] \"Hamiltonian Monte Carlo for Hierarchical Models,\"\n", + " M. J. Betancourt, Mark Girolami.\n", + "\n", + "[2] \"NeuTra-lizing Bad Geometry in Hamiltonian Monte Carlo Using Neural Transport,\"\n", + " Matthew Hoffman, Pavel Sountsov, Joshua V. Dillon, Ian Langmore, Dustin Tran, Srinivas Vasudevan.\n", + " \n", + "[3] \"Reparameterization\" in the Stan user's manual.\n", + " https://mc-stan.org/docs/2_27/stan-users-guide/reparameterization-section.html" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From a0222329de6c2b043da6dac802de3537dc91c385 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Mon, 6 Sep 2021 11:39:27 -0700 Subject: [PATCH 168/222] fix hs (#1148) --- examples/horseshoe_regression.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/examples/horseshoe_regression.py b/examples/horseshoe_regression.py index b24261a42..c47429caf 100644 --- a/examples/horseshoe_regression.py +++ b/examples/horseshoe_regression.py @@ -45,7 +45,7 @@ def model_normal_likelihood(X, Y): # integrate out the coefficients (as is done for example in sparse_regression.py). # however, this trick wouldn't be applicable to other likelihoods # (e.g. bernoulli, see below) so we don't make use of it here. - unscaled_betas = numpyro.sample("unscaled_betas", dist.Normal(jnp.ones(D_X))) + unscaled_betas = numpyro.sample("unscaled_betas", dist.Normal(0.0, jnp.ones(D_X))) scaled_betas = numpyro.deterministic("betas", tau * lambdas * unscaled_betas) # compute mean function using linear coefficients @@ -68,7 +68,7 @@ def model_bernoulli_likelihood(X, Y): # note that this reparameterization (i.e. coordinate transformation) improves # posterior geometry and makes NUTS sampling more efficient - unscaled_betas = numpyro.sample("unscaled_betas", dist.Normal(jnp.ones(D_X))) + unscaled_betas = numpyro.sample("unscaled_betas", dist.Normal(0.0, jnp.ones(D_X))) scaled_betas = numpyro.deterministic("betas", tau * lambdas * unscaled_betas) # compute mean function using linear coefficients @@ -116,7 +116,6 @@ def get_data(N=50, D_X=3, sigma_obs=0.05, response="continuous"): if response == "continuous": Y += sigma_obs * np.random.randn(N) - Y /= Y.std() elif response == "binary": Y = np.random.binomial(1, expit(Y)) @@ -141,6 +140,8 @@ def main(args): # correspond to relevant covariates (see get_data) print("Posterior median over lambdas (leading 5 dimensions):") print(summary["lambdas"]["median"][:5]) + print("Posterior mean over betas (leading 5 dimensions):") + print(summary["betas"]["mean"][:5]) print("[Experiment with binary-valued responses]") # next generate and analyze data with binary-valued responses @@ -156,6 +157,8 @@ def main(args): # correspond to relevant covariates (see get_data) print("Posterior median over lambdas (leading 5 dimensions):") print(summary["lambdas"]["median"][:5]) + print("Posterior mean over betas (leading 5 dimensions):") + print(summary["betas"]["mean"][:5]) if __name__ == "__main__": From 062d822fd53dd3be7771d10ea05a77e235e7a824 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Mon, 6 Sep 2021 11:43:06 -0700 Subject: [PATCH 169/222] add ScaledUnitLowerCholeskyTransform and change default AutoMultivariateNormal parameterization (#1146) * initial commit * rm cruft * tweak * cleanup * fix test * remove print * registry * fix inverse * add to test_biject_to * fix transform implementation * black * add docs * add docstrings * string literal * fix docs * lint * update scaled unit lower cholesky transform to use softplus * fix log det bug * fix docstring Co-authored-by: Du Phan --- docs/source/distributions.rst | 12 +++++++ numpyro/distributions/constraints.py | 6 ++++ numpyro/distributions/transforms.py | 49 +++++++++++++++++++++++++++- numpyro/infer/autoguide.py | 16 +++------ test/test_distributions.py | 2 ++ 5 files changed, 72 insertions(+), 13 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 2ad8ad534..5fb98bb11 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -674,6 +674,10 @@ real_vector ^^^^^^^^^^^ .. autodata:: numpyro.distributions.constraints.real_vector +scaled_unit_lower_cholesky +^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autodata:: numpyro.distributions.constraints.scaled_unit_lower_cholesky + softplus_positive ^^^^^^^^^^^^^^^^^ .. autodata:: numpyro.distributions.constraints.softplus_positive @@ -830,6 +834,14 @@ PowerTransform :show-inheritance: :member-order: bysource +ScaledUnitLowerCholeskyTransform +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: numpyro.distributions.transforms.ScaledUnitLowerCholeskyTransform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + SigmoidTransform ^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.transforms.SigmoidTransform diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index 7b81b64cf..acf099918 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -47,6 +47,7 @@ "positive_integer", "real", "real_vector", + "scaled_unit_lower_cholesky", "simplex", "sphere", "softplus_lower_cholesky", @@ -452,6 +453,10 @@ def feasible_like(self, prototype): ) +class _ScaledUnitLowerCholesky(_LowerCholesky): + pass + + class _Sphere(Constraint): """ Constrain to the Euclidean sphere of any dimension. @@ -487,6 +492,7 @@ def feasible_like(self, prototype): interval = _Interval l1_ball = _L1Ball() lower_cholesky = _LowerCholesky() +scaled_unit_lower_cholesky = _ScaledUnitLowerCholesky() multinomial = _Multinomial nonnegative_integer = _IntegerGreaterThan(0) ordered_vector = _OrderedVector() diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 9932b14b4..443a5b8fc 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -37,6 +37,7 @@ "InvCholeskyTransform", "L1BallTransform", "LowerCholeskyTransform", + "ScaledUnitLowerCholeskyTransform", "LowerCholeskyAffine", "PermuteTransform", "PowerTransform", @@ -680,6 +681,13 @@ def inverse_shape(self, shape): class LowerCholeskyTransform(Transform): + """ + Transform a real vector to a lower triangular cholesky + factor, where the strictly lower triangular submatrix is + unconstrained and the diagonal is parameterized with an + exponential transform. + """ + domain = constraints.real_vector codomain = constraints.lower_cholesky @@ -707,6 +715,39 @@ def inverse_shape(self, shape): return _matrix_inverse_shape(shape) +class ScaledUnitLowerCholeskyTransform(LowerCholeskyTransform): + r""" + Like `LowerCholeskyTransform` this `Transform` transforms + a real vector to a lower triangular cholesky factor. However + it does so via a decomposition + + :math:`y = loc + unit\_scale\_tril\ @\ scale\_diag\ @\ x`. + + where :math:`unit\_scale\_tril` has ones along the diagonal + and :math:`scale\_diag` is a diagonal matrix with all positive + entries that is parameterized with a softplus transform. + """ + domain = constraints.real_vector + codomain = constraints.scaled_unit_lower_cholesky + + def __call__(self, x): + n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) + z = vec_to_tril_matrix(x[..., :-n], diagonal=-1) + diag = softplus(x[..., -n:]) + return (z + jnp.identity(n)) * diag[..., None] + + def _inverse(self, y): + diag = jnp.diagonal(y, axis1=-2, axis2=-1) + z = matrix_to_tril_vec(y / diag[..., None], diagonal=-1) + return jnp.concatenate([z, _softplus_inv(diag)], axis=-1) + + def log_abs_det_jacobian(self, x, y, intermediates=None): + n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) + diag = x[..., -n:] + diag_softplus = jnp.diagonal(y, axis1=-2, axis2=-1) + return (jnp.log(diag_softplus) * jnp.arange(n) - softplus(-diag)).sum(-1) + + class OrderedTransform(Transform): """ Transform a real vector to an ordered vector. @@ -879,7 +920,8 @@ def _inverse(self, y): return jnp.concatenate([z, diag], axis=-1) def log_abs_det_jacobian(self, x, y, intermediates=None): - # the jacobian is diagonal, so logdet is the sum of diagonal `exp` transform + # the jacobian is diagonal, so logdet is the sum of diagonal + # `softplus` transform n = round((math.sqrt(1 + 8 * x.shape[-1]) - 1) / 2) return -softplus(-x[..., -n:]).sum(-1) @@ -1079,6 +1121,11 @@ def _transform_to_lower_cholesky(constraint): return LowerCholeskyTransform() +@biject_to.register(constraints.scaled_unit_lower_cholesky) +def _transform_to_scaled_unit_lower_cholesky(constraint): + return ScaledUnitLowerCholeskyTransform() + + @biject_to.register(constraints.ordered_vector) def _transform_to_ordered_vector(constraint): return OrderedTransform() diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index dfd1a2d6f..8d17c186d 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -224,9 +224,7 @@ class AutoNormal(AutoGuide): automatically as usual. This is useful for data subsampling. """ - # TODO consider switching to constraints.softplus_positive - # See https://github.com/pyro-ppl/numpyro/issues/855 - scale_constraint = constraints.positive + scale_constraint = constraints.softplus_positive def __init__( self, @@ -825,9 +823,7 @@ class AutoDiagonalNormal(AutoContinuous): svi = SVI(model, guide, ...) """ - # TODO consider switching to constraints.softplus_positive - # See https://github.com/pyro-ppl/numpyro/issues/855 - scale_constraint = constraints.positive + scale_constraint = constraints.softplus_positive def __init__( self, @@ -896,9 +892,7 @@ class AutoMultivariateNormal(AutoContinuous): svi = SVI(model, guide, ...) """ - # TODO consider switching to constraints.softplus_lower_cholesky - # See https://github.com/pyro-ppl/numpyro/issues/855 - scale_tril_constraint = constraints.lower_cholesky + scale_tril_constraint = constraints.scaled_unit_lower_cholesky def __init__( self, @@ -970,9 +964,7 @@ class AutoLowRankMultivariateNormal(AutoContinuous): svi = SVI(model, guide, ...) """ - # TODO consider switching to constraints.softplus_positive - # See https://github.com/pyro-ppl/numpyro/issues/855 - scale_constraint = constraints.positive + scale_constraint = constraints.softplus_positive def __init__( self, diff --git a/test/test_distributions.py b/test/test_distributions.py index 496d242b2..dd5b25f20 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1582,6 +1582,7 @@ def test_constraints(constraint, x, expected): constraints.l1_ball, constraints.less_than(1), constraints.lower_cholesky, + constraints.scaled_unit_lower_cholesky, constraints.ordered_vector, constraints.positive, constraints.positive_definite, @@ -1666,6 +1667,7 @@ def inv_vec_transform(y): inv_expected = np.linalg.slogdet(jax.jacobian(inv_vec_transform)(y_tril))[1] elif constraint in [ constraints.lower_cholesky, + constraints.scaled_unit_lower_cholesky, constraints.positive_definite, constraints.softplus_lower_cholesky, ]: From b7b6e937297ea47c55760446134f84fc82936a9d Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Mon, 6 Sep 2021 13:47:40 -0700 Subject: [PATCH 170/222] init commit (#1149) --- numpyro/infer/svi.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index d37d08299..faeefae95 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -311,6 +311,9 @@ def run( :rtype: SVIRunResult """ + if num_steps < 1: + raise ValueError("num_steps must be a positive integer.") + def body_fn(svi_state, _): if stable_update: svi_state, loss = self.stable_update(svi_state, *args, **kwargs) From 0a08b8ba45fb23c572e05d04464fde45a7eeb937 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Thu, 9 Sep 2021 10:20:21 -0700 Subject: [PATCH 171/222] tweak autodais initialization and parameterization (#1153) * tweak autodais init/reparam * fix docstring --- numpyro/infer/autoguide.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 8d17c186d..4a89c76a5 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -638,10 +638,10 @@ class AutoDAIS(AutoContinuous): :param callable model: A NumPyro model. :param str prefix: A prefix that will be prefixed to all param internal sites. :param int K: A positive integer that controls the number of HMC steps used. - Defaults to 8. + Defaults to 4. :param str base_dist: Controls whether the base Normal variational distribution is parameterized by a "diagonal" covariance matrix or a full-rank covariance - matrix parameterized by a lower-diagonal "cholesky" factor. Defaults to "diagonal". + matrix parameterized by a lower-triangular "cholesky" factor. Defaults to "diagonal". :param float eta_init: The initial value of the step size used in HMC. Defaults to 0.01. :param float eta_max: The maximum value of the learnable step size used in HMC. @@ -659,7 +659,7 @@ def __init__( self, model, *, - K=8, + K=4, base_dist="diagonal", eta_init=0.01, eta_max=0.1, @@ -741,7 +741,8 @@ def log_density(x): inv_mass_matrix = 0.5 / mass_matrix init_z_loc = numpyro.param( - "{}_z_0_loc".format(self.prefix), jnp.zeros(self.latent_dim) + "{}_z_0_loc".format(self.prefix), + self._init_latent, ) if self.base_dist == "diagonal": @@ -755,7 +756,7 @@ def log_density(x): scale_tril = numpyro.param( "{}_z_0_scale_tril".format(self.prefix), jnp.identity(self.latent_dim) * self._init_scale, - constraint=constraints.lower_cholesky, + constraint=constraints.scaled_unit_lower_cholesky, ) base_z_dist = dist.MultivariateNormal(init_z_loc, scale_tril=scale_tril) From 34aba30151eec65067b81d2159bb5e5a25e76ab5 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Thu, 9 Sep 2021 10:21:53 -0700 Subject: [PATCH 172/222] add plate to bnn.py example for clarity (#1152) * add palte * add comment --- examples/bnn.py | 36 ++++++++++++++++++++---------------- 1 file changed, 20 insertions(+), 16 deletions(-) diff --git a/examples/bnn.py b/examples/bnn.py index ab404d86b..d709a2adb 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -40,34 +40,38 @@ def nonlin(x): # a two-layer bayesian neural network with computational flow # given by D_X => D_H => D_H => D_Y where D_H is the number of # hidden units. (note we indicate tensor dimensions in the comments) -def model(X, Y, D_H): - - D_X, D_Y = X.shape[1], 1 +def model(X, Y, D_H, D_Y=1): + N, D_X = X.shape # sample first layer (we put unit normal priors on all weights) - w1 = numpyro.sample( - "w1", dist.Normal(jnp.zeros((D_X, D_H)), jnp.ones((D_X, D_H))) - ) # D_X D_H - z1 = nonlin(jnp.matmul(X, w1)) # N D_H <= first layer of activations + w1 = numpyro.sample("w1", dist.Normal(jnp.zeros((D_X, D_H)), jnp.ones((D_X, D_H)))) + assert w1.shape == (D_X, D_H) + z1 = nonlin(jnp.matmul(X, w1)) # <= first layer of activations + assert z1.shape == (N, D_H) # sample second layer - w2 = numpyro.sample( - "w2", dist.Normal(jnp.zeros((D_H, D_H)), jnp.ones((D_H, D_H))) - ) # D_H D_H - z2 = nonlin(jnp.matmul(z1, w2)) # N D_H <= second layer of activations + w2 = numpyro.sample("w2", dist.Normal(jnp.zeros((D_H, D_H)), jnp.ones((D_H, D_H)))) + assert w2.shape == (D_H, D_H) + z2 = nonlin(jnp.matmul(z1, w2)) # <= second layer of activations + assert z2.shape == (N, D_H) # sample final layer of weights and neural network output - w3 = numpyro.sample( - "w3", dist.Normal(jnp.zeros((D_H, D_Y)), jnp.ones((D_H, D_Y))) - ) # D_H D_Y - z3 = jnp.matmul(z2, w3) # N D_Y <= output of the neural network + w3 = numpyro.sample("w3", dist.Normal(jnp.zeros((D_H, D_Y)), jnp.ones((D_H, D_Y)))) + assert w3.shape == (D_H, D_Y) + z3 = jnp.matmul(z2, w3) # <= output of the neural network + assert z3.shape == (N, D_Y) + + if Y is not None: + assert z3.shape == Y.shape # we put a prior on the observation noise prec_obs = numpyro.sample("prec_obs", dist.Gamma(3.0, 1.0)) sigma_obs = 1.0 / jnp.sqrt(prec_obs) # observe data - numpyro.sample("Y", dist.Normal(z3, sigma_obs), obs=Y) + with numpyro.plate("data", N): + # note we use to_event(1) because each observation has shape (1,) + numpyro.sample("Y", dist.Normal(z3, sigma_obs).to_event(1), obs=Y) # helper function for HMC inference From e91bd439c619b1446f4d507d4ae70da45a2d9f90 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Mon, 20 Sep 2021 14:02:59 +0200 Subject: [PATCH 173/222] Sine Skewed distribution (#1055) * added sine_skewed distribution * Fixed missing math import. * Fixed failing tests. * Fixed linter and test cases. * Ran isort on entire project. * Fixed compact.pyro * Removed rogue .isort.cfg file. * Ran black. * Fixed docstring for `SineSkewed` distribution. * Added `base_dist.event_shape` check to instantiation, fixed docstring and added todo. * Fixed assert in `SineSkewed` * Fixed logp1 * Fixed lint. * Added L1BallTransform. * Fixed docstring. * Changed to l1ball constraint on skewness. Co-authored-by: Ola --- docs/source/distributions.rst | 14 ++- numpyro/compat/pyro.py | 4 +- numpyro/distributions/__init__.py | 2 + numpyro/distributions/directional.py | 132 ++++++++++++++++++++++++++- test/test_distributions.py | 57 ++++++++++-- 5 files changed, 194 insertions(+), 15 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 5fb98bb11..5406fa07f 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -502,13 +502,21 @@ ProjectedNormal :member-order: bysource SineBivariateVonMises ---------------------- +^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.directional.SineBivariateVonMises :members: :undoc-members: :show-inheritance: :member-order: bysource +SineSkewed +^^^^^^^^^^ +.. autoclass:: numpyro.distributions.directional.SineSkewed + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + VonMises ^^^^^^^^ .. autoclass:: numpyro.distributions.directional.VonMises @@ -599,7 +607,7 @@ boolean .. autodata:: numpyro.distributions.constraints.boolean circular --------- +^^^^^^^^ .. autodata:: numpyro.distributions.constraints.circular corr_cholesky @@ -787,7 +795,7 @@ InvCholeskyTransform :member-order: bysource L1BallTransform ---------------- +^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.transforms.L1BallTransform :members: :undoc-members: diff --git a/numpyro/compat/pyro.py b/numpyro/compat/pyro.py index 47f805596..07d94df97 100644 --- a/numpyro/compat/pyro.py +++ b/numpyro/compat/pyro.py @@ -4,7 +4,9 @@ import warnings from numpyro.compat.util import UnsupportedAPIWarning -from numpyro.primitives import module, param as _param, plate, sample # noqa: F401 + +from numpyro.primitives import module, plate, sample # noqa: F401 isort:skip +from numpyro.primitives import param as _param # noqa: F401 isort:skip _PARAM_STORE = {} diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 4a24d2880..a413224a9 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -40,6 +40,7 @@ from numpyro.distributions.directional import ( ProjectedNormal, SineBivariateVonMises, + SineSkewed, VonMises, ) from numpyro.distributions.discrete import ( @@ -152,6 +153,7 @@ "PRNGIdentity", "RightTruncatedDistribution", "SineBivariateVonMises", + "SineSkewed", "SoftLaplace", "StudentT", "TransformedDistribution", diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index f27126587..6fb19d7ff 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -153,6 +153,136 @@ def variance(self): PhiMarginalState = namedtuple("PhiMarginalState", ["i", "done", "phi", "key"]) +class SineSkewed(Distribution): + """Sine-skewing [1] is a procedure for producing a distribution that breaks pointwise symmetry on a torus + distribution. The new distribution is called the Sine Skewed X distribution, where X is the name of the (symmetric) + base distribution. Torus distributions are distributions with support on products of circles + (i.e., ⨂^d S^1 where S^1=[-pi,pi) ). So, a 0-torus is a point, the 1-torus is a circle, + and the 2-torus is commonly associated with the donut shape. + + The sine skewed X distribution is parameterized by a weight parameter for each dimension of the event of X. + For example with a von Mises distribution over a circle (1-torus), the sine skewed von Mises distribution has one + skew parameter. The skewness parameters can be inferred using :class:`~numpyro.infer.HMC` or + :class:`~numpyro.infer.NUTS`. For example, the following will produce a prior over + skewness for the 2-torus,:: + + @numpyro.handlers.reparam(config={'phi_loc': CircularReparam(), 'psi_loc': CircularReparam()}) + def model(obs): + # Sine priors + phi_loc = numpyro.sample('phi_loc', VonMises(pi, 2.)) + psi_loc = numpyro.sample('psi_loc', VonMises(-pi / 2, 2.)) + phi_conc = numpyro.sample('phi_conc', Beta(1., 1.)) + psi_conc = numpyro.sample('psi_conc', Beta(1., 1.)) + corr_scale = numpyro.sample('corr_scale', Beta(2., 5.)) + + # Skewing prior + ball_trans = L1BallTransform() + skewness = numpyro.sample('skew_phi', Normal(0, 0.5).expand((2,))) + skewness = ball_trans(skewness) # constraint sum |skewness_i| <= 1 + + with numpyro.plate('obs_plate'): + sine = SineBivariateVonMises(phi_loc=phi_loc, psi_loc=psi_loc, + phi_concentration=70 * phi_conc, + psi_concentration=70 * psi_conc, + weighted_correlation=corr_scale) + return numpyro.sample('phi_psi', SineSkewed(sine, skewness), obs=obs) + + To ensure the skewing does not alter the normalization constant of the (sine bivariate von Mises) base + distribution the skewness parameters are constraint. The constraint requires the sum of the absolute values of + skewness to be less than or equal to one. We can use the :class:`~numpyro.distriubtions.transforms.L1BallTransform` + to achieve this. + + In the context of :class:`~pyro.infer.SVI`, this distribution can freely be used as a likelihood, but use as + latent variables it will lead to slow inference for 2 and higher dim toruses. This is because the base_dist + cannot be reparameterized. + + .. note:: An event in the base distribution must be on a d-torus, so the event_shape must be `(d,)`. + + .. note:: For the skewness parameter, it must hold that the sum of the absolute value of its weights for an event + must be less than or equal to one. See eq. 2.1 in [1]. + + ** References: ** + 1. Sine-skewed toroidal distributions and their application in protein bioinformatics + Ameijeiras-Alonso, J., Ley, C. (2019) + + :param numpyro.distributions.Distribution base_dist: base density on a d-dimensional torus. Supported base + distributions include: 1D :class:`~numpyro.distributions.VonMises`, + :class:`~numnumpyro.distributions.SineBivariateVonMises`, 1D :class:`~numpyro.distributions.ProjectedNormal`, + and :class:`~numpyro.distributions.Uniform` (-pi, pi). + :param jax.numpy.array skewness: skewness of the distribution. + """ + + arg_constraints = {"skewness": constraints.l1_ball} + + support = constraints.independent(constraints.circular, 1) + + def __init__(self, base_dist: Distribution, skewness, validate_args=None): + assert ( + base_dist.event_shape == skewness.shape[-1:] + ), "Sine Skewing is only valid with a skewness parameter for each dimension of `base_dist.event_shape`." + + batch_shape = jnp.broadcast_shapes(base_dist.batch_shape, skewness.shape[:-1]) + event_shape = skewness.shape[-1:] + self.skewness = jnp.broadcast_to(skewness, batch_shape + event_shape) + self.base_dist = base_dist.expand(batch_shape) + super().__init__(batch_shape, event_shape, validate_args=validate_args) + + def __repr__(self): + args_string = ", ".join( + [ + "{}: {}".format( + p, + getattr(self, p) + if getattr(self, p).numel() == 1 + else getattr(self, p).size(), + ) + for p in self.arg_constraints.keys() + ] + ) + return ( + self.__class__.__name__ + + "(" + + f"base_density: {str(self.base_dist)}, " + + args_string + + ")" + ) + + def sample(self, key, sample_shape=()): + base_key, skew_key = random.split(key) + bd = self.base_dist + ys = bd.sample(base_key, sample_shape) + u = random.uniform(skew_key, sample_shape + self.batch_shape) + + # Section 2.3 step 3 in [1] + mask = u <= 0.5 + 0.5 * ( + self.skewness * jnp.sin((ys - bd.mean) % (2 * jnp.pi)) + ).sum(-1) + mask = mask[..., None] + samples = (jnp.where(mask, ys, -ys + 2 * bd.mean) + jnp.pi) % ( + 2 * jnp.pi + ) - jnp.pi + return samples + + def log_prob(self, value): + if self._validate_args: + self._validate_sample(value) + if self.base_dist._validate_args: + self.base_dist._validate_sample(value) + + # Eq. 2.1 in [1] + skew_prob = jnp.log1p( + (self.skewness * jnp.sin((value - self.base_dist.mean) % (2 * jnp.pi))).sum( + -1 + ) + ) + return self.base_dist.log_prob(value) + skew_prob + + @property + def mean(self): + """Mean of the base distribution""" + return self.base_dist.mean + + class SineBivariateVonMises(Distribution): r"""Unimodal distribution of two dependent angles on the 2-torus (S^1 ⨂ S^1) given by @@ -389,8 +519,6 @@ def mean(self): mean = (jnp.stack((self.phi_loc, self.psi_loc), axis=-1) + jnp.pi) % ( 2.0 * jnp.pi ) - jnp.pi - print(mean.shape) - print(self.batch_shape) return jnp.broadcast_to(mean, (*self.batch_shape, 2)) def _bfind(self, eig): diff --git a/test/test_distributions.py b/test/test_distributions.py index dd5b25f20..706d8420f 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -95,6 +95,27 @@ def _TruncatedNormal(loc, scale, low, high): _TruncatedNormal.infer_shapes = lambda *args: (lax.broadcast_shapes(*args), ()) +class SineSkewedUniform(dist.SineSkewed): + def __init__(self, skewness, **kwargs): + lower, upper = (jnp.array([-math.pi, -math.pi]), jnp.array([math.pi, math.pi])) + base_dist = dist.Uniform(lower, upper, **kwargs).to_event(lower.ndim) + super().__init__(base_dist, skewness, **kwargs) + + +class SineSkewedVonMises(dist.SineSkewed): + def __init__(self, skewness, **kwargs): + von_loc, von_conc = (jnp.array([0.0]), jnp.array([1.0])) + base_dist = dist.VonMises(von_loc, von_conc, **kwargs).to_event(von_loc.ndim) + super().__init__(base_dist, skewness, **kwargs) + + +class SineSkewedVonMisesBatched(dist.SineSkewed): + def __init__(self, skewness, **kwargs): + von_loc, von_conc = (jnp.array([0.0, -1.234]), jnp.array([1.0, 10.0])) + base_dist = dist.VonMises(von_loc, von_conc, **kwargs).to_event(von_loc.ndim) + super().__init__(base_dist, skewness, **kwargs) + + def _GaussianMixture(mixing_probs, loc, scale): component_dist = dist.Normal(loc=loc, scale=scale) mixing_distribution = dist.Categorical(probs=mixing_probs) @@ -434,6 +455,9 @@ def get_sp_dist(jax_dist): T(dist.ProjectedNormal, jnp.array([[2.0, 3.0]])), T(dist.ProjectedNormal, jnp.array([0.0, 0.0, 0.0])), T(dist.ProjectedNormal, jnp.array([[-1.0, 2.0, 3.0]])), + T(SineSkewedUniform, jnp.array([-math.pi / 4, 0.1])), + T(SineSkewedVonMises, jnp.array([0.342355])), + T(SineSkewedVonMisesBatched, jnp.array([[0.342355, -0.0001], [0.91, 0.09]])), ] DISCRETE = [ @@ -561,6 +585,12 @@ def gen_values_within_bounds(constraint, size, key=random.PRNGKey(11)): elif constraint is constraints.sphere: x = random.normal(key, size) return x / jnp.linalg.norm(x, axis=-1) + elif constraint is constraints.l1_ball: + key1, key2 = random.split(key) + sign = random.bernoulli(key1) + bounds = [0, (-1) ** sign * 0.5] + return random.uniform(key, size, float, *sorted(bounds)) + else: raise NotImplementedError("{} not implemented.".format(constraint)) @@ -622,6 +652,11 @@ def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)): x = random.normal(key, size) x = x / jnp.linalg.norm(x, axis=-1, keepdims=True) return 2 * x + elif constraint is constraints.l1_ball: + key1, key2 = random.split(key) + sign = random.bernoulli(key1) + bounds = [(-1) ** sign * 1.1, (-1) ** sign * 2] + return random.uniform(key, size, float, *sorted(bounds)) else: raise NotImplementedError("{} not implemented.".format(constraint)) @@ -839,15 +874,13 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): rng_key = random.PRNGKey(0) samples = jax_dist.sample(key=rng_key, sample_shape=prepend_shape) assert jax_dist.log_prob(samples).shape == prepend_shape + jax_dist.batch_shape + truncated_dists = ( + dist.LeftTruncatedDistribution, + dist.RightTruncatedDistribution, + dist.TwoSidedTruncatedDistribution, + ) if sp_dist is None: - if isinstance( - jax_dist, - ( - dist.LeftTruncatedDistribution, - dist.RightTruncatedDistribution, - dist.TwoSidedTruncatedDistribution, - ), - ): + if isinstance(jax_dist, truncated_dists): if isinstance(params[0], dist.Distribution): # new api loc, scale, low, high = ( @@ -1200,6 +1233,8 @@ def test_mean_var(jax_dist, sp_dist, params): pytest.skip("Improper distribution does not has mean/var implemented") if jax_dist is FoldedNormal: pytest.skip("Folded distribution does not has mean/var implemented") + if "SineSkewed" in jax_dist.__name__: + pytest.skip("Skewed Distribution are not symmetric about location.") if jax_dist in ( _TruncatedNormal, dist.LeftTruncatedDistribution, @@ -1316,6 +1351,8 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): and dist_args[i] != "concentration" ): continue + if "SineSkewed" in jax_dist.__name__ and dist_args[i] != "skewness": + continue if ( jax_dist is dist.TwoSidedTruncatedDistribution and dist_args[i] == "base_dist" @@ -1347,7 +1384,9 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): assert jax_dist(*oob_params) # Invalid parameter values throw ValueError - if not dependent_constraint and jax_dist is not _ImproperWrapper: + if not dependent_constraint and ( + jax_dist is not _ImproperWrapper and "SineSkewed" not in jax_dist.__name__ + ): with pytest.raises(ValueError): jax_dist(*oob_params, validate_args=True) From 9930f3a3401b08441823d6e7b859170b0bcc4097 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 24 Sep 2021 10:18:14 -0400 Subject: [PATCH 174/222] Fix import issue for the last jax release (#1157) * fix importing partial from jax * assert both ndarray and jnp.ndarray * lint * adjust precision of failing test --- numpyro/handlers.py | 4 ++-- numpyro/infer/hmc.py | 3 ++- numpyro/infer/mcmc.py | 4 +++- test/contrib/test_optim.py | 4 +++- test/infer/test_compute_downstream_costs.py | 2 +- test/test_optimizers.py | 4 +++- 6 files changed, 14 insertions(+), 7 deletions(-) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 8f1386b9e..5d25b172e 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -674,11 +674,11 @@ class seed(Messenger): def __init__(self, fn=None, rng_seed=None): if isinstance(rng_seed, int) or ( - isinstance(rng_seed, jnp.ndarray) and not jnp.shape(rng_seed) + isinstance(rng_seed, (np.ndarray, jnp.ndarray)) and not jnp.shape(rng_seed) ): rng_seed = random.PRNGKey(rng_seed) if not ( - isinstance(rng_seed, jnp.ndarray) + isinstance(rng_seed, (np.ndarray, jnp.ndarray)) and rng_seed.dtype == jnp.uint32 and rng_seed.shape == (2,) ): diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 4be8cb645..0f8409454 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -2,10 +2,11 @@ # SPDX-License-Identifier: Apache-2.0 from collections import OrderedDict, namedtuple +from functools import partial import math import os -from jax import device_put, lax, partial, random, vmap +from jax import device_put, lax, random, vmap from jax.flatten_util import ravel_pytree import jax.numpy as jnp diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index f617e274d..95a5e4076 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -7,6 +7,8 @@ import os import warnings +import numpy as np + from jax import jit, lax, local_device_count, pmap, random, vmap from jax.core import Tracer from jax.interpreters.xla import DeviceArray @@ -190,7 +192,7 @@ def _hashable(x): return x elif isinstance(x, DeviceArray): return x.copy().tobytes() - elif isinstance(x, jnp.ndarray): + elif isinstance(x, (np.ndarray, jnp.ndarray)): return x.tobytes() return x diff --git a/test/contrib/test_optim.py b/test/contrib/test_optim.py index 361c8f5ae..294236b4b 100644 --- a/test/contrib/test_optim.py +++ b/test/contrib/test_optim.py @@ -1,10 +1,12 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +from functools import partial + from numpy.testing import assert_allclose import pytest -from jax import grad, jit, partial, random +from jax import grad, jit, random from jax.lax import fori_loop import jax.numpy as jnp from jax.test_util import check_close diff --git a/test/infer/test_compute_downstream_costs.py b/test/infer/test_compute_downstream_costs.py index 38d770995..91b55cdf7 100644 --- a/test/infer/test_compute_downstream_costs.py +++ b/test/infer/test_compute_downstream_costs.py @@ -304,7 +304,7 @@ def test_compute_downstream_costs_big_model_guide_pair( for k in dc: assert guide_trace[k]["log_prob"].shape == dc[k].shape - assert_allclose(dc[k], dc_brute[k]) + assert_allclose(dc[k], dc_brute[k], rtol=2e-7) def plate_reuse_model_guide(include_obs=True, dim1=3, dim2=2): diff --git a/test/test_optimizers.py b/test/test_optimizers.py index 9d7a30f8a..cee01e415 100644 --- a/test/test_optimizers.py +++ b/test/test_optimizers.py @@ -1,9 +1,11 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +from functools import partial + import pytest -from jax import grad, jit, partial +from jax import grad, jit import jax.numpy as jnp from numpyro import optim From cd5549cf977b11ffdc853fec7f7ebafd8d9d61a3 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 24 Sep 2021 10:18:34 -0400 Subject: [PATCH 175/222] Assert sample shape argument is a tuple (#1158) * fix importing partial from jax * assert both ndarray and jnp.ndarray * lint * assert sample shape needs to be a tuple * adjust precision of failing test --- numpyro/primitives.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index fb6632e47..14b179daf 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -131,6 +131,9 @@ def sample( + "_unobserved"`` which should be used by guides. :return: sample from the stochastic `fn`. """ + assert isinstance( + sample_shape, tuple + ), "sample_shape needs to be a tuple of integers" if not isinstance(fn, numpyro.distributions.Distribution): type_error = TypeError( "It looks like you tried to use a fn that isn't an instance of " From a8c1cf4e97ece314bddbd93f88a06f1ebeaca224 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 24 Sep 2021 11:42:17 -0400 Subject: [PATCH 176/222] Improve docs for MCMC (#1159) * fix importing partial from jax * assert both ndarray and jnp.ndarray * lint * add docs to clarify various points in mcmc * adjust precision of failing test --- numpyro/infer/hmc.py | 12 ++++++++++-- numpyro/infer/mcmc.py | 5 ++++- 2 files changed, 14 insertions(+), 3 deletions(-) diff --git a/numpyro/infer/hmc.py b/numpyro/infer/hmc.py index 0f8409454..850a16fa3 100644 --- a/numpyro/infer/hmc.py +++ b/numpyro/infer/hmc.py @@ -512,7 +512,11 @@ class HMC(MCMCKernel): Hamiltonian Monte Carlo inference, using fixed trajectory length, with provision for step size and mass matrix adaptation. - .. note:: until the kernel is used in an MCMC run, `postprocess_fn` will return the identity + .. note:: Until the kernel is used in an MCMC run, `postprocess_fn` will return the + identity function. + + .. note:: The default init strategy ``init_to_uniform`` might not be a good strategy + for some models. You might want to try other init strategies like ``init_to_median``. **References:** @@ -769,7 +773,11 @@ class NUTS(HMC): Hamiltonian Monte Carlo inference, using the No U-Turn Sampler (NUTS) with adaptive path length and mass matrix adaptation. - .. note:: until the kernel is used in an MCMC run, `postprocess_fn` will return the identity + .. note:: Until the kernel is used in an MCMC run, `postprocess_fn` will return the + identity function. + + .. note:: The default init strategy ``init_to_uniform`` might not be a good strategy + for some models. You might want to try other init strategies like ``init_to_median``. **References:** diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 95a5e4076..367afbfdf 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -209,7 +209,8 @@ class MCMC(object): .. note:: If setting `num_chains` greater than `1` in a Jupyter Notebook, then you will need to have installed `ipywidgets `_ in the environment from which you launced Jupyter in order for the progress bars to render - correctly. + correctly. If you are using Jupyter Notebook or Jupyter Lab, please also install the + corresponding extension package like `widgetsnbextension` or `jupyterlab_widgets`. :param MCMCKernel sampler: an instance of :class:`~numpyro.infer.mcmc.MCMCKernel` that determines the sampler for running MCMC. Currently, only :class:`~numpyro.infer.hmc.HMC` @@ -236,6 +237,8 @@ class MCMC(object): :param bool jit_model_args: If set to `True`, this will compile the potential energy computation as a function of model arguments. As such, calling `MCMC.run` again on a same sized but different dataset will not result in additional compilation cost. + Note that currently, this does not take effect for the case ``num_chains > 1`` + and ``chain_method == 'parallel'``. """ def __init__( From 968349e01da2268be531cfa008b3eb7bfc01d6e5 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Sat, 25 Sep 2021 12:22:21 +0100 Subject: [PATCH 177/222] Use black[jupyter] in notebooks (#1162) * use black[jupyter] * update version number --- notebooks/source/bad_posterior_geometry.ipynb | 86 +- ...esian_hierarchical_linear_regression.ipynb | 128 +- notebooks/source/bayesian_imputation.ipynb | 11 +- notebooks/source/bayesian_regression.ipynb | 4666 +++++++++-------- notebooks/source/discrete_imputation.ipynb | 135 +- notebooks/source/logistic_regression.ipynb | 39 +- notebooks/source/model_rendering.ipynb | 47 +- notebooks/source/ordinal_regression.ipynb | 124 +- .../source/time_series_forecasting.ipynb | 2 +- scripts/update_version.py | 4 +- setup.py | 2 +- 11 files changed, 2688 insertions(+), 2556 deletions(-) diff --git a/notebooks/source/bad_posterior_geometry.ipynb b/notebooks/source/bad_posterior_geometry.ipynb index 3b72a6dca..cacea25a7 100644 --- a/notebooks/source/bad_posterior_geometry.ipynb +++ b/notebooks/source/bad_posterior_geometry.ipynb @@ -49,7 +49,8 @@ "from numpyro.diagnostics import summary\n", "\n", "from numpyro.infer import MCMC, NUTS\n", - "assert numpyro.__version__.startswith('0.7.2')\n", + "\n", + "assert numpyro.__version__.startswith(\"0.7.2\")\n", "\n", "# NB: replace cpu by gpu to run this notebook on gpu\n", "numpyro.set_platform(\"cpu\")" @@ -68,15 +69,11 @@ "metadata": {}, "outputs": [], "source": [ - "def run_inference(model, \n", - " num_warmup=1000, \n", - " num_samples=1000,\n", - " max_tree_depth=10, \n", - " dense_mass=False):\n", - " \n", - " kernel = NUTS(model, \n", - " max_tree_depth=max_tree_depth,\n", - " dense_mass=dense_mass)\n", + "def run_inference(\n", + " model, num_warmup=1000, num_samples=1000, max_tree_depth=10, dense_mass=False\n", + "):\n", + "\n", + " kernel = NUTS(model, max_tree_depth=max_tree_depth, dense_mass=dense_mass)\n", " mcmc = MCMC(\n", " kernel,\n", " num_warmup=num_warmup,\n", @@ -85,12 +82,12 @@ " progress_bar=False,\n", " )\n", " mcmc.run(random.PRNGKey(0))\n", - " summary_dict = summary(mcmc.get_samples(), group_by_chain=False) \n", - " \n", + " summary_dict = summary(mcmc.get_samples(), group_by_chain=False)\n", + "\n", " # print the largest r_hat for each variable\n", " for k, v in summary_dict.items():\n", " spaces = \" \" * max(12 - len(k), 0)\n", - " print(\"[{}] {} \\t max r_hat: {:.4f}\".format(k, spaces, np.max(v['r_hat'])))" + " print(\"[{}] {} \\t max r_hat: {:.4f}\".format(k, spaces, np.max(v[\"r_hat\"])))" ] }, { @@ -170,15 +167,17 @@ "outputs": [], "source": [ "# In this reparameterized model none of the parameters of the distributions\n", - "# explicitly depend on other parameters. This model is exactly equivalent \n", + "# explicitly depend on other parameters. This model is exactly equivalent\n", "# to _unrep_hs_model but is expressed in a different coordinate system.\n", "def _rep_hs_model1(X, Y):\n", " lambdas = numpyro.sample(\"lambdas\", dist.HalfCauchy(jnp.ones(X.shape[1])))\n", " tau = numpyro.sample(\"tau\", dist.HalfCauchy(jnp.ones(1)))\n", - " unscaled_betas = numpyro.sample(\"unscaled_betas\", dist.Normal(scale=jnp.ones(X.shape[1])))\n", + " unscaled_betas = numpyro.sample(\n", + " \"unscaled_betas\", dist.Normal(scale=jnp.ones(X.shape[1]))\n", + " )\n", " scaled_betas = numpyro.deterministic(\"betas\", tau * lambdas * unscaled_betas)\n", " mean_function = jnp.dot(X, scaled_betas)\n", - " numpyro.sample(\"Y\", dist.Normal(mean_function, 0.05), obs=Y) " + " numpyro.sample(\"Y\", dist.Normal(mean_function, 0.05), obs=Y)" ] }, { @@ -196,7 +195,8 @@ "metadata": {}, "outputs": [], "source": [ - "from numpyro.infer.reparam import LocScaleReparam \n", + "from numpyro.infer.reparam import LocScaleReparam\n", + "\n", "# LocScaleReparam with centered=0 fully \"decenters\" the prior over betas.\n", "config = {\"betas\": LocScaleReparam(centered=0)}\n", "# The coordinate system of this model is equivalent to that in _rep_hs_model1 above.\n", @@ -217,30 +217,31 @@ "outputs": [], "source": [ "from numpyro.distributions.transforms import AffineTransform\n", - "from numpyro.infer.reparam import TransformReparam \n", + "from numpyro.infer.reparam import TransformReparam\n", "\n", "# In this reparameterized model none of the parameters of the distributions\n", - "# explicitly depend on other parameters. This model is exactly equivalent \n", + "# explicitly depend on other parameters. This model is exactly equivalent\n", "# to _unrep_hs_model but is expressed in a different coordinate system.\n", "def _rep_hs_model3(X, Y):\n", " lambdas = numpyro.sample(\"lambdas\", dist.HalfCauchy(jnp.ones(X.shape[1])))\n", " tau = numpyro.sample(\"tau\", dist.HalfCauchy(jnp.ones(1)))\n", - " \n", + "\n", " # instruct NumPyro to do the reparameterization automatically.\n", " reparam_config = {\"betas\": TransformReparam()}\n", " with numpyro.handlers.reparam(config=reparam_config):\n", " betas_root_variance = tau * lambdas\n", " # in order to use TransformReparam we have to express the prior\n", " # over betas as a TransformedDistribution\n", - " betas = numpyro.sample(\"betas\", \n", + " betas = numpyro.sample(\n", + " \"betas\",\n", " dist.TransformedDistribution(\n", - " dist.Normal(0., jnp.ones(X.shape[1])), \n", - " AffineTransform(0., betas_root_variance)\n", - " )\n", + " dist.Normal(0.0, jnp.ones(X.shape[1])),\n", + " AffineTransform(0.0, betas_root_variance),\n", + " ),\n", " )\n", - " \n", + "\n", " mean_function = jnp.dot(X, betas)\n", - " numpyro.sample(\"Y\", dist.Normal(mean_function, 0.05), obs=Y) " + " numpyro.sample(\"Y\", dist.Normal(mean_function, 0.05), obs=Y)" ] }, { @@ -349,17 +350,17 @@ } ], "source": [ - "# Because rho is very close to 1.0 the posterior geometry \n", - "# is extremely skewed and using the \"diagonal\" coordinate system \n", + "# Because rho is very close to 1.0 the posterior geometry\n", + "# is extremely skewed and using the \"diagonal\" coordinate system\n", "# implied by dense_mass=False leads to bad results\n", "rho = 0.9999\n", "cov = jnp.array([[10.0, rho], [rho, 0.1]])\n", "\n", + "\n", "def mvn_model():\n", - " numpyro.sample(\"x\", \n", - " dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", - " )\n", - " \n", + " numpyro.sample(\"x\", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov))\n", + "\n", + "\n", "print(\"dense_mass = False (bad r_hat)\")\n", "run_inference(mvn_model, dense_mass=False, max_tree_depth=3)\n", "\n", @@ -391,12 +392,12 @@ "# In this model x1 and x2 are highly correlated with one another\n", "# but not correlated with y at all.\n", "def partially_correlated_model():\n", - " x1 = numpyro.sample(\"x1\", \n", - " dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", + " x1 = numpyro.sample(\n", + " \"x1\", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", + " )\n", + " x2 = numpyro.sample(\n", + " \"x2\", dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", " )\n", - " x2 = numpyro.sample(\"x2\", \n", - " dist.MultivariateNormal(jnp.zeros(2), covariance_matrix=cov)\n", - " ) \n", " y = numpyro.sample(\"y\", dist.Normal(jnp.zeros(100), 1.0))\n", " numpyro.sample(\"obs\", dist.Normal(x1 - x2, 0.1), jnp.ones(2))" ] @@ -484,18 +485,19 @@ } ], "source": [ - "# Because rho is very close to 1.0 the posterior geometry is extremely \n", + "# Because rho is very close to 1.0 the posterior geometry is extremely\n", "# skewed and using small max_tree_depth leads to bad results.\n", "rho = 0.999\n", "dim = 200\n", "cov = rho * jnp.ones((dim, dim)) + (1 - rho) * jnp.eye(dim)\n", "\n", + "\n", "def mvn_model():\n", - " x = numpyro.sample(\"x\", \n", - " dist.MultivariateNormal(jnp.zeros(dim), \n", - " covariance_matrix=cov)\n", + " x = numpyro.sample(\n", + " \"x\", dist.MultivariateNormal(jnp.zeros(dim), covariance_matrix=cov)\n", " )\n", - " \n", + "\n", + "\n", "print(\"max_tree_depth = 5 (bad r_hat)\")\n", "run_inference(mvn_model, max_tree_depth=5)\n", "\n", diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index e858ffd9a..495af5a01 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -145,10 +145,12 @@ } ], "source": [ - "train = pd.read_csv('https://gist.githubusercontent.com/ucals/'\n", - " '2cf9d101992cb1b78c2cdd6e3bac6a4b/raw/'\n", - " '43034c39052dcf97d4b894d2ec1bc3f90f3623d9/'\n", - " 'osic_pulmonary_fibrosis.csv')\n", + "train = pd.read_csv(\n", + " \"https://gist.githubusercontent.com/ucals/\"\n", + " \"2cf9d101992cb1b78c2cdd6e3bac6a4b/raw/\"\n", + " \"43034c39052dcf97d4b894d2ec1bc3f90f3623d9/\"\n", + " \"osic_pulmonary_fibrosis.csv\"\n", + ")\n", "train.head()" ] }, @@ -181,17 +183,17 @@ ], "source": [ "def chart(patient_id, ax):\n", - " data = train[train['Patient'] == patient_id]\n", - " x = data['Weeks']\n", - " y = data['FVC']\n", + " data = train[train[\"Patient\"] == patient_id]\n", + " x = data[\"Weeks\"]\n", + " y = data[\"FVC\"]\n", " ax.set_title(patient_id)\n", - " ax = sns.regplot(x, y, ax=ax, ci=None, line_kws={'color':'red'})\n", - " \n", + " ax = sns.regplot(x, y, ax=ax, ci=None, line_kws={\"color\": \"red\"})\n", + "\n", "\n", "f, axes = plt.subplots(1, 3, figsize=(15, 5))\n", - "chart('ID00007637202177411956430', axes[0])\n", - "chart('ID00009637202177434476278', axes[1])\n", - "chart('ID00010637202177584971671', axes[2])" + "chart(\"ID00007637202177411956430\", axes[0])\n", + "chart(\"ID00009637202177434476278\", axes[1])\n", + "chart(\"ID00010637202177584971671\", axes[2])" ] }, { @@ -242,7 +244,7 @@ "import numpyro.distributions as dist\n", "from jax import random\n", "\n", - "assert numpyro.__version__.startswith('0.7.2')" + "assert numpyro.__version__.startswith(\"0.7.2\")" ] }, { @@ -252,21 +254,21 @@ "outputs": [], "source": [ "def model(PatientID, Weeks, FVC_obs=None):\n", - " μ_α = numpyro.sample(\"μ_α\", dist.Normal(0., 100.))\n", - " σ_α = numpyro.sample(\"σ_α\", dist.HalfNormal(100.))\n", - " μ_β = numpyro.sample(\"μ_β\", dist.Normal(0., 100.))\n", - " σ_β = numpyro.sample(\"σ_β\", dist.HalfNormal(100.))\n", - " \n", + " μ_α = numpyro.sample(\"μ_α\", dist.Normal(0.0, 100.0))\n", + " σ_α = numpyro.sample(\"σ_α\", dist.HalfNormal(100.0))\n", + " μ_β = numpyro.sample(\"μ_β\", dist.Normal(0.0, 100.0))\n", + " σ_β = numpyro.sample(\"σ_β\", dist.HalfNormal(100.0))\n", + "\n", " unique_patient_IDs = np.unique(PatientID)\n", " n_patients = len(unique_patient_IDs)\n", - " \n", + "\n", " with numpyro.plate(\"plate_i\", n_patients):\n", " α = numpyro.sample(\"α\", dist.Normal(μ_α, σ_α))\n", " β = numpyro.sample(\"β\", dist.Normal(μ_β, σ_β))\n", - " \n", - " σ = numpyro.sample(\"σ\", dist.HalfNormal(100.))\n", + "\n", + " σ = numpyro.sample(\"σ\", dist.HalfNormal(100.0))\n", " FVC_est = α[PatientID] + β[PatientID] * Weeks\n", - " \n", + "\n", " with numpyro.plate(\"data\", len(PatientID)):\n", " numpyro.sample(\"obs\", dist.Normal(FVC_est, σ), obs=FVC_obs)" ] @@ -292,11 +294,11 @@ "from sklearn.preprocessing import LabelEncoder\n", "\n", "le = LabelEncoder()\n", - "train['PatientID'] = le.fit_transform(train['Patient'].values)\n", + "train[\"PatientID\"] = le.fit_transform(train[\"Patient\"].values)\n", "\n", - "FVC_obs = train['FVC'].values\n", - "Weeks = train['Weeks'].values\n", - "PatientID = train['PatientID'].values" + "FVC_obs = train[\"FVC\"].values\n", + "Weeks = train[\"Weeks\"].values\n", + "PatientID = train[\"PatientID\"].values" ] }, { @@ -380,10 +382,10 @@ "outputs": [], "source": [ "pred_template = []\n", - "for i in range(train['Patient'].nunique()):\n", - " df = pd.DataFrame(columns=['PatientID', 'Weeks'])\n", - " df['Weeks'] = np.arange(-12, 134)\n", - " df['PatientID'] = i\n", + "for i in range(train[\"Patient\"].nunique()):\n", + " df = pd.DataFrame(columns=[\"PatientID\", \"Weeks\"])\n", + " df[\"Weeks\"] = np.arange(-12, 134)\n", + " df[\"PatientID\"] = i\n", " pred_template.append(df)\n", "pred_template = pd.concat(pred_template, ignore_index=True)" ] @@ -401,12 +403,10 @@ "metadata": {}, "outputs": [], "source": [ - "PatientID = pred_template['PatientID'].values\n", - "Weeks = pred_template['Weeks'].values\n", - "predictive = Predictive(model, posterior_samples, \n", - " return_sites=['σ', 'obs'])\n", - "samples_predictive = predictive(random.PRNGKey(0), \n", - " PatientID, Weeks, None)" + "PatientID = pred_template[\"PatientID\"].values\n", + "Weeks = pred_template[\"Weeks\"].values\n", + "predictive = Predictive(model, posterior_samples, return_sites=[\"σ\", \"obs\"])\n", + "samples_predictive = predictive(random.PRNGKey(0), PatientID, Weeks, None)" ] }, { @@ -528,16 +528,17 @@ } ], "source": [ - "df = pd.DataFrame(columns=['Patient', 'Weeks', 'FVC_pred', 'sigma'])\n", - "df['Patient'] = le.inverse_transform(pred_template['PatientID'])\n", - "df['Weeks'] = pred_template['Weeks']\n", - "df['FVC_pred'] = samples_predictive['obs'].T.mean(axis=1)\n", - "df['sigma'] = samples_predictive['obs'].T.std(axis=1)\n", - "df['FVC_inf'] = df['FVC_pred'] - df['sigma']\n", - "df['FVC_sup'] = df['FVC_pred'] + df['sigma']\n", - "df = pd.merge(df, train[['Patient', 'Weeks', 'FVC']], \n", - " how='left', on=['Patient', 'Weeks'])\n", - "df = df.rename(columns={'FVC': 'FVC_true'})\n", + "df = pd.DataFrame(columns=[\"Patient\", \"Weeks\", \"FVC_pred\", \"sigma\"])\n", + "df[\"Patient\"] = le.inverse_transform(pred_template[\"PatientID\"])\n", + "df[\"Weeks\"] = pred_template[\"Weeks\"]\n", + "df[\"FVC_pred\"] = samples_predictive[\"obs\"].T.mean(axis=1)\n", + "df[\"sigma\"] = samples_predictive[\"obs\"].T.std(axis=1)\n", + "df[\"FVC_inf\"] = df[\"FVC_pred\"] - df[\"sigma\"]\n", + "df[\"FVC_sup\"] = df[\"FVC_pred\"] + df[\"sigma\"]\n", + "df = pd.merge(\n", + " df, train[[\"Patient\", \"Weeks\", \"FVC\"]], how=\"left\", on=[\"Patient\", \"Weeks\"]\n", + ")\n", + "df = df.rename(columns={\"FVC\": \"FVC_true\"})\n", "df.head()" ] }, @@ -568,21 +569,20 @@ ], "source": [ "def chart(patient_id, ax):\n", - " data = df[df['Patient'] == patient_id]\n", - " x = data['Weeks']\n", + " data = df[df[\"Patient\"] == patient_id]\n", + " x = data[\"Weeks\"]\n", " ax.set_title(patient_id)\n", - " ax.plot(x, data['FVC_true'], 'o')\n", - " ax.plot(x, data['FVC_pred'])\n", - " ax = sns.regplot(x, data['FVC_true'], ax=ax, ci=None, \n", - " line_kws={'color':'red'})\n", - " ax.fill_between(x, data[\"FVC_inf\"], data[\"FVC_sup\"],\n", - " alpha=0.5, color='#ffcd3c')\n", - " ax.set_ylabel('FVC')\n", + " ax.plot(x, data[\"FVC_true\"], \"o\")\n", + " ax.plot(x, data[\"FVC_pred\"])\n", + " ax = sns.regplot(x, data[\"FVC_true\"], ax=ax, ci=None, line_kws={\"color\": \"red\"})\n", + " ax.fill_between(x, data[\"FVC_inf\"], data[\"FVC_sup\"], alpha=0.5, color=\"#ffcd3c\")\n", + " ax.set_ylabel(\"FVC\")\n", + "\n", "\n", "f, axes = plt.subplots(1, 3, figsize=(15, 5))\n", - "chart('ID00007637202177411956430', axes[0])\n", - "chart('ID00009637202177434476278', axes[1])\n", - "chart('ID00011637202177653955184', axes[2])" + "chart(\"ID00007637202177411956430\", axes[0])\n", + "chart(\"ID00009637202177434476278\", axes[1])\n", + "chart(\"ID00011637202177653955184\", axes[2])" ] }, { @@ -628,15 +628,15 @@ ], "source": [ "y = df.dropna()\n", - "rmse = ((y['FVC_pred'] - y['FVC_true']) ** 2).mean() ** (1/2)\n", - "print(f'RMSE: {rmse:.1f} ml')\n", + "rmse = ((y[\"FVC_pred\"] - y[\"FVC_true\"]) ** 2).mean() ** (1 / 2)\n", + "print(f\"RMSE: {rmse:.1f} ml\")\n", "\n", - "sigma_c = y['sigma'].values\n", + "sigma_c = y[\"sigma\"].values\n", "sigma_c[sigma_c < 70] = 70\n", - "delta = (y['FVC_pred'] - y['FVC_true']).abs()\n", + "delta = (y[\"FVC_pred\"] - y[\"FVC_true\"]).abs()\n", "delta[delta > 1000] = 1000\n", - "lll = - np.sqrt(2) * delta / sigma_c - np.log(np.sqrt(2) * sigma_c)\n", - "print(f'Laplace Log Likelihood: {lll.mean():.4f}')" + "lll = -np.sqrt(2) * delta / sigma_c - np.log(np.sqrt(2) * sigma_c)\n", + "print(f\"Laplace Log Likelihood: {lll.mean():.4f}\")" ] }, { diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index 611ffbc52..e4890185d 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -55,7 +55,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith('0.7.2')" + "assert numpyro.__version__.startswith(\"0.7.2\")" ] }, { @@ -494,7 +494,9 @@ "metadata": {}, "outputs": [], "source": [ - "def model(age, pclass, title, sex, sibsp, parch, embarked, survived=None, bayesian_impute=True):\n", + "def model(\n", + " age, pclass, title, sex, sibsp, parch, embarked, survived=None, bayesian_impute=True\n", + "):\n", " b_pclass = numpyro.sample(\"b_Pclass\", dist.Normal(0, 1).expand([3]))\n", " b_title = numpyro.sample(\"b_Title\", dist.Normal(0, 1).expand([5]))\n", " b_sex = numpyro.sample(\"b_Sex\", dist.Normal(0, 1).expand([2]))\n", @@ -511,11 +513,12 @@ " age_sigma = numpyro.sample(\"age_sigma\", dist.Normal(0, 1).expand([5]))\n", " age_sigma = age_sigma[title]\n", " age_impute = numpyro.sample(\n", - " \"age_impute\", dist.Normal(age_mu[age_nanidx], age_sigma[age_nanidx]).mask(False)\n", + " \"age_impute\",\n", + " dist.Normal(age_mu[age_nanidx], age_sigma[age_nanidx]).mask(False),\n", " )\n", " age = ops.index_update(age, age_nanidx, age_impute)\n", " numpyro.sample(\"age\", dist.Normal(age_mu, age_sigma), obs=age)\n", - " else: \n", + " else:\n", " # fill missing data by the mean of ages for each title\n", " age_impute = age_mean_by_title[title][age_nanidx]\n", " age = ops.index_update(age, age_nanidx, age_impute)\n", diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index 8cc1fb567..ae2e0ab78 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -1,2360 +1,2442 @@ { - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.8" - }, - "colab": { - "name": "bayesian_regression.ipynb", - "provenance": [] - } + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" }, - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "ZJhD80bfN7ly" - }, - "source": [ - "# Bayesian Regression Using NumPyro\n", - "\n", - "In this tutorial, we will explore how to do bayesian regression in NumPyro, using a simple example adapted from Statistical Rethinking [[1](#References)]. In particular, we would like to explore the following:\n", - "\n", - " - Write a simple model using the `sample` NumPyro primitive.\n", - " - Run inference using MCMC in NumPyro, in particular, using the No U-Turn Sampler (NUTS) to get a posterior distribution over our regression parameters of interest.\n", - " - Learn about inference utilities such as `Predictive` and `log_likelihood`.\n", - " - Learn how we can use effect-handlers in NumPyro to generate execution traces from the model, condition on sample statements, seed models with RNG seeds, etc., and use this to implement various utilities that will be useful for MCMC. e.g. computing model log likelihood, generating empirical distribution over the posterior predictive, etc.\n", - "\n", - "## Tutorial Outline:\n", - "\n", - "1. [Dataset](#Dataset)\n", - "2. [Regression Model to Predict Divorce Rate](#Regression-Model-to-Predict-Divorce-Rate)\n", - " - [Model-1: Predictor-Marriage Rate](#Model-1:-Predictor---Marriage-Rate)\n", - " - [Posterior Distribution over the Regression Parameters](#Posterior-Distribution-over-the-Regression-Parameters)\n", - " - [Posterior Predictive Distribution](#Posterior-Predictive-Distribution)\n", - " - [Predictive Utility With Effect Handlers](#Predictive-Utility-With-Effect-Handlers)\n", - " - [Model Predictive Density](#Model-Predictive-Density)\n", - " - [Model-2: Predictor-Median Age of Marriage](#Model-2:-Predictor---Median-Age-of-Marriage)\n", - " - [Model-3: Predictor-Marriage Rate and Median Age of Marriage](#Model-3:-Predictor---Marriage-Rate-and-Median-Age-of-Marriage)\n", - " - [Divorce Rate Residuals by State](#Divorce-Rate-Residuals-by-State)\n", - "3. [Regression Model with Measurement Error](#Regression-Model-with-Measurement-Error)\n", - " - [Effect of Incorporating Measurement Noise on Residuals](#Effect-of-Incorporating-Measurement-Noise-on-Residuals)\n", - "4. [References](#References)" - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "FlhcyvtqN7l1" - }, - "source": [ - "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" - ], - "execution_count": 1, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "B_9Gru7DN7l3" - }, - "source": [ - "import os\n", - "\n", - "from IPython.display import set_matplotlib_formats\n", - "import jax.numpy as jnp\n", - "from jax import random, vmap\n", - "from jax.scipy.special import logsumexp\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "\n", - "import numpyro\n", - "from numpyro.diagnostics import hpdi\n", - "import numpyro.distributions as dist\n", - "from numpyro import handlers\n", - "from numpyro.infer import MCMC, NUTS\n", - "\n", - "plt.style.use('bmh')\n", - "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", - " set_matplotlib_formats('svg')\n", - "\n", - "assert numpyro.__version__.startswith('0.7.2')" - ], - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "YfP23JA7N7l3" - }, - "source": [ - "## Dataset\n", - "\n", - "For this example, we will use the `WaffleDivorce` dataset from Chapter 05, Statistical Rethinking [[1](#References)]. The dataset contains divorce rates in each of the 50 states in the USA, along with predictors such as population, median age of marriage, whether it is a Southern state and, curiously, number of Waffle Houses." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "KsCe9ruUN7l4", - "outputId": "f26f9596-9f21-46d6-ec58-33dfc92b58a0" - }, - "source": [ - "DATASET_URL = 'https://raw.githubusercontent.com/rmcelreath/rethinking/master/data/WaffleDivorce.csv'\n", - "dset = pd.read_csv(DATASET_URL, sep=';')\n", - "dset" - ], - "execution_count": 3, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    LocationLocPopulationMedianAgeMarriageMarriageMarriage SEDivorceDivorce SEWaffleHousesSouthSlaves1860Population1860PropSlaves1860
    0AlabamaAL4.7825.320.21.2712.70.7912814350809642010.450000
    1AlaskaAK0.7125.226.02.9312.52.0500000.000000
    2ArizonaAZ6.3325.820.30.9810.80.74180000.000000
    3ArkansasAR2.9224.326.41.7013.51.224111111154354500.260000
    4CaliforniaCA37.2526.819.10.398.00.240003799940.000000
    5ColoradoCO5.0325.723.51.2411.60.941100342770.000000
    6ConnecticutCT3.5727.617.11.066.70.770004601470.000000
    7DelawareDE0.9026.623.12.898.91.393017981122160.016000
    8District of ColumbiaDC0.6029.717.72.536.31.89000750800.000000
    9FloridaFL18.8026.417.00.588.50.321331617451404240.440000
    10GeorgiaGA9.6925.922.10.8111.50.58381146219810572860.440000
    11HawaiiHI1.3626.924.92.548.31.2700000.000000
    12IdahoID1.5723.225.81.847.71.0500000.000000
    13IllinoisIL12.8327.017.90.588.00.4520017119510.000000
    14IndianaIN6.4825.719.80.8111.00.63170013504280.000000
    15IowaIA3.0525.421.51.4610.20.910006749130.000000
    16KansasKS2.8525.022.11.4810.61.096021072060.000019
    17KentuckyKY4.3424.822.21.1112.60.7564122548311556840.000000
    18LouisianaLA4.5325.920.61.1911.00.896613317267080020.470000
    19MaineME1.3326.413.51.4013.01.480006282790.000000
    20MarylandMD5.7727.318.31.028.80.69110871896870490.130000
    21MassachusettsMA6.5528.515.80.707.80.5200012310660.000000
    22MichiganMI9.8826.416.50.699.20.530007491130.000000
    23MinnesotaMN5.3026.315.30.777.40.600001720230.000000
    24MississippiMS2.9725.819.31.5411.11.017214366317913050.550000
    25MissouriMO5.9925.618.60.819.50.6739111493111820120.097000
    26MontanaMT0.9925.718.52.319.11.7100000.000000
    27NebraskaNE1.8325.419.61.448.80.940015288410.000520
    28New HampshireNH1.3226.816.71.7610.11.610003260730.000000
    29New JerseyNJ8.7927.714.80.596.10.4600186720350.000027
    30New MexicoNM2.0625.820.41.9010.21.11200935160.000000
    31New YorkNY19.3828.416.80.476.60.3100038807350.000000
    32North CarolinaNC9.5425.720.40.989.90.4814213310599926220.330000
    33North DakotaND0.6725.326.72.938.01.4400000.000000
    34OhioOH11.5426.316.90.619.50.45640023395110.000000
    35OklahomaOK3.7524.423.81.2912.81.01160000.000000
    36OregonOR3.8326.018.91.1010.40.80000524650.000000
    37PennsylvaniaPA12.7027.115.50.487.70.43110029062150.000000
    38Rhode IslandRI1.0528.215.02.119.41.790001746200.000000
    39South CarolinaSC4.6326.418.11.188.10.7014414024067037080.570000
    40South DakotaSD0.8125.620.12.6410.92.5000048370.000000
    41TennesseeTN6.3525.219.40.8511.40.75103127571911098010.200000
    42TexasTX25.1525.221.50.6110.00.359911825666042150.300000
    43UtahUT2.7623.329.61.7710.20.93000402730.000000
    44VermontVT0.6326.916.42.409.61.870003150980.000000
    45VirginiaVA8.0026.420.50.838.90.5240149086512196300.400000
    46WashingtonWA6.7225.921.41.0010.00.65000115940.000000
    47West VirginiaWV1.8525.022.21.6910.91.3441183713766880.049000
    48WisconsinWI5.6926.317.20.798.30.570007758810.000000
    49WyomingWY0.5624.230.73.9210.31.9000000.000000
    \n", - "
    " - ], - "text/plain": [ - " Location Loc ... Population1860 PropSlaves1860\n", - "0 Alabama AL ... 964201 0.450000\n", - "1 Alaska AK ... 0 0.000000\n", - "2 Arizona AZ ... 0 0.000000\n", - "3 Arkansas AR ... 435450 0.260000\n", - "4 California CA ... 379994 0.000000\n", - "5 Colorado CO ... 34277 0.000000\n", - "6 Connecticut CT ... 460147 0.000000\n", - "7 Delaware DE ... 112216 0.016000\n", - "8 District of Columbia DC ... 75080 0.000000\n", - "9 Florida FL ... 140424 0.440000\n", - "10 Georgia GA ... 1057286 0.440000\n", - "11 Hawaii HI ... 0 0.000000\n", - "12 Idaho ID ... 0 0.000000\n", - "13 Illinois IL ... 1711951 0.000000\n", - "14 Indiana IN ... 1350428 0.000000\n", - "15 Iowa IA ... 674913 0.000000\n", - "16 Kansas KS ... 107206 0.000019\n", - "17 Kentucky KY ... 1155684 0.000000\n", - "18 Louisiana LA ... 708002 0.470000\n", - "19 Maine ME ... 628279 0.000000\n", - "20 Maryland MD ... 687049 0.130000\n", - "21 Massachusetts MA ... 1231066 0.000000\n", - "22 Michigan MI ... 749113 0.000000\n", - "23 Minnesota MN ... 172023 0.000000\n", - "24 Mississippi MS ... 791305 0.550000\n", - "25 Missouri MO ... 1182012 0.097000\n", - "26 Montana MT ... 0 0.000000\n", - "27 Nebraska NE ... 28841 0.000520\n", - "28 New Hampshire NH ... 326073 0.000000\n", - "29 New Jersey NJ ... 672035 0.000027\n", - "30 New Mexico NM ... 93516 0.000000\n", - "31 New York NY ... 3880735 0.000000\n", - "32 North Carolina NC ... 992622 0.330000\n", - "33 North Dakota ND ... 0 0.000000\n", - "34 Ohio OH ... 2339511 0.000000\n", - "35 Oklahoma OK ... 0 0.000000\n", - "36 Oregon OR ... 52465 0.000000\n", - "37 Pennsylvania PA ... 2906215 0.000000\n", - "38 Rhode Island RI ... 174620 0.000000\n", - "39 South Carolina SC ... 703708 0.570000\n", - "40 South Dakota SD ... 4837 0.000000\n", - "41 Tennessee TN ... 1109801 0.200000\n", - "42 Texas TX ... 604215 0.300000\n", - "43 Utah UT ... 40273 0.000000\n", - "44 Vermont VT ... 315098 0.000000\n", - "45 Virginia VA ... 1219630 0.400000\n", - "46 Washington WA ... 11594 0.000000\n", - "47 West Virginia WV ... 376688 0.049000\n", - "48 Wisconsin WI ... 775881 0.000000\n", - "49 Wyoming WY ... 0 0.000000\n", - "\n", - "[50 rows x 13 columns]" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 3 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Hu-1n8UfN7l6" - }, - "source": [ - "Let us plot the pair-wise relationship amongst the main variables in the dataset, using `seaborn.pairplot`. " - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "pNjxHdVvN7l6", - "outputId": "eb113ed4-bc40-45f5-e82d-c56142336227" - }, - "source": [ - "vars = ['Population', 'MedianAgeMarriage', 'Marriage', 'WaffleHouses', 'South', 'Divorce']\n", - "sns.pairplot(dset, x_vars=vars, y_vars=vars, palette='husl');" - ], - "execution_count": 4, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Nzqje01_N7l7" - }, - "source": [ - "From the plots above, we can clearly observe that there is a relationship between divorce rates and marriage rates in a state (as might be expected), and also between divorce rates and median age of marriage. \n", - "\n", - "There is also a weak relationship between number of Waffle Houses and divorce rates, which is not obvious from the plot above, but will be clearer if we regress `Divorce` against `WaffleHouse` and plot the results. " - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 279 - }, - "id": "jBhug-OzN7l8", - "outputId": "9f95c298-43e7-4f40-cde5-0a9364088980" - }, - "source": [ - "sns.regplot(x='WaffleHouses', y='Divorce', data=dset);" - ], - "execution_count": 5, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Kc4rautdN7l9" - }, - "source": [ - "This is an example of a spurious association. We do not expect the number of Waffle Houses in a state to affect the divorce rate, but it is likely correlated with other factors that have an effect on the divorce rate. We will not delve into this spurious association in this tutorial, but the interested reader is encouraged to read Chapters 5 and 6 of [[1](#References)] which explores the problem of causal association in the presence of multiple predictors. \n", - "\n", - "For simplicity, we will primarily focus on marriage rate and the median age of marriage as our predictors for divorce rate throughout the remaining tutorial." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "mQuCSnFLN7l9" - }, - "source": [ - "## Regression Model to Predict Divorce Rate\n", - "\n", - "Let us now write a regressionn model in *NumPyro* to predict the divorce rate as a linear function of marriage rate and median age of marriage in each of the states. \n", - "\n", - "First, note that our predictor variables have somewhat different scales. It is a good practice to standardize our predictors and response variables to mean `0` and standard deviation `1`, which should result in [faster inference](https://mc-stan.org/docs/2_19/stan-users-guide/standardizing-predictors-and-outputs.html)." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "CPtcs7a6N7l-" - }, - "source": [ - "standardize = lambda x: (x - x.mean()) / x.std()\n", - "\n", - "dset['AgeScaled'] = dset.MedianAgeMarriage.pipe(standardize)\n", - "dset['MarriageScaled'] = dset.Marriage.pipe(standardize)\n", - "dset['DivorceScaled'] = dset.Divorce.pipe(standardize)" - ], - "execution_count": 6, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "olBAKjb1N7l-" - }, - "source": [ - "We write the NumPyro model as follows. While the code should largely be self-explanatory, take note of the following:\n", - "\n", - " - In NumPyro, *model* code is any Python callable which can optionally accept additional arguments and keywords. For HMC which we will be using for this tutorial, these arguments and keywords remain static during inference, but we can reuse the same model to generate [predictions](#Posterior-Predictive-Distribution) on new data.\n", - " - In addition to regular Python statements, the model code also contains primitives like `sample`. These primitives can be interpreted with various side-effects using effect handlers. For more on effect handlers, refer to [[3](#References)], [[4](#References)]. For now, just remember that a `sample` statement makes this a stochastic function that samples some latent parameters from a *prior distribution*. Our goal is to infer the *posterior distribution* of these parameters conditioned on observed data.\n", - " - The reason why we have kept our predictors as optional keyword arguments is to be able to reuse the same model as we vary the set of predictors. Likewise, the reason why the response variable is optional is that we would like to reuse this model to sample from the posterior predictive distribution. See the [section](#Posterior-Predictive-Distribution) on plotting the posterior predictive distribution, as an example." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "hVzAKfmnN7l-" - }, - "source": [ - "def model(marriage=None, age=None, divorce=None):\n", - " a = numpyro.sample('a', dist.Normal(0., 0.2))\n", - " M, A = 0., 0.\n", - " if marriage is not None:\n", - " bM = numpyro.sample('bM', dist.Normal(0., 0.5))\n", - " M = bM * marriage\n", - " if age is not None:\n", - " bA = numpyro.sample('bA', dist.Normal(0., 0.5))\n", - " A = bA * age\n", - " sigma = numpyro.sample('sigma', dist.Exponential(1.))\n", - " mu = a + M + A\n", - " numpyro.sample('obs', dist.Normal(mu, sigma), obs=divorce)" - ], - "execution_count": 7, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "tsUGIXf4N7l_" - }, - "source": [ - "### Model 1: Predictor - Marriage Rate\n", - "\n", - "We first try to model the divorce rate as depending on a single variable, marriage rate. As mentioned above, we can use the same `model` code as earlier, but only pass values for `marriage` and `divorce` keyword arguments. We will use the No U-Turn Sampler (see [[5](#References)] for more details on the NUTS algorithm) to run inference on this simple model.\n", - "\n", - "The Hamiltonian Monte Carlo (or, the NUTS) implementation in NumPyro takes in a potential energy function. This is the negative log joint density for the model. Therefore, for our model description above, we need to construct a function which given the parameter values returns the potential energy (or negative log joint density). Additionally, the verlet integrator in HMC (or, NUTS) returns sample values simulated using Hamiltonian dynamics in the unconstrained space. As such, continuous variables with bounded support need to be transformed into unconstrained space using bijective transforms. We also need to transform these samples back to their constrained support before returning these values to the user. Thankfully, this is handled on the backend for us, within a convenience class for doing [MCMC inference](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.MCMC) that has the following methods:\n", - "\n", - " - `run(...)`: runs warmup, adapts steps size and mass matrix, and does sampling using the sample from the warmup phase.\n", - " - `print_summary()`: print diagnostic information like quantiles, effective sample size, and the Gelman-Rubin diagnostic.\n", - " - `get_samples()`: gets samples from the posterior distribution.\n", - "\n", - "Note the following:\n", - "\n", - " - JAX uses functional PRNGs. Unlike other languages / frameworks which maintain a global random state, in JAX, every call to a sampler requires an [explicit PRNGKey](https://github.com/google/jax#random-numbers-are-different). We will split our initial random seed for subsequent operations, so that we do not accidentally reuse the same seed.\n", - " - We run inference with the `NUTS` sampler. To run vanilla HMC, we can instead use the [HMC](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.HMC) class." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "er7-QqEhN7l_", - "outputId": "d52e722b-0061-49a1-d9df-d977a311b88d" - }, - "source": [ - "# Start from this source of randomness. We will split keys for subsequent operations.\n", - "rng_key = random.PRNGKey(0)\n", - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "# Run NUTS.\n", - "kernel = NUTS(model)\n", - "num_samples = 2000\n", - "mcmc = MCMC(kernel, num_warmup=1000, num_samples=num_samples)\n", - "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_1 = mcmc.get_samples()" - ], - "execution_count": 8, - "outputs": [ - { - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 3000/3000 [00:04<00:00, 748.14it/s, 7 steps of size 7.41e-01. acc. prob=0.92]\n" - ], - "name": "stderr" - }, - { - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a 0.00 0.11 0.00 -0.16 0.20 1510.96 1.00\n", - " bM 0.35 0.13 0.35 0.14 0.57 2043.12 1.00\n", - " sigma 0.95 0.10 0.94 0.78 1.10 1565.40 1.00\n", - "\n", - "Number of divergences: 0\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "0IfifzKHN7mA" - }, - "source": [ - "#### Posterior Distribution over the Regression Parameters\n", - "\n", - "We notice that the progress bar gives us online statistics on the acceptance probability, step size and number of steps taken per sample while running NUTS. In particular, during warmup, we adapt the step size and mass matrix to achieve a certain target acceptance probability which is 0.8, by default. We were able to successfully adapt our step size to achieve this target in the warmup phase.\n", - "\n", - "During warmup, the aim is to adapt hyper-parameters such as step size and mass matrix (the HMC algorithm is very sensitive to these hyper-parameters), and to reach the typical set (see [[6](#References)] for more details). If there are any issues in the model specification, the first signal to notice would be low acceptance probabilities or very high number of steps. We use the sample from the end of the warmup phase to seed the MCMC chain (denoted by the second `sample` progress bar) from which we generate the desired number of samples from our target distribution.\n", - "\n", - "At the end of inference, NumPyro prints the mean, std and 90% CI values for each of the latent parameters. Note that since we standardized our predictors and response variable, we would expect the intercept to have mean 0, as can be seen here. It also prints other convergence diagnostics on the latent parameters in the model, including [effective sample size](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.effective_sample_size) and the [gelman rubin diagnostic](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.gelman_rubin) ($\\hat{R}$). The value for these diagnostics indicates that the chain has converged to the target distribution. In our case, the \"target distribution\" is the posterior distribution over the latent parameters that we are interested in. Note that this is often worth verifying with multiple chains for more complicated models. In the end, `samples_1` is a collection (in our case, a `dict` since `init_samples` was a `dict`) containing samples from the posterior distribution for each of the latent parameters in the model.\n", - "\n", - "To look at our regression fit, let us plot the regression line using our posterior estimates for the regression parameters, along with the 90% Credibility Interval (CI). Note that the [hpdi](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.hpdi) function in NumPyro's diagnostics module can be used to compute CI. In the functions below, note that the collected samples from the posterior are all along the leading axis." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 405 - }, - "id": "UX-DbOtsN7mA", - "outputId": "163ad2c9-7567-490f-9535-f6834f457c8a" - }, - "source": [ - "def plot_regression(x, y_mean, y_hpdi):\n", - " # Sort values for plotting by x axis\n", - " idx = jnp.argsort(x)\n", - " marriage = x[idx]\n", - " mean = y_mean[idx]\n", - " hpdi = y_hpdi[:, idx]\n", - " divorce = dset.DivorceScaled.values[idx]\n", - "\n", - " # Plot\n", - " fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 6))\n", - " ax.plot(marriage, mean)\n", - " ax.plot(marriage, divorce, 'o')\n", - " ax.fill_between(marriage, hpdi[0], hpdi[1], alpha=0.3, interpolate=True)\n", - " return ax\n", - "\n", - "# Compute empirical posterior distribution over mu\n", - "posterior_mu = jnp.expand_dims(samples_1['a'], -1) + \\\n", - " jnp.expand_dims(samples_1['bM'], -1) * dset.MarriageScaled.values\n", - "\n", - "mean_mu = jnp.mean(posterior_mu, axis=0)\n", - "hpdi_mu = hpdi(posterior_mu, 0.9)\n", - "ax = plot_regression(dset.MarriageScaled.values, mean_mu, hpdi_mu)\n", - "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Regression line with 90% CI');" - ], - "execution_count": 9, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "sndvig_RQi0s" - }, - "source": [ - "We can see from the plot, that the CI broadens towards the tails where the data is relatively sparse, as can be expected.\n", - "\n", - "#### Prior Predictive Distribution\n", - "\n", - "Let us check that we have set sensible priors by sampling from the prior predictive distribution. NumPyro provides a handy [Predictive](http://num.pyro.ai/en/latest/utilities.html#numpyro.infer.util.Predictive) utility for this purpose." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 405 - }, - "id": "vSfDasR7Q5Be", - "outputId": "a11554aa-96b7-4298-9456-d44e0d63d8af" - }, - "source": [ - "from numpyro.infer import Predictive\n", - "\n", - "rng_key, rng_key_ = random.split(rng_key)\n", - "prior_predictive = Predictive(model, num_samples=100)\n", - "prior_predictions = prior_predictive(rng_key_, marriage=dset.MarriageScaled.values)['obs']\n", - "mean_prior_pred = jnp.mean(prior_predictions, axis=0)\n", - "hpdi_prior_pred = hpdi(prior_predictions, 0.9)\n", - "\n", - "ax = plot_regression(dset.MarriageScaled.values, mean_prior_pred, hpdi_prior_pred)\n", - "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Predictions with 90% CI');" - ], - "execution_count": 10, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Q1ojeyHpN7mB" - }, - "source": [ - "#### Posterior Predictive Distribution\n", - "\n", - "Let us now look at the posterior predictive distribution to see how our predictive distribution looks with respect to the observed divorce rates. To get samples from the posterior predictive distribution, we need to run the model by substituting the latent parameters with samples from the posterior. Note that by default we generate a single prediction for each sample from the joint posterior distribution, but this can be controlled using the `num_samples` argument." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 206 - }, - "id": "XzzsqL7jN7mB", - "outputId": "00bb95d0-8be6-4686-f9d9-bc8a8891aa2c" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictive = Predictive(model, samples_1)\n", - "predictions = predictive(rng_key_, marriage=dset.MarriageScaled.values)['obs']\n", - "df = dset.filter(['Location'])\n", - "df['Mean Predictions'] = jnp.mean(predictions, axis=0)\n", - "df.head()" - ], - "execution_count": 11, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    LocationMean Predictions
    0Alabama0.016434
    1Alaska0.501293
    2Arizona0.025105
    3Arkansas0.600058
    4California-0.082887
    \n", - "
    " - ], - "text/plain": [ - " Location Mean Predictions\n", - "0 Alabama 0.016434\n", - "1 Alaska 0.501293\n", - "2 Arizona 0.025105\n", - "3 Arkansas 0.600058\n", - "4 California -0.082887" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 11 - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "n-Sm_5H8N7mC" - }, - "source": [ - "#### Predictive Utility With Effect Handlers\n", - "\n", - "To remove the magic behind `Predictive`, let us see how we can combine [effect handlers](https://numpyro.readthedocs.io/en/latest/handlers.html) with the [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) JAX primitive to implement our own simplified predictive utility function that can do vectorized predictions." - ] - }, - { - "cell_type": "code", - "metadata": { - "id": "gSKilj8dN7mC" - }, - "source": [ - "def predict(rng_key, post_samples, model, *args, **kwargs):\n", - " model = handlers.seed(handlers.condition(model, post_samples), rng_key)\n", - " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", - " return model_trace['obs']['value']\n", - "\n", - "# vectorize predictions via vmap\n", - "predict_fn = vmap(lambda rng_key, samples: predict(rng_key, samples, model, marriage=dset.MarriageScaled.values))" - ], - "execution_count": 12, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "hGB12J3-N7mC" - }, - "source": [ - "Note the use of the `condition`, `seed` and `trace` effect handlers in the `predict` function.\n", - "\n", - " - The `seed` effect-handler is used to wrap a stochastic function with an initial `PRNGKey` seed. When a sample statement inside the model is called, it uses the existing seed to sample from a distribution but this effect-handler also splits the existing key to ensure that future `sample` calls in the model use the newly split key instead. This is to prevent us from having to explicitly pass in a `PRNGKey` to each `sample` statement in the model.\n", - " - The `condition` effect handler conditions the latent sample sites to certain values. In our case, we are conditioning on values from the posterior distribution returned by MCMC.\n", - " - The `trace` effect handler runs the model and records the execution trace within an `OrderedDict`. This trace object contains execution metadata that is useful for computing quantities such as the log joint density.\n", - " \n", - "It should be clear now that the `predict` function simply runs the model by substituting the latent parameters with samples from the posterior (generated by the `mcmc` function) to generate predictions. Note the use of JAX's auto-vectorization transform called [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) to vectorize predictions. Note that if we didn't use `vmap`, we would have to use a native for loop which for each sample which is much slower. Each draw from the posterior can be used to get predictions over all the 50 states. When we vectorize this over all the samples from the posterior using `vmap`, we will get a `predictions_1` array of shape `(num_samples, 50)`. We can then compute the mean and 90% CI of these samples to plot the posterior predictive distribution. We note that our mean predictions match those obtained from the `Predictive` utility class." - ] - }, - { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 206 - }, - "id": "Hbo0AzmSN7mD", - "outputId": "9183ecd2-bb3b-473b-e912-09188806573e" - }, - "source": [ - "# Using the same key as we used for Predictive - note that the results are identical.\n", - "\n", - "predictions_1 = predict_fn(random.split(rng_key_, num_samples), samples_1)\n", - "\n", - "mean_pred = jnp.mean(predictions_1, axis=0)\n", - "df = dset.filter(['Location'])\n", - "df['Mean Predictions'] = mean_pred\n", - "df.head()" - ], - "execution_count": 13, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/html": [ - "
    \n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
    LocationMean Predictions
    0Alabama0.016434
    1Alaska0.501293
    2Arizona0.025105
    3Arkansas0.600058
    4California-0.082887
    \n", - "
    " - ], - "text/plain": [ - " Location Mean Predictions\n", - "0 Alabama 0.016434\n", - "1 Alaska 0.501293\n", - "2 Arizona 0.025105\n", - "3 Arkansas 0.600058\n", - "4 California -0.082887" - ] - }, - "metadata": { - "tags": [] - }, - "execution_count": 13 - } - ] + "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.8.8" + }, + "colab": { + "name": "bayesian_regression.ipynb", + "provenance": [] + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "ZJhD80bfN7ly" + }, + "source": [ + "# Bayesian Regression Using NumPyro\n", + "\n", + "In this tutorial, we will explore how to do bayesian regression in NumPyro, using a simple example adapted from Statistical Rethinking [[1](#References)]. In particular, we would like to explore the following:\n", + "\n", + " - Write a simple model using the `sample` NumPyro primitive.\n", + " - Run inference using MCMC in NumPyro, in particular, using the No U-Turn Sampler (NUTS) to get a posterior distribution over our regression parameters of interest.\n", + " - Learn about inference utilities such as `Predictive` and `log_likelihood`.\n", + " - Learn how we can use effect-handlers in NumPyro to generate execution traces from the model, condition on sample statements, seed models with RNG seeds, etc., and use this to implement various utilities that will be useful for MCMC. e.g. computing model log likelihood, generating empirical distribution over the posterior predictive, etc.\n", + "\n", + "## Tutorial Outline:\n", + "\n", + "1. [Dataset](#Dataset)\n", + "2. [Regression Model to Predict Divorce Rate](#Regression-Model-to-Predict-Divorce-Rate)\n", + " - [Model-1: Predictor-Marriage Rate](#Model-1:-Predictor---Marriage-Rate)\n", + " - [Posterior Distribution over the Regression Parameters](#Posterior-Distribution-over-the-Regression-Parameters)\n", + " - [Posterior Predictive Distribution](#Posterior-Predictive-Distribution)\n", + " - [Predictive Utility With Effect Handlers](#Predictive-Utility-With-Effect-Handlers)\n", + " - [Model Predictive Density](#Model-Predictive-Density)\n", + " - [Model-2: Predictor-Median Age of Marriage](#Model-2:-Predictor---Median-Age-of-Marriage)\n", + " - [Model-3: Predictor-Marriage Rate and Median Age of Marriage](#Model-3:-Predictor---Marriage-Rate-and-Median-Age-of-Marriage)\n", + " - [Divorce Rate Residuals by State](#Divorce-Rate-Residuals-by-State)\n", + "3. [Regression Model with Measurement Error](#Regression-Model-with-Measurement-Error)\n", + " - [Effect of Incorporating Measurement Noise on Residuals](#Effect-of-Incorporating-Measurement-Noise-on-Residuals)\n", + "4. [References](#References)" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "FlhcyvtqN7l1" + }, + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ], + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "B_9Gru7DN7l3" + }, + "source": [ + "import os\n", + "\n", + "from IPython.display import set_matplotlib_formats\n", + "import jax.numpy as jnp\n", + "from jax import random, vmap\n", + "from jax.scipy.special import logsumexp\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "import numpyro\n", + "from numpyro.diagnostics import hpdi\n", + "import numpyro.distributions as dist\n", + "from numpyro import handlers\n", + "from numpyro.infer import MCMC, NUTS\n", + "\n", + "plt.style.use(\"bmh\")\n", + "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", + " set_matplotlib_formats(\"svg\")\n", + "\n", + "assert numpyro.__version__.startswith(\"0.7.2\")" + ], + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YfP23JA7N7l3" + }, + "source": [ + "## Dataset\n", + "\n", + "For this example, we will use the `WaffleDivorce` dataset from Chapter 05, Statistical Rethinking [[1](#References)]. The dataset contains divorce rates in each of the 50 states in the USA, along with predictors such as population, median age of marriage, whether it is a Southern state and, curiously, number of Waffle Houses." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 }, + "id": "KsCe9ruUN7l4", + "outputId": "f26f9596-9f21-46d6-ec58-33dfc92b58a0" + }, + "source": [ + "DATASET_URL = \"https://raw.githubusercontent.com/rmcelreath/rethinking/master/data/WaffleDivorce.csv\"\n", + "dset = pd.read_csv(DATASET_URL, sep=\";\")\n", + "dset" + ], + "execution_count": 3, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 405 - }, - "id": "x57YjUCLN7mD", - "outputId": "19ed4248-f852-40d1-da61-f06faa6c4cbd" - }, - "source": [ - "hpdi_pred = hpdi(predictions_1, 0.9)\n", - "\n", - "ax = plot_regression(dset.MarriageScaled.values, mean_pred, hpdi_pred)\n", - "ax.set(xlabel='Marriage rate', ylabel='Divorce rate', title='Predictions with 90% CI');" + "output_type": "execute_result", + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    LocationLocPopulationMedianAgeMarriageMarriageMarriage SEDivorceDivorce SEWaffleHousesSouthSlaves1860Population1860PropSlaves1860
    0AlabamaAL4.7825.320.21.2712.70.7912814350809642010.450000
    1AlaskaAK0.7125.226.02.9312.52.0500000.000000
    2ArizonaAZ6.3325.820.30.9810.80.74180000.000000
    3ArkansasAR2.9224.326.41.7013.51.224111111154354500.260000
    4CaliforniaCA37.2526.819.10.398.00.240003799940.000000
    5ColoradoCO5.0325.723.51.2411.60.941100342770.000000
    6ConnecticutCT3.5727.617.11.066.70.770004601470.000000
    7DelawareDE0.9026.623.12.898.91.393017981122160.016000
    8District of ColumbiaDC0.6029.717.72.536.31.89000750800.000000
    9FloridaFL18.8026.417.00.588.50.321331617451404240.440000
    10GeorgiaGA9.6925.922.10.8111.50.58381146219810572860.440000
    11HawaiiHI1.3626.924.92.548.31.2700000.000000
    12IdahoID1.5723.225.81.847.71.0500000.000000
    13IllinoisIL12.8327.017.90.588.00.4520017119510.000000
    14IndianaIN6.4825.719.80.8111.00.63170013504280.000000
    15IowaIA3.0525.421.51.4610.20.910006749130.000000
    16KansasKS2.8525.022.11.4810.61.096021072060.000019
    17KentuckyKY4.3424.822.21.1112.60.7564122548311556840.000000
    18LouisianaLA4.5325.920.61.1911.00.896613317267080020.470000
    19MaineME1.3326.413.51.4013.01.480006282790.000000
    20MarylandMD5.7727.318.31.028.80.69110871896870490.130000
    21MassachusettsMA6.5528.515.80.707.80.5200012310660.000000
    22MichiganMI9.8826.416.50.699.20.530007491130.000000
    23MinnesotaMN5.3026.315.30.777.40.600001720230.000000
    24MississippiMS2.9725.819.31.5411.11.017214366317913050.550000
    25MissouriMO5.9925.618.60.819.50.6739111493111820120.097000
    26MontanaMT0.9925.718.52.319.11.7100000.000000
    27NebraskaNE1.8325.419.61.448.80.940015288410.000520
    28New HampshireNH1.3226.816.71.7610.11.610003260730.000000
    29New JerseyNJ8.7927.714.80.596.10.4600186720350.000027
    30New MexicoNM2.0625.820.41.9010.21.11200935160.000000
    31New YorkNY19.3828.416.80.476.60.3100038807350.000000
    32North CarolinaNC9.5425.720.40.989.90.4814213310599926220.330000
    33North DakotaND0.6725.326.72.938.01.4400000.000000
    34OhioOH11.5426.316.90.619.50.45640023395110.000000
    35OklahomaOK3.7524.423.81.2912.81.01160000.000000
    36OregonOR3.8326.018.91.1010.40.80000524650.000000
    37PennsylvaniaPA12.7027.115.50.487.70.43110029062150.000000
    38Rhode IslandRI1.0528.215.02.119.41.790001746200.000000
    39South CarolinaSC4.6326.418.11.188.10.7014414024067037080.570000
    40South DakotaSD0.8125.620.12.6410.92.5000048370.000000
    41TennesseeTN6.3525.219.40.8511.40.75103127571911098010.200000
    42TexasTX25.1525.221.50.6110.00.359911825666042150.300000
    43UtahUT2.7623.329.61.7710.20.93000402730.000000
    44VermontVT0.6326.916.42.409.61.870003150980.000000
    45VirginiaVA8.0026.420.50.838.90.5240149086512196300.400000
    46WashingtonWA6.7225.921.41.0010.00.65000115940.000000
    47West VirginiaWV1.8525.022.21.6910.91.3441183713766880.049000
    48WisconsinWI5.6926.317.20.798.30.570007758810.000000
    49WyomingWY0.5624.230.73.9210.31.9000000.000000
    \n", + "
    " ], - "execution_count": 14, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } + "text/plain": [ + " Location Loc ... Population1860 PropSlaves1860\n", + "0 Alabama AL ... 964201 0.450000\n", + "1 Alaska AK ... 0 0.000000\n", + "2 Arizona AZ ... 0 0.000000\n", + "3 Arkansas AR ... 435450 0.260000\n", + "4 California CA ... 379994 0.000000\n", + "5 Colorado CO ... 34277 0.000000\n", + "6 Connecticut CT ... 460147 0.000000\n", + "7 Delaware DE ... 112216 0.016000\n", + "8 District of Columbia DC ... 75080 0.000000\n", + "9 Florida FL ... 140424 0.440000\n", + "10 Georgia GA ... 1057286 0.440000\n", + "11 Hawaii HI ... 0 0.000000\n", + "12 Idaho ID ... 0 0.000000\n", + "13 Illinois IL ... 1711951 0.000000\n", + "14 Indiana IN ... 1350428 0.000000\n", + "15 Iowa IA ... 674913 0.000000\n", + "16 Kansas KS ... 107206 0.000019\n", + "17 Kentucky KY ... 1155684 0.000000\n", + "18 Louisiana LA ... 708002 0.470000\n", + "19 Maine ME ... 628279 0.000000\n", + "20 Maryland MD ... 687049 0.130000\n", + "21 Massachusetts MA ... 1231066 0.000000\n", + "22 Michigan MI ... 749113 0.000000\n", + "23 Minnesota MN ... 172023 0.000000\n", + "24 Mississippi MS ... 791305 0.550000\n", + "25 Missouri MO ... 1182012 0.097000\n", + "26 Montana MT ... 0 0.000000\n", + "27 Nebraska NE ... 28841 0.000520\n", + "28 New Hampshire NH ... 326073 0.000000\n", + "29 New Jersey NJ ... 672035 0.000027\n", + "30 New Mexico NM ... 93516 0.000000\n", + "31 New York NY ... 3880735 0.000000\n", + "32 North Carolina NC ... 992622 0.330000\n", + "33 North Dakota ND ... 0 0.000000\n", + "34 Ohio OH ... 2339511 0.000000\n", + "35 Oklahoma OK ... 0 0.000000\n", + "36 Oregon OR ... 52465 0.000000\n", + "37 Pennsylvania PA ... 2906215 0.000000\n", + "38 Rhode Island RI ... 174620 0.000000\n", + "39 South Carolina SC ... 703708 0.570000\n", + "40 South Dakota SD ... 4837 0.000000\n", + "41 Tennessee TN ... 1109801 0.200000\n", + "42 Texas TX ... 604215 0.300000\n", + "43 Utah UT ... 40273 0.000000\n", + "44 Vermont VT ... 315098 0.000000\n", + "45 Virginia VA ... 1219630 0.400000\n", + "46 Washington WA ... 11594 0.000000\n", + "47 West Virginia WV ... 376688 0.049000\n", + "48 Wisconsin WI ... 775881 0.000000\n", + "49 Wyoming WY ... 0 0.000000\n", + "\n", + "[50 rows x 13 columns]" ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 3 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Hu-1n8UfN7l6" + }, + "source": [ + "Let us plot the pair-wise relationship amongst the main variables in the dataset, using `seaborn.pairplot`. " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 }, + "id": "pNjxHdVvN7l6", + "outputId": "eb113ed4-bc40-45f5-e82d-c56142336227" + }, + "source": [ + "vars = [\n", + " \"Population\",\n", + " \"MedianAgeMarriage\",\n", + " \"Marriage\",\n", + " \"WaffleHouses\",\n", + " \"South\",\n", + " \"Divorce\",\n", + "]\n", + "sns.pairplot(dset, x_vars=vars, y_vars=vars, palette=\"husl\");" + ], + "execution_count": 4, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "b5i71NCFN7mE" - }, - "source": [ - "We have used the same `plot_regression` function as earlier. We notice that our CI for the predictive distribution is much broader as compared to the last plot due to the additional noise introduced by the `sigma` parameter. Most data points lie well within the 90% CI, which indicates a good fit.\n", - "\n", - "#### Posterior Predictive Density\n", - "\n", - "Likewise, making use of effect-handlers and `vmap`, we can also compute the log likelihood for this model given the dataset, and the log posterior predictive density [[6](#References)] which is given by \n", - "$$ log \\prod_{i=1}^{n} \\int p(y_i | \\theta) p_{post}(\\theta) d\\theta \n", - "\\approx \\sum_{i=1}^n log \\frac{\\sum_s p(\\theta^{s})}{S} \\\\\n", - "= \\sum_{i=1}^n (log \\sum_s p(\\theta^{s}) - log(S))\n", - "$$.\n", - "\n", - "Here, $i$ indexes the observed data points $y$ and $s$ indexes the posterior samples over the latent parameters $\\theta$. If the posterior predictive density for a model has a comparatively high value, it indicates that the observed data-points have higher probability under the given model." + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nzqje01_N7l7" + }, + "source": [ + "From the plots above, we can clearly observe that there is a relationship between divorce rates and marriage rates in a state (as might be expected), and also between divorce rates and median age of marriage. \n", + "\n", + "There is also a weak relationship between number of Waffle Houses and divorce rates, which is not obvious from the plot above, but will be clearer if we regress `Divorce` against `WaffleHouse` and plot the results. " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 279 }, + "id": "jBhug-OzN7l8", + "outputId": "9f95c298-43e7-4f40-cde5-0a9364088980" + }, + "source": [ + "sns.regplot(x=\"WaffleHouses\", y=\"Divorce\", data=dset);" + ], + "execution_count": 5, + "outputs": [ { - "cell_type": "code", - "metadata": { - "id": "ZpNwpvk_N7mE" - }, - "source": [ - "def log_likelihood(rng_key, params, model, *args, **kwargs):\n", - " model = handlers.condition(model, params)\n", - " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", - " obs_node = model_trace['obs']\n", - " return obs_node['fn'].log_prob(obs_node['value'])\n", - " \n", - "def log_pred_density(rng_key, params, model, *args, **kwargs):\n", - " n = list(params.values())[0].shape[0]\n", - " log_lk_fn = vmap(lambda rng_key, params: log_likelihood(rng_key, params, model, *args, **kwargs))\n", - " log_lk_vals = log_lk_fn(random.split(rng_key, n), params)\n", - " return (logsumexp(log_lk_vals, 0) - jnp.log(n)).sum()" - ], - "execution_count": 15, - "outputs": [] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "dXu_hzcDN7mE" - }, - "source": [ - "Note that NumPyro provides the [log_likelihood](http://num.pyro.ai/en/latest/utilities.html#log-likelihood) utility function that can be used directly for computing `log likelihood` as in the first function for any general model. In this tutorial, we would like to emphasize that there is nothing magical about such utility functions, and you can roll out your own inference utilities using NumPyro's effect handling stack." + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Kc4rautdN7l9" + }, + "source": [ + "This is an example of a spurious association. We do not expect the number of Waffle Houses in a state to affect the divorce rate, but it is likely correlated with other factors that have an effect on the divorce rate. We will not delve into this spurious association in this tutorial, but the interested reader is encouraged to read Chapters 5 and 6 of [[1](#References)] which explores the problem of causal association in the presence of multiple predictors. \n", + "\n", + "For simplicity, we will primarily focus on marriage rate and the median age of marriage as our predictors for divorce rate throughout the remaining tutorial." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mQuCSnFLN7l9" + }, + "source": [ + "## Regression Model to Predict Divorce Rate\n", + "\n", + "Let us now write a regressionn model in *NumPyro* to predict the divorce rate as a linear function of marriage rate and median age of marriage in each of the states. \n", + "\n", + "First, note that our predictor variables have somewhat different scales. It is a good practice to standardize our predictors and response variables to mean `0` and standard deviation `1`, which should result in [faster inference](https://mc-stan.org/docs/2_19/stan-users-guide/standardizing-predictors-and-outputs.html)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "CPtcs7a6N7l-" + }, + "source": [ + "standardize = lambda x: (x - x.mean()) / x.std()\n", + "\n", + "dset[\"AgeScaled\"] = dset.MedianAgeMarriage.pipe(standardize)\n", + "dset[\"MarriageScaled\"] = dset.Marriage.pipe(standardize)\n", + "dset[\"DivorceScaled\"] = dset.Divorce.pipe(standardize)" + ], + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "olBAKjb1N7l-" + }, + "source": [ + "We write the NumPyro model as follows. While the code should largely be self-explanatory, take note of the following:\n", + "\n", + " - In NumPyro, *model* code is any Python callable which can optionally accept additional arguments and keywords. For HMC which we will be using for this tutorial, these arguments and keywords remain static during inference, but we can reuse the same model to generate [predictions](#Posterior-Predictive-Distribution) on new data.\n", + " - In addition to regular Python statements, the model code also contains primitives like `sample`. These primitives can be interpreted with various side-effects using effect handlers. For more on effect handlers, refer to [[3](#References)], [[4](#References)]. For now, just remember that a `sample` statement makes this a stochastic function that samples some latent parameters from a *prior distribution*. Our goal is to infer the *posterior distribution* of these parameters conditioned on observed data.\n", + " - The reason why we have kept our predictors as optional keyword arguments is to be able to reuse the same model as we vary the set of predictors. Likewise, the reason why the response variable is optional is that we would like to reuse this model to sample from the posterior predictive distribution. See the [section](#Posterior-Predictive-Distribution) on plotting the posterior predictive distribution, as an example." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "hVzAKfmnN7l-" + }, + "source": [ + "def model(marriage=None, age=None, divorce=None):\n", + " a = numpyro.sample(\"a\", dist.Normal(0.0, 0.2))\n", + " M, A = 0.0, 0.0\n", + " if marriage is not None:\n", + " bM = numpyro.sample(\"bM\", dist.Normal(0.0, 0.5))\n", + " M = bM * marriage\n", + " if age is not None:\n", + " bA = numpyro.sample(\"bA\", dist.Normal(0.0, 0.5))\n", + " A = bA * age\n", + " sigma = numpyro.sample(\"sigma\", dist.Exponential(1.0))\n", + " mu = a + M + A\n", + " numpyro.sample(\"obs\", dist.Normal(mu, sigma), obs=divorce)" + ], + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tsUGIXf4N7l_" + }, + "source": [ + "### Model 1: Predictor - Marriage Rate\n", + "\n", + "We first try to model the divorce rate as depending on a single variable, marriage rate. As mentioned above, we can use the same `model` code as earlier, but only pass values for `marriage` and `divorce` keyword arguments. We will use the No U-Turn Sampler (see [[5](#References)] for more details on the NUTS algorithm) to run inference on this simple model.\n", + "\n", + "The Hamiltonian Monte Carlo (or, the NUTS) implementation in NumPyro takes in a potential energy function. This is the negative log joint density for the model. Therefore, for our model description above, we need to construct a function which given the parameter values returns the potential energy (or negative log joint density). Additionally, the verlet integrator in HMC (or, NUTS) returns sample values simulated using Hamiltonian dynamics in the unconstrained space. As such, continuous variables with bounded support need to be transformed into unconstrained space using bijective transforms. We also need to transform these samples back to their constrained support before returning these values to the user. Thankfully, this is handled on the backend for us, within a convenience class for doing [MCMC inference](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.MCMC) that has the following methods:\n", + "\n", + " - `run(...)`: runs warmup, adapts steps size and mass matrix, and does sampling using the sample from the warmup phase.\n", + " - `print_summary()`: print diagnostic information like quantiles, effective sample size, and the Gelman-Rubin diagnostic.\n", + " - `get_samples()`: gets samples from the posterior distribution.\n", + "\n", + "Note the following:\n", + "\n", + " - JAX uses functional PRNGs. Unlike other languages / frameworks which maintain a global random state, in JAX, every call to a sampler requires an [explicit PRNGKey](https://github.com/google/jax#random-numbers-are-different). We will split our initial random seed for subsequent operations, so that we do not accidentally reuse the same seed.\n", + " - We run inference with the `NUTS` sampler. To run vanilla HMC, we can instead use the [HMC](https://numpyro.readthedocs.io/en/latest/mcmc.html#numpyro.mcmc.HMC) class." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "er7-QqEhN7l_", + "outputId": "d52e722b-0061-49a1-d9df-d977a311b88d" + }, + "source": [ + "# Start from this source of randomness. We will split keys for subsequent operations.\n", + "rng_key = random.PRNGKey(0)\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "# Run NUTS.\n", + "kernel = NUTS(model)\n", + "num_samples = 2000\n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=num_samples)\n", + "mcmc.run(\n", + " rng_key_, marriage=dset.MarriageScaled.values, divorce=dset.DivorceScaled.values\n", + ")\n", + "mcmc.print_summary()\n", + "samples_1 = mcmc.get_samples()" + ], + "execution_count": 8, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "dZxKq_ETN7mF", - "outputId": "9574a5f7-56aa-404a-e491-f7dc2a1c6636" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "print('Log posterior predictive density: {}'.format(log_pred_density(rng_key_,\n", - " samples_1, \n", - " model,\n", - " marriage=dset.MarriageScaled.values,\n", - " divorce=dset.DivorceScaled.values)))" - ], - "execution_count": 16, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Log posterior predictive density: -66.70008087158203\n" - ], - "name": "stdout" - } - ] + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 3000/3000 [00:04<00:00, 748.14it/s, 7 steps of size 7.41e-01. acc. prob=0.92]\n" + ], + "name": "stderr" }, { - "cell_type": "markdown", - "metadata": { - "id": "wbxnyQazN7mF" - }, - "source": [ - "### Model 2: Predictor - Median Age of Marriage\n", - "\n", - "We will now model the divorce rate as a function of the median age of marriage. The computations are mostly a reproduction of what we did for Model 1. Notice the following:\n", - "\n", - " - Divorce rate is inversely related to the age of marriage. Hence states where the median age of marriage is low will likely have a higher divorce rate.\n", - " - We get a higher log likelihood as compared to Model 2, indicating that median age of marriage is likely a much better predictor of divorce rate. " - ] + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a 0.00 0.11 0.00 -0.16 0.20 1510.96 1.00\n", + " bM 0.35 0.13 0.35 0.14 0.57 2043.12 1.00\n", + " sigma 0.95 0.10 0.94 0.78 1.10 1565.40 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0IfifzKHN7mA" + }, + "source": [ + "#### Posterior Distribution over the Regression Parameters\n", + "\n", + "We notice that the progress bar gives us online statistics on the acceptance probability, step size and number of steps taken per sample while running NUTS. In particular, during warmup, we adapt the step size and mass matrix to achieve a certain target acceptance probability which is 0.8, by default. We were able to successfully adapt our step size to achieve this target in the warmup phase.\n", + "\n", + "During warmup, the aim is to adapt hyper-parameters such as step size and mass matrix (the HMC algorithm is very sensitive to these hyper-parameters), and to reach the typical set (see [[6](#References)] for more details). If there are any issues in the model specification, the first signal to notice would be low acceptance probabilities or very high number of steps. We use the sample from the end of the warmup phase to seed the MCMC chain (denoted by the second `sample` progress bar) from which we generate the desired number of samples from our target distribution.\n", + "\n", + "At the end of inference, NumPyro prints the mean, std and 90% CI values for each of the latent parameters. Note that since we standardized our predictors and response variable, we would expect the intercept to have mean 0, as can be seen here. It also prints other convergence diagnostics on the latent parameters in the model, including [effective sample size](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.effective_sample_size) and the [gelman rubin diagnostic](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.gelman_rubin) ($\\hat{R}$). The value for these diagnostics indicates that the chain has converged to the target distribution. In our case, the \"target distribution\" is the posterior distribution over the latent parameters that we are interested in. Note that this is often worth verifying with multiple chains for more complicated models. In the end, `samples_1` is a collection (in our case, a `dict` since `init_samples` was a `dict`) containing samples from the posterior distribution for each of the latent parameters in the model.\n", + "\n", + "To look at our regression fit, let us plot the regression line using our posterior estimates for the regression parameters, along with the 90% Credibility Interval (CI). Note that the [hpdi](https://numpyro.readthedocs.io/en/latest/diagnostics.html#numpyro.diagnostics.hpdi) function in NumPyro's diagnostics module can be used to compute CI. In the functions below, note that the collected samples from the posterior are all along the leading axis." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 }, + "id": "UX-DbOtsN7mA", + "outputId": "163ad2c9-7567-490f-9535-f6834f457c8a" + }, + "source": [ + "def plot_regression(x, y_mean, y_hpdi):\n", + " # Sort values for plotting by x axis\n", + " idx = jnp.argsort(x)\n", + " marriage = x[idx]\n", + " mean = y_mean[idx]\n", + " hpdi = y_hpdi[:, idx]\n", + " divorce = dset.DivorceScaled.values[idx]\n", + "\n", + " # Plot\n", + " fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 6))\n", + " ax.plot(marriage, mean)\n", + " ax.plot(marriage, divorce, \"o\")\n", + " ax.fill_between(marriage, hpdi[0], hpdi[1], alpha=0.3, interpolate=True)\n", + " return ax\n", + "\n", + "\n", + "# Compute empirical posterior distribution over mu\n", + "posterior_mu = (\n", + " jnp.expand_dims(samples_1[\"a\"], -1)\n", + " + jnp.expand_dims(samples_1[\"bM\"], -1) * dset.MarriageScaled.values\n", + ")\n", + "\n", + "mean_mu = jnp.mean(posterior_mu, axis=0)\n", + "hpdi_mu = hpdi(posterior_mu, 0.9)\n", + "ax = plot_regression(dset.MarriageScaled.values, mean_mu, hpdi_mu)\n", + "ax.set(\n", + " xlabel=\"Marriage rate\", ylabel=\"Divorce rate\", title=\"Regression line with 90% CI\"\n", + ");" + ], + "execution_count": 9, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "ZBdf-6NEN7mF", - "outputId": "128e3a0b-1742-44a3-f3d1-43b0cc4c5eef" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "mcmc.run(rng_key_, age=dset.AgeScaled.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_2 = mcmc.get_samples()" - ], - "execution_count": 17, - "outputs": [ - { - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 3000/3000 [00:04<00:00, 722.23it/s, 7 steps of size 7.58e-01. acc. prob=0.92]\n" - ], - "name": "stderr" - }, - { - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a -0.00 0.10 -0.00 -0.17 0.16 1942.82 1.00\n", - " bA -0.57 0.12 -0.57 -0.75 -0.38 1995.70 1.00\n", - " sigma 0.82 0.08 0.82 0.69 0.96 1865.82 1.00\n", - "\n", - "Number of divergences: 0\n" - ], - "name": "stdout" - } + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sndvig_RQi0s" + }, + "source": [ + "We can see from the plot, that the CI broadens towards the tails where the data is relatively sparse, as can be expected.\n", + "\n", + "#### Prior Predictive Distribution\n", + "\n", + "Let us check that we have set sensible priors by sampling from the prior predictive distribution. NumPyro provides a handy [Predictive](http://num.pyro.ai/en/latest/utilities.html#numpyro.infer.util.Predictive) utility for this purpose." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 }, + "id": "vSfDasR7Q5Be", + "outputId": "a11554aa-96b7-4298-9456-d44e0d63d8af" + }, + "source": [ + "from numpyro.infer import Predictive\n", + "\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "prior_predictive = Predictive(model, num_samples=100)\n", + "prior_predictions = prior_predictive(rng_key_, marriage=dset.MarriageScaled.values)[\n", + " \"obs\"\n", + "]\n", + "mean_prior_pred = jnp.mean(prior_predictions, axis=0)\n", + "hpdi_prior_pred = hpdi(prior_predictions, 0.9)\n", + "\n", + "ax = plot_regression(dset.MarriageScaled.values, mean_prior_pred, hpdi_prior_pred)\n", + "ax.set(xlabel=\"Marriage rate\", ylabel=\"Divorce rate\", title=\"Predictions with 90% CI\");" + ], + "execution_count": 10, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 405 - }, - "id": "6udy6d7_N7mG", - "outputId": "28a2e4af-81be-4229-b944-1af4d64ddd98" - }, - "source": [ - "posterior_mu = jnp.expand_dims(samples_2['a'], -1) + \\\n", - " jnp.expand_dims(samples_2['bA'], -1) * dset.AgeScaled.values\n", - "mean_mu = jnp.mean(posterior_mu, axis=0)\n", - "hpdi_mu = hpdi(posterior_mu, 0.9)\n", - "ax = plot_regression(dset.AgeScaled.values, mean_mu, hpdi_mu)\n", - "ax.set(xlabel='Median marriage age', ylabel='Divorce rate', title='Regression line with 90% CI');" - ], - "execution_count": 18, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q1ojeyHpN7mB" + }, + "source": [ + "#### Posterior Predictive Distribution\n", + "\n", + "Let us now look at the posterior predictive distribution to see how our predictive distribution looks with respect to the observed divorce rates. To get samples from the posterior predictive distribution, we need to run the model by substituting the latent parameters with samples from the posterior. Note that by default we generate a single prediction for each sample from the joint posterior distribution, but this can be controlled using the `num_samples` argument." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 }, + "id": "XzzsqL7jN7mB", + "outputId": "00bb95d0-8be6-4686-f9d9-bc8a8891aa2c" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictive = Predictive(model, samples_1)\n", + "predictions = predictive(rng_key_, marriage=dset.MarriageScaled.values)[\"obs\"]\n", + "df = dset.filter([\"Location\"])\n", + "df[\"Mean Predictions\"] = jnp.mean(predictions, axis=0)\n", + "df.head()" + ], + "execution_count": 11, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 405 - }, - "id": "DYGHPBueN7mG", - "outputId": "7646a234-b1ee-44f2-8510-02b76654d582" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictions_2 = Predictive(model, samples_2)(rng_key_,\n", - " age=dset.AgeScaled.values)['obs']\n", - "\n", - "mean_pred = jnp.mean(predictions_2, axis=0)\n", - "hpdi_pred = hpdi(predictions_2, 0.9)\n", - "\n", - "ax = plot_regression(dset.AgeScaled.values, mean_pred, hpdi_pred)\n", - "ax.set(xlabel='Median Age', ylabel='Divorce rate', title='Predictions with 90% CI');" + "output_type": "execute_result", + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    LocationMean Predictions
    0Alabama0.016434
    1Alaska0.501293
    2Arizona0.025105
    3Arkansas0.600058
    4California-0.082887
    \n", + "
    " ], - "execution_count": 19, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } + "text/plain": [ + " Location Mean Predictions\n", + "0 Alabama 0.016434\n", + "1 Alaska 0.501293\n", + "2 Arizona 0.025105\n", + "3 Arkansas 0.600058\n", + "4 California -0.082887" ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 11 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n-Sm_5H8N7mC" + }, + "source": [ + "#### Predictive Utility With Effect Handlers\n", + "\n", + "To remove the magic behind `Predictive`, let us see how we can combine [effect handlers](https://numpyro.readthedocs.io/en/latest/handlers.html) with the [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) JAX primitive to implement our own simplified predictive utility function that can do vectorized predictions." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gSKilj8dN7mC" + }, + "source": [ + "def predict(rng_key, post_samples, model, *args, **kwargs):\n", + " model = handlers.seed(handlers.condition(model, post_samples), rng_key)\n", + " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", + " return model_trace[\"obs\"][\"value\"]\n", + "\n", + "\n", + "# vectorize predictions via vmap\n", + "predict_fn = vmap(\n", + " lambda rng_key, samples: predict(\n", + " rng_key, samples, model, marriage=dset.MarriageScaled.values\n", + " )\n", + ")" + ], + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hGB12J3-N7mC" + }, + "source": [ + "Note the use of the `condition`, `seed` and `trace` effect handlers in the `predict` function.\n", + "\n", + " - The `seed` effect-handler is used to wrap a stochastic function with an initial `PRNGKey` seed. When a sample statement inside the model is called, it uses the existing seed to sample from a distribution but this effect-handler also splits the existing key to ensure that future `sample` calls in the model use the newly split key instead. This is to prevent us from having to explicitly pass in a `PRNGKey` to each `sample` statement in the model.\n", + " - The `condition` effect handler conditions the latent sample sites to certain values. In our case, we are conditioning on values from the posterior distribution returned by MCMC.\n", + " - The `trace` effect handler runs the model and records the execution trace within an `OrderedDict`. This trace object contains execution metadata that is useful for computing quantities such as the log joint density.\n", + " \n", + "It should be clear now that the `predict` function simply runs the model by substituting the latent parameters with samples from the posterior (generated by the `mcmc` function) to generate predictions. Note the use of JAX's auto-vectorization transform called [vmap](https://github.com/google/jax#auto-vectorization-with-vmap) to vectorize predictions. Note that if we didn't use `vmap`, we would have to use a native for loop which for each sample which is much slower. Each draw from the posterior can be used to get predictions over all the 50 states. When we vectorize this over all the samples from the posterior using `vmap`, we will get a `predictions_1` array of shape `(num_samples, 50)`. We can then compute the mean and 90% CI of these samples to plot the posterior predictive distribution. We note that our mean predictions match those obtained from the `Predictive` utility class." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 }, + "id": "Hbo0AzmSN7mD", + "outputId": "9183ecd2-bb3b-473b-e912-09188806573e" + }, + "source": [ + "# Using the same key as we used for Predictive - note that the results are identical.\n", + "\n", + "predictions_1 = predict_fn(random.split(rng_key_, num_samples), samples_1)\n", + "\n", + "mean_pred = jnp.mean(predictions_1, axis=0)\n", + "df = dset.filter([\"Location\"])\n", + "df[\"Mean Predictions\"] = mean_pred\n", + "df.head()" + ], + "execution_count": 13, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "FbKMD13UN7mH", - "outputId": "b271e24a-b880-4e2c-97e9-15ea3a671610" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "print('Log posterior predictive density: {}'.format(log_pred_density(rng_key_,\n", - " samples_2, \n", - " model,\n", - " age=dset.AgeScaled.values,\n", - " divorce=dset.DivorceScaled.values)))" + "output_type": "execute_result", + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    LocationMean Predictions
    0Alabama0.016434
    1Alaska0.501293
    2Arizona0.025105
    3Arkansas0.600058
    4California-0.082887
    \n", + "
    " ], - "execution_count": 20, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Log posterior predictive density: -59.251956939697266\n" - ], - "name": "stdout" - } - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "xVss4FJNN7mH" - }, - "source": [ - "### Model 3: Predictor - Marriage Rate and Median Age of Marriage\n", - "\n", - "Finally, we will also model divorce rate as depending on both marriage rate as well as the median age of marriage. Note that the model's posterior predictive density is similar to Model 2 which likely indicates that the marginal information from marriage rate in predicting divorce rate is low when the median age of marriage is already known." + "text/plain": [ + " Location Mean Predictions\n", + "0 Alabama 0.016434\n", + "1 Alaska 0.501293\n", + "2 Arizona 0.025105\n", + "3 Arkansas 0.600058\n", + "4 California -0.082887" ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 }, + "id": "x57YjUCLN7mD", + "outputId": "19ed4248-f852-40d1-da61-f06faa6c4cbd" + }, + "source": [ + "hpdi_pred = hpdi(predictions_1, 0.9)\n", + "\n", + "ax = plot_regression(dset.MarriageScaled.values, mean_pred, hpdi_pred)\n", + "ax.set(xlabel=\"Marriage rate\", ylabel=\"Divorce rate\", title=\"Predictions with 90% CI\");" + ], + "execution_count": 14, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "18Qm4F2_N7mH", - "outputId": "2ce7fc1d-48bb-4c7f-bad6-f0b929f3ac6b" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_3 = mcmc.get_samples()" - ], - "execution_count": 21, - "outputs": [ - { - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 3000/3000 [00:04<00:00, 644.48it/s, 7 steps of size 4.65e-01. acc. prob=0.94]\n" - ], - "name": "stderr" - }, - { - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a 0.00 0.10 0.00 -0.17 0.16 2007.41 1.00\n", - " bA -0.61 0.16 -0.61 -0.89 -0.37 1225.02 1.00\n", - " bM -0.07 0.16 -0.07 -0.34 0.19 1275.37 1.00\n", - " sigma 0.83 0.08 0.82 0.69 0.96 1820.77 1.00\n", - "\n", - "Number of divergences: 0\n" - ], - "name": "stdout" - } + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "b5i71NCFN7mE" + }, + "source": [ + "We have used the same `plot_regression` function as earlier. We notice that our CI for the predictive distribution is much broader as compared to the last plot due to the additional noise introduced by the `sigma` parameter. Most data points lie well within the 90% CI, which indicates a good fit.\n", + "\n", + "#### Posterior Predictive Density\n", + "\n", + "Likewise, making use of effect-handlers and `vmap`, we can also compute the log likelihood for this model given the dataset, and the log posterior predictive density [[6](#References)] which is given by \n", + "$$ log \\prod_{i=1}^{n} \\int p(y_i | \\theta) p_{post}(\\theta) d\\theta \n", + "\\approx \\sum_{i=1}^n log \\frac{\\sum_s p(\\theta^{s})}{S} \\\\\n", + "= \\sum_{i=1}^n (log \\sum_s p(\\theta^{s}) - log(S))\n", + "$$.\n", + "\n", + "Here, $i$ indexes the observed data points $y$ and $s$ indexes the posterior samples over the latent parameters $\\theta$. If the posterior predictive density for a model has a comparatively high value, it indicates that the observed data-points have higher probability under the given model." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ZpNwpvk_N7mE" + }, + "source": [ + "def log_likelihood(rng_key, params, model, *args, **kwargs):\n", + " model = handlers.condition(model, params)\n", + " model_trace = handlers.trace(model).get_trace(*args, **kwargs)\n", + " obs_node = model_trace[\"obs\"]\n", + " return obs_node[\"fn\"].log_prob(obs_node[\"value\"])\n", + "\n", + "\n", + "def log_pred_density(rng_key, params, model, *args, **kwargs):\n", + " n = list(params.values())[0].shape[0]\n", + " log_lk_fn = vmap(\n", + " lambda rng_key, params: log_likelihood(rng_key, params, model, *args, **kwargs)\n", + " )\n", + " log_lk_vals = log_lk_fn(random.split(rng_key, n), params)\n", + " return (logsumexp(log_lk_vals, 0) - jnp.log(n)).sum()" + ], + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dXu_hzcDN7mE" + }, + "source": [ + "Note that NumPyro provides the [log_likelihood](http://num.pyro.ai/en/latest/utilities.html#log-likelihood) utility function that can be used directly for computing `log likelihood` as in the first function for any general model. In this tutorial, we would like to emphasize that there is nothing magical about such utility functions, and you can roll out your own inference utilities using NumPyro's effect handling stack." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "dZxKq_ETN7mF", + "outputId": "9574a5f7-56aa-404a-e491-f7dc2a1c6636" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "print(\n", + " \"Log posterior predictive density: {}\".format(\n", + " log_pred_density(\n", + " rng_key_,\n", + " samples_1,\n", + " model,\n", + " marriage=dset.MarriageScaled.values,\n", + " divorce=dset.DivorceScaled.values,\n", + " )\n", + " )\n", + ")" + ], + "execution_count": 16, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "XfW5xgpwN7mI", - "outputId": "0561ac6d-ae08-4f60-a5a2-13c81f13ce3f" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "print('Log posterior predictive density: {}'.format(\n", - " log_pred_density(rng_key_,\n", - " samples_3,\n", - " model,\n", - " marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values,\n", - " divorce=dset.DivorceScaled.values)\n", - "))" - ], - "execution_count": 22, - "outputs": [ - { - "output_type": "stream", - "text": [ - "Log posterior predictive density: -59.06374740600586\n" - ], - "name": "stdout" - } - ] + "output_type": "stream", + "text": [ + "Log posterior predictive density: -66.70008087158203\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wbxnyQazN7mF" + }, + "source": [ + "### Model 2: Predictor - Median Age of Marriage\n", + "\n", + "We will now model the divorce rate as a function of the median age of marriage. The computations are mostly a reproduction of what we did for Model 1. Notice the following:\n", + "\n", + " - Divorce rate is inversely related to the age of marriage. Hence states where the median age of marriage is low will likely have a higher divorce rate.\n", + " - We get a higher log likelihood as compared to Model 2, indicating that median age of marriage is likely a much better predictor of divorce rate. " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "ZBdf-6NEN7mF", + "outputId": "128e3a0b-1742-44a3-f3d1-43b0cc4c5eef" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "mcmc.run(rng_key_, age=dset.AgeScaled.values, divorce=dset.DivorceScaled.values)\n", + "mcmc.print_summary()\n", + "samples_2 = mcmc.get_samples()" + ], + "execution_count": 17, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "nptmx2OaN7mI" - }, - "source": [ - "### Divorce Rate Residuals by State\n", - "\n", - "The regression plots above shows that the observed divorce rates for many states differs considerably from the mean regression line. To dig deeper into how the last model (Model 3) under-predicts or over-predicts for each of the states, we will plot the posterior predictive and residuals (`Observed divorce rate - Predicted divorce rate`) for each of the states." - ] + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 3000/3000 [00:04<00:00, 722.23it/s, 7 steps of size 7.58e-01. acc. prob=0.92]\n" + ], + "name": "stderr" }, { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 948 - }, - "id": "3vEDRtFON7mI", - "outputId": "a11368d2-222d-484d-9529-10ae11cc042a" - }, - "source": [ - "# Predictions for Model 3.\n", - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictions_3 = Predictive(model, samples_3)(rng_key_,\n", - " marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values)['obs']\n", - "y = jnp.arange(50)\n", - "\n", - "\n", - "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 16))\n", - "pred_mean = jnp.mean(predictions_3, axis=0)\n", - "pred_hpdi = hpdi(predictions_3, 0.9)\n", - "residuals_3 = dset.DivorceScaled.values - predictions_3\n", - "residuals_mean = jnp.mean(residuals_3, axis=0)\n", - "residuals_hpdi = hpdi(residuals_3, 0.9)\n", - "idx = jnp.argsort(residuals_mean)\n", - "\n", - "# Plot posterior predictive\n", - "ax[0].plot(jnp.zeros(50), y, '--')\n", - "ax[0].errorbar(pred_mean[idx], y, xerr=pred_hpdi[1, idx] - pred_mean[idx], \n", - " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", - "ax[0].plot(dset.DivorceScaled.values[idx], y, marker='o', \n", - " ls='none', color='gray')\n", - "ax[0].set(xlabel='Posterior Predictive (red) vs. Actuals (gray)', ylabel='State', \n", - " title='Posterior Predictive with 90% CI')\n", - "ax[0].set_yticks(y)\n", - "ax[0].set_yticklabels(dset.Loc.values[idx], fontsize=10);\n", - "\n", - "# Plot residuals\n", - "residuals_3 = dset.DivorceScaled.values - predictions_3\n", - "residuals_mean = jnp.mean(residuals_3, axis=0)\n", - "residuals_hpdi = hpdi(residuals_3, 0.9)\n", - "err = residuals_hpdi[1] - residuals_mean\n", - "\n", - "ax[1].plot(jnp.zeros(50), y, '--')\n", - "ax[1].errorbar(residuals_mean[idx], y, xerr=err[idx], \n", - " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", - "ax[1].set(xlabel='Residuals', ylabel='State', title='Residuals with 90% CI')\n", - "ax[1].set_yticks(y)\n", - "ax[1].set_yticklabels(dset.Loc.values[idx], fontsize=10);" - ], - "execution_count": 23, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a -0.00 0.10 -0.00 -0.17 0.16 1942.82 1.00\n", + " bA -0.57 0.12 -0.57 -0.75 -0.38 1995.70 1.00\n", + " sigma 0.82 0.08 0.82 0.69 0.96 1865.82 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 }, + "id": "6udy6d7_N7mG", + "outputId": "28a2e4af-81be-4229-b944-1af4d64ddd98" + }, + "source": [ + "posterior_mu = (\n", + " jnp.expand_dims(samples_2[\"a\"], -1)\n", + " + jnp.expand_dims(samples_2[\"bA\"], -1) * dset.AgeScaled.values\n", + ")\n", + "mean_mu = jnp.mean(posterior_mu, axis=0)\n", + "hpdi_mu = hpdi(posterior_mu, 0.9)\n", + "ax = plot_regression(dset.AgeScaled.values, mean_mu, hpdi_mu)\n", + "ax.set(\n", + " xlabel=\"Median marriage age\",\n", + " ylabel=\"Divorce rate\",\n", + " title=\"Regression line with 90% CI\",\n", + ");" + ], + "execution_count": 18, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "_gtKVD5jN7mJ" - }, - "source": [ - "The plot on the left shows the mean predictions with 90% CI for each of the states using Model 3. The gray markers indicate the actual observed divorce rates. The right plot shows the residuals for each of the states, and both these plots are sorted by the residuals, i.e. at the bottom, we are looking at states where the model predictions are higher than the observed rates, whereas at the top, the reverse is true.\n", - "\n", - "Overall, the model fit seems good because most observed data points like within a 90% CI around the mean predictions. However, notice how the model over-predicts by a large margin for states like Idaho (bottom left), and on the other end under-predicts for states like Maine (top right). This is likely indicative of other factors that we are missing out in our model that affect divorce rate across different states. Even ignoring other socio-political variables, one such factor that we have not yet modeled is the measurement noise given by `Divorce SE` in the dataset. We will explore this in the next section." + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 }, + "id": "DYGHPBueN7mG", + "outputId": "7646a234-b1ee-44f2-8510-02b76654d582" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictions_2 = Predictive(model, samples_2)(rng_key_, age=dset.AgeScaled.values)[\"obs\"]\n", + "\n", + "mean_pred = jnp.mean(predictions_2, axis=0)\n", + "hpdi_pred = hpdi(predictions_2, 0.9)\n", + "\n", + "ax = plot_regression(dset.AgeScaled.values, mean_pred, hpdi_pred)\n", + "ax.set(xlabel=\"Median Age\", ylabel=\"Divorce rate\", title=\"Predictions with 90% CI\");" + ], + "execution_count": 19, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "ZB2I6FAhN7mJ" - }, - "source": [ - "## Regression Model with Measurement Error\n", - "\n", - "Note that in our previous models, each data point influences the regression line equally. Is this well justified? We will build on the previous model to incorporate measurement error given by `Divorce SE` variable in the dataset. Incorporating measurement noise will be useful in ensuring that observations that have higher confidence (i.e. lower measurement noise) have a greater impact on the regression line. On the other hand, this will also help us better model outliers with high measurement errors. For more details on modeling errors due to measurement noise, refer to Chapter 14 of [[1](#References)].\n", - "\n", - "To do this, we will reuse Model 3, with the only change that the final observed value has a measurement error given by `divorce_sd` (notice that this has to be standardized since the `divorce` variable itself has been standardized to mean 0 and std 1)." + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "FbKMD13UN7mH", + "outputId": "b271e24a-b880-4e2c-97e9-15ea3a671610" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "print(\n", + " \"Log posterior predictive density: {}\".format(\n", + " log_pred_density(\n", + " rng_key_,\n", + " samples_2,\n", + " model,\n", + " age=dset.AgeScaled.values,\n", + " divorce=dset.DivorceScaled.values,\n", + " )\n", + " )\n", + ")" + ], + "execution_count": 20, + "outputs": [ { - "cell_type": "code", - "metadata": { - "id": "ue9-HyWuN7mJ" - }, - "source": [ - "def model_se(marriage, age, divorce_sd, divorce=None):\n", - " a = numpyro.sample('a', dist.Normal(0., 0.2))\n", - " bM = numpyro.sample('bM', dist.Normal(0., 0.5))\n", - " M = bM * marriage\n", - " bA = numpyro.sample('bA', dist.Normal(0., 0.5))\n", - " A = bA * age\n", - " sigma = numpyro.sample('sigma', dist.Exponential(1.))\n", - " mu = a + M + A\n", - " divorce_rate = numpyro.sample('divorce_rate', dist.Normal(mu, sigma))\n", - " numpyro.sample('obs', dist.Normal(divorce_rate, divorce_sd), obs=divorce)" - ], - "execution_count": 24, - "outputs": [] - }, - { - "cell_type": "code", - "metadata": { - "id": "BFm91doZN7mJ" - }, - "source": [ - "# Standardize\n", - "dset['DivorceScaledSD'] = dset['Divorce SE'] / jnp.std(dset.Divorce.values)" - ], - "execution_count": 25, - "outputs": [] + "output_type": "stream", + "text": [ + "Log posterior predictive density: -59.251956939697266\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xVss4FJNN7mH" + }, + "source": [ + "### Model 3: Predictor - Marriage Rate and Median Age of Marriage\n", + "\n", + "Finally, we will also model divorce rate as depending on both marriage rate as well as the median age of marriage. Note that the model's posterior predictive density is similar to Model 2 which likely indicates that the marginal information from marriage rate in predicting divorce rate is low when the median age of marriage is already known." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "18Qm4F2_N7mH", + "outputId": "2ce7fc1d-48bb-4c7f-bad6-f0b929f3ac6b" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "mcmc.run(\n", + " rng_key_,\n", + " marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values,\n", + " divorce=dset.DivorceScaled.values,\n", + ")\n", + "mcmc.print_summary()\n", + "samples_3 = mcmc.get_samples()" + ], + "execution_count": 21, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "twtxSbBpN7mJ", - "outputId": "1eb4cd42-3b0d-4ae8-bb65-335b6faf205a" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "\n", - "kernel = NUTS(model_se, target_accept_prob=0.9) \n", - "mcmc = MCMC(kernel, num_warmup=1000, num_samples=3000)\n", - "mcmc.run(rng_key_, marriage=dset.MarriageScaled.values, age=dset.AgeScaled.values,\n", - " divorce_sd=dset.DivorceScaledSD.values, divorce=dset.DivorceScaled.values)\n", - "mcmc.print_summary()\n", - "samples_4 = mcmc.get_samples()" - ], - "execution_count": 26, - "outputs": [ - { - "output_type": "stream", - "text": [ - "sample: 100%|██████████| 4000/4000 [00:06<00:00, 578.19it/s, 15 steps of size 2.58e-01. acc. prob=0.93]\n" - ], - "name": "stderr" - }, - { - "output_type": "stream", - "text": [ - "\n", - " mean std median 5.0% 95.0% n_eff r_hat\n", - " a -0.06 0.10 -0.06 -0.20 0.11 3203.01 1.00\n", - " bA -0.61 0.16 -0.61 -0.87 -0.35 2156.51 1.00\n", - " bM 0.06 0.17 0.06 -0.21 0.33 1943.15 1.00\n", - " divorce_rate[0] 1.16 0.36 1.15 0.53 1.72 2488.98 1.00\n", - " divorce_rate[1] 0.69 0.55 0.68 -0.15 1.65 4832.63 1.00\n", - " divorce_rate[2] 0.42 0.34 0.42 -0.16 0.96 4419.13 1.00\n", - " divorce_rate[3] 1.41 0.46 1.40 0.63 2.11 4782.86 1.00\n", - " divorce_rate[4] -0.90 0.13 -0.90 -1.12 -0.71 4269.33 1.00\n", - " divorce_rate[5] 0.65 0.39 0.65 0.01 1.31 4139.51 1.00\n", - " divorce_rate[6] -1.36 0.35 -1.36 -1.96 -0.82 5180.21 1.00\n", - " divorce_rate[7] -0.33 0.49 -0.33 -1.15 0.45 4089.39 1.00\n", - " divorce_rate[8] -1.88 0.59 -1.88 -2.89 -0.93 3305.68 1.00\n", - " divorce_rate[9] -0.62 0.17 -0.61 -0.90 -0.34 4936.95 1.00\n", - "divorce_rate[10] 0.76 0.29 0.76 0.28 1.24 3627.89 1.00\n", - "divorce_rate[11] -0.55 0.50 -0.55 -1.38 0.26 3822.80 1.00\n", - "divorce_rate[12] 0.20 0.53 0.20 -0.74 0.99 1476.70 1.00\n", - "divorce_rate[13] -0.86 0.23 -0.87 -1.24 -0.48 5333.10 1.00\n", - "divorce_rate[14] 0.55 0.30 0.55 0.09 1.05 5533.56 1.00\n", - "divorce_rate[15] 0.28 0.38 0.28 -0.35 0.92 5179.68 1.00\n", - "divorce_rate[16] 0.49 0.43 0.49 -0.23 1.16 5134.56 1.00\n", - "divorce_rate[17] 1.25 0.35 1.24 0.69 1.84 4571.21 1.00\n", - "divorce_rate[18] 0.42 0.38 0.41 -0.15 1.10 4946.86 1.00\n", - "divorce_rate[19] 0.38 0.55 0.36 -0.50 1.29 2145.11 1.00\n", - "divorce_rate[20] -0.56 0.34 -0.56 -1.12 -0.02 5219.59 1.00\n", - "divorce_rate[21] -1.11 0.27 -1.11 -1.53 -0.65 3778.88 1.00\n", - "divorce_rate[22] -0.28 0.26 -0.28 -0.71 0.13 5751.65 1.00\n", - "divorce_rate[23] -0.99 0.30 -0.99 -1.46 -0.49 4385.57 1.00\n", - "divorce_rate[24] 0.43 0.41 0.42 -0.26 1.08 3868.84 1.00\n", - "divorce_rate[25] -0.03 0.32 -0.03 -0.57 0.48 5927.41 1.00\n", - "divorce_rate[26] -0.01 0.49 -0.01 -0.79 0.81 4581.29 1.00\n", - "divorce_rate[27] -0.16 0.39 -0.15 -0.79 0.49 4522.45 1.00\n", - "divorce_rate[28] -0.27 0.50 -0.29 -1.08 0.53 3824.97 1.00\n", - "divorce_rate[29] -1.79 0.24 -1.78 -2.18 -1.39 5134.14 1.00\n", - "divorce_rate[30] 0.17 0.42 0.16 -0.55 0.82 5978.21 1.00\n", - "divorce_rate[31] -1.66 0.16 -1.66 -1.93 -1.41 5976.18 1.00\n", - "divorce_rate[32] 0.12 0.25 0.12 -0.27 0.52 5759.99 1.00\n", - "divorce_rate[33] -0.04 0.52 -0.04 -0.91 0.82 2926.68 1.00\n", - "divorce_rate[34] -0.13 0.22 -0.13 -0.50 0.23 4390.05 1.00\n", - "divorce_rate[35] 1.27 0.43 1.27 0.53 1.94 4659.54 1.00\n", - "divorce_rate[36] 0.22 0.36 0.22 -0.36 0.84 3758.16 1.00\n", - "divorce_rate[37] -1.02 0.23 -1.02 -1.38 -0.64 5954.84 1.00\n", - "divorce_rate[38] -0.93 0.54 -0.94 -1.84 -0.06 3289.66 1.00\n", - "divorce_rate[39] -0.67 0.33 -0.67 -1.18 -0.09 4787.55 1.00\n", - "divorce_rate[40] 0.25 0.55 0.24 -0.67 1.16 4526.98 1.00\n", - "divorce_rate[41] 0.73 0.34 0.73 0.17 1.29 4237.28 1.00\n", - "divorce_rate[42] 0.20 0.18 0.20 -0.10 0.48 5156.91 1.00\n", - "divorce_rate[43] 0.81 0.43 0.81 0.14 1.50 2067.24 1.00\n", - "divorce_rate[44] -0.42 0.51 -0.43 -1.23 0.45 3844.29 1.00\n", - "divorce_rate[45] -0.39 0.25 -0.39 -0.78 0.04 4611.94 1.00\n", - "divorce_rate[46] 0.13 0.31 0.13 -0.36 0.64 5879.70 1.00\n", - "divorce_rate[47] 0.56 0.47 0.56 -0.15 1.37 4319.38 1.00\n", - "divorce_rate[48] -0.63 0.28 -0.63 -1.11 -0.18 5820.05 1.00\n", - "divorce_rate[49] 0.86 0.59 0.88 -0.10 1.79 2460.53 1.00\n", - " sigma 0.58 0.11 0.57 0.40 0.76 735.02 1.00\n", - "\n", - "Number of divergences: 0\n" - ], - "name": "stdout" - } - ] + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 3000/3000 [00:04<00:00, 644.48it/s, 7 steps of size 4.65e-01. acc. prob=0.94]\n" + ], + "name": "stderr" }, { - "cell_type": "markdown", - "metadata": { - "id": "puqL7TzPN7mJ" - }, - "source": [ - "### Effect of Incorporating Measurement Noise on Residuals\n", - "\n", - "Notice that our values for the regression coefficients is very similar to Model 3. However, introducing measurement noise allows us to more closely match our predictive distribution to the observed values. We can see this if we plot the residuals as earlier. " - ] + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a 0.00 0.10 0.00 -0.17 0.16 2007.41 1.00\n", + " bA -0.61 0.16 -0.61 -0.89 -0.37 1225.02 1.00\n", + " bM -0.07 0.16 -0.07 -0.34 0.19 1275.37 1.00\n", + " sigma 0.83 0.08 0.82 0.69 0.96 1820.77 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "XfW5xgpwN7mI", + "outputId": "0561ac6d-ae08-4f60-a5a2-13c81f13ce3f" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "print(\n", + " \"Log posterior predictive density: {}\".format(\n", + " log_pred_density(\n", + " rng_key_,\n", + " samples_3,\n", + " model,\n", + " marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values,\n", + " divorce=dset.DivorceScaled.values,\n", + " )\n", + " )\n", + ")" + ], + "execution_count": 22, + "outputs": [ { - "cell_type": "code", - "metadata": { - "id": "XKnLI7__N7mJ" - }, - "source": [ - "rng_key, rng_key_ = random.split(rng_key)\n", - "predictions_4 = Predictive(model_se, samples_4)(rng_key_,\n", - " marriage=dset.MarriageScaled.values,\n", - " age=dset.AgeScaled.values,\n", - " divorce_sd=dset.DivorceScaledSD.values)['obs']" - ], - "execution_count": 27, - "outputs": [] + "output_type": "stream", + "text": [ + "Log posterior predictive density: -59.06374740600586\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nptmx2OaN7mI" + }, + "source": [ + "### Divorce Rate Residuals by State\n", + "\n", + "The regression plots above shows that the observed divorce rates for many states differs considerably from the mean regression line. To dig deeper into how the last model (Model 3) under-predicts or over-predicts for each of the states, we will plot the posterior predictive and residuals (`Observed divorce rate - Predicted divorce rate`) for each of the states." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 948 }, + "id": "3vEDRtFON7mI", + "outputId": "a11368d2-222d-484d-9529-10ae11cc042a" + }, + "source": [ + "# Predictions for Model 3.\n", + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictions_3 = Predictive(model, samples_3)(\n", + " rng_key_, marriage=dset.MarriageScaled.values, age=dset.AgeScaled.values\n", + ")[\"obs\"]\n", + "y = jnp.arange(50)\n", + "\n", + "\n", + "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(12, 16))\n", + "pred_mean = jnp.mean(predictions_3, axis=0)\n", + "pred_hpdi = hpdi(predictions_3, 0.9)\n", + "residuals_3 = dset.DivorceScaled.values - predictions_3\n", + "residuals_mean = jnp.mean(residuals_3, axis=0)\n", + "residuals_hpdi = hpdi(residuals_3, 0.9)\n", + "idx = jnp.argsort(residuals_mean)\n", + "\n", + "# Plot posterior predictive\n", + "ax[0].plot(jnp.zeros(50), y, \"--\")\n", + "ax[0].errorbar(\n", + " pred_mean[idx],\n", + " y,\n", + " xerr=pred_hpdi[1, idx] - pred_mean[idx],\n", + " marker=\"o\",\n", + " ms=5,\n", + " mew=4,\n", + " ls=\"none\",\n", + " alpha=0.8,\n", + ")\n", + "ax[0].plot(dset.DivorceScaled.values[idx], y, marker=\"o\", ls=\"none\", color=\"gray\")\n", + "ax[0].set(\n", + " xlabel=\"Posterior Predictive (red) vs. Actuals (gray)\",\n", + " ylabel=\"State\",\n", + " title=\"Posterior Predictive with 90% CI\",\n", + ")\n", + "ax[0].set_yticks(y)\n", + "ax[0].set_yticklabels(dset.Loc.values[idx], fontsize=10)\n", + "\n", + "# Plot residuals\n", + "residuals_3 = dset.DivorceScaled.values - predictions_3\n", + "residuals_mean = jnp.mean(residuals_3, axis=0)\n", + "residuals_hpdi = hpdi(residuals_3, 0.9)\n", + "err = residuals_hpdi[1] - residuals_mean\n", + "\n", + "ax[1].plot(jnp.zeros(50), y, \"--\")\n", + "ax[1].errorbar(\n", + " residuals_mean[idx], y, xerr=err[idx], marker=\"o\", ms=5, mew=4, ls=\"none\", alpha=0.8\n", + ")\n", + "ax[1].set(xlabel=\"Residuals\", ylabel=\"State\", title=\"Residuals with 90% CI\")\n", + "ax[1].set_yticks(y)\n", + "ax[1].set_yticklabels(dset.Loc.values[idx], fontsize=10);" + ], + "execution_count": 23, + "outputs": [ { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 993 - }, - "id": "a7aC5dgdN7mJ", - "outputId": "e6878a39-dbb8-485c-bd56-79a66155f8a5" - }, - "source": [ - "sd = dset.DivorceScaledSD.values\n", - "residuals_4 = dset.DivorceScaled.values - predictions_4\n", - "residuals_mean = jnp.mean(residuals_4, axis=0)\n", - "residuals_hpdi = hpdi(residuals_4, 0.9)\n", - "err = residuals_hpdi[1] - residuals_mean\n", - "idx = jnp.argsort(residuals_mean)\n", - "y = jnp.arange(50)\n", - "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 16))\n", - "\n", - "\n", - "# Plot Residuals\n", - "ax.plot(jnp.zeros(50), y, '--')\n", - "ax.errorbar(residuals_mean[idx], y, xerr=err[idx], \n", - " marker='o', ms=5, mew=4, ls='none', alpha=0.8)\n", - "\n", - "# Plot SD \n", - "ax.errorbar(residuals_mean[idx], y, xerr=sd[idx], \n", - " ls='none', color='orange', alpha=0.9)\n", - "\n", - "# Plot earlier mean residual\n", - "ax.plot(jnp.mean(dset.DivorceScaled.values - predictions_3, 0)[idx], y,\n", - " ls='none', marker='o', ms=6, color='black', alpha=0.6)\n", - "\n", - "ax.set(xlabel='Residuals', ylabel='State', title='Residuals with 90% CI')\n", - "ax.set_yticks(y)\n", - "ax.set_yticklabels(dset.Loc.values[idx], fontsize=10);\n", - "ax.text(-2.8, -7, 'Residuals (with error-bars) from current model (in red). '\n", - " 'Black marker \\nshows residuals from the previous model (Model 3). '\n", - " 'Measurement \\nerror is indicated by orange bar.');" - ], - "execution_count": 28, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_gtKVD5jN7mJ" + }, + "source": [ + "The plot on the left shows the mean predictions with 90% CI for each of the states using Model 3. The gray markers indicate the actual observed divorce rates. The right plot shows the residuals for each of the states, and both these plots are sorted by the residuals, i.e. at the bottom, we are looking at states where the model predictions are higher than the observed rates, whereas at the top, the reverse is true.\n", + "\n", + "Overall, the model fit seems good because most observed data points like within a 90% CI around the mean predictions. However, notice how the model over-predicts by a large margin for states like Idaho (bottom left), and on the other end under-predicts for states like Maine (top right). This is likely indicative of other factors that we are missing out in our model that affect divorce rate across different states. Even ignoring other socio-political variables, one such factor that we have not yet modeled is the measurement noise given by `Divorce SE` in the dataset. We will explore this in the next section." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZB2I6FAhN7mJ" + }, + "source": [ + "## Regression Model with Measurement Error\n", + "\n", + "Note that in our previous models, each data point influences the regression line equally. Is this well justified? We will build on the previous model to incorporate measurement error given by `Divorce SE` variable in the dataset. Incorporating measurement noise will be useful in ensuring that observations that have higher confidence (i.e. lower measurement noise) have a greater impact on the regression line. On the other hand, this will also help us better model outliers with high measurement errors. For more details on modeling errors due to measurement noise, refer to Chapter 14 of [[1](#References)].\n", + "\n", + "To do this, we will reuse Model 3, with the only change that the final observed value has a measurement error given by `divorce_sd` (notice that this has to be standardized since the `divorce` variable itself has been standardized to mean 0 and std 1)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "ue9-HyWuN7mJ" + }, + "source": [ + "def model_se(marriage, age, divorce_sd, divorce=None):\n", + " a = numpyro.sample(\"a\", dist.Normal(0.0, 0.2))\n", + " bM = numpyro.sample(\"bM\", dist.Normal(0.0, 0.5))\n", + " M = bM * marriage\n", + " bA = numpyro.sample(\"bA\", dist.Normal(0.0, 0.5))\n", + " A = bA * age\n", + " sigma = numpyro.sample(\"sigma\", dist.Exponential(1.0))\n", + " mu = a + M + A\n", + " divorce_rate = numpyro.sample(\"divorce_rate\", dist.Normal(mu, sigma))\n", + " numpyro.sample(\"obs\", dist.Normal(divorce_rate, divorce_sd), obs=divorce)" + ], + "execution_count": 24, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "BFm91doZN7mJ" + }, + "source": [ + "# Standardize\n", + "dset[\"DivorceScaledSD\"] = dset[\"Divorce SE\"] / jnp.std(dset.Divorce.values)" + ], + "execution_count": 25, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" }, + "id": "twtxSbBpN7mJ", + "outputId": "1eb4cd42-3b0d-4ae8-bb65-335b6faf205a" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "\n", + "kernel = NUTS(model_se, target_accept_prob=0.9)\n", + "mcmc = MCMC(kernel, num_warmup=1000, num_samples=3000)\n", + "mcmc.run(\n", + " rng_key_,\n", + " marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values,\n", + " divorce_sd=dset.DivorceScaledSD.values,\n", + " divorce=dset.DivorceScaled.values,\n", + ")\n", + "mcmc.print_summary()\n", + "samples_4 = mcmc.get_samples()" + ], + "execution_count": 26, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "05vX0drHN7mK" - }, - "source": [ - "The plot above shows the residuals for each of the states, along with the measurement noise given by inner error bar. The gray dots are the mean residuals from our earlier Model 3. Notice how having an additional degree of freedom to model the measurement noise has shrunk the residuals. In particular, for Idaho and Maine, our predictions are now much closer to the observed values after incorporating measurement noise in the model.\n", - "\n", - "To better see how measurement noise affects the movement of the regression line, let us plot the residuals with respect to the measurement noise." - ] + "output_type": "stream", + "text": [ + "sample: 100%|██████████| 4000/4000 [00:06<00:00, 578.19it/s, 15 steps of size 2.58e-01. acc. prob=0.93]\n" + ], + "name": "stderr" }, { - "cell_type": "code", - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 405 - }, - "id": "lmvXOBAsN7mK", - "outputId": "12aba4b5-d974-4887-8be1-b223f73d0ad0" - }, - "source": [ - "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n", - "x = dset.DivorceScaledSD.values\n", - "y1 = jnp.mean(residuals_3, 0)\n", - "y2 = jnp.mean(residuals_4, 0)\n", - "ax.plot(x, y1, ls='none', marker='o')\n", - "ax.plot(x, y2, ls='none', marker='o')\n", - "for i, (j, k) in enumerate(zip(y1, y2)):\n", - " ax.plot([x[i], x[i]], [j, k], '--', color='gray');\n", - "\n", - "ax.set(xlabel='Measurement Noise', ylabel='Residual', title='Mean residuals (Model 4: red, Model 3: blue)');" - ], - "execution_count": 29, - "outputs": [ - { - "output_type": "display_data", - "data": { - "image/png": "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\n", - "text/plain": [ - "
    " - ] - }, - "metadata": { - "tags": [], - "needs_background": "light" - } - } - ] + "output_type": "stream", + "text": [ + "\n", + " mean std median 5.0% 95.0% n_eff r_hat\n", + " a -0.06 0.10 -0.06 -0.20 0.11 3203.01 1.00\n", + " bA -0.61 0.16 -0.61 -0.87 -0.35 2156.51 1.00\n", + " bM 0.06 0.17 0.06 -0.21 0.33 1943.15 1.00\n", + " divorce_rate[0] 1.16 0.36 1.15 0.53 1.72 2488.98 1.00\n", + " divorce_rate[1] 0.69 0.55 0.68 -0.15 1.65 4832.63 1.00\n", + " divorce_rate[2] 0.42 0.34 0.42 -0.16 0.96 4419.13 1.00\n", + " divorce_rate[3] 1.41 0.46 1.40 0.63 2.11 4782.86 1.00\n", + " divorce_rate[4] -0.90 0.13 -0.90 -1.12 -0.71 4269.33 1.00\n", + " divorce_rate[5] 0.65 0.39 0.65 0.01 1.31 4139.51 1.00\n", + " divorce_rate[6] -1.36 0.35 -1.36 -1.96 -0.82 5180.21 1.00\n", + " divorce_rate[7] -0.33 0.49 -0.33 -1.15 0.45 4089.39 1.00\n", + " divorce_rate[8] -1.88 0.59 -1.88 -2.89 -0.93 3305.68 1.00\n", + " divorce_rate[9] -0.62 0.17 -0.61 -0.90 -0.34 4936.95 1.00\n", + "divorce_rate[10] 0.76 0.29 0.76 0.28 1.24 3627.89 1.00\n", + "divorce_rate[11] -0.55 0.50 -0.55 -1.38 0.26 3822.80 1.00\n", + "divorce_rate[12] 0.20 0.53 0.20 -0.74 0.99 1476.70 1.00\n", + "divorce_rate[13] -0.86 0.23 -0.87 -1.24 -0.48 5333.10 1.00\n", + "divorce_rate[14] 0.55 0.30 0.55 0.09 1.05 5533.56 1.00\n", + "divorce_rate[15] 0.28 0.38 0.28 -0.35 0.92 5179.68 1.00\n", + "divorce_rate[16] 0.49 0.43 0.49 -0.23 1.16 5134.56 1.00\n", + "divorce_rate[17] 1.25 0.35 1.24 0.69 1.84 4571.21 1.00\n", + "divorce_rate[18] 0.42 0.38 0.41 -0.15 1.10 4946.86 1.00\n", + "divorce_rate[19] 0.38 0.55 0.36 -0.50 1.29 2145.11 1.00\n", + "divorce_rate[20] -0.56 0.34 -0.56 -1.12 -0.02 5219.59 1.00\n", + "divorce_rate[21] -1.11 0.27 -1.11 -1.53 -0.65 3778.88 1.00\n", + "divorce_rate[22] -0.28 0.26 -0.28 -0.71 0.13 5751.65 1.00\n", + "divorce_rate[23] -0.99 0.30 -0.99 -1.46 -0.49 4385.57 1.00\n", + "divorce_rate[24] 0.43 0.41 0.42 -0.26 1.08 3868.84 1.00\n", + "divorce_rate[25] -0.03 0.32 -0.03 -0.57 0.48 5927.41 1.00\n", + "divorce_rate[26] -0.01 0.49 -0.01 -0.79 0.81 4581.29 1.00\n", + "divorce_rate[27] -0.16 0.39 -0.15 -0.79 0.49 4522.45 1.00\n", + "divorce_rate[28] -0.27 0.50 -0.29 -1.08 0.53 3824.97 1.00\n", + "divorce_rate[29] -1.79 0.24 -1.78 -2.18 -1.39 5134.14 1.00\n", + "divorce_rate[30] 0.17 0.42 0.16 -0.55 0.82 5978.21 1.00\n", + "divorce_rate[31] -1.66 0.16 -1.66 -1.93 -1.41 5976.18 1.00\n", + "divorce_rate[32] 0.12 0.25 0.12 -0.27 0.52 5759.99 1.00\n", + "divorce_rate[33] -0.04 0.52 -0.04 -0.91 0.82 2926.68 1.00\n", + "divorce_rate[34] -0.13 0.22 -0.13 -0.50 0.23 4390.05 1.00\n", + "divorce_rate[35] 1.27 0.43 1.27 0.53 1.94 4659.54 1.00\n", + "divorce_rate[36] 0.22 0.36 0.22 -0.36 0.84 3758.16 1.00\n", + "divorce_rate[37] -1.02 0.23 -1.02 -1.38 -0.64 5954.84 1.00\n", + "divorce_rate[38] -0.93 0.54 -0.94 -1.84 -0.06 3289.66 1.00\n", + "divorce_rate[39] -0.67 0.33 -0.67 -1.18 -0.09 4787.55 1.00\n", + "divorce_rate[40] 0.25 0.55 0.24 -0.67 1.16 4526.98 1.00\n", + "divorce_rate[41] 0.73 0.34 0.73 0.17 1.29 4237.28 1.00\n", + "divorce_rate[42] 0.20 0.18 0.20 -0.10 0.48 5156.91 1.00\n", + "divorce_rate[43] 0.81 0.43 0.81 0.14 1.50 2067.24 1.00\n", + "divorce_rate[44] -0.42 0.51 -0.43 -1.23 0.45 3844.29 1.00\n", + "divorce_rate[45] -0.39 0.25 -0.39 -0.78 0.04 4611.94 1.00\n", + "divorce_rate[46] 0.13 0.31 0.13 -0.36 0.64 5879.70 1.00\n", + "divorce_rate[47] 0.56 0.47 0.56 -0.15 1.37 4319.38 1.00\n", + "divorce_rate[48] -0.63 0.28 -0.63 -1.11 -0.18 5820.05 1.00\n", + "divorce_rate[49] 0.86 0.59 0.88 -0.10 1.79 2460.53 1.00\n", + " sigma 0.58 0.11 0.57 0.40 0.76 735.02 1.00\n", + "\n", + "Number of divergences: 0\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "puqL7TzPN7mJ" + }, + "source": [ + "### Effect of Incorporating Measurement Noise on Residuals\n", + "\n", + "Notice that our values for the regression coefficients is very similar to Model 3. However, introducing measurement noise allows us to more closely match our predictive distribution to the observed values. We can see this if we plot the residuals as earlier. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "XKnLI7__N7mJ" + }, + "source": [ + "rng_key, rng_key_ = random.split(rng_key)\n", + "predictions_4 = Predictive(model_se, samples_4)(\n", + " rng_key_,\n", + " marriage=dset.MarriageScaled.values,\n", + " age=dset.AgeScaled.values,\n", + " divorce_sd=dset.DivorceScaledSD.values,\n", + ")[\"obs\"]" + ], + "execution_count": 27, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 993 }, + "id": "a7aC5dgdN7mJ", + "outputId": "e6878a39-dbb8-485c-bd56-79a66155f8a5" + }, + "source": [ + "sd = dset.DivorceScaledSD.values\n", + "residuals_4 = dset.DivorceScaled.values - predictions_4\n", + "residuals_mean = jnp.mean(residuals_4, axis=0)\n", + "residuals_hpdi = hpdi(residuals_4, 0.9)\n", + "err = residuals_hpdi[1] - residuals_mean\n", + "idx = jnp.argsort(residuals_mean)\n", + "y = jnp.arange(50)\n", + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 16))\n", + "\n", + "\n", + "# Plot Residuals\n", + "ax.plot(jnp.zeros(50), y, \"--\")\n", + "ax.errorbar(\n", + " residuals_mean[idx], y, xerr=err[idx], marker=\"o\", ms=5, mew=4, ls=\"none\", alpha=0.8\n", + ")\n", + "\n", + "# Plot SD\n", + "ax.errorbar(residuals_mean[idx], y, xerr=sd[idx], ls=\"none\", color=\"orange\", alpha=0.9)\n", + "\n", + "# Plot earlier mean residual\n", + "ax.plot(\n", + " jnp.mean(dset.DivorceScaled.values - predictions_3, 0)[idx],\n", + " y,\n", + " ls=\"none\",\n", + " marker=\"o\",\n", + " ms=6,\n", + " color=\"black\",\n", + " alpha=0.6,\n", + ")\n", + "\n", + "ax.set(xlabel=\"Residuals\", ylabel=\"State\", title=\"Residuals with 90% CI\")\n", + "ax.set_yticks(y)\n", + "ax.set_yticklabels(dset.Loc.values[idx], fontsize=10)\n", + "ax.text(\n", + " -2.8,\n", + " -7,\n", + " \"Residuals (with error-bars) from current model (in red). \"\n", + " \"Black marker \\nshows residuals from the previous model (Model 3). \"\n", + " \"Measurement \\nerror is indicated by orange bar.\",\n", + ");" + ], + "execution_count": 28, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "YzFlMShkN7mL" - }, - "source": [ - "The plot above shows what has happend in more detail - the regression line itself has moved to ensure a better fit for observations with low measurement noise (left of the plot) where the residuals have shrunk very close to 0. That is to say that data points with low measurement error have a concomitantly higher contribution in determining the regression line. On the other hand, for states with high measurement error (right of the plot), incorporating measurement noise allows us to move our posterior distribution mass closer to the observations resulting in a shrinkage of residuals as well." + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "05vX0drHN7mK" + }, + "source": [ + "The plot above shows the residuals for each of the states, along with the measurement noise given by inner error bar. The gray dots are the mean residuals from our earlier Model 3. Notice how having an additional degree of freedom to model the measurement noise has shrunk the residuals. In particular, for Idaho and Maine, our predictions are now much closer to the observed values after incorporating measurement noise in the model.\n", + "\n", + "To better see how measurement noise affects the movement of the regression line, let us plot the residuals with respect to the measurement noise." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 }, + "id": "lmvXOBAsN7mK", + "outputId": "12aba4b5-d974-4887-8be1-b223f73d0ad0" + }, + "source": [ + "fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 6))\n", + "x = dset.DivorceScaledSD.values\n", + "y1 = jnp.mean(residuals_3, 0)\n", + "y2 = jnp.mean(residuals_4, 0)\n", + "ax.plot(x, y1, ls=\"none\", marker=\"o\")\n", + "ax.plot(x, y2, ls=\"none\", marker=\"o\")\n", + "for i, (j, k) in enumerate(zip(y1, y2)):\n", + " ax.plot([x[i], x[i]], [j, k], \"--\", color=\"gray\")\n", + "\n", + "ax.set(\n", + " xlabel=\"Measurement Noise\",\n", + " ylabel=\"Residual\",\n", + " title=\"Mean residuals (Model 4: red, Model 3: blue)\",\n", + ");" + ], + "execution_count": 29, + "outputs": [ { - "cell_type": "markdown", - "metadata": { - "id": "1NmiOj_fN7mL" - }, - "source": [ - "## References\n", - "\n", - "1. McElreath, R. (2016). Statistical Rethinking: A Bayesian Course with Examples in R and Stan CRC Press.\n", - "2. Stan Development Team. [Stan User's Guide](https://mc-stan.org/docs/2_19/stan-users-guide/index.html)\n", - "3. Goodman, N.D., and StuhlMueller, A. (2014). [The Design and Implementation of Probabilistic Programming Languages](http://dippl.org/)\n", - "4. Pyro Development Team. [Poutine: A Guide to Programming with Effect Handlers in Pyro](http://pyro.ai/examples/effect_handlers.html)\n", - "5. Hoffman, M.D., Gelman, A. (2011). The No-U-Turn Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo.\n", - "6. Betancourt, M. (2017). A Conceptual Introduction to Hamiltonian Monte Carlo.\n", - "7. JAX Development Team (2018). [Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more](https://github.com/google/jax)\n", - "8. Gelman, A., Hwang, J., and Vehtari A. [Understanding predictive information criteria for Bayesian models](https://arxiv.org/pdf/1307.5928.pdf)" + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } } - ] + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YzFlMShkN7mL" + }, + "source": [ + "The plot above shows what has happend in more detail - the regression line itself has moved to ensure a better fit for observations with low measurement noise (left of the plot) where the residuals have shrunk very close to 0. That is to say that data points with low measurement error have a concomitantly higher contribution in determining the regression line. On the other hand, for states with high measurement error (right of the plot), incorporating measurement noise allows us to move our posterior distribution mass closer to the observations resulting in a shrinkage of residuals as well." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "1NmiOj_fN7mL" + }, + "source": [ + "## References\n", + "\n", + "1. McElreath, R. (2016). Statistical Rethinking: A Bayesian Course with Examples in R and Stan CRC Press.\n", + "2. Stan Development Team. [Stan User's Guide](https://mc-stan.org/docs/2_19/stan-users-guide/index.html)\n", + "3. Goodman, N.D., and StuhlMueller, A. (2014). [The Design and Implementation of Probabilistic Programming Languages](http://dippl.org/)\n", + "4. Pyro Development Team. [Poutine: A Guide to Programming with Effect Handlers in Pyro](http://pyro.ai/examples/effect_handlers.html)\n", + "5. Hoffman, M.D., Gelman, A. (2011). The No-U-Turn Sampler: Adaptively Setting Path Lengths in Hamiltonian Monte Carlo.\n", + "6. Betancourt, M. (2017). A Conceptual Introduction to Hamiltonian Monte Carlo.\n", + "7. JAX Development Team (2018). [Composable transformations of Python+NumPy programs: differentiate, vectorize, JIT to GPU/TPU, and more](https://github.com/google/jax)\n", + "8. Gelman, A., Hwang, J., and Vehtari A. [Understanding predictive information criteria for Bayesian models](https://arxiv.org/pdf/1307.5928.pdf)" + ] + } + ] } \ No newline at end of file diff --git a/notebooks/source/discrete_imputation.ipynb b/notebooks/source/discrete_imputation.ipynb index 3b1a564b6..dc67bd8d8 100644 --- a/notebooks/source/discrete_imputation.ipynb +++ b/notebooks/source/discrete_imputation.ipynb @@ -38,7 +38,7 @@ "from graphviz import Digraph\n", "\n", "simkeys = random.split(random.PRNGKey(0), 10)\n", - "nsim = 5000\n", + "nsim = 5000\n", "mcmc_key = random.PRNGKey(1)" ] }, @@ -132,11 +132,11 @@ ], "source": [ "dot = Digraph()\n", - "dot.node('A')\n", - "dot.node('B')\n", - "dot.node('Z')\n", - "dot.node('Y')\n", - "dot.edges(['ZA', 'ZB', 'AY', 'BY'])\n", + "dot.node(\"A\")\n", + "dot.node(\"B\")\n", + "dot.node(\"Z\")\n", + "dot.node(\"Y\")\n", + "dot.edges([\"ZA\", \"ZB\", \"AY\", \"BY\"])\n", "dot" ] }, @@ -149,7 +149,7 @@ "b_A = 0.25\n", "b_B = 0.25\n", "s_Y = 0.25\n", - "Z = random.normal(simkeys[0], (nsim, ))\n", + "Z = random.normal(simkeys[0], (nsim,))\n", "A = random.bernoulli(simkeys[1], expit(Z))\n", "B = random.bernoulli(simkeys[2], expit(Z))\n", "Y = A * b_A + B * b_B + s_Y * random.normal(simkeys[3], (nsim,))" @@ -267,14 +267,14 @@ "source": [ "dot_mnar_y = Digraph()\n", "with dot_mnar_y.subgraph() as s:\n", - " s.attr(rank='same')\n", - " s.node('Y')\n", - " s.node('M')\n", - "dot_mnar_y.node('A')\n", - "dot_mnar_y.node('B')\n", - "dot_mnar_y.node('Z')\n", - "dot_mnar_y.node('M')\n", - "dot_mnar_y.edges(['YM', 'ZA', 'ZB', 'AY', 'BY'])\n", + " s.attr(rank=\"same\")\n", + " s.node(\"Y\")\n", + " s.node(\"M\")\n", + "dot_mnar_y.node(\"A\")\n", + "dot_mnar_y.node(\"B\")\n", + "dot_mnar_y.node(\"Z\")\n", + "dot_mnar_y.node(\"M\")\n", + "dot_mnar_y.edges([\"YM\", \"ZA\", \"ZB\", \"AY\", \"BY\"])\n", "dot_mnar_y" ] }, @@ -299,7 +299,7 @@ "metadata": {}, "outputs": [], "source": [ - "A_isobs = random.bernoulli(simkeys[4], expit(3*(Y - Y.mean())))\n", + "A_isobs = random.bernoulli(simkeys[4], expit(3 * (Y - Y.mean())))\n", "Aobs = jnp.where(A_isobs, A, -1)\n", "A_obsidx = jnp.where(A_isobs)\n", "\n", @@ -332,12 +332,12 @@ "def ccmodel(A, B, Y):\n", " ntotal = A.shape[0]\n", " # get parameters of outcome model\n", - " b_A = sample('b_A', dist.Normal(0, 2.5))\n", - " b_B = sample('b_B', dist.Normal(0, 2.5))\n", - " s_Y = sample('s_Y', dist.HalfCauchy(2.5))\n", - " \n", - " with numpyro.plate('obs', ntotal):\n", - " ### outcome model \n", + " b_A = sample(\"b_A\", dist.Normal(0, 2.5))\n", + " b_B = sample(\"b_B\", dist.Normal(0, 2.5))\n", + " s_Y = sample(\"s_Y\", dist.HalfCauchy(2.5))\n", + "\n", + " with numpyro.plate(\"obs\", ntotal):\n", + " ### outcome model\n", " eta_Y = b_A * A + b_B * B\n", " sample(\"obs_Y\", dist.Normal(eta_Y, s_Y), obs=Y)" ] @@ -370,7 +370,7 @@ ], "source": [ "cckernel = NUTS(ccmodel)\n", - "ccmcmc = MCMC(cckernel, num_warmup=250, num_samples=750)\n", + "ccmcmc = MCMC(cckernel, num_warmup=250, num_samples=750)\n", "ccmcmc.run(mcmc_key, Acc, Bcc, Ycc)\n", "ccmcmc.print_summary()" ] @@ -387,34 +387,34 @@ "\n", " # get parameters of imputation model\n", " mu_A = sample(\"mu_A\", dist.Normal(0, 2.5))\n", - " b_B_A = sample(\"b_B_A\", dist.Normal(0, 2.5)) \n", + " b_B_A = sample(\"b_B_A\", dist.Normal(0, 2.5))\n", "\n", " # get parameters of outcome model\n", - " b_A = sample('b_A', dist.Normal(0, 2.5))\n", - " b_B = sample('b_B', dist.Normal(0, 2.5))\n", - " s_Y = sample('s_Y', dist.HalfCauchy(2.5))\n", - " \n", - " with numpyro.plate('obs', ntotal):\n", + " b_A = sample(\"b_A\", dist.Normal(0, 2.5))\n", + " b_B = sample(\"b_B\", dist.Normal(0, 2.5))\n", + " s_Y = sample(\"s_Y\", dist.HalfCauchy(2.5))\n", + "\n", + " with numpyro.plate(\"obs\", ntotal):\n", " ### imputation model\n", " # get linear predictor for missing values\n", " eta_A = mu_A + B * b_B_A\n", "\n", " # sample imputation values for A\n", " # mask out to not add log_prob to total likelihood right now\n", - " Aimp = sample(\"A\", dist.Bernoulli(logits=eta_A).mask(False)) \n", - " \n", + " Aimp = sample(\"A\", dist.Bernoulli(logits=eta_A).mask(False))\n", + "\n", " # 'manually' calculate the log_prob\n", " log_prob = dist.Bernoulli(logits=eta_A).log_prob(Aimp)\n", - " \n", + "\n", " # cancel out enumerated values that are not equal to observed values\n", - " log_prob = jnp.where(A_isobs & (Aimp != A), -inf, log_prob) \n", - " \n", + " log_prob = jnp.where(A_isobs & (Aimp != A), -inf, log_prob)\n", + "\n", " # add to total likelihood for sampler\n", - " numpyro.factor('A_obs', log_prob)\n", - " \n", - " ### outcome model \n", + " numpyro.factor(\"A_obs\", log_prob)\n", + "\n", + " ### outcome model\n", " eta_Y = b_A * Aimp + b_B * B\n", - " sample(\"obs_Y\", dist.Normal(eta_Y, s_Y), obs=Y)\n" + " sample(\"obs_Y\", dist.Normal(eta_Y, s_Y), obs=Y)" ] }, { @@ -447,7 +447,7 @@ ], "source": [ "impkernel = NUTS(impmodel)\n", - "impmcmc = MCMC(impkernel, num_warmup=250, num_samples=750)\n", + "impmcmc = MCMC(impkernel, num_warmup=250, num_samples=750)\n", "impmcmc.run(mcmc_key, Aobs, B, Y)\n", "impmcmc.print_summary()" ] @@ -571,13 +571,13 @@ "source": [ "dot_mnar_x = Digraph()\n", "with dot_mnar_y.subgraph() as s:\n", - " s.attr(rank='same')\n", - " s.node('A')\n", - " s.node('M')\n", - "dot_mnar_x.node('B')\n", - "dot_mnar_x.node('Z')\n", - "dot_mnar_x.node('Y')\n", - "dot_mnar_x.edges(['AM', 'ZA', 'ZB', 'AY', 'BY'])\n", + " s.attr(rank=\"same\")\n", + " s.node(\"A\")\n", + " s.node(\"M\")\n", + "dot_mnar_x.node(\"B\")\n", + "dot_mnar_x.node(\"Z\")\n", + "dot_mnar_x.node(\"Y\")\n", + "dot_mnar_x.edges([\"AM\", \"ZA\", \"ZB\", \"AY\", \"BY\"])\n", "dot_mnar_x" ] }, @@ -625,7 +625,7 @@ ], "source": [ "cckernel = NUTS(ccmodel)\n", - "ccmcmc = MCMC(cckernel, num_warmup=250, num_samples=750)\n", + "ccmcmc = MCMC(cckernel, num_warmup=250, num_samples=750)\n", "ccmcmc.run(mcmc_key, Acc, Bcc, Ycc)\n", "ccmcmc.print_summary()" ] @@ -667,7 +667,7 @@ ], "source": [ "impkernel = NUTS(impmodel)\n", - "impmcmc = MCMC(impkernel, num_warmup=250, num_samples=750)\n", + "impmcmc = MCMC(impkernel, num_warmup=250, num_samples=750)\n", "impmcmc.run(mcmc_key, Aobs, B, Y)\n", "impmcmc.print_summary()" ] @@ -694,43 +694,42 @@ "\n", " # get parameters of imputation model\n", " mu_A = sample(\"mu_A\", dist.Normal(0, 2.5))\n", - " b_B_A = sample(\"b_B_A\", dist.Normal(0, 2.5)) \n", + " b_B_A = sample(\"b_B_A\", dist.Normal(0, 2.5))\n", "\n", " # get parameters of outcome model\n", - " b_A = sample('b_A', dist.Normal(0, 2.5))\n", - " b_B = sample('b_B', dist.Normal(0, 2.5))\n", - " s_Y = sample('s_Y', dist.HalfCauchy(2.5))\n", - " \n", + " b_A = sample(\"b_A\", dist.Normal(0, 2.5))\n", + " b_B = sample(\"b_B\", dist.Normal(0, 2.5))\n", + " s_Y = sample(\"s_Y\", dist.HalfCauchy(2.5))\n", + "\n", " # get parameter of model of missingness\n", - " with numpyro.plate('obsmodel', 2):\n", - " p_Aobs = sample('p_Aobs', dist.Beta(1,1))\n", - " \n", - " with numpyro.plate('obs', ntotal):\n", + " with numpyro.plate(\"obsmodel\", 2):\n", + " p_Aobs = sample(\"p_Aobs\", dist.Beta(1, 1))\n", + "\n", + " with numpyro.plate(\"obs\", ntotal):\n", " ### imputation model\n", " # get linear predictor for missing values\n", " eta_A = mu_A + B * b_B_A\n", "\n", " # sample imputation values for A\n", " # mask out to not add log_prob to total likelihood right now\n", - " Aimp = sample(\"A\", dist.Bernoulli(logits=eta_A).mask(False)) \n", - " \n", + " Aimp = sample(\"A\", dist.Bernoulli(logits=eta_A).mask(False))\n", + "\n", " # 'manually' calculate the log_prob\n", " log_prob = dist.Bernoulli(logits=eta_A).log_prob(Aimp)\n", - " \n", + "\n", " # cancel out enumerated values that are not equal to observed values\n", - " log_prob = jnp.where(A_isobs & (Aimp != A), -inf, log_prob) \n", - " \n", + " log_prob = jnp.where(A_isobs & (Aimp != A), -inf, log_prob)\n", + "\n", " # add to total likelihood for sampler\n", - " numpyro.factor('obs_A', log_prob)\n", - " \n", - " ### outcome model \n", + " numpyro.factor(\"obs_A\", log_prob)\n", + "\n", + " ### outcome model\n", " eta_Y = b_A * Aimp + b_B * B\n", " sample(\"obs_Y\", dist.Normal(eta_Y, s_Y), obs=Y)\n", "\n", " ### missingness / observationmodel\n", " eta_Aobs = jnp.where(Aimp, p_Aobs[0], p_Aobs[1])\n", - " sample('obs_Aobs', dist.Bernoulli(probs=eta_Aobs), obs=A_isobs)\n", - " " + " sample(\"obs_Aobs\", dist.Bernoulli(probs=eta_Aobs), obs=A_isobs)" ] }, { @@ -765,7 +764,7 @@ ], "source": [ "impmisskernel = NUTS(impmissmodel)\n", - "impmissmcmc = MCMC(impmisskernel, num_warmup=250, num_samples=750)\n", + "impmissmcmc = MCMC(impmisskernel, num_warmup=250, num_samples=750)\n", "impmissmcmc.run(mcmc_key, Aobs, B, Y)\n", "impmissmcmc.print_summary()" ] diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index b355d62c5..04bfe0e3a 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -40,7 +40,8 @@ "import numpyro.distributions as dist\n", "from numpyro.examples.datasets import COVTYPE, load_dataset\n", "from numpyro.infer import HMC, MCMC, NUTS\n", - "assert numpyro.__version__.startswith('0.7.2')\n", + "\n", + "assert numpyro.__version__.startswith(\"0.7.2\")\n", "\n", "# NB: replace gpu by cpu to run this notebook in cpu\n", "numpyro.set_platform(\"gpu\")" @@ -80,12 +81,15 @@ "# make binary feature\n", "_, counts = np.unique(labels, return_counts=True)\n", "specific_category = jnp.argmax(counts)\n", - "labels = (labels == specific_category)\n", + "labels = labels == specific_category\n", "\n", "N, dim = features.shape\n", "print(\"Data shape:\", features.shape)\n", - "print(\"Label distribution: {} has label 1, {} has label 0\"\n", - " .format(labels.sum(), N - labels.sum()))" + "print(\n", + " \"Label distribution: {} has label 1, {} has label 0\".format(\n", + " labels.sum(), N - labels.sum()\n", + " )\n", + ")" ] }, { @@ -102,9 +106,9 @@ "outputs": [], "source": [ "def model(data, labels):\n", - " coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(dim), jnp.ones(dim)))\n", + " coefs = numpyro.sample(\"coefs\", dist.Normal(jnp.zeros(dim), jnp.ones(dim)))\n", " logits = jnp.dot(data, coefs)\n", - " return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels)" + " return numpyro.sample(\"obs\", dist.Bernoulli(logits=logits), obs=labels)" ] }, { @@ -189,13 +193,18 @@ ], "source": [ "step_size = jnp.sqrt(0.5 / N)\n", - "kernel = HMC(model, step_size=step_size, trajectory_length=(10 * step_size), adapt_step_size=False)\n", + "kernel = HMC(\n", + " model,\n", + " step_size=step_size,\n", + " trajectory_length=(10 * step_size),\n", + " adapt_step_size=False,\n", + ")\n", "mcmc = MCMC(kernel, num_warmup=500, num_samples=500, progress_bar=False)\n", - "mcmc.warmup(random.PRNGKey(2019), features, labels, extra_fields=('num_steps',))\n", - "mcmc.get_extra_fields()['num_steps'].sum().copy()\n", + "mcmc.warmup(random.PRNGKey(2019), features, labels, extra_fields=(\"num_steps\",))\n", + "mcmc.get_extra_fields()[\"num_steps\"].sum().copy()\n", "tic = time.time()\n", - "mcmc.run(random.PRNGKey(2020), features, labels, extra_fields=['num_steps'])\n", - "num_leapfrogs = mcmc.get_extra_fields()['num_steps'].sum().copy()\n", + "mcmc.run(random.PRNGKey(2020), features, labels, extra_fields=[\"num_steps\"])\n", + "num_leapfrogs = mcmc.get_extra_fields()[\"num_steps\"].sum().copy()\n", "toc = time.time()\n", "print(\"number of leapfrog steps:\", num_leapfrogs)\n", "print(\"avg. time for each step :\", (toc - tic) / num_leapfrogs)\n", @@ -291,11 +300,11 @@ ], "source": [ "mcmc = MCMC(NUTS(model), num_warmup=50, num_samples=50, progress_bar=False)\n", - "mcmc.warmup(random.PRNGKey(2019), features, labels, extra_fields=('num_steps',))\n", - "mcmc.get_extra_fields()['num_steps'].sum().copy()\n", + "mcmc.warmup(random.PRNGKey(2019), features, labels, extra_fields=(\"num_steps\",))\n", + "mcmc.get_extra_fields()[\"num_steps\"].sum().copy()\n", "tic = time.time()\n", - "mcmc.run(random.PRNGKey(2020), features, labels, extra_fields=['num_steps'])\n", - "num_leapfrogs = mcmc.get_extra_fields()['num_steps'].sum().copy()\n", + "mcmc.run(random.PRNGKey(2020), features, labels, extra_fields=[\"num_steps\"])\n", + "num_leapfrogs = mcmc.get_extra_fields()[\"num_steps\"].sum().copy()\n", "toc = time.time()\n", "print(\"number of leapfrog steps:\", num_leapfrogs)\n", "print(\"avg. time for each step :\", (toc - tic) / num_leapfrogs)\n", diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index 22b66b689..4ed98467d 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -33,7 +33,7 @@ "import numpyro\n", "import numpyro.distributions as dist\n", "\n", - "assert numpyro.__version__.startswith('0.7.2')" + "assert numpyro.__version__.startswith(\"0.7.2\")" ] }, { @@ -54,10 +54,10 @@ "outputs": [], "source": [ "def model(data):\n", - " m = numpyro.sample('m', dist.Normal(0, 1))\n", - " sd = numpyro.sample('sd', dist.LogNormal(m, 1))\n", - " with numpyro.plate('N', len(data)):\n", - " numpyro.sample('obs', dist.Normal(m, sd), obs=data)" + " m = numpyro.sample(\"m\", dist.Normal(0, 1))\n", + " sd = numpyro.sample(\"sd\", dist.LogNormal(m, 1))\n", + " with numpyro.plate(\"N\", len(data)):\n", + " numpyro.sample(\"obs\", dist.Normal(m, sd), obs=data)" ] }, { @@ -153,7 +153,7 @@ "metadata": {}, "outputs": [], "source": [ - "graph = numpyro.render_model(model, model_args=(data,), filename='model.pdf')" + "graph = numpyro.render_model(model, model_args=(data,), filename=\"model.pdf\")" ] }, { @@ -182,21 +182,25 @@ " num_classes = int(jnp.max(annotations)) + 1\n", " num_items, num_positions = annotations.shape\n", "\n", - " with numpyro.plate('annotator', num_annotators):\n", - " epsilon = numpyro.sample('epsilon', dist.Dirichlet(jnp.full(num_classes, 10)))\n", - " theta = numpyro.sample('theta', dist.Beta(0.5, 0.5))\n", + " with numpyro.plate(\"annotator\", num_annotators):\n", + " epsilon = numpyro.sample(\"epsilon\", dist.Dirichlet(jnp.full(num_classes, 10)))\n", + " theta = numpyro.sample(\"theta\", dist.Beta(0.5, 0.5))\n", "\n", - " with numpyro.plate('item', num_items, dim=-2):\n", + " with numpyro.plate(\"item\", num_items, dim=-2):\n", " # NB: using constant logits for discrete uniform prior\n", " # (NumPyro does not have DiscreteUniform distribution yet)\n", - " c = numpyro.sample('c', dist.Categorical(logits=jnp.zeros(num_classes)))\n", + " c = numpyro.sample(\"c\", dist.Categorical(logits=jnp.zeros(num_classes)))\n", + "\n", + " with numpyro.plate(\"position\", num_positions):\n", + " s = numpyro.sample(\"s\", dist.Bernoulli(1 - theta[positions]))\n", + " probs = jnp.where(\n", + " s[..., None] == 0, nn.one_hot(c, num_classes), epsilon[positions]\n", + " )\n", + " numpyro.sample(\"y\", dist.Categorical(probs), obs=annotations)\n", + "\n", "\n", - " with numpyro.plate('position', num_positions):\n", - " s = numpyro.sample('s', dist.Bernoulli(1 - theta[positions]))\n", - " probs = jnp.where(s[..., None] == 0, nn.one_hot(c, num_classes), epsilon[positions])\n", - " numpyro.sample('y', dist.Categorical(probs), obs=annotations)\n", - " \n", "positions = jnp.array([1, 1, 1, 2, 3, 4, 5])\n", + "# fmt: off\n", "annotations = jnp.array([\n", " [1, 3, 1, 2, 2, 2, 1, 3, 2, 2, 4, 2, 1, 2, 1,\n", " 1, 1, 1, 2, 2, 2, 2, 2, 2, 1, 1, 2, 1, 1, 1,\n", @@ -220,6 +224,7 @@ " 1, 1, 1, 1, 2, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1,\n", " 1, 3, 1, 2, 2, 3, 2, 3, 2, 1, 1, 1, 2, 1, 2],\n", "]).T\n", + "# fmt: on\n", "\n", "# we subtract 1 because the first index starts with 0 in Python\n", "positions -= 1\n", @@ -456,10 +461,10 @@ "outputs": [], "source": [ "def model(data):\n", - " x = numpyro.sample('x', dist.Normal(0, 1))\n", - " y = numpyro.sample('y', dist.LogNormal(x, 1))\n", - " with numpyro.plate('N', len(data)):\n", - " numpyro.sample('z', dist.Normal(x, y), obs=data)" + " x = numpyro.sample(\"x\", dist.Normal(0, 1))\n", + " y = numpyro.sample(\"y\", dist.LogNormal(x, 1))\n", + " with numpyro.plate(\"N\", len(data)):\n", + " numpyro.sample(\"z\", dist.Normal(x, y), obs=data)" ] }, { @@ -563,7 +568,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 578fbf2f6..c05ddc05e 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -36,15 +36,24 @@ "source": [ "from jax import numpy as np, random\n", "import numpyro\n", - "from numpyro import sample,handlers\n", - "from numpyro.distributions import (Categorical, Dirichlet, ImproperUniform, Normal, OrderedLogistic,\n", - " TransformedDistribution, constraints, transforms)\n", + "from numpyro import sample, handlers\n", + "from numpyro.distributions import (\n", + " Categorical,\n", + " Dirichlet,\n", + " ImproperUniform,\n", + " Normal,\n", + " OrderedLogistic,\n", + " TransformedDistribution,\n", + " constraints,\n", + " transforms,\n", + ")\n", "from numpyro.infer import MCMC, NUTS\n", "from numpyro.infer.reparam import TransformReparam\n", "\n", "import pandas as pd\n", "import seaborn as sns\n", - "assert numpyro.__version__.startswith('0.7.2')" + "\n", + "assert numpyro.__version__.startswith(\"0.7.2\")" ] }, { @@ -82,15 +91,15 @@ } ], "source": [ - "simkeys = random.split(random.PRNGKey(1), 2)\n", - "nsim = 50\n", + "simkeys = random.split(random.PRNGKey(1), 2)\n", + "nsim = 50\n", "nclasses = 3\n", - "Y = Categorical(logits=np.zeros(nclasses)).sample(simkeys[0], sample_shape=(nsim,))\n", - "X = Normal().sample(simkeys[1], sample_shape = (nsim,))\n", - "X += Y\n", + "Y = Categorical(logits=np.zeros(nclasses)).sample(simkeys[0], sample_shape=(nsim,))\n", + "X = Normal().sample(simkeys[1], sample_shape=(nsim,))\n", + "X += Y\n", "\n", "print(\"value counts of Y:\")\n", - "df = pd.DataFrame({'X': X, 'Y': Y})\n", + "df = pd.DataFrame({\"X\": X, \"Y\": Y})\n", "print(df.Y.value_counts())\n", "\n", "for i in range(nclasses):\n", @@ -116,7 +125,7 @@ } ], "source": [ - "sns.violinplot(x='Y', y='X', data=df);" + "sns.violinplot(x=\"Y\", y=\"X\", data=df);" ] }, { @@ -161,18 +170,24 @@ ], "source": [ "def model1(X, Y, nclasses=3):\n", - " b_X_eta = sample('b_X_eta', Normal(0, 5))\n", - " c_y = sample('c_y', ImproperUniform(support=constraints.ordered_vector,\n", - " batch_shape=(),\n", - " event_shape=(nclasses-1,)))\n", - " with numpyro.plate('obs', X.shape[0]):\n", + " b_X_eta = sample(\"b_X_eta\", Normal(0, 5))\n", + " c_y = sample(\n", + " \"c_y\",\n", + " ImproperUniform(\n", + " support=constraints.ordered_vector,\n", + " batch_shape=(),\n", + " event_shape=(nclasses - 1,),\n", + " ),\n", + " )\n", + " with numpyro.plate(\"obs\", X.shape[0]):\n", " eta = X * b_X_eta\n", - " sample('Y', OrderedLogistic(eta, c_y), obs=Y)\n", + " sample(\"Y\", OrderedLogistic(eta, c_y), obs=Y)\n", + "\n", "\n", "mcmc_key = random.PRNGKey(1234)\n", "kernel = NUTS(model1)\n", - "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", - "mcmc.run(mcmc_key, X,Y, nclasses)\n", + "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", + "mcmc.run(mcmc_key, X, Y, nclasses)\n", "mcmc.print_summary()" ] }, @@ -213,18 +228,24 @@ ], "source": [ "def model2(X, Y, nclasses=3):\n", - " b_X_eta = sample('b_X_eta', Normal(0, 5)) \n", - " c_y = sample('c_y', ImproperUniform(support=constraints.ordered_vector,\n", - " batch_shape=(),\n", - " event_shape=(nclasses-1,)))\n", - " sample('c_y_smp', Normal(0,1), obs=c_y)\n", - " with numpyro.plate('obs', X.shape[0]):\n", + " b_X_eta = sample(\"b_X_eta\", Normal(0, 5))\n", + " c_y = sample(\n", + " \"c_y\",\n", + " ImproperUniform(\n", + " support=constraints.ordered_vector,\n", + " batch_shape=(),\n", + " event_shape=(nclasses - 1,),\n", + " ),\n", + " )\n", + " sample(\"c_y_smp\", Normal(0, 1), obs=c_y)\n", + " with numpyro.plate(\"obs\", X.shape[0]):\n", " eta = X * b_X_eta\n", - " sample('Y', OrderedLogistic(eta, c_y), obs=Y)\n", + " sample(\"Y\", OrderedLogistic(eta, c_y), obs=Y)\n", + "\n", "\n", "kernel = NUTS(model2)\n", - "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", - "mcmc.run(mcmc_key, X,Y, nclasses)\n", + "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", + "mcmc.run(mcmc_key, X, Y, nclasses)\n", "mcmc.print_summary()" ] }, @@ -270,16 +291,21 @@ ], "source": [ "def model3(X, Y, nclasses=3):\n", - " b_X_eta = sample('b_X_eta', Normal(0, 5)) \n", - " c_y = sample(\"c_y\", TransformedDistribution(Normal(0, 1).expand([nclasses - 1]),\n", - " transforms.OrderedTransform()))\n", - " with numpyro.plate('obs', X.shape[0]):\n", + " b_X_eta = sample(\"b_X_eta\", Normal(0, 5))\n", + " c_y = sample(\n", + " \"c_y\",\n", + " TransformedDistribution(\n", + " Normal(0, 1).expand([nclasses - 1]), transforms.OrderedTransform()\n", + " ),\n", + " )\n", + " with numpyro.plate(\"obs\", X.shape[0]):\n", " eta = X * b_X_eta\n", - " sample('Y', OrderedLogistic(eta, c_y), obs=Y)\n", + " sample(\"Y\", OrderedLogistic(eta, c_y), obs=Y)\n", + "\n", "\n", "kernel = NUTS(model3)\n", - "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", - "mcmc.run(mcmc_key, X,Y, nclasses)\n", + "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", + "mcmc.run(mcmc_key, X, Y, nclasses)\n", "mcmc.print_summary()" ] }, @@ -311,7 +337,7 @@ "outputs": [], "source": [ "# We will apply a nudge towards equal probability for each category (corresponds to equal logits of the true data generating process)\n", - "concentration=np.ones((nclasses,))*10.0" + "concentration = np.ones((nclasses,)) * 10.0" ] }, { @@ -344,19 +370,25 @@ } ], "source": [ - "def model4(X, Y, nclasses,concentration,anchor_point=0.0):\n", - " b_X_eta = sample('b_X_eta', Normal(0, 5)) \n", - " \n", - " with handlers.reparam(config={'c_y': TransformReparam()}):\n", - " c_y=sample(\"c_y\", TransformedDistribution(Dirichlet(concentration), \n", - " transforms.SimplexToOrderedTransform(anchor_point)))\n", - " with numpyro.plate('obs', X.shape[0]):\n", + "def model4(X, Y, nclasses, concentration, anchor_point=0.0):\n", + " b_X_eta = sample(\"b_X_eta\", Normal(0, 5))\n", + "\n", + " with handlers.reparam(config={\"c_y\": TransformReparam()}):\n", + " c_y = sample(\n", + " \"c_y\",\n", + " TransformedDistribution(\n", + " Dirichlet(concentration),\n", + " transforms.SimplexToOrderedTransform(anchor_point),\n", + " ),\n", + " )\n", + " with numpyro.plate(\"obs\", X.shape[0]):\n", " eta = X * b_X_eta\n", - " sample('Y', OrderedLogistic(eta, c_y), obs=Y)\n", + " sample(\"Y\", OrderedLogistic(eta, c_y), obs=Y)\n", + "\n", "\n", "kernel = NUTS(model4)\n", - "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", - "mcmc.run(mcmc_key, X,Y, nclasses,concentration)\n", + "mcmc = MCMC(kernel, num_warmup=250, num_samples=750)\n", + "mcmc.run(mcmc_key, X, Y, nclasses, concentration)\n", "# with exclude_deterministic=False, we will also show the ordinal probabilities sampled from Dirichlet (vis. `c_y_base`)\n", "mcmc.print_summary(exclude_deterministic=False)" ] diff --git a/notebooks/source/time_series_forecasting.ipynb b/notebooks/source/time_series_forecasting.ipynb index 4ecb36510..01360c511 100644 --- a/notebooks/source/time_series_forecasting.ipynb +++ b/notebooks/source/time_series_forecasting.ipynb @@ -48,7 +48,7 @@ " set_matplotlib_formats(\"svg\")\n", "\n", "numpyro.set_host_device_count(4)\n", - "assert numpyro.__version__.startswith(\"0.5.0\")" + "assert numpyro.__version__.startswith(\"0.7.2\")" ] }, { diff --git a/scripts/update_version.py b/scripts/update_version.py index e3e0bbcbf..87f7d0581 100644 --- a/scripts/update_version.py +++ b/scripts/update_version.py @@ -22,9 +22,9 @@ # Update version string. pattern1 = re.compile('assert numpyro.__version__.startswith\\("[^"]*"\\)') -pattern2 = re.compile("assert numpyro.__version__.startswith\\('[^']*'\\)") +pattern2 = re.compile('assert numpyro.__version__.startswith\\(\\\\"[^"]*\\\\"\\)') text1 = f"assert numpyro.__version__.startswith({new_version})" -text2 = text1.replace('"', "'") +text2 = text1.replace('"', '\\"') for filename in filenames: with open(filename) as f: old_text = f.read() diff --git a/setup.py b/setup.py index 79e8873e9..9b74345a3 100644 --- a/setup.py +++ b/setup.py @@ -53,7 +53,7 @@ "sphinx-gallery", ], "test": [ - "black", + "black[jupyter]>=21.8b0", "flake8", "isort>=5.0", "pytest>=4.1", From df47c993fdf7d11b131d1130d6f6bb99d0a611e3 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 25 Sep 2021 11:15:49 -0400 Subject: [PATCH 178/222] fix rendering tutorials (#1166) --- docs/source/distributions.rst | 4 ++++ notebooks/source/bad_posterior_geometry.ipynb | 14 +++++++------- notebooks/source/ordinal_regression.ipynb | 14 +++++++------- 3 files changed, 18 insertions(+), 14 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 5406fa07f..901197c12 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -638,6 +638,10 @@ interval ^^^^^^^^ .. autofunction:: numpyro.distributions.constraints.interval +l1_ball +^^^^^^^ +.. autofunction:: numpyro.distributions.constraints.l1_ball + less_than ^^^^^^^^^ .. autofunction:: numpyro.distributions.constraints.less_than diff --git a/notebooks/source/bad_posterior_geometry.ipynb b/notebooks/source/bad_posterior_geometry.ipynb index cacea25a7..37d87561e 100644 --- a/notebooks/source/bad_posterior_geometry.ipynb +++ b/notebooks/source/bad_posterior_geometry.ipynb @@ -94,7 +94,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Evaluating HMC/NUTS\n", + "## Evaluating HMC/NUTS\n", "\n", "In general it is difficult to assess whether the samples returned from HMC or NUTS represent accurate (approximate) samples from the posterior. \n", "Two general rules of thumb, however, are to look at the effective sample size (ESS) and `r_hat` diagnostics returned by `mcmc.print_summary()`.\n", @@ -107,7 +107,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Model reparameterization\n", + "## Model reparameterization\n", "\n", "### Example #1\n", "\n", @@ -324,7 +324,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Mass matrices\n", + "## Mass matrices\n", "By default HMC/NUTS use diagonal mass matrices. \n", "For models with complex geometries it can pay to use a richer set of mass matrices.\n", "\n", @@ -461,7 +461,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# `max_tree_depth`\n", + "## `max_tree_depth`\n", "\n", "The hyperparameter `max_tree_depth` can play an important role in determining the quality of posterior samples generated by NUTS. The default value in NumPyro is `max_tree_depth=10`. In some models, in particular those with especially difficult geometries, it may be necessary to increase `max_tree_depth` above `10`. In other cases where computing the gradient of the model log density is particularly expensive, it may be necessary to decrease `max_tree_depth` below `10` to reduce compute. As an example where large `max_tree_depth` is essential, we return to a variant of example #2. (We note that in this particular case another way to improve performance would be to use `dense_mass=True`).\n", "\n", @@ -509,7 +509,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Other strategies\n", + "## Other strategies\n", "\n", "- In some cases it can make sense to use variational inference to *learn* a new coordinate system. For details see [examples/neutra.py](https://github.com/pyro-ppl/numpyro/blob/master/examples/neutra.py) and reference [2]." ] @@ -518,7 +518,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# References\n", + "## References\n", "\n", "[1] \"Hamiltonian Monte Carlo for Hierarchical Models,\"\n", " M. J. Betancourt, Mark Girolami.\n", @@ -547,7 +547,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.2" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index c05ddc05e..182f3ecb3 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -60,7 +60,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Data Generation" + "## Data Generation" ] }, { @@ -132,7 +132,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Improper Prior" + "## Improper Prior" ] }, { @@ -253,7 +253,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Proper Prior" + "## Proper Prior" ] }, { @@ -313,7 +313,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Principled prior with Dirichlet Distribution" + "## Principled prior with Dirichlet Distribution" ] }, { @@ -396,9 +396,9 @@ ], "metadata": { "kernelspec": { - "display_name": "conda_env_my", + "display_name": "Python 3", "language": "python", - "name": "conda_env_my" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -410,7 +410,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.8.8" } }, "nbformat": 4, From cc827815f27a1cd3615aca31c362cb6bb9ec9a00 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 25 Sep 2021 14:08:34 -0400 Subject: [PATCH 179/222] Add warning when initializing a substituted model (#1058) * add warning when initializing a substitute model * fix lint * Fix Examples:: generating wrong docstring * removing ... unnecessarily * change catching warning * fix importing partial from jax * assert both ndarray and jnp.ndarray * lint * adjust precision of failing test --- numpyro/handlers.py | 12 ++++++++---- numpyro/infer/initialization.py | 17 +++++++++++++++-- test/infer/test_mcmc.py | 11 +++++++++++ 3 files changed, 34 insertions(+), 6 deletions(-) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 5d25b172e..549b50a1a 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -112,7 +112,7 @@ class trace(Messenger): Returns a handler that records the inputs and outputs at primitive calls inside `fn`. - **Example** + **Example:** .. doctest:: @@ -175,7 +175,7 @@ class replay(Messenger): :param fn: Python callable with NumPyro primitives. :param guide_trace: an OrderedDict containing execution metadata. - **Example** + **Example:** .. doctest:: @@ -600,14 +600,14 @@ class scope(Messenger): """ This handler prepend a prefix followed by a divider to the name of sample sites. - **Example** + **Example:** .. doctest:: >>> import numpyro >>> import numpyro.distributions as dist >>> from numpyro.handlers import scope, seed, trace - >>> + >>> def model(): ... with scope(prefix="a"): ... with scope(prefix="b", divider="."): @@ -711,6 +711,10 @@ class substitute(Messenger): replaced by the value returned from the call to `substitute_fn` for the given site. + .. note:: This handler is mainly used for internal algorithms. + For conditioning a generative model on observed data, please + using the :class:`condition` handler. + :param fn: Python callable with NumPyro primitives. :param dict data: dictionary of `numpy.ndarray` values keyed by site names. diff --git a/numpyro/infer/initialization.py b/numpyro/infer/initialization.py index 8aacef780..78afe5435 100644 --- a/numpyro/infer/initialization.py +++ b/numpyro/infer/initialization.py @@ -2,8 +2,8 @@ # SPDX-License-Identifier: Apache-2.0 from functools import partial +import warnings -from jax import random import jax.numpy as jnp import numpyro.distributions as dist @@ -25,6 +25,13 @@ def init_to_median(site=None, num_samples=15): and not site["is_observed"] and not site["fn"].is_discrete ): + if site["value"] is not None: + warnings.warn( + f"init_to_median() skipping initialization of site '{site['name']}'" + " which already stores a value." + ) + return site["value"] + rng_key = site["kwargs"].get("rng_key") sample_shape = site["kwargs"].get("sample_shape") try: @@ -58,12 +65,18 @@ def init_to_uniform(site=None, radius=2): and not site["is_observed"] and not site["fn"].is_discrete ): + if site["value"] is not None: + warnings.warn( + f"init_to_uniform() skipping initialization of site '{site['name']}'" + " which already stores a value." + ) + return site["value"] + # XXX: we import here to avoid circular import from numpyro.infer.util import helpful_support_errors rng_key = site["kwargs"].get("rng_key") sample_shape = site["kwargs"].get("sample_shape") - rng_key, subkey = random.split(rng_key) with helpful_support_errors(site): transform = biject_to(site["fn"].support) diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index 6ce06c39c..dc9e3fa15 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -1049,3 +1049,14 @@ def model(): assert set(inverse_mass_matrix.keys()) == {("x", "z")} expected_mm = jnp.diag(expected_mm) if dense_mass else expected_mm assert_allclose(inverse_mass_matrix[("x", "z")], expected_mm) + + +def test_init_strategy_substituted_model(): + def model(): + numpyro.sample("x", dist.Normal(0, 1)) + numpyro.sample("y", dist.Normal(0, 1)) + + subs_model = numpyro.handlers.substitute(model, data={"x": 10.0}) + mcmc = MCMC(NUTS(subs_model), num_warmup=10, num_samples=10) + with pytest.warns(UserWarning, match="skipping initialization"): + mcmc.run(random.PRNGKey(1)) From 632a13ad37a5fb9c47664fde3659161697abd6d4 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 25 Sep 2021 23:29:03 -0400 Subject: [PATCH 180/222] Bump to 0.8.0 (#1167) * fix rendering tutorials * Bump to version 0.8.0 --- examples/annotation.py | 2 +- examples/baseball.py | 2 +- examples/bnn.py | 2 +- examples/covtype.py | 2 +- examples/funnel.py | 2 +- examples/gaussian_shells.py | 2 +- examples/gp.py | 2 +- examples/hmm.py | 2 +- examples/horseshoe_regression.py | 2 +- examples/minipyro.py | 2 +- examples/neutra.py | 2 +- examples/ode.py | 2 +- examples/prodlda.py | 2 +- examples/proportion_test.py | 2 +- examples/sparse_regression.py | 2 +- examples/stochastic_volatility.py | 2 +- examples/thompson_sampling.py | 2 +- examples/ucbadmit.py | 2 +- examples/vae.py | 2 +- notebooks/source/bad_posterior_geometry.ipynb | 2 +- notebooks/source/bayesian_hierarchical_linear_regression.ipynb | 2 +- notebooks/source/bayesian_imputation.ipynb | 2 +- notebooks/source/bayesian_regression.ipynb | 2 +- notebooks/source/logistic_regression.ipynb | 2 +- notebooks/source/model_rendering.ipynb | 2 +- notebooks/source/ordinal_regression.ipynb | 2 +- notebooks/source/time_series_forecasting.ipynb | 2 +- numpyro/version.py | 2 +- 28 files changed, 28 insertions(+), 28 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index f7314cf1f..49adfa764 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -327,7 +327,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Bayesian Models of Annotation") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/baseball.py b/examples/baseball.py index 09cb9f688..cc5768e4c 100644 --- a/examples/baseball.py +++ b/examples/baseball.py @@ -210,7 +210,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Baseball batting average using MCMC") parser.add_argument("-n", "--num-samples", nargs="?", default=3000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/bnn.py b/examples/bnn.py index d709a2adb..b67aefb3d 100644 --- a/examples/bnn.py +++ b/examples/bnn.py @@ -160,7 +160,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Bayesian neural network example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/covtype.py b/examples/covtype.py index ff5c98cec..db8d8dab1 100644 --- a/examples/covtype.py +++ b/examples/covtype.py @@ -206,7 +206,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-samples", default=1000, type=int, help="number of samples" diff --git a/examples/funnel.py b/examples/funnel.py index 281003ebf..5ef996cf6 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -108,7 +108,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser( description="Non-centered reparameterization example" ) diff --git a/examples/gaussian_shells.py b/examples/gaussian_shells.py index 9224992ee..5685ae97b 100644 --- a/examples/gaussian_shells.py +++ b/examples/gaussian_shells.py @@ -120,7 +120,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Nested sampler for Gaussian shells") parser.add_argument("-n", "--num-samples", nargs="?", default=10000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/gp.py b/examples/gp.py index d31f3da2f..fbd3e6e74 100644 --- a/examples/gp.py +++ b/examples/gp.py @@ -170,7 +170,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/hmm.py b/examples/hmm.py index 17ff58eb5..b0490b001 100644 --- a/examples/hmm.py +++ b/examples/hmm.py @@ -263,7 +263,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Semi-supervised Hidden Markov Model") parser.add_argument("--num-categories", default=3, type=int) parser.add_argument("--num-words", default=10, type=int) diff --git a/examples/horseshoe_regression.py b/examples/horseshoe_regression.py index c47429caf..3b5daa581 100644 --- a/examples/horseshoe_regression.py +++ b/examples/horseshoe_regression.py @@ -162,7 +162,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Horseshoe regression example") parser.add_argument("-n", "--num-samples", nargs="?", default=2000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/minipyro.py b/examples/minipyro.py index 6b48dfdfc..7ec79aec6 100644 --- a/examples/minipyro.py +++ b/examples/minipyro.py @@ -58,7 +58,7 @@ def body_fn(i, val): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Mini Pyro demo") parser.add_argument("-f", "--full-pyro", action="store_true", default=False) parser.add_argument("-n", "--num-steps", default=1001, type=int) diff --git a/examples/neutra.py b/examples/neutra.py index 15e81a130..ba96e410d 100644 --- a/examples/neutra.py +++ b/examples/neutra.py @@ -197,7 +197,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="NeuTra HMC") parser.add_argument("-n", "--num-samples", nargs="?", default=4000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/ode.py b/examples/ode.py index b5f19ba9b..aa437ab49 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -116,7 +116,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Predator-Prey Model") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) diff --git a/examples/prodlda.py b/examples/prodlda.py index 65ca22e3b..bad0c9ea1 100644 --- a/examples/prodlda.py +++ b/examples/prodlda.py @@ -314,7 +314,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser( description="Probabilistic topic modelling with Flax and Haiku" ) diff --git a/examples/proportion_test.py b/examples/proportion_test.py index 6665fa539..305b757da 100644 --- a/examples/proportion_test.py +++ b/examples/proportion_test.py @@ -160,7 +160,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Testing whether ") parser.add_argument("-n", "--num-samples", nargs="?", default=500, type=int) parser.add_argument("--num-warmup", nargs="?", default=1500, type=int) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index 9f90ddefa..9dae25b82 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -401,7 +401,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Gaussian Process example") parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=500, type=int) diff --git a/examples/stochastic_volatility.py b/examples/stochastic_volatility.py index 39c8a1966..4e68a8377 100644 --- a/examples/stochastic_volatility.py +++ b/examples/stochastic_volatility.py @@ -122,7 +122,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Stochastic Volatility Model") parser.add_argument("-n", "--num-samples", nargs="?", default=600, type=int) parser.add_argument("--num-warmup", nargs="?", default=600, type=int) diff --git a/examples/thompson_sampling.py b/examples/thompson_sampling.py index 6a33734c3..7389e2a1c 100644 --- a/examples/thompson_sampling.py +++ b/examples/thompson_sampling.py @@ -294,7 +294,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="Thompson sampling example") parser.add_argument( "--num-random", nargs="?", default=2, type=int, help="number of random draws" diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index 8898bb3d8..51d38e131 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -151,7 +151,7 @@ def main(args): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser( description="UCBadmit gender discrimination using HMC" ) diff --git a/examples/vae.py b/examples/vae.py index 913017f53..6d2569343 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -159,7 +159,7 @@ def reconstruct_img(epoch, rng_key): if __name__ == "__main__": - assert numpyro.__version__.startswith("0.7.2") + assert numpyro.__version__.startswith("0.8.0") parser = argparse.ArgumentParser(description="parse args") parser.add_argument( "-n", "--num-epochs", default=15, type=int, help="number of training epochs" diff --git a/notebooks/source/bad_posterior_geometry.ipynb b/notebooks/source/bad_posterior_geometry.ipynb index 37d87561e..62abec938 100644 --- a/notebooks/source/bad_posterior_geometry.ipynb +++ b/notebooks/source/bad_posterior_geometry.ipynb @@ -50,7 +50,7 @@ "\n", "from numpyro.infer import MCMC, NUTS\n", "\n", - "assert numpyro.__version__.startswith(\"0.7.2\")\n", + "assert numpyro.__version__.startswith(\"0.8.0\")\n", "\n", "# NB: replace cpu by gpu to run this notebook on gpu\n", "numpyro.set_platform(\"cpu\")" diff --git a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb index 495af5a01..cbb52e0b1 100644 --- a/notebooks/source/bayesian_hierarchical_linear_regression.ipynb +++ b/notebooks/source/bayesian_hierarchical_linear_regression.ipynb @@ -244,7 +244,7 @@ "import numpyro.distributions as dist\n", "from jax import random\n", "\n", - "assert numpyro.__version__.startswith(\"0.7.2\")" + "assert numpyro.__version__.startswith(\"0.8.0\")" ] }, { diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index e4890185d..ab399f1f4 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -55,7 +55,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith(\"0.7.2\")" + "assert numpyro.__version__.startswith(\"0.8.0\")" ] }, { diff --git a/notebooks/source/bayesian_regression.ipynb b/notebooks/source/bayesian_regression.ipynb index ae2e0ab78..4aedf2d0d 100644 --- a/notebooks/source/bayesian_regression.ipynb +++ b/notebooks/source/bayesian_regression.ipynb @@ -95,7 +95,7 @@ "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", " set_matplotlib_formats(\"svg\")\n", "\n", - "assert numpyro.__version__.startswith(\"0.7.2\")" + "assert numpyro.__version__.startswith(\"0.8.0\")" ], "execution_count": 2, "outputs": [] diff --git a/notebooks/source/logistic_regression.ipynb b/notebooks/source/logistic_regression.ipynb index 04bfe0e3a..8bef90e16 100644 --- a/notebooks/source/logistic_regression.ipynb +++ b/notebooks/source/logistic_regression.ipynb @@ -41,7 +41,7 @@ "from numpyro.examples.datasets import COVTYPE, load_dataset\n", "from numpyro.infer import HMC, MCMC, NUTS\n", "\n", - "assert numpyro.__version__.startswith(\"0.7.2\")\n", + "assert numpyro.__version__.startswith(\"0.8.0\")\n", "\n", "# NB: replace gpu by cpu to run this notebook in cpu\n", "numpyro.set_platform(\"gpu\")" diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index 4ed98467d..c1be6d73b 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -33,7 +33,7 @@ "import numpyro\n", "import numpyro.distributions as dist\n", "\n", - "assert numpyro.__version__.startswith(\"0.7.2\")" + "assert numpyro.__version__.startswith(\"0.8.0\")" ] }, { diff --git a/notebooks/source/ordinal_regression.ipynb b/notebooks/source/ordinal_regression.ipynb index 182f3ecb3..be2d2aecb 100644 --- a/notebooks/source/ordinal_regression.ipynb +++ b/notebooks/source/ordinal_regression.ipynb @@ -53,7 +53,7 @@ "import pandas as pd\n", "import seaborn as sns\n", "\n", - "assert numpyro.__version__.startswith(\"0.7.2\")" + "assert numpyro.__version__.startswith(\"0.8.0\")" ] }, { diff --git a/notebooks/source/time_series_forecasting.ipynb b/notebooks/source/time_series_forecasting.ipynb index 01360c511..670713b5a 100644 --- a/notebooks/source/time_series_forecasting.ipynb +++ b/notebooks/source/time_series_forecasting.ipynb @@ -48,7 +48,7 @@ " set_matplotlib_formats(\"svg\")\n", "\n", "numpyro.set_host_device_count(4)\n", - "assert numpyro.__version__.startswith(\"0.7.2\")" + "assert numpyro.__version__.startswith(\"0.8.0\")" ] }, { diff --git a/numpyro/version.py b/numpyro/version.py index 5483712f8..d514afbbf 100644 --- a/numpyro/version.py +++ b/numpyro/version.py @@ -1,4 +1,4 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -__version__ = "0.7.2" +__version__ = "0.8.0" From eb3907adb47d3df85da15a58bf30393e48922ee3 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Thu, 7 Oct 2021 22:25:58 -0400 Subject: [PATCH 181/222] Allow pickle autoguide (#1169) * allow pickle ravelpytree * make pickle work and add tests * fix lint --- numpyro/distributions/transforms.py | 10 ++++++++ numpyro/infer/autoguide.py | 38 +++++++++++++++++++++++++++-- test/test_pickle.py | 32 ++++++++++++++++++++++++ 3 files changed, 78 insertions(+), 2 deletions(-) diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 443a5b8fc..1fffe42ac 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -106,6 +106,16 @@ def inverse_shape(self, shape): """ return shape + # Allow for pickle serialization of transforms. + def __getstate__(self): + attrs = {} + for k, v in self.__dict__.items(): + if isinstance(v, weakref.ref): + attrs[k] = None + else: + attrs[k] = v + return attrs + class _InverseTransform(Transform): def __init__(self, transform): diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 4a89c76a5..01be6640e 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -4,6 +4,7 @@ # Adapted from pyro.infer.autoguide from abc import ABC, abstractmethod from contextlib import ExitStack +from functools import partial import warnings import numpy as np @@ -11,7 +12,6 @@ import jax from jax import grad, hessian, lax, random, tree_map from jax.experimental import stax -from jax.flatten_util import ravel_pytree import jax.numpy as jnp import numpyro @@ -104,6 +104,11 @@ def _create_plates(self, *args, **kwargs): ) return self.plates + def __getstate__(self): + state = self.__dict__.copy() + state.pop("plates", None) + return state + @abstractmethod def __call__(self, *args, **kwargs): """ @@ -450,6 +455,34 @@ def median(self, params): return locs +def _unravel_dict(x_flat, shape_dict): + """Return `x` from the flatten version `x_flat`. Shape information + of each item in `x` is defined in `shape_dict`. + """ + assert jnp.ndim(x_flat) == 1 + assert isinstance(shape_dict, dict) + x = {} + curr_pos = next_pos = 0 + for name, shape in shape_dict.items(): + next_pos = curr_pos + int(np.prod(shape)) + x[name] = x_flat[curr_pos:next_pos].reshape(shape) + curr_pos = next_pos + assert next_pos == x_flat.shape[0] + return x + + +def _ravel_dict(x): + """Return the flatten version of `x` and shapes of each item in `x`.""" + assert isinstance(x, dict) + shape_dict = {} + x_flat = [] + for name, value in x.items(): + shape_dict[name] = jnp.shape(value) + x_flat.append(value.reshape(-1)) + x_flat = jnp.concatenate(x_flat) if x_flat else jnp.zeros((0,)) + return x_flat, shape_dict + + class AutoContinuous(AutoGuide): """ Base class for implementations of continuous-valued Automatic @@ -474,7 +507,8 @@ class AutoContinuous(AutoGuide): def _setup_prototype(self, *args, **kwargs): super()._setup_prototype(*args, **kwargs) - self._init_latent, unpack_latent = ravel_pytree(self._init_locs) + self._init_latent, shape_dict = _ravel_dict(self._init_locs) + unpack_latent = partial(_unravel_dict, shape_dict=shape_dict) # this is to match the behavior of Pyro, where we can apply # unpack_latent for a batch of samples self._unpack_latent = UnpackTransform(unpack_latent) diff --git a/test/test_pickle.py b/test/test_pickle.py index bf0d79793..f5ee768c2 100644 --- a/test/test_pickle.py +++ b/test/test_pickle.py @@ -3,6 +3,7 @@ import pickle +import numpy as np import pytest from jax import random, test_util @@ -16,10 +17,13 @@ MCMC, NUTS, SA, + SVI, BarkerMH, DiscreteHMCGibbs, MixedHMC, + Predictive, ) +from numpyro.infer.autoguide import AutoDelta, AutoDiagonalNormal, AutoNormal def normal_model(): @@ -59,3 +63,31 @@ def test_pickle_hmcecs(): mcmc.run(random.PRNGKey(0)) pickled_mcmc = pickle.loads(pickle.dumps(mcmc)) test_util.check_close(mcmc.get_samples(), pickled_mcmc.get_samples()) + + +def poisson_regression(x, N): + rate = numpyro.sample("param", dist.Gamma(1.0, 1.0)) + batch_size = len(x) if x is not None else None + with numpyro.plate("batch", N, batch_size): + numpyro.sample("x", dist.Poisson(rate), obs=x) + + +@pytest.mark.parametrize("guide_class", [AutoDelta, AutoDiagonalNormal, AutoNormal]) +def test_pickle_autoguide(guide_class): + x = np.random.poisson(1.0, size=(100,)) + + guide = guide_class(poisson_regression) + optim = numpyro.optim.Adam(1e-2) + svi = SVI(poisson_regression, guide, optim, numpyro.infer.Trace_ELBO()) + svi_result = svi.run(random.PRNGKey(1), 3, x, len(x)) + pickled_guide = pickle.loads(pickle.dumps(guide)) + + predictive = Predictive( + poisson_regression, + guide=pickled_guide, + params=svi_result.params, + num_samples=1, + return_sites=["param", "x"], + ) + samples = predictive(random.PRNGKey(1), None, 1) + assert set(samples.keys()) == {"param", "x"} From 641fc8921e6e6fad664408912de94d3b2777c6e4 Mon Sep 17 00:00:00 2001 From: Amal Date: Sat, 9 Oct 2021 14:19:11 +0100 Subject: [PATCH 182/222] extend scope handler (#1182) * extend scope handler * add test for scope frames --- numpyro/handlers.py | 16 +++++++++++++++- test/test_handlers.py | 20 ++++++++++++++++++++ 2 files changed, 35 insertions(+), 1 deletion(-) diff --git a/numpyro/handlers.py b/numpyro/handlers.py index 549b50a1a..337eadcab 100644 --- a/numpyro/handlers.py +++ b/numpyro/handlers.py @@ -86,7 +86,13 @@ import numpyro from numpyro.distributions.distribution import COERCIONS -from numpyro.primitives import _PYRO_STACK, Messenger, apply_stack, plate +from numpyro.primitives import ( + _PYRO_STACK, + CondIndepStackFrame, + Messenger, + apply_stack, + plate, +) from numpyro.util import not_jax_tracer __all__ = [ @@ -629,6 +635,14 @@ def process_message(self, msg): if msg.get("name"): msg["name"] = f"{self.prefix}{self.divider}{msg['name']}" + if msg.get("cond_indep_stack"): + msg["cond_indep_stack"] = [ + CondIndepStackFrame( + f"{self.prefix}{self.divider}{i.name}", i.dim, i.size + ) + for i in msg["cond_indep_stack"] + ] + class seed(Messenger): """ diff --git a/test/test_handlers.py b/test/test_handlers.py index a58926278..e43804773 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -591,6 +591,26 @@ def fn(): assert "b/a/x" in trace +def test_scope_frames(): + def model(y): + mu = numpyro.sample("mu", dist.Normal()) + sigma = numpyro.sample("sigma", dist.HalfNormal()) + + with numpyro.plate("plate1", y.shape[0]): + numpyro.sample("y", dist.Normal(mu, sigma), obs=y) + + scope_prefix = "scope" + scoped_model = handlers.scope(model, prefix=scope_prefix) + + obs = np.random.normal(size=(10,)) + + trace = handlers.trace(handlers.seed(model, 0)).get_trace(obs) + scoped_trace = handlers.trace(handlers.seed(scoped_model, 0)).get_trace(obs) + + assert trace["y"]["cond_indep_stack"][0].name in trace + assert scoped_trace[f"{scope_prefix}/y"]["cond_indep_stack"][0].name in scoped_trace + + def test_lift(): def model(): loc1 = numpyro.param("loc1", 0.0) From 4ec9fc7894bfcf6f05579b598133ffb2610297ed Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Tue, 12 Oct 2021 00:35:57 +0100 Subject: [PATCH 183/222] User contributed tutorial: Bayesian Hierarchical Stacking case study (#1161) * Add Bayesian Hierarchical Stacking case study * add some comments / document some parts * add some titles * use numpyro.plate, expand * move image to docs/source/_static/img/tutorials * use nested numpyro.plate * use nested numpyro.plate * revert accidental change to linear regression nb * run black formatter * vectorise for loop * add thumbnail to docs landing page * remove jpeg file * correct jax random key usage --- .../bayesian_hierarchical_stacking.png | Bin 0 -> 648828 bytes docs/source/index.rst | 1 + .../bayesian_hierarchical_stacking.ipynb | 1238 +++++++++++++++++ 3 files changed, 1239 insertions(+) create mode 100644 docs/source/_static/img/tutorials/bayesian_hierarchical_stacking.png create mode 100644 notebooks/source/bayesian_hierarchical_stacking.ipynb diff --git a/docs/source/_static/img/tutorials/bayesian_hierarchical_stacking.png b/docs/source/_static/img/tutorials/bayesian_hierarchical_stacking.png new file mode 100644 index 0000000000000000000000000000000000000000..4c2dd98371c8f1d1aafd580c23afee10576d6f94 GIT binary patch literal 648828 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

    KaRR8qHk-Fl%ci<-LqB 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�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�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%0DKxR^}Lz*@4rkMEcY~8si&mKm>KY<%X;Oh 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Ξ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\n", + " \n", + "

    Photo by Belinda Fewings, https://unsplash.com/photos/6p-KtXCBGNw.
    \n", + "
    \n", + "\n", + "### Table of Contents\n", + "\n", + "* [Intro](#intro)\n", + "* [1. Exploratory Data Analysis](#1)\n", + "* [2. Prepare 6 Different Models](#2)\n", + " * [2.1 Feature Engineering](#2.1)\n", + " * [2.2 Training](#2.2)\n", + "* [3. Bayesian Hierarchical Stacking](#3)\n", + " * [3.1 Prepare stacking datasets](#3.1)\n", + " * [3.2 Define stacking model](#3.2)\n", + "* [4. Evaluate on test set](#4)\n", + " * [4.1 Stack predictions](#4.1)\n", + " * [4.2 Compare methods](#4.2)\n", + "* [Conclusion](#conclusion)\n", + "* [References](#references)\n", + "\n", + "## Intro \n", + "\n", + "Suppose you have just fit 6 models to a dataset, and need to choose which one to use to make predictions on your test set. How do you choose which one to use? A couple of common tactics are:\n", + "- choose the best model based on cross-validation;\n", + "- average the models, using weights based on cross-validation scores.\n", + "\n", + "In the paper [Bayesian hierarchical stacking: Some models are (somewhere) useful](https://arxiv.org/abs/2101.08954), a new technique is introduced: average models based on weights which are allowed to vary across according to the input data, based on a hierarchical structure.\n", + "\n", + "\n", + "Here, we'll implement the first case study from that paper - readers are nonetheless encouraged to look at the original paper to find other cases studies, as well as theoretical results. Code from the article (in R / Stan) can be found [here](https://github.com/yao-yl/hierarchical-stacking-code)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "2d43427d-0ac3-4383-8441-375164cbecb0", + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q numpyro@git+https://github.com/pyro-ppl/numpyro" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7a71e927", + "metadata": { + "papermill": { + "duration": 4.069199, + "end_time": "2021-09-18T10:52:00.594720", + "exception": false, + "start_time": "2021-09-18T10:51:56.525521", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "import arviz as az\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import scipy\n", + "from scipy.interpolate import BSpline\n", + "import scipy.stats as stats\n", + "import seaborn as sns\n", + "\n", + "import jax\n", + "import jax.numpy as jnp\n", + "\n", + "import numpyro\n", + "import numpyro.distributions as dist\n", + "\n", + "plt.style.use(\"seaborn\")\n", + "if \"NUMPYRO_SPHINXBUILD\" in os.environ:\n", + " set_matplotlib_formats(\"svg\")\n", + "\n", + "numpyro.set_host_device_count(4)\n", + "assert numpyro.__version__.startswith(\"0.7.2\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "227f2ff1-63f3-4529-89ba-4c92fc7bb518", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "id": "255e8d79", + "metadata": { + "papermill": { + "duration": 0.043256, + "end_time": "2021-09-18T10:52:00.780796", + "exception": false, + "start_time": "2021-09-18T10:52:00.737540", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 1. Exploratory Data Analysis \n", + "\n", + "The data we have to work with looks at households in Bangladesh, some of which were affected by high levels of arsenic in their water. Would affected households want to switch to a neighbour's well?\n", + "\n", + "We'll split the data into a train and test set, and then we'll train six different models to try to predict whether households would switch wells. Then, we'll see how we can stack them when predicting on the test set!\n", + "\n", + "But first, let's load it in and visualise it! Each row represents a household, and the features we have available to us are:\n", + "\n", + "- switch: whether a household switched to another well;\n", + "- arsenic: level of arsenic in drinking water;\n", + "- educ: level of education of \"head of household\";\n", + "- dist100: distance to nearest safe-drinking well;\n", + "- assoc: whether the household participates in any community activities." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "01d1703b", + "metadata": { + "papermill": { + "duration": 0.078754, + "end_time": "2021-09-18T10:52:00.905455", + "exception": false, + "start_time": "2021-09-18T10:52:00.826701", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "wells = pd.read_csv(\n", + " \"http://stat.columbia.edu/~gelman/arm/examples/arsenic/wells.dat\", sep=\" \"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "2bf6c000-cb9a-4c81-898f-5ac4cdd1020a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
    \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
    switcharsenicdistassoceduc
    112.3616.82600000
    210.7147.32199900
    302.0720.966999010
    411.1521.486000012
    511.1040.874001114
    \n", + "
    " + ], + "text/plain": [ + " switch arsenic dist assoc educ\n", + "1 1 2.36 16.826000 0 0\n", + "2 1 0.71 47.321999 0 0\n", + "3 0 2.07 20.966999 0 10\n", + "4 1 1.15 21.486000 0 12\n", + "5 1 1.10 40.874001 1 14" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "wells.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5dec77a2", + "metadata": { + "papermill": { + "duration": 1.122344, + "end_time": "2021-09-18T10:52:02.072825", + "exception": false, + "start_time": "2021-09-18T10:52:00.950481", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 2, figsize=(12, 6))\n", + "fig.suptitle(\"Target variable plotted against various predictors\")\n", + "sns.scatterplot(data=wells, x=\"arsenic\", y=\"switch\", ax=ax[0][0])\n", + "sns.scatterplot(data=wells, x=\"dist\", y=\"switch\", ax=ax[0][1])\n", + "sns.barplot(\n", + " data=wells.groupby(\"assoc\")[\"switch\"].mean().reset_index(),\n", + " x=\"assoc\",\n", + " y=\"switch\",\n", + " ax=ax[1][0],\n", + ")\n", + "ax[1][0].set_ylabel(\"Proportion switch\")\n", + "sns.barplot(\n", + " data=wells.groupby(\"educ\")[\"switch\"].mean().reset_index(),\n", + " x=\"educ\",\n", + " y=\"switch\",\n", + " ax=ax[1][1],\n", + ")\n", + "ax[1][1].set_ylabel(\"Proportion switch\");" + ] + }, + { + "cell_type": "markdown", + "id": "05c9daff", + "metadata": { + "papermill": { + "duration": 0.046834, + "end_time": "2021-09-18T10:52:02.167845", + "exception": false, + "start_time": "2021-09-18T10:52:02.121011", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Next, we'll choose 200 observations to be part of our train set, and 1500 to be part of our test set." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "e6b41da0", + "metadata": { + "papermill": { + "duration": 0.058671, + "end_time": "2021-09-18T10:52:02.274078", + "exception": false, + "start_time": "2021-09-18T10:52:02.215407", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "np.random.seed(1)\n", + "train_id = wells.sample(n=200).index\n", + "test_id = wells.loc[~wells.index.isin(train_id)].sample(n=1500).index\n", + "y_train = wells.loc[train_id, \"switch\"].to_numpy()\n", + "y_test = wells.loc[test_id, \"switch\"].to_numpy()" + ] + }, + { + "cell_type": "markdown", + "id": "01c56e27", + "metadata": { + "papermill": { + "duration": 0.047031, + "end_time": "2021-09-18T10:52:02.368998", + "exception": false, + "start_time": "2021-09-18T10:52:02.321967", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 2. Prepare 6 different candidate models \n", + "\n", + "### 2.1 Feature Engineering \n", + "\n", + "First, let's add a few new columns:\n", + "- `edu0`: whether `educ` is `0`,\n", + "- `edu1`: whether `educ` is between `1` and `5`,\n", + "- `edu2`: whether `educ` is between `6` and `11`,\n", + "- `edu3`: whether `educ` is between `12` and `17`,\n", + "- `logarsenic`: natural logarithm of `arsenic`,\n", + "- `assoc_half`: half of `assoc`,\n", + "- `as_square`: natural logarithm of `arsenic`, squared,\n", + "- `as_third`: natural logarithm of `arsenic`, cubed,\n", + "- `dist100`: `dist` divided by `100`,\n", + " - `intercept`: just a columns of `1`s.\n", + "\n", + "We're going to start by fitting 6 different models to our train set:\n", + "\n", + "- logistic regression using `intercept`, `arsenic`, `assoc`, `edu1`, `edu2`, and `edu3`;\n", + "- same as above, but with `logarsenic` instead of `arsenic`;\n", + "- same as the first one, but with square and cubic features as well;\n", + "- same as the first one, but with spline features derived from `logarsenic` as well;\n", + "- same as the first one, but with spline features derived from `dist100` as well;\n", + "- same as the first one, but with `educ` instead of the binary `edu` variables." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "fa79c0ee-54b9-458d-9f97-c9e91ae83e7a", + "metadata": {}, + "outputs": [], + "source": [ + "wells[\"edu0\"] = wells[\"educ\"].isin(np.arange(0, 1)).astype(int)\n", + "wells[\"edu1\"] = wells[\"educ\"].isin(np.arange(1, 6)).astype(int)\n", + "wells[\"edu2\"] = wells[\"educ\"].isin(np.arange(6, 12)).astype(int)\n", + "wells[\"edu3\"] = wells[\"educ\"].isin(np.arange(12, 18)).astype(int)\n", + "wells[\"logarsenic\"] = np.log(wells[\"arsenic\"])\n", + "wells[\"assoc_half\"] = wells[\"assoc\"] / 2.0\n", + "wells[\"as_square\"] = wells[\"logarsenic\"] ** 2\n", + "wells[\"as_third\"] = wells[\"logarsenic\"] ** 3\n", + "wells[\"dist100\"] = wells[\"dist\"] / 100.0\n", + "wells[\"intercept\"] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "6726d0fa", + "metadata": { + "papermill": { + "duration": 0.062523, + "end_time": "2021-09-18T10:52:02.478421", + "exception": false, + "start_time": "2021-09-18T10:52:02.415898", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def bs(x, knots, degree):\n", + " \"\"\"\n", + " Generate the B-spline basis matrix for a polynomial spline.\n", + "\n", + " Parameters\n", + " ----------\n", + " x\n", + " predictor variable.\n", + " knots\n", + " locations of internal breakpoints (not padded).\n", + " degree\n", + " degree of the piecewise polynomial.\n", + "\n", + " Returns\n", + " -------\n", + " pd.DataFrame\n", + " Spline basis matrix.\n", + "\n", + " Notes\n", + " -----\n", + " This mirrors ``bs`` from splines package in R.\n", + " \"\"\"\n", + " padded_knots = np.hstack(\n", + " [[x.min()] * (degree + 1), knots, [x.max()] * (degree + 1)]\n", + " )\n", + " return pd.DataFrame(\n", + " BSpline(padded_knots, np.eye(len(padded_knots) - degree - 1), degree)(x)[:, 1:],\n", + " index=x.index,\n", + " )\n", + "\n", + "\n", + "knots = np.quantile(wells.loc[train_id, \"logarsenic\"], np.linspace(0.1, 0.9, num=10))\n", + "spline_arsenic = bs(wells[\"logarsenic\"], knots=knots, degree=3)\n", + "knots = np.quantile(wells.loc[train_id, \"dist100\"], np.linspace(0.1, 0.9, num=10))\n", + "spline_dist = bs(wells[\"dist100\"], knots=knots, degree=3)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "064a3de6", + "metadata": { + "papermill": { + "duration": 0.081958, + "end_time": "2021-09-18T10:52:02.608879", + "exception": false, + "start_time": "2021-09-18T10:52:02.526921", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "features_0 = [\"intercept\", \"dist100\", \"arsenic\", \"assoc\", \"edu1\", \"edu2\", \"edu3\"]\n", + "features_1 = [\"intercept\", \"dist100\", \"logarsenic\", \"assoc\", \"edu1\", \"edu2\", \"edu3\"]\n", + "features_2 = [\n", + " \"intercept\",\n", + " \"dist100\",\n", + " \"arsenic\",\n", + " \"as_third\",\n", + " \"as_square\",\n", + " \"assoc\",\n", + " \"edu1\",\n", + " \"edu2\",\n", + " \"edu3\",\n", + "]\n", + "features_3 = [\"intercept\", \"dist100\", \"assoc\", \"edu1\", \"edu2\", \"edu3\"]\n", + "features_4 = [\"intercept\", \"logarsenic\", \"assoc\", \"edu1\", \"edu2\", \"edu3\"]\n", + "features_5 = [\"intercept\", \"dist100\", \"logarsenic\", \"assoc\", \"educ\"]\n", + "\n", + "X0 = wells.loc[train_id, features_0].to_numpy()\n", + "X1 = wells.loc[train_id, features_1].to_numpy()\n", + "X2 = wells.loc[train_id, features_2].to_numpy()\n", + "X3 = (\n", + " pd.concat([wells.loc[:, features_3], spline_arsenic], axis=1)\n", + " .loc[train_id]\n", + " .to_numpy()\n", + ")\n", + "X4 = pd.concat([wells.loc[:, features_4], spline_dist], axis=1).loc[train_id].to_numpy()\n", + "X5 = wells.loc[train_id, features_5].to_numpy()\n", + "\n", + "X0_test = wells.loc[test_id, features_0].to_numpy()\n", + "X1_test = wells.loc[test_id, features_1].to_numpy()\n", + "X2_test = wells.loc[test_id, features_2].to_numpy()\n", + "X3_test = (\n", + " pd.concat([wells.loc[:, features_3], spline_arsenic], axis=1)\n", + " .loc[test_id]\n", + " .to_numpy()\n", + ")\n", + "X4_test = (\n", + " pd.concat([wells.loc[:, features_4], spline_dist], axis=1).loc[test_id].to_numpy()\n", + ")\n", + "X5_test = wells.loc[test_id, features_5].to_numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "64fa1b43", + "metadata": { + "papermill": { + "duration": 0.055757, + "end_time": "2021-09-18T10:52:02.713347", + "exception": false, + "start_time": "2021-09-18T10:52:02.657590", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "train_x_list = [X0, X1, X2, X3, X4, X5]\n", + "test_x_list = [X0_test, X1_test, X2_test, X3_test, X4_test, X5_test]\n", + "K = len(train_x_list)" + ] + }, + { + "cell_type": "markdown", + "id": "e7d1a65d", + "metadata": { + "papermill": { + "duration": 0.049466, + "end_time": "2021-09-18T10:52:02.811950", + "exception": false, + "start_time": "2021-09-18T10:52:02.762484", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### 2.2 Training \n", + "\n", + "Each model will be trained in the same way - with a Bernoulli likelihood and a logit link function." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c070567f", + "metadata": { + "papermill": { + "duration": 0.056796, + "end_time": "2021-09-18T10:52:02.917713", + "exception": false, + "start_time": "2021-09-18T10:52:02.860917", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def logistic(x, y=None):\n", + " beta = numpyro.sample(\"beta\", dist.Normal(0, 3).expand([x.shape[1]]))\n", + " logits = numpyro.deterministic(\"logits\", jnp.matmul(x, beta))\n", + "\n", + " numpyro.sample(\n", + " \"obs\",\n", + " dist.Bernoulli(logits=logits),\n", + " obs=y,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b29ed6c2", + "metadata": { + "papermill": { + "duration": 820.388941, + "end_time": "2021-09-18T11:05:43.355092", + "exception": false, + "start_time": "2021-09-18T10:52:02.966151", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "fit_list = []\n", + "for k in range(K):\n", + " sampler = numpyro.infer.NUTS(logistic)\n", + " mcmc = numpyro.infer.MCMC(\n", + " sampler, num_chains=4, num_samples=1000, num_warmup=1000, progress_bar=False\n", + " )\n", + " rng_key = jax.random.fold_in(jax.random.PRNGKey(13), k)\n", + " mcmc.run(rng_key, x=train_x_list[k], y=y_train)\n", + " fit_list.append(mcmc)" + ] + }, + { + "cell_type": "markdown", + "id": "c2ac5012", + "metadata": { + "papermill": { + "duration": 0.051074, + "end_time": "2021-09-18T11:05:43.479751", + "exception": false, + "start_time": "2021-09-18T11:05:43.428677", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### 2.3 Estimate leave-one-out cross-validated score for each training point \n", + "\n", + "Rather than refitting each model 100 times, we will estimate the leave-one-out cross-validated score using [LOO](https://arxiv.org/abs/2001.00980)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "0dfe6166", + "metadata": { + "papermill": { + "duration": 14.787853, + "end_time": "2021-09-18T11:05:58.318434", + "exception": false, + "start_time": "2021-09-18T11:05:43.530581", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def find_point_wise_loo_score(fit):\n", + " return az.loo(az.from_numpyro(fit), pointwise=True, scale=\"log\").loo_i.values\n", + "\n", + "\n", + "lpd_point = np.vstack([find_point_wise_loo_score(fit) for fit in fit_list]).T\n", + "exp_lpd_point = np.exp(lpd_point)" + ] + }, + { + "cell_type": "markdown", + "id": "e3f7a74a", + "metadata": { + "papermill": { + "duration": 0.051972, + "end_time": "2021-09-18T11:05:58.422802", + "exception": false, + "start_time": "2021-09-18T11:05:58.370830", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 3. Bayesian Hierarchical Stacking \n", + "\n", + "### 3.1 Prepare stacking datasets \n", + "\n", + "To determine how the stacking weights should vary across training and test sets, we will need to create \"stacking datasets\" which include all the features which we want the stacking weights to depend on. How should such features be included? For discrete features, this is easy, we just one-hot-encode them. But for continuous features, we need a trick. In Equation (16), the authors recommend the following: if you have a continuous feature `f`, then replace it with the following two features:\n", + "\n", + "- `f_l`: `f` minus the median of `f`, clipped above at 0;\n", + "- `f_r`: `f` minus the median of `f`, clipped below at 0;" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "8450ac11", + "metadata": { + "papermill": { + "duration": 0.078407, + "end_time": "2021-09-18T11:05:58.566113", + "exception": false, + "start_time": "2021-09-18T11:05:58.487706", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "dist100_median = wells.loc[wells.index[train_id], \"dist100\"].median()\n", + "logarsenic_median = wells.loc[wells.index[train_id], \"logarsenic\"].median()\n", + "wells[\"dist100_l\"] = (wells[\"dist100\"] - dist100_median).clip(upper=0)\n", + "wells[\"dist100_r\"] = (wells[\"dist100\"] - dist100_median).clip(lower=0)\n", + "wells[\"logarsenic_l\"] = (wells[\"logarsenic\"] - logarsenic_median).clip(upper=0)\n", + "wells[\"logarsenic_r\"] = (wells[\"logarsenic\"] - logarsenic_median).clip(lower=0)\n", + "\n", + "stacking_features = [\n", + " \"edu0\",\n", + " \"edu1\",\n", + " \"edu2\",\n", + " \"edu3\",\n", + " \"assoc_half\",\n", + " \"dist100_l\",\n", + " \"dist100_r\",\n", + " \"logarsenic_l\",\n", + " \"logarsenic_r\",\n", + "]\n", + "X_stacking_train = wells.loc[train_id, stacking_features].to_numpy()\n", + "X_stacking_test = wells.loc[test_id, stacking_features].to_numpy()" + ] + }, + { + "cell_type": "markdown", + "id": "cb323c68", + "metadata": { + "papermill": { + "duration": 0.052318, + "end_time": "2021-09-18T11:05:58.671602", + "exception": false, + "start_time": "2021-09-18T11:05:58.619284", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### 3.2 Define stacking model \n", + "\n", + "What we seek to find is a matrix of weights $W$ with which to multiply the models' predictions. Let's define a matrix $Pred$ such that $Pred_{i,k}$ represents the prediction made for point $i$ by model $k$. Then the final prediction for point $i$ will then be:\n", + "\n", + "$$ \\sum_k W_{i, k}Pred_{i,k} $$\n", + "\n", + "Such a matrix $W$ would be required to have each column sum to $1$. Hence, we calculate each row $W_i$ of $W$ as:\n", + "\n", + "$$ W_i = \\text{softmax}(X\\text{_stacking}_i \\cdot \\beta), $$\n", + "\n", + "where $\\beta$ is a matrix whose values we seek to determine. For the discrete features, $\\beta$ is given a hierarchical structure over the possible inputs. Continuous features, on the other hand, get no hierarchical structure in this case study and just vary according to the input values.\n", + "\n", + "Notice how, for the discrete features, a [non-centered parametrisation is used](https://twiecki.io/blog/2017/02/08/bayesian-hierchical-non-centered/). Also note that we only need to estimate `K-1` columns of $\\beta$, because the weights `W_{i, k}` will have to sum to `1` for each `i`." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "f2203a8c", + "metadata": { + "papermill": { + "duration": 0.075301, + "end_time": "2021-09-18T11:05:58.799743", + "exception": false, + "start_time": "2021-09-18T11:05:58.724442", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "def stacking(\n", + " X,\n", + " d_discrete,\n", + " X_test,\n", + " exp_lpd_point,\n", + " tau_mu,\n", + " tau_sigma,\n", + " *,\n", + " test,\n", + "):\n", + " \"\"\"\n", + " Get weights with which to stack candidate models' predictions.\n", + "\n", + " Parameters\n", + " ----------\n", + " X\n", + " Training stacking matrix: features on which stacking weights should depend, for the\n", + " training set.\n", + " d_discrete\n", + " Number of discrete features in `X` and `X_test`. The first `d_discrete` features\n", + " from these matrices should be the discrete ones, with the continuous ones coming\n", + " after them.\n", + " X_test\n", + " Test stacking matrix: features on which stacking weights should depend, for the\n", + " testing set.\n", + " exp_lpd_point\n", + " LOO score evaluated at each point in the training set, for each candidate model.\n", + " tau_mu\n", + " Hyperprior for mean of `beta`, for discrete features.\n", + " tau_sigma\n", + " Hyperprior for standard deviation of `beta`, for continuous features.\n", + " test\n", + " Whether to calculate stacking weights for test set.\n", + "\n", + " Notes\n", + " -----\n", + " Naming of variables mirrors what's used in the original paper.\n", + " \"\"\"\n", + " N = X.shape[0]\n", + " d = X.shape[1]\n", + " N_test = X_test.shape[0]\n", + " K = lpd_point.shape[1] # number of candidate models\n", + "\n", + " with numpyro.plate(\"Candidate models\", K - 1, dim=-2):\n", + " # mean effect of discrete features on stacking weights\n", + " mu = numpyro.sample(\"mu\", dist.Normal(0, tau_mu))\n", + " # standard deviation effect of discrete features on stacking weights\n", + " sigma = numpyro.sample(\"sigma\", dist.HalfNormal(scale=tau_sigma))\n", + " with numpyro.plate(\"Discrete features\", d_discrete, dim=-1):\n", + " # effect of discrete features on stacking weights\n", + " tau = numpyro.sample(\"tau\", dist.Normal(0, 1))\n", + " with numpyro.plate(\"Continuous features\", d - d_discrete, dim=-1):\n", + " # effect of continuous features on stacking weights\n", + " beta_con = numpyro.sample(\"beta_con\", dist.Normal(0, 1))\n", + "\n", + " # effects of features on stacking weights\n", + " beta = numpyro.deterministic(\n", + " \"beta\", jnp.hstack([(sigma.squeeze() * tau.T + mu.squeeze()).T, beta_con])\n", + " )\n", + " assert beta.shape == (K - 1, d)\n", + "\n", + " # stacking weights (in unconstrained space)\n", + " f = jnp.hstack([X @ beta.T, jnp.zeros((N, 1))])\n", + " assert f.shape == (N, K)\n", + "\n", + " # log probability of LOO training scores weighted by stacking weights.\n", + " log_w = jax.nn.log_softmax(f, axis=1)\n", + " # stacking weights (constrained to sum to 1)\n", + " w = numpyro.deterministic(\"w\", jnp.exp(log_w))\n", + " logp = jax.nn.logsumexp(lpd_point + log_w, axis=1)\n", + " numpyro.factor(\"logp\", jnp.sum(logp))\n", + "\n", + " if test:\n", + " # test set stacking weights (in unconstrained space)\n", + " f_test = jnp.hstack([X_test @ beta.T, jnp.zeros((N_test, 1))])\n", + " # test set stacking weights (constrained to sum to 1)\n", + " w_test = numpyro.deterministic(\"w_test\", jax.nn.softmax(f_test, axis=1))\n", + " numpyro.deterministic(\"w_test\", w_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "9827977d", + "metadata": { + "papermill": { + "duration": 296.084187, + "end_time": "2021-09-18T11:10:54.936288", + "exception": false, + "start_time": "2021-09-18T11:05:58.852101", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "sampler = numpyro.infer.NUTS(stacking)\n", + "mcmc = numpyro.infer.MCMC(\n", + " sampler, num_chains=4, num_samples=1000, num_warmup=1000, progress_bar=False\n", + ")\n", + "mcmc.run(\n", + " jax.random.PRNGKey(17),\n", + " X=X_stacking_train,\n", + " d_discrete=4,\n", + " X_test=X_stacking_test,\n", + " exp_lpd_point=exp_lpd_point,\n", + " tau_mu=1.0,\n", + " tau_sigma=0.5,\n", + " test=True,\n", + ")\n", + "trace = mcmc.get_samples()" + ] + }, + { + "cell_type": "markdown", + "id": "c7ede764", + "metadata": { + "papermill": { + "duration": 0.052553, + "end_time": "2021-09-18T11:10:55.042375", + "exception": false, + "start_time": "2021-09-18T11:10:54.989822", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "We can now extract the weights with which to weight the different models from the posterior, and then visualise how they vary across the training set.\n", + "\n", + "Let's compare them with what the weights would've been if we'd just used fixed stacking weights derived from the LOO scores." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "812117cb", + "metadata": { + "papermill": { + "duration": 2.523295, + "end_time": "2021-09-18T11:10:57.979955", + "exception": false, + "start_time": "2021-09-18T11:10:55.456660", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6AAAAGeCAYAAACKKmxFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3hc1Zn48e/0UZdV3Hvh2LhRQgslBAIECL0YMKYYQkkIpG3KpvxINtnNZpOQCoTQQje9twAhoXcMNvbBxlWWi6zeps/vj3PvaGY0I42ksSzJ7+d5/Fgzc8u5/bz3NEc8HkcIIYQQQgghhNjVnLs7AUIIIYQQQggh9gwSgAohhBBCCCGEGBQSgAohhBBCCCGEGBQSgAohhBBCCCGEGBQSgAohhBBCCCGEGBQSgAohhBBCCCGEGBTu3Z0AIfJBKXUt8P/Svm4FNgP/AH6htd452OnqK6XUy8BUrfXUQVznkcA/gSu11jdmmWYDsE1rfbD1+VrM/p6mtd4wKAkdIKXURcBtwCFa6zdzmO6LWuuX85yGIzH7+mKt9e29THsE8A3gAGAsEAM2Ak8BP9dat+QzbT2kYyqwHviZ1vraHqaLA3/XWl80GOna1ZRStwMXaq0dfZzvInI4z4Toj/T7da7X53BkPQ/Haq1n7+J1DOozVwghJaBi5DkTk2E/ADgVuB+4AnhJKeXZjenK1eXASbs7ETm4CbOPa3d3QnaBJzDb9t7uSoBS6gLgZWAU8B/AkZhz+zngm8DzSil30vR/sgKm3ekA4NrdnIZ8uhazTbuMUupjK2AVor9qMefpTYO5UqXU/tZLpyG5vD4YEs9cpVSVUipmvVAQYsSTElAx0qzUWq9O+vySUsqBKa07Anhx9yQrN1prvbvTkAutdS0jM/hEa10P1O/mZPwEWAUcp7WOJn3/tFJqM/C/wDHAM9b3RwAfDG4SU2mt392d6883q2R/w65avlKqApi7q5Yv9gxa6xCwO669I4b48nIyhJ65hwN9qm0hxHAmAajYE3xk/V+V/KVS6mJMFcc5QABYAVyrtX7R+v0FYB9gvPWQT573EyCstV5ofT4O+BGwPxAHPsRU+302aZ7xwC+ALwGjgQbgJeCHWuvN1jQvk1YdSCl1EvB9YF8gCnwK/FprfX/SNLdjSnxnA38GjrLS8TLwda31ttx3V+8yVcFVSo0D/hs4HlNyVwPcBfy31jpoTXMRpnri8Zgga39gtNa6RSk1H1Pq9EWgEFPd9E5rW0M5zD8R+BVwLODHHM+fJx8Di0sp9d/ARUAl8DHwDa31G2nrSFTBVUqNwhy7U4FyzDH4jdb67qR9MgX4GXACUAZsAR7FnFN9rS47EXg5Lfi0/Qm4XmvdmVT9DmCBUupCrOq9SqlK4KfAGZjzbRvwAvCfyeeDUspvTXcupqrveuCvwB+11hlLJKzaBM9gro/DtNar06vgWtW2P8Qck99Y0zYC9wI/0lqHrelcmOO+FKjAZKavAX4JzMlWNU4p9Trg0loflPTdOdby/6a1vizp+2sx12eF1rpVKXUg5lh9HvBggv3rtNZ3Jc1zO2lVcK3l/xSYjglOfwZMtrYxvTp61vMs6RwDuE0pdZs9v1LqGuBSYBoQAVZiroHHMu2HpLT1ev738Ro7EFPqfj7mfP4YuEZr/XaW9X8J09zha1rrG9J+uxy4EThaa/1SLtdKUlXT84HzrDQfB/wb+K7W+rdp6zgbWAacrrV+JEsac7pGc7zec5mm0prmJMw1WA88i7kGt/awnQdprT9WSu0L/BH4HKZJyQOYKvjJ2zSVtCq41rX4B8zx+C/Mc2E7cIPW+tdJ8xYCvwYWAQXAK8DXgKeB7VrrI7Psx5eBLySt61/2tEqpUzHPqwWYgOoTzLV1d6Zl9bY867vpwA3AoZhr4glMFeS2pGl6fQb3sO7EMzfXZ6k13bnAXphz+3DM8/lJ4GrrRaa9/Nla67Fp630TU714qn2vsX5ar5TaKFWCxUgnVXDFnmCO9f9K+wsr+LwVeB2TYVuMeSHztJVJA/g7JuN4YvLClFJzrWXeYX0+EZMZbwVOB87GBJdPKaVOSJr1UUyG9zuYh9r3rM/PW6W03SiljrbmqwW+Yi1/G7DMeuAmcwEPA29hHqC/tqbf5VWzlFIlmIzhMcB/YvbprZhtvD3DLD8DHgKOBjqUUtWYYHwG5kF8DPAIJvP0sxzmLwdeAw4GrgZOweyzJ5VSR2WYtxRYgql+NR24RymV8X5oBVv/AM4CfozJvL4B3GVVlUUp5cUEd0cCX8cc3xustPw103J78THwJaXUFclVbcGUeGitO62PdvU7MBmfAzCZMzDnwgWYTNmRmIDuLOChtPNtGSbg+x3wZUwm9/eYAD+bGzHn7klpNQ7STQFuweyLr2Aycf+BefFj+wlmvz6ByajfCzxozduTF4B9rUy07UhMJj+9NOULwJtW8Lkv8C9M0LAEc658CNxpBUoZWefRPcAOus6FHwEnZ5mlp/PsCUzTAHu6A4BapdTXgN8Cd2NesizCvMh5WCl1aA9pK6eX878f19hvMUGanf5ZmHuaL0sy/okJck7P8NtZVnpe7se18k2s6wFznD7DnNeZ1tFAWoBmy3W9OV7vud4TXsQ8D/7bSv+PMNfYv9LO2/Tt3GAFuM8Dk4CvYoLTEOZlTi4OxBxbOwD+FPhfpVTy8bne2hd/xZzH/8LcR0b1suzLrenAnLuXW9u8CHNObcGcu6dhnrt3KaUu7evyLH7M9fCQtR13YYL179kT9OEZnKtcn6VeTDOf5zDX6/9igtK/93F91wJ/s/4+mSFQJViIXU1KQMWIZWXKjga+C9yqtV6R9PMY4GGt9VVJ02/BZHDOxGQEHgL+gsnsJL9RPwvzpvMe6/P/WdOfmlSq87z13S8xQW0F5sH6Ta31A9Z8ryulVmAyQiVAplKyKZhMyMVa63Zr2e9iHq7nYR58tmLgAa31ddbnfyulTrP2wa52JTAT8+beLiH5lxXo/JdS6lda6+VJ06/XWv/O/qCUmgG8CfxKa/2a9fUrVpB9HvDDtPWlz/9VTEnU3lrrVdZ3rwJrMRnol5LmrUs77vMwLwUUpiQs3amYt+onaK3tKq//Ukrtj8nI34HJJK4E7tBaP2xN85pS6vPAmUqpC+xzI0ffxGSobgCuVaY0/lXgRa31Gnsiu/qdUgqg3q4Gq5QqA3ZiShrtzNDrSqnZ1rKnYt60H4DJ8CSXWv1LKbU3cJ5S6pfpCVNK/ae13afZpcY92AfYX2v9vjXvu8A5mHPyd1YwdhXwntbaDsheUEo1YALRjT0s+x+Y4PUgTPADJri4DfiuUmq01nqHFTAdjAkCwFyTjcCXtdbN9rKs0rFfKKVu0VpHMqzvG5gA4ExtdWimlHoHk7HPJOt5prVepZSyq/5tSDpuxwEfa61/lTTfC8D71rqzyeX87+s11ph0TOzSU7tk6530BGito0qpB4ArlFKjtNaN1nzVmOPye611TCnV12slorX+QVI6/g78XCm10L6nWMHcCZgS+Gz7Kdf1nkrv13su0ywCFgLnaa3vtab5t1KqERPcnIN5SZdtO6/C1Nq5IGkdL1j7eA692xeYoU1zCfv5tgpz7T1sPZPOBx7SWv/Ymucl617yP0DWF0taa62Uqrf+Tq7++0trHYvs2hvWs3Ah5lq9uY/LA/MMvFxr/Zy1vH9hAszjMLURIIdncLZtyaIvz9IntNa/t/5+xbp3LlZKTdZab8plZVbNB7tJy8d6mHTsJ8RASAAqRppV1gM02cPAD5K/SM7gJVlr/T/JmqZDKfUgcL5SqtKuUoMJQF/UWm+1MlNzMFW4EpkmrXVEKfUkJiNcALRjAszLrEz461rruNb6Q0zQm5HW+lZSMylorZush/WkDLM8mvZ5HXCQUsrbQ8bMdoNS6oYefu+pGu9xmIx0evU8u4TlECA5AH0+eSJtegvN9NZ3LaYKabrn0z4fA9TYmW9rmWEyl6I9mvbZDnKqyOwYzAuHlPbDyVU/tdafYTKl6dZi7rPjgJwyI9byXrcyMt/ClCIstv6hlHof+L7W+oUe5m8m835LPsfXY7YNuh+Ps+y/k68nq4TjF8BXtdZP0LtNdvBpLbdNKVVHVwnLBEwtg/SShQczfJfuTaANOAz4p1JqLOYlwlmYaq+HY14iHYQpRXneKrk6Crg3Kfi0PYLJYM4kc+Z7AfC+TupNW2u9USn1EqZUK92jaZ97O8/AXGMnKKWuBO7SWrdaGfn/7WEeyOH878c1lp7+ddb/PZWO3Yd5oXAyXaVAp2FKlO620tHXa+UfadPdgSmxvRD4tvXdiZgqxXdmS1gf1tvr9Z7jNF/E9FydXnX6Wev7w0m9t6dv54HWdC+lff8k5iVpb962g09L+vGbizku6ffS2zABaJ8opSZjXnL8r05qOqC1jiulngZ+qJSaorXu6aVSJp3JabReYmzGuo5yfQYn1RrJ1aNpn7M9S9Onex5zr96bPtzzhdjTSAAqRprT6Oo4xIsp6fk6JjA9xX7zr0zbnB9gMiQTMRlUW3JVzNuBizHVav5sBQV70/WAnmD9f60y7cwyGa+1/kwpdSYmU/Yq0GCVbCwDHtVaxzLNaL3Z/y7mje9UoChLOm3pQaL9oMyluv0vMRn/THp7gzwBmKqy92I4Ie1zXfoEyrRf/Cpm//ZWBSx9/vGY6n+5SJ/OzrS4skw/HmjqLYBXSp2MyXzviwmqkqu59rm5g9Z6C+bYf9fK3B2OOb9PBp5VSh2ttf5XD+k5HJNBPwSoTkuD/fd46/9c9t1BmBKw9VjVz3OQ6aVFKGn9o63/tyZPYGUe12GqyWaktQ5bpSGHWV8diakZsAJTHfUITAB6JKbE8x1rfT7gIpW999kJZA5AR5P5ZZEmcwDa1/MMzP6djqka+Uel1NvA48AtuudhpHI6//t4jfXnXvI6JtN9Bl0B6FnAaq11opOsPl4rKde6FfS/jCmh/55VWn0WsLa3Evkc15vL9Z7LNBOsaTrS0t+plGqi69qzpd/TxmJKoYNp3+fa+VvK8dNah6yXSb1de9uVUukvZ3Jh3+O3ZPjNXsd4eq7VkMkO3b0tepiu6yinZzCm6nZf5Hr+pweZO6z/q/u4PiH2KBKAipFmtU5tk/a2UupRTEcIfwT2t6qF/gOYjwkkXwSaMQHrW2nLewXz5nMJpkOCszClmemdXPyO7G/fawG01v9QSk3DvD0/HtMm7mzgGaXUiRkesmBKDU611v0oJoMdx7RlymQg3djXWCWy3Sileis9BVOScFaW39IzVynVUZXpeOX3mLfHF2EyMVFMpyrpbV27zY8pKfDmkMb+6HXZynS88QgmyPk6JkgLY9qXXTzQBFhVue4G7rYCy39h2hBmDECVUp/DlJysx7SV0kAQU3Lyo6RJ7Rcfuey7L2NeRJwA/JzuVTYz6e18tF/8ZHoBk8u5/ALwM2U6MjoSeMUqcXkVq8QY0/7zRavkxJ7vPrKXKq7P8r1/AOnMida6CTjGqu56EuY+8T/AfyiljtBaf5Jl1lzO0b5eY33eLmvfLwO+oZQqxuyzI0lqY9qPayVT1fW/Y14OHmO9hDgBUw0zqz6sN5d7SS7T9LT/HHQ/l9K3M1uPqLm+zNrV115f5rG3JeOL1jzp9RncR7nug/RtynVbpcdbsUeTAFSMeNab3+XAKVbwOQ/zBvzPWmu7DYndDjF93rhS6g7M29XpmLZSD2urPSaw2frflS14S1teEFOF6kmrjc+1mHYsX8B00JKglCrFdCbypNb6G0nf+zGdgwwlmzFtoj7KVprbiwswpVQnJre/U0oVZZ+l2/oPVko5kgN5a36X7nsvtOnLLlFKlSVX27SqVnut75ZgMiwnaq3rkqbp89izVlXSI4DnrYAkhdb6FaXUdkwJSTbnYu7v52qtE+OZKqXSq1ra5+8kzMsNezofplfM5P12i9b6UqXUjcD3lFLP9lQCmyN7nWOSv1Smbeg0oKmX+V8ArsNUjz2Srmq7r2A6XKnGlABfY32/E9PjdUEu12uGtI7J8P3MPi6nV1rrjzHt1/5bKbUAU7L4PUzgmEku5/9Ar7Fc3YfpaOp4zH3KTVd7ecjPtfIg5qXcOZhS8iJ6qH7bx/Xmcr3nMk0NcKxSqijpeWHXaiknc0lhsjqgPEOVz8m9zJerbNdeFT3UPOhBjfX/xAy/9VQ6OlB9egbvAmPpatoAXSXL9jkWw/S0nW4cuzYgF2JIk15wxYhnZTD2wZTwxel68bI5bdJvWf+nV5G7A5Nx+SWmy/VE9UOrmuQqTCcWKb1DKqX+w2rLhTKDbN+WnNmz0mK3D8rULsyFeUuans6rrG3oqSrfYPsHpkpfSo+DSqkDlFJ/VEqNzjxbghvYlpYxPgjT0ypWCVdPXsMM4XFk0vxOTCb+gSzz5MrusCW9d89nAbvNqxvowAQ49vqnYqrMQt+O1cGYqtnfyfSjMr0wj6ZreCFb8jq6nePKdEx0cdq02bbtJkzVsuSXlHYG89uYDNedynT0NRBrMe04j0z7/jRyeMmiTcdiWzFVPhVdJcLvYwLNr2MC6eet6SOYDouOs4LTBKXUxUqpH6ssPVJjqt/up0yPz/Y8EzC9lvaHHSi6rGV5lFK/U2m9dmqtP8LUwuip7Wgu5/9Ar7GcWG1+P8XcC04D3tBar0uaZMDXihXQPYSpjn4h8FraOjLJdb25XO+5TPMPzP37lLRpTra+z9qG2/Kelab0jm+y9brcV3ab/CPTvr+Q3MSh67zRWtdgqq6frJJ6FLf+/oqZRNdkWlCm5eUq12fwLpTey+4xmG2x78+NmBcJifuZMj1xp/fhkHI/EGKkkxJQMdLMtap+gbmRT6RrCAQ7870a017qa0qpVZgqtRdjMqy1wKFKqSOAV7XWMa31eqXUvzFv27fQvVOIH2Cqdv1DmV5DQ5hqs1djSgLAtCc5E5iulPqDtZ7R1u/1GZaJ1rpRKfURcI61/lpMhmc2psv/+cqMvfd6f3ZUnt2IqRJ6l1Lqu5gMwd6YqnfbMQ/hnrwMXK2U+gGm9OpzmPHobgYuAy5RSj3ew/w3YHrivcuqargTc9ynYMaXHIgHMMfpD0qpGKbq3hmYUko7s/YyJmP4O2U6rtoLMxzNDZh2nEuUGesxF49jMtc/VkrthekNditmSI8DMKV5m0mtQroVOFKZsRDXWum5Gvi9Mh1LjceUtN+GGTbibKXUZquzo6eA/1Sm59n3MJ2nnI/p1MNuN5agTedcizHn3V8xvX32i9WO8w7MtfgbzBAaszHHfhWmY5nevIg51i1YbTSt5b5tLefTtI5Pfopph/1PpdSPMOfmFzFVk2/KUhUezLl4LHCfUupPmJ4yf4S5Fr+Y80Z3sdvFnatMz6hvY0p971JK/dTaFiemg5159Dz8Ri7n/8sM7Brri/swbU3L6boH2l4mP9fK7Zjr7zi6hrTpSa7rzeV6z2WahzDVff9oPZNWY+6J/2V9/1Av6b0LM9byTUqp72FK1M4hTyWgWutaZToHOs96Dr6B6fjoNJKC9B7Y5+8PlVIrtNaPYqrlPwzcq5S6FfMMvgjTSVCmjq56W16ucnkG7ypLlBkq623MOKXnAffrrrGWn8IawiXpXvxDzPWd3A7b3v5rlGlC8JDOPA60ECOClICKkeZBzMP9Hcxb6j9ietE7Smt9O5hOIDAPw52YkqbbMaU9V2KGaqjCZKCSX9DYHWrck17FVGv9OF1vQR/CDJ9xBGYQ+99Y02zBdCLThMm0/xszxMsO4HCtdQOZnYt5k3ozZrwxHyaQ/TWm/dZ9DIHODqwqfodhMh+/wJRE/QyT5i/p3ocg+Skmw/UfmAf2MZg2cP+HCaiuw+y/bOtvtNb/Kqb07jlM1cjjtNYv93e7rGWHMaVcyzD7/QUrfedqre3S8L8Af8Icr2cxmdDFmPZ772M6l+ktA2avL4YJ6r6Gqd51K+ZcfgTTxvavwL5pPVz+JyZY+ztwpNb6Ecw+PRyzL75r/fs5JmC70Fo+mHbIf7B+fwnzMuYaTIl/tjS+i6k+frbK3plPrr6LGQNvKaZGwEmYfdVCbu2w/oG5Zl9Py7C9grk20nv4fRdzfW7G1GZ4AXPcvo/JsGakzfBJ38G0HX8Ek4n8T7pKvPrUbk5r/Sld46neigkszsOMm/ota7sexZRQXZx0rmVaVi7n/4CusT66F1PF0IO5ByTL17XyL0yHc6EM68gkp/Xmcr3nOE0E88Lifsy18iLm5c99wLG93RO11tsx7a63YF4c3YtpJ/rVHLY1VxdizuX/xNy798cEblF6P5//iilF/X9YYwZbQePJmBcfj2AC9QnAV6x7Up+Wl6tcnsG70BJMKfUzmP14J+aFju0OzDX2eUwb+m9gjmF6Z0zLMPesKzDXopSEihHNEY/nrf8EIUYsZTqweBgzzl7W8dGEEPmhlPoEMzbigt2dlp4opa7HvLyq7OFFktgFlFIfAqu01ufu7rSMFFYV9DZMx135qu474iilbscE8AVa68BuTo4Qw46UgArRC6tNyg+Bf0jwKUR+KaWuVkrdldz2UpkOwfaihzFyB5tS6lil1MNKqSlJ37kxJV+bJfgcXEqpk4CFmFouoh+UUj+3moQkOwJTm+LDwU+REGJPIW1AhcjC6qRkDqbKzL7WPyFEfrVhqkI6lFJ/w7Qb/Bmmh8jf775kdbMFUyVyklLqZ5g245djqrpmrbor8ksptQ/mXvwbTJOIHsf+FL262mrH+gimuuyvMMOS/W23pkoIMaJJCagQ2R2L6bhiP+AErfXK3ZscIUYerfWtmPafczFtE+/CdAx0jNWj6pBgXf/HYtqm3kFXh0lXaK3/tDvTtoe5H7geeAK4dDenZbj7f5jhfb6MaTd8A6bn5CO01um9rwshRN5IG1AhhBBCCCGEEINCSkCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUCFEEIIIYQQQgwKCUAHiVLqBqXUautfWCm1MelzSR+Wc5VS6r96mWaCUmrFwFM9cDmmd6pSKpLlN59S6oI+rvMgpdRmpdQTfZmvv5RScaXUWutYfqqUekYpNX0w1p2UhheVUvvlaVkZj4dS6lql1M3W3/+jlLoiH+vrY9qOVEqtzfJbv9PU03J7mOer/VmXNW+2fTxkrl0hxNCT9ryx/z1n/ZbP58DNSqlr87GspGWeppS6NYfp4kqpiVl+6/d915q/z9ullDrQ3sf5oJSKKKWmZvj+a0qpbUqpH+VrXT2kIfE878M8hymlNuyi9NyhlDoph+kGdPzF0OHe3QnYU2itr7T/ti7g87XWr/ZjOX/OYZotwLy+LntXyCW9vdgXuAC4ow/zHAu8rLVeMsB198WRWusaMIEQ8Aeg15tpvmitjx6sdVnr++Fgri8Xg5kmpZQL+D/gb/lc7lC6doUQQ1bieZNssJ8DfaW1fgR4pL/zK6XGAt8jz/fd3mit3waOG4RVnQH8SGt9yyCsa0jRWvda0LC7jr/YNSQAHQKUUkcC/w3UAGGt9WKl1KXAdzDHaCuwRGu90XpzN1FrfalS6mXgceB0YBrwb+A8YAqwVmvtVkpdBJwItACHAxHgLK31SusN3CNAOfAcMBF4UGt9e1LaLgG+qLU+3/r8CfCI1vpHSiknsBPYC1DA74FR1nfnaa3XpaV3P2CZtei7MDfbq4EN1rKXAt+0lvE94CUrfaVKqVe01ocrpX4BnAU4rP11vta6Nim9ZwLXAG6l1NPArzPs27OA/2ft21rgq1rrz6y0jgEmAfsDL1jpvRaYYE33ZI8H03gJODkpTd2OpXU8tgDTtNbbrel+Y03zLeAnwGLADzwKfFtrHU1KuwsIA1drrV9OfqnRw7lzEVnOhRy2KYVS6nbMOfYLpdTewA3AOCAIXKy1freP5/VF1j4rA97TWn9PKfV94HIrnU9a89nr/xFwPuAFLtVa/zMtTfsDNwEl1nou0lqvV0odAvwZKAJi1v57oYftdAM3WvvLBXwEXIQ5JmVKqdXA8VY6bgEqAQ/wE631vdYyvgz81vr+U8wLlfT13AU0WtPl5doVQuxZ7OcAcBDwBa31ydb3zwOPaa3/opQ6BfgF5h64FvOs3qmUqgTuBWYBnwAdmHt38vKPBn6mtT7M+vw00Ki1Xmx9tu+PATI/Ey7CPKe+lMM97ASl1OXWMn6rtf4t8Dow0brvLgAuA76OyQ+0WOtJeZ71tF25PrswAc/NmGfUq8BorXXEWsajwLPAbZiXkl/GPA9u0lr/tzXN8cCfrGVlLAFWSv0aOASYo5SaZH09AVgI3AP8EfgvTL4J4E3g61rrdisv+CxwCjATk2cZhTkXYsCJWuv1mdZrrXsDcD2wCJgM3Ki1/on1248xz+GdmPxmr5RScUw+bCkwHvip1vpG67ergSswNTA15vldZ23DzVrru6z5LwC+DYwFfq21vo6046+1DuWSHjE0SRXcoWNfzEW/WCk1GpNJPkZrPQvzkPhJlvlOAo7BBIFHAZ/PMM0JwPVa672Af2KCPIDfAM9rradhbl5fyjDvPzE3RZRS1ZibvL2O+cBGzI37CeA/tdYzMaV/92dY1k3A76xtarbSbHMCXq31AkwA9gsrMPsh8IYVfM4FzgbmWdvySHqatdYPYvbdg1rrE6yvk/ftZMzD5FSt9WzgKeCvSYv4CuamOQ8T6B6vtf4c8Evg+xm2KYVSyou56T9ufc54LLXWjZgAd1HS7KcB91nznw0cCMyw/tkl6NdjHiZzgK+RFOj2tL6kSbKdC/1ivYR4FLjDWuYVwGNW4AZ9O6+PBa6wgs/DgEsxD995wGHAmdZ0E4GPrX1wA/DjDEm7D/hx0nlil8TfBPyfdex/hQkue3Ic5uXObEwGZiXmelgKRLXWs60H+2+AJ600LQVuUUp5lFJFwN3AIistazGZiOR9+H1MZuGbGdY/kGtXCLFn+j0wQSl1rBVwlgA3KNM05E7gXK31dMw9xb4Hfh+os+4pXydzid/rwDzr3uYCqoE5AEqpckwg9yE9PxNsvd3Dpmqt98c8436hlPJg7q2brPu3D3MvPdD6/H+YF3bpMm5XX55d9oK01p8A2zAvBFFKFWLyXQ9hXprvjckXzQXOVEp9xdpPtwBfs54PMczLzBRa6+8BbwPf01pfa319AnCC1vr3mDzB8ZiX43Mxgfu3khZxhJWuizEv3mus/fKJtd96cwgmzzEX+LpSaqEVoH8b+Jz1b0EOy7HN0lrvY6Xp90qpSqXUwcB/YErwZwObgP/JMv9crfW+mOP/39Z+TBx/CT6HPwlAh45OrfVLAFrrHUBpUhWbV4BsbQof1Fp3aq3bMaUrkzNM84nW+j3r7/eTpjkc82YQrfWjmNLAFFrrdZjSxNHW9P8AKqyHwWHAi9b3NVrrf1jz3AvMtII9AJRSBZgb573WV3/BvLW0OeiqZvsBJshI14R54C1WSo3SWv9Ja51L1dzEvsUE6//UWtvt/W4Gvpj00Hlda71Da12PKTl7xvr+Y8ybvGxett7KbQcOwLwN7e1Y3gucC6CUWgC4tNZvYl4q3Kq1brbest6MKeUG2AFcoZSaorV+VWv97eRE5HDuZDsX0rlUahuj1cBVGaabDYzGequrtX4NqKPrJUVfzutPtdZrrL9PAJ7SWrdaD5ojgYet31q01vab2G7nilJqL6BKa20fuz/T9dZ4H7pejvR0XdnqMJmK04BCrfVPtNaZ2gKdgskAgXlD7sdkxg4FNmut7Xad3yMp06CUOhE4BzhHax3NsNx+X7tCiBHr5bT7c0qVROte8lVMjYpfYWrvxDClcy8n3Y9uBE62MvdHYN0btdYbgH+lr1Rr3QksxwRnC4HVQL1SagLmXvcven8m2Hq7h91l/f8B5n5alfZ7AIgDlyilxmitH9Ba/zrDvsq2XTk/u9I8SNeL3y8Db2ut6zDP7eu11kErP3YH5rk9C/BrrZ+35rk9wzKzeUtrvdP6+0Tg71rrduv43oZ5aWt7wsovfAwUWumE3vMutju01lHrOf0KZj8cAfxLa73dWuddPS4hlb1fNaak80BrGx601gEmb3Ns5tm50/r/fczxH92HdYthQKrgDh0N9h/Ww+DnSqmTMW/KSjDBZSbNSX9HyfBmrYdpRiWvF1MlNBO7FPQITFWZKZgH0OHA363lzLCCFFsQEyzaRgFxrXUTgNY6rJTakfR7VGvd0dN2aK23KKVOB74L/Ekp9W9MidnmLOm2JW9jNaaqo73MZqWUg66HW2tymoC2ntKUJLkN6BHAv6wqxzvIfiwfB/6mlJoGnEpXYFQOfFcpdZn12Y15MIJ58P0YeE8ptRn4ptY6kVHI4dzJ5XwBq3Qv+Qu7OnXadOWYh90qpZT9XSmmKmojfTuvk49TFUkZEvvcsNbR0ss2VJG0ndZD2e7wZzFwtTIdf7lIfQnSjdb6baXUN4BvAH9XpmOrr2WY9Djgx1YtgZi1XKeVlqak5YWStsOJeTOu6TrP0g302hVCjDwZ24Am01q/r5RqwdzL7YCzHDgi7VndjLlfV5B6v2kkMzs/4MCUiNov2vbDvJAuJ/szIVlv97AWazui1nJS7vNWHuJo4D+Bn1nVf7+mtf44bTnZtqundKY8u9I8iKlV8y3Mc9tuVlQOXKeU+m/rsw9TollB6jMr237NJGvexfo7OSiz8y5RAK11rnmXTOtqxBwfyO2cyHV51aS+aEjfhmTNkP34i+FPAtChaREm0DhCm7YZX8VknPOtBShO+jwuy3T2A+dQTNuCKdbfBwKXYEr8VmlTVTWF6urVrAVwKKUKtdYdVoljdfr0vdFa/xP4p1W18TeYt7t92TfbrW2x0zcKEzDszDpH39P4b6XURkwJsYcsx1KbthtPYKr6nompOgPmBv24ztCBk9b6M+Biq/rQBZi2IROSJhmsc8dWiymRnJ3+g9WOJllf0raTpDfeVjueXO3ElNI7tdYxq7R+Al1teQ7SWn+olJpF9hc7CdpU635QKVWBeav7HyR1gmAt/wHgbK3100opH9CZZTsKMRkS22GYN+LfBK7rwzbmeu0KIfZAVu2KCOBXSp2gtX4ac79+QWt9ZobpGzFt8G3VwLoMi/4npkmIB/gZpnTNrhp6KxAi+zPhoqSPA76Haa0/AM6ymr58D1Oie2jaZNm2qy/PruR1fqSUiiqlFmJePNo1WmqB3+i0fiKUUnMwgW3y+vtjO6lBfKX1Xb4klzBXYAJIB933XV+WtzFtebt6G8QwIlVwh6bRwAbd1THA2aTeqPPlbWvZKKW+QvZqGv/EtM9wWyWYb1jzbbGqmrwFjFNKHWQta7pS6k6rZBFIvI1bZa8P06g9nkMaw5hOiBxWe5a/WIFFO6YqUC7LSPYPzBtgu+rlFZh2KBmHgekPqwqowlRP6u1Y3oMpUStMqmr5GLDEClZQSl2ulLpQKVWtlPqHUqrUqk71Jt23f7DOHdtGoEaZzp9QSlUppe61XhCk60vaHsdUDRtlvax4lNx7IVyD6TzCrrZ8CabtZzXQDqy2lnmZleas+0cpdbFS6icAWusGzDGNY85Lp1WSWmT9e9ea7RpMJqwYUx13rFLqAOu3nwA/tf6OWVXBLwZ+pJJew+cg12tXCLGHse6/f8A0m/gG8Bfru+eAw+3nnzLDi/zBmu0NTFMDlFIzMC/HMnmTrrb5K6zPhwFjtNafkvszoT/3sDBQrJRyK6XmK6UeUEp5rZol75I5P5Btu/ry7Er3IOZl/IdWcx0wz+1LlVIuK7/yY2U6oFsLRJKC2ouzpLM3TwLnK6UKrefXJZg+LPJlkVLKqZQag9lHr2D23WFW3sOF6Z8iV3bzojmYashvWek9PemF8uX0bRsSx78P84ghSgLQoeleoFKZcQnvxVS5nKSU+m2e1/M9zM1gNXA05mbT7caotd6EqV7ytvXVx5iG6nbbvk5MCd6flFKrMNVTHtBapy/ra5iM9kpMhn1LpvWleRXzYKoFXsNUmfnUWsYiujLzObGqLV2K6WxgNaZa8eV9WUYWiTY5mNKwy62qQL0dy+cwb0eXJS3rUUynTu9byzsZeM5qZ/Is8I4yvRHfh3kIJRuscwcA6xifA1xlpfXfwIvWC4J0OafNagv7f5gOLT7BtAO5N326HtJ0FuZcW4PpGfpKzAuLpzGlnm9g9vGbZGjrlOQxYH+l1Brr3N4b+B2mffCrmE4U9sZ0+vCBUuoD4DPMMXwS8wb5DOAupdSnmE4c/jMtvWuAn2PaDOVazSina1cIsUf6GaZTtI+1GULkRUzHflsxbUMfse5nf6br2fM/wBSl1HpMj60PZ1guWusg5tm9QWsds15K+zDVcfvyTOjPPewjTEnaNkwJ6npgpZUfuBbz8i9dxu3q47Mr3YOkNpsB06/FRkxHdasxnTO9qrUOY1523mrt8xjZm1z0ts6ngfcwgf9mTM+4+bISk8dbCfxRa71Sa/0hplT5fWu9fRk6cIdS6kPMfr1aa91onYu/Al6x9nk50JcxTxPHXyX1MSKGJ0c8LnmWPZlSymEHikqpdzAPqccGaX11wJe01st31fqGA+vheZY2PewJkZPBvnaFECKf5B42NKgBjE2fZXlxYFJv7ZTFnk1KQPdgSqn/w7y1Qyk1G/PG7r0eZxrY+h7AvPVEKXUUpnSo1zZ4I5lS6hxgqwSfoi8G+9oVQoh8knuYEHs2qUe9Z/sdcKdVJTKKGdR4V76x+ilwm1LqEkwbuSVW9d09klLqH5iG+t06hBCiF4N97QohRD7JPWyYUkr9ELgwy8//neV7IVJIFVwhhBBCCCGEEINCquAKIYQQQgghhBgUEoAKIYQQQgghhBgUg94GtK6uNW91fkeNKqSxsSNfixs0ku7BN1zTLukefMM17XtyuqurSxy9TyV6Is9mSffuMFzTLukefMM17Xtyunt6Ng/rElC3O9ch84YWSffgG65pl3QPvuGadkm3GCqG6zGVdA++4Zp2SffgG65pl3RnNqwDUCGEEEIIIYQQw4cEoEIIIYQQQgghBkVObUCVUtcBBwNx4Bqt9TtJv00C7gW8wPta6yt2RUKFEEIIIYQQQgxvvZaAKqW+AMzSWh8CXAL8MW2S3wK/1VofCESVUpPzn0whhBBCCCGEEMNdLlVwjwYeBdBarwJGKaVKAZRSTuBw4HHr969rrTftmqQKIYQQQgghhBjOHPF4zz2vK6VuAp7SWj9mfX4FuERr/alSagzwCvAssB/witb6hz0tLxKJxodrj1BCCCGGJBmGZYDk2SyEECLPsj6b+zMOqCPt7wnAH4ANwFNKqRO11k9lmzmfY+FUV5dQV9eat+UNFkn34BuuaZd0D77hmvY9Od3V1SV5Ss2eS57Nku7dYbimXdI9+IZr2vfkdPf0bM4lAK0FxiZ9Hg9stf7eCWzUWn8GoJR6EZgLZA1AhRBCiGz++MffsnLlChwOB9dc8x3mzJm7u5MkhBBCiDzKpQ3o88CZAEqp/YBarXUrgNY6AqxTSs2ypt0f0LsioUIIIYaWYDjKjsYOguFoXpb3wQfvUVOzmb/+9TZ+8IOf8Pvf/yYvyxVCCCHE0NFrCajW+nWl1HtKqdeBGPB1pdRFQLPW+hHgm8DtVodEHwNP7ML0CiGE2M2isRjLXlrLB5/W0dASpKLUx757VbPoqJm4nP0fXvq9997h8MOPBGDq1Gm0trbQ3t5GUVFxnlIudqVYJEZHe4hwIEowEMbjcxEORhP/FxR66ewMUVDQ9X8kGk2Zpqdpd/U8NRsbcLtd/VpPtmkHY54Nn+3E7/cM+v7Kxzy1m5sGfK7sjvNrIOfKYM2T7Vxxe5zDYh8P5FzZnfs4fZ7hcK6kz4MDPK5d2ydATjkFrfUPtNaf11ofprVerrW+3Qo+0Vqvtb7/vNb6cq11bJemWAghxG617KW1vPBuDfUtQeJAfUuQF96tYdlLawe03Pr6esrLyxOfy8tHUV9fP7DEikHT0R7izhveZNP6Bu688U1qNjSl/N/eFuTOG1L/T5+mp2l39Ty3/vG1fq8n27SDMc8d17+xW/ZXPubJx7myO86vgZwrgzVPtnNluOzjgZwru3Mfp88zHM6V9HnuvOFN2loDu/R50WsvuPlWV9eatxXuyQ17d4fhmm4YvmmXdA++4Zr2wUp3MBzlx397k/qWYLffKkv9/OKrB+Hz5P7mNDnd//u/v+Tznz80UQp65ZWX8MMf/pTJk6f0tgzpBXeABvJstks+iTvYvrWFyqoi6ne2p/zvcDmIhqO4PK6U/51OZ7dp63e2M3psCbF4POd5si1/sObJth2DNU9f99eevo9lf8k+Hmr7eCjsr7ptbbz0zGoATj5nIWWjCigs8uJ0969mU0/P5v7XlRJCCLHHaW4L0pAh+ARobA3Q3Jb5t1xUVVWllHju3LmTqqqqfi9PDA675HP71haef2wl9Tvbu/2/c3sby257t9v/maZ9/rGV7NjW2qd5sk07WPNk247Bmqev+2tP38eyv2QfD7V9PBT2lx18Ajx+33LuvOFN83JxF5AAVAghRM7Kin1UlPoy/jaqxE9ZcebfcnHggQfz8ssvAqD1aqqqqigsLOr38oQQQggx9EgV3N1A0j34hmvaJd2Db7imfTDTfc8Ln/LCuzXdvv/S5yZy3pf26tOy0tN9ww1/YvnyD3A4HHz7299n1qzelydVcAdOquAOnap4w7X63nDax7K/ZB8PtX08FPaXVMEVQggxZC06aiZf+txEKkv9OB2m7eeXPjeRRUfNHPCyr7zyG9x4463ccMMtOQWfYvdzup0Ul/nBEc9aHe2em97C7XF1+z9b1bJ4PN6nebJNO1jz9FQVbzDm6ev+2tP3sewv2cdDbR8Phf3l9nb131A1upjiMn+/g8/eSAnobiDpHnzDNe2S7sE3XNO+O9IdDEdpbgtSVuzrU8dDyfKRbikBHbh8PJvtklCfzzMsh2GJRKLDchiWSDg2bIdhicXiw3IYloGcK7tziJBIODZsh2Hpy7kylIZhGQ7nSqZhWEZVFBGODmyM756ezRKA7gaS7sE3XNMu6R58wzXte3K6JQAdOHk2S7p3h+Gadkn34Buuad+T0y1VcIUQQgghhBBC7HYSgAohhBBCCCGEGBQSgAohhBBCCCGEGBQSgAohhBBCCCGEGBQSgAohhBgy1q1by9lnn8JDDy3b3UkRQgghxC4gAagQQog+C0XDPX7uj87OTq677v/Yf/8DB7wsIYQQQgxNEoAKIYTok7qOnfz2vb/wxLrnAHhi3XP89r2/UNexc0DL9Xg8/OY3f6CqqiofyRRCCCHEEOTe3QkQQggxfISiYW5ecRc1bbVsbd/O5pYaVjeuJRqPcvOKu/jO/l/H6/L0a9lutxu3Wx5LQgghxEgmJaBCCCFy5nV5mFc1B5fDRTQeZWWDJhqP4nK4mFc1p9/BpxBCCCH2DBKACiGE6JOTph/H7FEzU76bPWomJ00/bjelSAghhBDDhQSgQggh+uSJdc+xunFtynerG9cm2oQKIYQQQmQjAagQQoichaJhVuxclah2O7dCJarjrti5akC94a5evYqrrrqMZ555kgceuI+rrrqMlpbmPKZeCCGEELub9PYghBAiZ16Xh0vnnc/NK+5iXtUcTpp+HE+se44VO1dx6bzzB9QGdPbsOfz5zzflMbVCCCGEGGokABVCCNEn1YVVKb3dnjT9OI6bcpR0QCSEEEKIXkkVXCGEEH2WHmxK8CmEEEKIXEgAKoQQQgghhBBiUEgAKoQQQgghhBBiUEgAKoQQQgghhBBiUEgAKoQQQgghhBBiUEgvuEIIIYaM66//A8uXf0g0GmXJkov4wheO2t1JEkIIIUQeSQAqhBBiSHj//XdZt+4z/vrX22hubuLiixdLACqEEEKMMBKACiGE6JN4LEZ4x46U7zyjR+NwDqxVx8KF+zJnzlwAiotLCAQCRKNRXC7XgJYrhBBCiKFDAlAhhBB9Et6xgw0//kHKd1N/8Su8Y8cOaLkul4uCggIAnnzyMQ455PMSfAohhBAjjASgQgghhpRXXnmZJ598jOuu+8vuTooQQggh8kwCUCGEEEPGW2+9wR133Mpvf/sniouLd3dyhBBCCJFnEoAKIYQYEtra2rj++j/w+99fT2lp2e5OjhBCCCF2AQlAhRBC9Iln9Gim/uJX3b4bqBdffJ6mpiZ+8pOu9qU//vHPGTvAtqVCCCGEGDokABVCCNEnDqdzwB0OZXLKKadzyimn5325QgghhBg6BtZnvhBCCCGEEEIIkSMJQIUQQgghhBBCDAoJQIUQQgghhBBCDAoJQIUQQgghhBBCDAoJQIUQQgghhBBCDAoJQIUQQgghhBBCDIqchmFRSl0HHAzEgWu01u8k/bYB2AxEra8Wa6235DmdQgghRrhAIMAvf3ktjY0NBINBLrroUg499PDdnSwhhBBC5FGvAahS6gvALK31IUqpOcCtwCFpkx2vtW7bFQkUQggx9MRicVqaOgEoLS/A6XQMeJmvvfZvZs+ew+LFF7Jt21a++c2vSwAqhBBCjDC5lIAeDTwKoLVepZQapZQq1Vq37NKUCSGEGLJamjq596a3ATj3sgMprygc8DKPPvrYxN/bt29n9OjRA16mEEIIIYaWXALQscB7SZ/rrO+SA9AblVJTgVeBH2qt43lLoRBCiCHDLvlsaQokvkv+Ox+loVdcsZQdO7bz61//fkDLEUIIIcTQ44jHe44VlVI3AU9prR+zPr8KLNVaf2p9vgB4FmjAlJTerrV+MNvyIpFo3O125Sf1QgghBlV9XRt/+dU/s/7+9R98kcrq4gGvZ9WqVXzve9/j8ccfx+HoNaAdeP3fPZw8m4UQQuRZ1mdzLiWgtZgST9t4YKv9QWt9h/23UuppYD6QNQBtbOzIYZW5qa4uoa6uNW/LGyyS7sE3XNMu6R58wzXtg5Xupoae7+ENDe3EyL0STHK6V69exahRoxgzZixVVRMJhcKsWbOJUaMqel2GGBh5Nku6d4fhmnZJ9+Abrmnfk9Pd07M5lwD0eeBnwF+VUvsBtVrrVgClVBlwP3CS1joEfIEegk8hhBDDW2l5AedediAtTQGeuv8jAE48ewGl5f7E7/21fPn7bNu2jWuu+Q4NDfV0dHRQVlaej2QLIYQQYojoNQDVWr+ulHpPKfU6EAO+rpS6CGjWWj9ilXq+qZTqBD5AAlAhhBixnE5Htw6HSsv9eemE6NRTz+B//ue/+NrXLiUYDPLtb38fp1OGqxZCCCFGkpzGAdVa/yDtq+VJv/0B+EM+EyWEEGLP4/P5ufbaX+7uZAghhBBiF8opABVCCCGS2VVx7b+FEEIIIXIhAagQQog+y1QVVwghhBCiN9K4RgghhBBCCCHEoJAAVAghhBBCCCHEoJAAVAghhBBCCCHEoJAAVAghhBBCCCHEoJAAVAghxJASDAY4++xTePrpJ3Z3UoQQQgiRZxKACiGE6LdYLJz3Zd5++y2UlpblfblCCCGE2P0kABVCCNEvHU2r2bb6JjqaVudtmRs3bmDDhvUccsiheVumEEIIIYYOCUCFEEL0WUfTaho2P0UkWE/D5qfyFoT++c/X8Y1vfCsvyxJCCCHE0CMBqBBCiD6xg89YpB2AWKQ9L0HoM888ydy58xk/fkI+kimEEEKIIci9uxMghBBi+IjFwjTVvpgIPhPfR9ppqn0Rf+kMnE5Pv5b9xhuvUVu7hddff5W6uh14PB6qq0dzwAEH5SPpQgghhBgCJAAVQgiRM6fTQ/n4o1NKQAGc7iLKxx/d7+AT4Oc//5/E37fc8lfGjRsvwacQQggxwkgVXCGEEH1SWD6bikkn4nQXASb4rJh0IoXls3dzyoQQQggx1EkJqBBCiD6zg82m2hcpH3903oPPSy65PK/LE0IIIcTQIAGoEEKIfiksnz2gNp9CCCGE2PNIFVwhhBD9JsGnEEIIIfpCAlAhhBBCCCGEEINCAlAhhBBCCCGEEINCAlAhhBBCCCGEEINCAlAhhBBCCCGEEINCesEVQggxJLz//rv89Kc/YOrU6QDMmDGTb33re7s5VUIIIYTIJwlAhRBC9Fs4FsPjzF9lmn322Y9f/OLXeVueEEIIIYYWqYIrhBCiX4LRGDetqiEUje3upAghhBBimJAAVAghRL+8uKWeLR1BXthSn7dlbtiwnu9//1tceeUlvPPOm3lbrhBCCCGGBqmCK4QQok+C0Rgvbqnng/oWAD6obwXg6AmV+Fz9f685adJkLr74qxx11DHU1m7hG9+4nGXLHsXj8eQl3UIIIYTY/aQEVAghRM7CsRg3r67h1e1NtEdM1dv2SJRXtzdx8+oawrH+V8etrh7N0Ucfi8PhYMKEiVRWVlJXtyNfSRdCCCHEECABqBBCiJx5nE4unT2Rw8aUU+R2AVDkdnHYmHK+OnvigDokev75Z7jnnjsBqK/fSUNDA9XVo/OSbiGEEEIMDVIFVwghRJ/4XE5OmFwNwKvbm9i3siTxeSAOO+wIrr32x7z66r8Ih8N897s/kOq3QgghxAgjAagQQoh+OXpCJetbO/nShMq8LK+wsIhf//q6vCxLCCGEEEOTBKBCCCH6xedyctmcgVW7FUIIIcSeRXINQggh+k2CTyGEEEL0heQchBBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCglAhRBCCCGEEEIMCncuEymlrgMOBuLANVrrdzJM8z/AIVrrI/OaQiGEEEIIIYQQI0KvJaBKqS8As7TWhwCXAH/MMM3ewBH5T54QQgghhBBCiJEilyq4RwOPAmitVwGjlFKladP8FvhRfpMmhBBCCCGEEGIkyaUK7ljgvaTPddZ3LQBKqYuAfwEbclnhqFGFuN2uPiWyJ9XVJXlb1mDaneluauigrTUAQHGJn/KKwpznHa77G4Zv2iXdg2+4pl3SLfpLns2GpHvwDde0S7oH33BNu6S7u5zagKZx2H8opSqAi4EvARNymbmxsaMfq8ysurqEurrWvC1vsOSa7lgkRkd7iMIiL053/vqLamsOcOcNbwKw5MqDCUejOc03XPc3DN+0S7oH33BN+56c7uH6cB9K5Nks6d4dhmvaJd2Db7imfU9Od0/P5lyimlpMiadtPLDV+vsooBp4BXgE2M/qsEjkQUd7iDtveJOO9lBelheLxGhrDtDc0Jn4rrmhk7bmALFILC/rGMns/Sf7SgghhBBCiP7JJQB9HjgTQCm1H1CrtW4F0Fo/qLXeW2t9MHAa8L7W+lu7LLV7iPRA0Q4SBxr82AHt48uWJ757fNnyvAa5I1m+XwgIIYQQQgixp+m1Cq7W+nWl1HtKqdeBGPB1q91ns9b6kV2dwD2RHejYkgPGJVceTHGZf3cka49lV4VOfiFgy3f16D2NvW9B9qUQQgghxJ4gpzagWusfpH21PMM0G4AjB54ksasUFnlZcuXBNDd0JoLakxctpKyigMIi725O3dAlLwR2neR9K/tyZNpVbdmFEEIIMTz1pxMisYulB4p2kGj/1l9Ot7NbBr+sokAy/b3YVcdjT5ZeqgxdJcsSqIws9ksGecEghBBCCJAAdEhKDxTzHSTaAZX9t+jZrj4ee6L0UmXoKlmWQEUIIYQQYuSSAHQIswPFfAeJmUpChRhMUh185JO200IIIYTIRALQIUwCxaFlV70Q2BNJdfCRT9pOCyGEECITCUCFyJG8EBAid9J2WgghhBCZSAAqhNhtpD3yyCVtp4UQQgiRiQSgQojdRkqVRz6pui6EEEKIZBKACiGE2GXkJYMQQggxvP3xj79l5coVOBwOrrnmO8yZM3dAy5NuCIUQQgghhBBiBAiGo+xo7CAYjuZleR988B41NZv5619v4wc/+Am///1vBrxMKQEVQvSZPcSGDKcxstjHFWSoFCGEEGI4icZiLHtpLR98WkdDS5CKUh/77lXNoqNm4nL2/3n+3nvvcPjhRwIwdeo0WltbaG9vo6iouN/LlNyFEKLP7CE27GBFjAz2cZVjK4QQQgwvy15aywvv1lDfEiQO1LcEeeHdGpa9tHZAy62vr6e8vDzxubx8FPX19QNapgSgQoicxCIx2poDtDUHaG7oBKC5oZO25gCxSGw3p04IIYQQYs8UDEf54NO6jL998OnOvFXHBYjH4wNexh5TBVeqlgkxMHbpWLLHly0HYMmVBw96RzNyTeePvS/tFwtA4m/Zt0IIIcTQ1twWpKElmPG3xtYAzW1BRo8q7Neyq6qqUko8d+7cSVVVVb+WZdtjchVStUyIkUWu6fyx96X9QgHMywXZt0IIIcTQV1bso6LUl/G3USV+yooz/5aLAw88mJdffhEArVdTVVVFYWFRv5cHe0AJ6Eh6sy8dv+x6so+zs8dzBHMNPb5sOScvWkhZRcGgjvE4kq7pocI+tvZxPer42VSPK8HtdlJQION3CiGEEEOZz+Ni372qeeHdmm6/7btXFT6Pq9/Lnj9/IUrN4YorluJwOPj2t78/kKQCe0AAOtSqDQ6EvS3DLd3Diezj7DKN51hWUTDo+2kkXdNDRfqxdXtdLLv1HcDap17Zp0IIIcRQtuiomYBp89nYGmBUiZ9996pKfD8QV175jQEvI9mID0DT3+wDu6XURoiRxL6udsc1JNf0rmPv21h04B0MCCGEEGLwuJxOzvvSXpzxhRk0twUpK/YNqORzVxrxAehQKbXpr+SOVpJ7HgWpbpgvso/7LtN1tTvXPZyu6eGgtTmQ+FuuBSGEEGL48Hlc/e5waLCM+AB0uJPqhrue7GMhDLkWhBBCCLGr7TEBaHIHKsOpmt5Q6fhlJNvT9/Fw7XhpsK7p4bp/bH0ZrkaqNwshhBBiVxt+ual+sqvtFZf5h1UmMjndZRUFQFd1w+G0HfkSi8Roaw4Qi8Tytsw9fR/bpV7DbbiNwbqmh+v+sfVluBp7n9rXAexZ14IQQgghdr09pgR0JNidHb8MFbu6l9o9ZR9Lu9fepQ/3kjzsy3DYRwMZrma41hgRQgghxNAnAegwsjs7ftlT7Cn7WNr69S59H9n7B3btPspXld+BHOM95ToQQgghRO/WrVvLD37wHRYtOo8zzlg04OVJACqGPCmty789vd3rUCZj0QohhBCiP0LRMF6XJ+vn/ujs7OS66/6P/fc/cKDJS5AAVAx5UlqXfzKUSe/SO+SxA3T7t6FOOhQSQggh9hx1HTu5ecVdzKuaw0nTj+OJdc+xYucqLp13PtWFVf1ersfj4Te/+QN33fX3vKVVAlAx5BUWeVl82UHUbW/D53PxxP0fSUZa7HLpQfquDtDz3eZUXjIIIYQQe4ZQNMzNK+6ipq2Wre3b2dxSw+rGtUTjUW5ecRff2f/r/S4JdbvduN35DRklABW7VU9DRCT/1toc4PnHVrJo6QEAlI3qX0a6L0NSjHT2vigo2DM6XuqvweqYKh9tTjO1H5UOhYQQQoiRzevyMK9qDlvbtxONR1nZoAFwOVzMq5oz4Gq4+SYBqNitkjPd6ZnsTFVv67a2cuwpc/H4XANa31HHz2bcpDKKS317bBAqbQ1zM1gd8uSjym+mYyodCgkhhBAj30nTj2NzS00i+ASYPWomJ00/bjemKrM9M+cthgU7Q77kyoM5edFCAIpLfYwZX4LH07cAtKmhg7bmQKJao9vr4u6b3qKtJZjXMUWF6K/0MTjt6rIyBqcQQgghevPEuudY3bg25bvVjWt5Yt1zuylF2UmuRuwWsUgsJSAE0+atrTmQCAjtDHmmTHlfM+RtrQHuvOFN2lqCHHvKXCKhKABbNzfT1hJMWe9Il77v7f0+1PeBne6hns6B6muVX3u/1Gxs6HZMR/J+EkIIIYQRioZZsXMV0XgUl8PF3AqFy+EiGo+yYucqQtFwv5e9evUqrrrqMp555kkeeOA+rrrqMlpamgeUXqmCK3aLwe7ZtrjEz5IrDyYUjLLs1ncS37/0zOrE33tKVdTdNb7lQPVUXXsk6WuVWeklWgghhNizeV0eLp13ftZecAfSBnT27Dn8+c835TG1EoCOOPkaxH5X6+sQEQPtCKa8opBwNEqwM5woAX3pmdXDbmiNfBjuw4uIVPbx9Hhc7NzeJmO6CiGEEHug6sKqlN5uT5p+HMdNOWrIdUAEUgV3xLFLQ+yeXoeq9PZu0HP1Wnv6gQbV4VCU5x9bidvrSlnnSGlnZ1fH7Knq5XBra5hLde2RIJdjl4l9PCdOqRhwVXUhhBBCDF/pweZQDD5BSkBHjHyPIThYBnuICHt9sWh8l69rd+hLz7aDNbzIQO0pVUzz0SvxcDmmQgghhNhzDesA1O7ZFIZ2kAWpVWN3hfRMeltLkEAgQiQUZcLU8iGbSR/sISLs9cUisRGVUe/PC4jhMjxHYZGXJVccTFNDB0/c/xHQc3XtPdlwOabJ4/F6XP0bUkkIIYQQw9OwDkDtnk1h6JeEJJduDAa318Xzj63k2FPmDsr6hpvhklHPVS4dCyVn+of6C5tkTrcTHBAMRhPf2VVMR4LhWnthIJLP16VXH4qvcGhWERJCCCFE/g3LANTOsLU2BxPf2Zm2kZphS5ceTKR3LDOqshCA6jHFUkokgOHXi2zyOd7c0EkkFGXR0gNwu50UFIycc3q49koshBBCCNEfwzIAzdYm7KjjZzNuUhnFpb4hE4RmKt2o2dhAOBwdULCcKZgoLPISi8Y59pS5dLSZ4Ly1OYDT5dhjAvORJBaJUbOxAY/X1euxG4k922a6zm1LrjyYYu/ICMxG4rHLJv1+CNCws4OSMp/co4QQQogh6vrr/8Dy5R8SjUZZsuQivvCFowa0vGEZgGbj9rq4+6a3hlSpQX9KN/o7lEpHe4i7b3or5buR2FnLnqIvndKkVylOrqKarRdZGBk1BvI99FA8FqXI30kw7CUS3fXtE3s6diNNppcKj97zASD3KCGEEGIoev/9d1m37jP++tfbaG5u4uKLF++ZAahdYtDaHOTRez7gqONnUz2uJFHqN5TaUGUq3agaU5woAc2kp8AjUwmC/XdBQVePsumlKSOtJGUocTodxGL561V3IG0CM/WCOlx7kU3uIbmn8zkfvcfaXK44LQ1rWfvBrUzY6xR8JXsPShAKI68H20wvBjKN/3vqefsmSkCFEEII0T/xWIzwjh0p33lGj8bhHFgctHDhvsyZY/qUKS4uIRAIEI1GcQ2gE8FhGYDaJQYej9lwt9fFslvfSfw+lNpQZSrdmDilgrq61m7TZgs8nE4HBYUeHC5nn4OJkVyakg8DLT1zuWLEQxvx+0cTCBflJU0DaROYqXOlTJn+4fBiItO29HQ+l5bG8Hg6CYYLMv7eG5crDuEtrP3odojH2KIfYYJi0ILQTNvrcIDf00Ek5iEc2X0d9TgcDpzOGNGoI+d5Mr0YyLSNFVWF0gmREEIIMUDhHTvY8OMfpHw39Re/wjt27ICW63K5KCgweasnn3yMQw75/ICCTximAaituMSftzEd812NL10upRuZAo/iUh9nnDsJr7uYCKNyDiZGWmlKLvpzDAdSeuZyxYh2rGXTJ/fhLahg6vyLswahu/r86klfA7mhKNP5nPzC5rhTptFQ8yzRSAdjpp9OKOzv0352OMDjaOJTK/i0bdGPMHVeIU7fzLyWcrtcDqK93LccDvC521i//FbKqudROvZwIlEPBb4ggZA/r+npOR0OvM5GAu21eIpUr8F4LiX4yaXbxSV+wtFoxmUJIYQQYmh45ZWXefLJx7juur8MeFk5BaBKqeuAg4E4cI3W+p2k374KXAJEgeXA17XWg5IzKq8oJByNJsZ0HEgnHvmsxpdJLsN+pAeXp5+/HxMnhdnw0S00bXExbZ9LCdF9TM9MwYS9PrcrSiye3yqiQ1VPxzB9zFh7+v4OfZEcfAKEOhvY8PFtWYPQvpxfu6pTmuRM/1B7MdHbEDGZrh97nx53yjTK/O/QsvMTALaueZBxs84kEi/Mef3xOMQdhZSPXkDT9g8T3xeUTMBbOJ5AOH/Xj9sVIdK5Dn/xJAKhzKW1dvC54aNbCQWaqNv8Ki53AcUVM1jz7h1MnbcEnGN3+XVtB5/rPvwb0UgnE9RpvZYI51KCn3w8yysKM9YIEUIIIcTQ8NZbb3DHHbfy29/+ieLi4gEvr9cAVCn1BWCW1voQpdQc4FbgEOu3QuAc4HCtdVgp9ZL12+sDTlkfjJROPJK3o7jUlwg+oxETOK3/8GYThEbLcwom3O4IgaaPKCqbSthZSSQUHZbjQPYmlxKX9DFjgQENfeHzhPhUP5zyXaizgfotrzBqwrGEwv3ft7vqfB7KY5/2Z4iYwiIvX/vegTTWPkdL3SeJ7ztbN7Bj3cOM2+ssgmFfzmkIhn1UTzkOhwMat31IQckEJs05j0A/q/Rm4nKE6WxcztbPnjbL3/u8jEGo39PJ+uUm+ATwFlTgKxzFug9vIRYNs275LUxfeMkuDULTg08gp2rJe1KvvkIIIcRI19bWxvXX/4Hf//56SkvL8rLMXEpAjwYeBdBar1JKjVJKlWqtW7TWHdbvdjBaBmzLS8r6oT/VTofqIPDHnzqdzavuSwSfAJFwOzWr7mfyvIvojHt6zKS73RE66t9j27rncLn9TN/nUtoDxcNqHMhc9afN5EAzyZ1BP9MXXsK65TcTi4YBKKlUVEw4kmBS8DnQDoWWXn0oHu/gdIKTL153iNbGdbhdFX2urgm599DrdDtxuvyUj15IS90KTAUNo3zsvkRjfW9hEAz7mLjXSfgKqiit3jevwafbFUkEnwCdrVvY/Mk9GYPQSMzDqLGfY/uGF3B5Chk/4zg2rXowca7FYxHWLb+FGft8lbBjNPF470Fob6XM3dLrjtC45e1E8Gnbvv4fzNxvFpGoK2PV8pHyQlAIIYQYTjyjRzP1F7/q9t1Avfji8zQ1NfGTn3S1L/3xj3/O2AG0Lc0lhzYWeC/pc531XYv9hVLqB8A1wO+11ut6WtioUYW43fnLUFdXlwxo/pqNDVmDl0u/eTjhkMnwFZf4Ka9IrdIXj5l2Sw6n2Z54PI7DkVsnHT2l2+Ny0eFzUzL5fD778G9Ewx3me18p0xYspqC4gp4KvyOhDupq3mbbuucAiEYCrPvwZibPXUpxqY+2liCtzUE8HlfG7epPupsaOmhrDfR5efkQ7Ahn/P6o42fj8bhobwnS0tQVyNvbPqqiKNGRVdWYYiZOqUiZ394myHL848XM2u8y1rx/E8XlM5gy9wy8/vKUabZvbWDntu088+h6IPX8Wnr1oUwcl583SbtKNBwgHGrFV1CROM97Eg62smXNi9TXvsOUvc+iYuxCXO7spZDp1x907aNc909z0wymzFvMxhV3A3Em730mFWP36XG9vRk3/SicLg8Du7sY9nlUUB5i3bpnU37rbN1CW/0Kxkw5Aqcr9XZcXHw4TqeDbRv+STwexeMrJ9hRl/jd4yvDV1BCWVHX3aCn+0ryvs513xb6jyEaDdC47UMA3N5i9tr/MgpKqilKWubSqw+l2OdJuV7sa8vjcfV6nx7ofVwM3FB7Nu8uku7BN1zTLukefMM17YOa7jH5y1fa6b700gu59NIL87Zc6F8nRN0iLK31r5RSfwCeVkq9qrV+LdvMjY0d/VhlZtXVJX1uO5ReCuDxurKWhAUDYe68savEMLmjDKcTnNFa4vEYeCbiIEo8tBlPwZis7br6km6P300wWs70fb7Kug//htPpZtrCS2gPFNLW2fO8Bb5O6jan1oKORgI0bv+IGWosy9/ZkTL2Xq4dgPSU7rbmQKKN42B3KJLtGMaicWo2NvH8YytTpk/edls4HO22bfY22dNm2i6Ho5KZ+11J3OGnudUFrV3LcLliOKPrKfG9yxXfPokbf/ceJ5/ddX55vK5ez4Pq6hLq69uIx+PkUMiVV253lEDTR9SufYppCy4Cz0TCweydKXndIRpqXqBh67sAbPzkAWKxOJ7izB3X+LzhHquPZjom2bj8U5k6/3yi4Q7chYqGxhAQ6jZdLp1BVVeXUN8QAAIZf+8r+zwaO76Y476yiJ2bliU6Oho17gCKRi2kvqEz47yFlQcw1uHC4x/NlHkXsnHF3wl21FmdXl1Ea4ef1o7WRLp72l/hcDTl79z2rYOqyccRj0Nb41qmL7yU1vYitm03gbBdWr1zexvBQCQxDrFdE2XJlQf3ep735z6eaRliYHb3s3kokHQPvuGadkn34Buuad+T093TszmXALQWU+JpGw9sBVBKVQDztNb/1lp3KqWeAQ4Fsgagu0JfqpZlamuWqbpYLBKjrSWYcRl28Ll++W3EiTNzv8sIdtSzedUDPbbrAvC4QoRDbTltVzweJ2QFoQ6Hk2CkJKcgJBAqYNrCS1i//BbCQVNQXVJ1AJtqJrP8nZqc1p1PblcUlzPSp/Z4fZGtyl9bc4BIKMriyw6ivS2UCDzTew3uqXdVW7ZqofE4BCLl3dKU3kkR8cc5+awj+lwdMR6P4Ypvx+UuJBgp7nMQ2pfed5On9frjJvhc8wQA6z+6nWkLLiIcqs7YmZLL5SDY+mki+LRtXv0g6qBvEomWpnzv9wTYuuZRxkw7houu+jwNde0Ze3X2uELEcfValTcadeL0TsHti+fUQU4+qqDnum+T22t3doaommyC0FFj96diwlEEI9mrfIcjbgpG7U845iIehinzLmTbZ08ydsaJOQ/7M5BqztDVNnbM1C/R0VlAa3MgEWiCqWkQCERoa2nu1/KFEEIIsWfJJWfwPHAmgFJqP6BWa22HxB7gdqWUXQfsQEDnPZW9sDOVd97wZiIQTReLxGhrDnTLhLU1B4hFYintR+3gc+vm5m7TOuKxruAzHqWkYiYdzRvYvOoBoKtdl8fRTiwSS0mD1x2mZftrbN/wb7zuzNVG05kgtIxAOLfg08wDwUgJ0xZegsdXSuWEzzNq/JGMqqpMTHPyooUDHqbF3qfJ+zV5n8YiMSLBAKHWVWxd8xB+T+aAPl8Ki7wsveZQiJNI00vPrKa1OUBRSVfwaweBTrczEbwmZ5Lt88kOiAqLvbS1NHPXX9/Ken4lcznTgk+gvekz/I5/U1GZewTpdDpoa1zPug9vZv3yW/C528ixhne3bckl3fa04VCUaMf6RPAJQDzG+o9up6S4A6+v+3uraDSOv3QWZdXzUr4fP/NEwtHUqst+T4AafR+tDZ+y7sObKS9ro6K6K5iyj4/fH6F5678INH+M2917qXos5iSaJfhMv/7t87SzLUQ81nWdOp19H+eyp32bHKQWl/nxFXh57slmZu1/FVUTjyYc7f2lTCTqSlz7gXAhY2ae3qcxZ9PPZzDVnHM9L8AEoZ2hQtrbzH1x8WUHseTKgzl50ULcXhfPP7aSl55ZDcD0vcopKgqx7NZ3c16+EEIIIfYcvZaAaq1fV0q9p5R6HYgBX1dKXQQ0a60fUUr9HPinUiqCGYbl8V2a4n5K76gGutqa2aUhhUVeOtpDxKLxlDf8ydN+4wcHsW3d88TjJkM8duqRrHn/5pRpO1u30LDtHYoqPo/D4TVVMYnSvO1V6ja/AkAsHqds9CGEkgaXz1aS25+ql3YQOn2fy4jGPIQiHsoqujLX+egYJH2f+vxuCgpDPPPwWo4/fT5+P3Q2r6Rxy1MA1K55iPGzziCwC0tCw+2hRLVp2+PLlnPU8bNZfNlBOF2OXoPu5A6KXnhqFWeeN4VQ66tc9f2vEAr3HrDHsdsFO0juGMfpcufcRtjpdOCKbWXN8luJxyKEg82sX34L0xZe0q+S0GySz7lEdcodbUydNo6Ckgl0tm5JTDtq9D60t7sIBSMZO1MKhn2MnnaiWVbdCsbPPBF/+UIi0a7bjB18djRvMuuPBvnsg78xfZ9LueiqzxONmpdBXneIptp/sXPLGwCMnwX+8vlEIv1ro5apo6rS8gJOWzQet8NL3DkGBzEc0a0EO0dj3q31vr9Ky/1UjIoQDHUSx9ettM9e79JrDiXcHoI4bKtto6HRT1Fp/17+BEPdb9uxSIyajQ14vK5uach17OBMHA5wu2KEI13LfOmZ1SklyG0bmlh82UG0NgdY8cFGDj3CSWvdMq74zkU5XS9CCCGE2LPk1AZUa/2DtK+WJ/12O3B7/pKUO3tsx/5WLUtnZxaPOn42x54yl0gomnirf9LZCxg7oRCPFybOXsTmT+6hs3ULNfoJJs85nU2rHk606yosm0194zTagh1MntJJNFBPW/PGRPAJULfxZQBKqw8hHPWkrB/y00ttPA6doa7Sp3yPA1lY5GXxZQdRt72NwkI3xcWdtO+4n3MuPAOHy02wbVUi+ATThqx2zUOMm3U6wfCu6RUzeRuT24RWjSnOmDnPJFEq6nJw5nlTaKq9l2i4g2i0k4lqUa89o8ZiTlz+6UyZdx4bV9wDxCmpVIydcWrO1ZD93iBr37ubeCyS+C4cbGbr2icYN+ssAhmCkMT6MwSV2a6LjC9m7luO0+ngqu+fQ+2a++hs3cKoMftRWzeXl+5430yTpadhOwitmngAuMcnx9+WCOFAc8o3sViYaLidotIKYjFHt+AToHbN4yYILZvfa3VcMIGT39tJJOohHOm+r+zgs2HzPdRvijFzv8sJdtazaeV9FJVNZoI6O+NxTt5fpeV+Tl00gXUf/oXiygMpG3MwYOZJr/ba3hpi2a3vsPTqQ1lyxcEUFOY3MEuvWpxePTiXsYPTmbFIW2na/gGl1QfR0BDvdj7FovFEQDp6XAGHljhp2PwoAJtW3Jb3FyZCCCGEGP6GdeMce2zHXKqW2YHJyYsWAuB0OThn6f6JKpvJ1XAnTC3H73fjThr+Yuz4QlxsYN2HN0I8wqS9z6OgZALxOPiKpjJpzhJwOCksm01b6CBeenYzRYUdbFp5G631qzMOk+B0mOX3Vj04X+yMaHqV076y09vRHqK1OcC/ntNMmuKgddsyQoFGNnx0Gw4acbr8pPdZ5fIUdvsun5K30e7sp6yigIlTKvq0zQ6Hg7KSjkTwCdDRvIkavQy/J3OHMcmiUQdOKwgtrZydNfj0e8MZq30GQj6mLrgIp6trHl/haMbNOqXH4BNSq6Tb10Zfq1zGYnEam1xM2vs8xs04jspJxzBh6rjE9WNX4U6uxm2CvjChiI/y6r1xxptprXsNr7trncFIsVU13OqlzeFk2vwLwDOJWMzeD3GisQwdCEVDmEoYPbMDp8/ev5H2ne/gcUdSrv/S8gKWfHUaDZvvIRYNUlQ2kY6WDWxaeR8Qp715Y6/H2Q4+G61ltOx4hUDzu3isqvXp1V4b6805VLOxCRzkrV1ktqrFbS3Bbsfb3ge5VL239+H65bewY+PL1Ne8SM362m7nk10dt6TUg5tNieATSJTa+zztedlWIYQQQowM/ekFd8goLvHnXLUsuRTA6XJwxuJZlBZvwOmZya1/eCtjh0R21bLCIgeu+AY2f3I/AOuX38LUBZcwfq9zgDjr1wZxOEoYO3MptTVhXnp2M2eeP532HfcTDrZQX/suVRMOpHrSYdRtfhWAMVOPprj6QMIRDx3tgV6rBw8VdvtYu4qyy+Xk3KUz2bTyNiIh0zQ4Ho+y7oObGK8upnrqGdRteAiIUzhqHqPGH9unzoj60olOuv6MC2tzOOLEwm0p47AChDrrgUiWeVKrS0ejDlz+6YyZMTFL8NlBzar7Gb/XSUScVSk9wsZicSLOKvb63OV8+u5f8fjKmDL/AgKh3oe4yVYKnOm66G3aQMhJQcVBhCJQnNSzd3oJmglY2qhZ9QATZ59Fe3MTn314M7FIgFg0TPm4wwlFvFbVcBOEbvjoVibsdSp4JhGNdQXhoYiPyknHANC41YwANXb6lymq3C9jaWYyO3Ba9+HNREKtbFv/D8YCRVUH4HSb9B557ES2r3+cWNS0SR43/RirGn3X/u9o3kTT9rcpGXME4XBX2uz9VVUVZe17f04sA6Bu0z9xewrxle2baI/c3hqisb4Dj3Xu+nyuxAuvfAShySWydmdAgdpWIiHTRCC95DvTvcThcKS8IEsOPu1OzBq3vcuEsXDp1Ydz8x/f6zZursPlwldYidPlS9knBcXjID6sHzNCCCHEHi0QCPDLX15LY2MDwWCQiy66lEMPPXxAyxzWOYPyisJuQ2P0VrWssMjLVd/7HFs+vYct27dSPfloPnfI2G5t2sC0dbrkmoNxOzaxyQo+AcLBFjZ8dAslY8/lzptWASbzFwz5CAadTJ5WhpvNicwbwM4tb1M16VDGTP0CDqeHosoDCFvtPwfSRmuwdbSHEqUeTpeD5oZOQsFO3J7CRAAKZsxSj8/Lv16IceSXFtHWsIry8ccQifpx9nDWpQecA+m1NFuGOxexGLg8E5k2/wLWf3wHxGO4vUVMW3gpwUj3bqVdrjgeGok5igkl9WoajTqIJnU043ZGiOPC4+5k04o7CbRvZ90HNzN930uJuatxOYMEQx4rDXGKyiYxY9/LcLoLIB7F6wllbFfncJjOjyJRZ5+qXOYybSQp3s4U1NvB54aPbjWdZnVuZdOqR4hZwfvOGtMpdrcgdJ/LCYW9KcGnLRT2JoJQX0F1TsEngN/TwWcf3JxyLm5b/w/GOd34rcDQ4aiksuJcM6RJ5062rHmaSbNPZfPqRxPV6EsqZlE29mCCodS02fsrFg9TOf4g6jb/O/Gbx1dGZ2gcoeYwRaU+wu2m2m2yJ+7/CBj4iyWXK47PE6KzrSt9dmdAyXp7keVwgMexE6fbRyBs+pJzOeN0tmxKuX8BNO9cQdWkw3E4up8j9guT6ftcyroPbyYWDVol/6fssjbfQgghhEgVi8VpaTIxTWl5QZ86V8zmtdf+zezZc1i8+EK2bdvKN7/59QEHoMO6Cq6tL1XLCguDbPn0HgJtWwGo2/Qie83aTu2m7Sk96drL9Pp8+AqqcLlTM28FJRMpqyhJVOt76ZnVeNxOxk0qY8e2dgrLplM16ZDE9E63n1Fj9qWk+vOMmXwYwYArUcXWztTaJQqQ2lPr7pDcw216NeCXnlmN0+VIpPmhu9cyYfZi/EVjAKiaeAhT551DNFaCXrmTCFOomnI8MUdhr9uT6Ik1HM1ctTDP1ZJ7Eo05wDOJafMvwOMrZdrCSwlFyxKlnPY+chAlFljHp+/+hYYtL6VUOU3mcUXobF6Ox9mQCD7BdMSz+ZMHcMW3sX3to/g9qaWuESqIhttZ8+6faaj5J15P6vLtICLY8jFuVyTxHXTvGbinfddTibHLGaPAG8zYa7AdfIYCTRSUjKOzdWsi+LQ1163A5eyKZONx6Az6MgafAH5vACcRKid+KefgEyAa81A+ekFq2t0FhKLjaGs111pRqZ9ApIgp8y/EV1BFONRGYek0ps031ehLKvdi7KzTCUd8FPqDGW/eoYiHktGHUD3pCMAEn0Wjz+KBO9clShOLSnwsvuwgjj1lLiedbdI0kN6nPW6zXJcrTizwGWve/RNlpR1ccOUhnLRoIZFQlEVLD2DxZQcl1nfmkv2yrs8+b9Z9+Dc2fHQrfo8ZHioSdeApVoyf9ZXEtE63nxn7XEowVMz5V2ReXiwWJ4IJQsvHLJTgUwghhBhkLU2d3HvT29x709uJQHSgjj76WBYvvhCA7du3M3r06AEvc0QEoNnaNvo9HSlDf7jd0NawOhF82lp2vMp+B43GkZTRTJQMOR2E45VM3+fSRBBaWrU3Y6afRJTCbm0NS8p9XHD5dGpW3UI8FqFq4iGJzFs4Xkko4sHtLerT8Bg96SlQHIj0oW3sXja7DbcSjRONxmhsdDN53hLGTj8Gt6eAT9+9gWjgEy779sG4PZ6UUsGetiO505ZMbRiT99mu2vZkdhA6fd8rU4JPMPvo38+tIh5cn+hsqKH27YxBqMcVoaPpQ7Z99iyhzvqUqr0eXxnjpn+Rzz64jZb6VdR++mBKEOqK70yUKjXUvpUShHYFETez5dPHCDR/jMcdxetsxO/tND0Dh6LceWPPwxQBGYNLMMFnLLCOjSvvxO9NHaze4YB4LEI0Yq6zlp2rCQdbqZ50aMr2TVu4lEC49+rDYILPWv0gG1f8HacjknPwCSYwLB93BFUTzfpd7gLKJ57L9m0+wqFoyrkSCJsgdNqCpWZYE89kZu53OVP3PotwxIczupW17/0Fj6MhYxAaifkoGX0I42Z8mQmzL+SBO9eh5o6isiKCx9mBz11P2SgfY8aXUF5htj3TiyWXK5410LV5PSHad75BgbeDWOAzNq4wbZPXL78ZYjsZVVHIS8+sxutzUVpRQHllIWpeJWPHtVJZ5eh2TJPPm1g0RCjQlBaEuvGXLWD8rK+k3L9wOnp8MWYHoVVTTpDgUwghhBgksVicpoYOWpq68o8tTQGaGjpoauhIaebVX1dcsZSf/exHXH31dwa8LEemznF2pbq61rytsLq6hLq61oy/+T0dbFzxd7wFFYybcWoiM+Rxh2jZ9mqiLabD4aJyyjl0BKrxWz1TZmpv6HQ68Djq2VnzGlWTU9sx2tVGi0t8eN31iUwdQOWEAxg1egEuTxmdVhW36uoS1q+t4+6b3uLr3zuQuKOAaCz7MCw9aWsO5LXn3OTeO5OrA5eU+bsNTQOm6vG4SWUUl/rw+WO073yLbetfTPw+ftZJ+MsX9Dp8RntLkE2f1fLvFzYRi8Y59pS5vPzsakLB7uM/2tvZl23v6Vzpi+Rj1NLYydhxMWo+uZ707l4nzDoZT8lCYnFHIvjcuvZpAJwuH5PnnMaWNc9Y036ZTaseTWk7V1Q+nfGzzsDrdbLqzd+n/AamDXHJ6ENwRBtMW0vrfPP6y5k05wzWf3QnXv8oJsw+n43rQjx2X/eq3bmcX13B571AHH/ROCbPW5zSFtXhcOB1NrDuw5uJRjpxunzsdcAVNG3/hPrat5m2cCnBSG7j2NrBZ1vTOgB8hdVMmXdBn8a9BPA4Q7TufIvC8jn8/YY1fP6omYnqqUuuOJji8sznisPhoLKykKa6taxffivxeBSX28/0fb5KOF7R7Qbe1hzgrX+tYcNnzai5o1iwoIWiYi8t9Z/S2viZ1cHSZMKhzG2ZTWnmOmpWP8R0K8hLX4fXE6Kh5p90tGygetKhbF71CMnnm8tdwPR9LqeltSDR03MkGKCz+RMatzxJ2ej5jJ56Qso9q9AfYu17f0mpqgxQPGo64/c6J9HRldsVwesOEwgX5uXhlUk+rs3q6pJd17PZHmKwns1DmaR78A3XtEu6B99wTftgpbupoYN7b3o76+/nXnZg4mV4LrKle80azS9+8f+4/fZ7ex1asKdn84goAU1nB5/Bjjpa6zVbP3sUFx3EIjHCES+lYw+jetJhOBwupsy/kGceb8Rf6O2xh9hYLE44Xknl5OO7dShjlxw5XE4cDhcOR1ewVb/lHTatepg4XSV2NRsbaGns5IzFs9i65h5ioU0QjWUtyd1VHA4HLldqniPboPVbNzez+PKDu/WCOmFqOcWlPjw+F7FgTUrwCVC75gmcsfoeT1KHAyorwoyrfIcrvr0vLo8TtXcRV3x7Hqefv2/K+nKpvuj3duL35qfaQbrkkuHH7lvOG//eTvm4L6Wuv2Q623ZU0tJkgkanM0JL3arE77FokE2rHmHy3mfiLx6Lw+FOBJC2UGc98VgEt7eQMdOOTvnN4y+nrHohsWiIhm3vpgSf42cex/qP7iQWDRFo387mT+7E5+vE5TLnU196w3U6Y8SCXcEnQKB9K5tW3I3f01USGo/HCcUqmL7PpXj85Uzf5xIKSyZQVPk5pu9zWc7Bp88TYuuaRxPBJ0Cwo46NK+6kwBvsYc7uGhtjvPtuBWt1nM8fNTPRKQ+Ym3SwM0xbU6aS8zhtjesTwSdANBJg3Yd/w+tsJP00LizyctAXZrHoogWJ4LN55ypaG9ZAPGbaD4c34fF2L112u+PEg+vYuOIeopEAn314Mx5HfUpJqB18NtS+RTjQgsvlxe0tTkmDt2A8gYCZp6M9hMsRwRldS+OWJwFo3vExOzY8jS+pNkhn0MvU+UtwurquJa+/nPGzTiUY7ipxjkTddAQLegw+B6MmghBCCCF2j9WrV7F9+zYAZs1SRKNRmpoaB7TMEReAFngDbFxxB8GOusR3rfWaHRuewu00GTA7CN3rwGuIO8dz3Knzeg1qvJ4YsVicUDh7dcB4PE44XmFV1zXVcr3+UUxdcDGBcHEieLn9L6/j9XYSbX2SztYtbFxxB454Da4+HI2BDt3icDjwupoIt36Mx9XVNi99uBowwd+EqeVUVhUlqhtXjS1OTO90O4lG47j84xk1bv+U9VRPOpy4szzjMDQmHaYN4fqPbqGlfjX1Nc/wje/tw9Y1y1i//CYmTAxTYlVzTu6lONu2+z0dbFpxF5tX3bdLgtDk9sYnL1rIR+/twOmfy9gZJwBQUjmH6ikn8fyTmxJp6uz0MkGdRVHZtMRyysfsg8MzmvGzTgPvVCbPXYw9PE1hyUQqpyxmw/oINZs6cPnmMs5avsdfzrQFS+kMuGnZ8S4ebxHlo+cDMFGdwmb9REowG+rcgSv8KocfMxnIrQ2ifW7FouByF+JwpJ6YHl8x8aRbh9MJfk8rwUgB0xdeTjhehcPhIBz10BkqIBqO5XRehqNexkz9Io6UXqocjJ1+LKFoV3p7C3i87gBl5S72OWgG5ZWFPP/YysR4vmA6AqrZ0MSdN3YPxGORGDF81nBBydtcBk5vt0Da6Xaac7NwO47YDkKBRtoauwJoOwj1e1PbxLpcDghtYMPHpuq2WbcJQr3Opq7pHCGatpuxV6ORTjavfoyJe52I22s6wioomUHIcQQ3/u49bv3ja9xz09t43Z3U6IdT1te842M6mlbjdptzLB6HcNy013S6vHh85Uyae3G/xuxMr67fG5dLCiuFEEKIfCotL+Dcyw7kxLO7+sE48ewFnHvZgZx72YGUlvc8hn1Pli9/n/vuuxuAhoZ6Ojo6KCsrH1B6R1wAGop6GTP1qJTvHE43heUHsH1bOJFpDUe8dIaKiTsyt3tL5vd00LjlhUQmMpFBz5D5NSWlJggtKBmfCD6hK3i5+gcHEGt/imCHeZtAPMbGFXcQD23CEcutBCFbSWUumUA7+Fy//GZq9KN0Ni1PBKE9dYhUXlGY2IZwMNptXXbPpXYQWj3pcErHHkrYav/pdILTkT7cQ5s13EMzXn8F42ccTY1+kM7WzcSiQTZ8dAsXXTmT4pKuUudM2/7kgx8RaG9g08q7CbRvpbNlc5+CUJ8ngNfdeylbpnFGcXhx+ecydua5VE74Ijs3PsCZi6fx/OOfJDpU2rkTxsw4ncKyqRRX7o+3+BAadkZpb3fT3BjmyUeamDj7XApLJzF2xomE2texcc1W7rj+Df76u7dw+ecycfZpTJu/lPZ2H7HAKnZufolt6/+Jv6iK8tHz2bHpVabNOyelBN7rL6d66vG8/s/NKceyp/Pd3r9tLSFirvFMW3hxYpklFbMYO/M0gmGrCms8hiNcy6dv/4GmLa/Q0RntFsCkt3f2ewN43N2HsnE7w7Q1b2Ly3mdYQaiDKfMW4/RPIxp1dFtepnPd5wlSt/FZAi3LGVXhxp22nUcdP5tjT5mbMkxJcjDb3hbixt9+zJR5SxNBnr9oDJPnLUlUO06//qPROL6iiQQDzfiLx1BQMiFlnZPnnE0gnNprsMfZQjwWxeMrTZm2sHgCOH2J9TQ0eJi+8FKcLtMzcjTSSSjUwfR9llI+Zl+qppzM4w9+xslnL2Tp1Ydy3mUHEooUMGn2GSnLLRu9gMLy2UQi8cSyW5sCNLeUMHnuUoqqz2LT+iitGUuFu4tFYolS5L68BHO7YhDemNNYukIIIYTIjdPpoLyikNKkJkal5SbvXl5ROKDecE899QwaGxv42tcu5T/+45t8+9vfx+kcWAg54gLQaNSJq3Amk+YsAkzwWTXlPB5/cAcP3vF+nzv+8Xs62LTybuq3vEmtfhC/N9BrB0J2EDpp7oWJ4BO6gpc4EI+ndQqCg7bWMJ2d4ZzSla2ksrfSreTgMxIyA8TXrn0qJQjtPk/375obM/dOawehU+Yt7h58RrfiiHaV9DocDiLhViKhNrz+UUyZezbbN7xMZ2tNYj2xaJCNH99GYWHXvs607Zd/a3/i7c8QaO/qYKqzZTM1qx/A7+35ePs8Qbave5KGGtN5UH+qFAaDTqLxEmpW30lnay2t25ax9Ko5HH/GfIIBE6z/+VfvEIwfydY6xdMPr+G+W95JnEOb17fQ2DKasdNPZMPHt9Ow5Vnmzmtin8+ZnsY6Oh14i+fT0OClo60ej7/ElMoB29b/E19hFWOnHYXDOzYRMHr95UxdsJSmJm/GtrS5iMVIBKGlVbNTgk+nE1yxbWz4+Dbi8SgtdW/Q2fAWHndqJ1F2gNLS2InH2cbGj2+no+GDlCDU6w7TvOMNtn32DNs+e4Epe5/JtPnnpQSfvZX6+zxBdmx4huYdH7F17dN0NH3IqAp3Sq+w9lAldono48uWs2VDE9trW2lrCdLc0EkwEGHzxjhT5i2lpGJmSvAJ3QNqgGCkgImzz6a+9gOqJh5IQclEACbvfQ6uwplEo8m9Brew7sOb2bjqYSbMOj5xHItHzWC8OpNAyJ9Yz+1/foPm1tJEEDpu5gkUlM4jGCmjasoJtHd4IG5eLEycUkFxmZ9o3I2neE4iCC0bvYDRU1ObDnR2hGhrrifY3sAdN63jiYc2MmGSE2IBwuHez5WO9lCiFDnXl2BuV4xwx6esX347NXqZBKFCCCHEMODz+bn22l9y/fU3c8std3LYYUcMeJnDdhxQryd7JikadRJhCpWTT8fpKubxB3fQsLMj6/TZ2MGnHdS0Na2jVj/I6Omn27Uls4rF4gSCnoy/xSlhojqH2jX309m6GYfDZQWr1Xi9medJ15exHpO5XVGatn+YCD4B3J4iGnd8RFnVXrhcHgIhfyLIKyiAosIAkbhJV/LA90BK5tPuCCgU9uL0zSRslbbYwef65bcSJ860+Rfi8kwiGouDcxzT97mESKiZ9R/fxcS9vkJHyxbCwWazUIeTyXsvIhjqyjxn2vZg2MPY6cey/uO/J8ZydDhcjJ32pR574DXB5xO07Pwk8V3J6CO584a3UrYpE3sfFRV78XtbWf/RvYlOXUoqZuD1hBgzxonL42LJlQcDJmDaVlvDyWeW4Cvai2DYC3G46KrPU1LcwoaPbkt0ONS09QX2P+B4DjnqENpa4oRDMcrKAmxauYzmmgCT55zKljXPEg42EwkHCEXKIe7G6RpvqoF7ighGiikojCXWn+3lRHLnSsk9HdvzuL3jGTP9VJNei9/djn7/tkRbSYCdNa/g9Zfhcn4u5VxxuZ34fZ1s/uQ+Qp11bP3sGcbG47gL5uPxeWirf5e6jS+bY9lZT+1nz+MtqGTCrPF0Rk1Jc/q5B13n39e+dwA7NvyD5h0fJX7buvZpxs2EiuqFOF0mgIyEoiy+7CBamwM8vmx51g62HrnnQ3x+N5dec3oiIEzuoCt5/9j7KICfibPPpq3+E6bMPYdQZwNxz/iU4BNI9B8UiwTYtPpRJs8+laa6Txg79Wg6w37SO7SKRuOEqWavA75JOOIhHDW37VDYRWGRI+NLp0jUiad4DjP2/SpOT0VK8OnzBimsCtG+/XkCHR2cdNaZuF1RNn9yE4XlCygsPgzI7T6UKzv43GyNp9zRvIkavYyJahHQfVxdIYQQQvSdXRXX/nuoGpYBqM8TpH7zi3jdX8DhKMrYZsnl9uIpnEk05uSwo8sSmU27B9DeOJ0OIqFGAu3bUr5vb95IPNpOQaG3WwY0146DyisKqauLMmnvc6hZdT+FFYcRCFfjL+z7sAV2EGT/3ZtwxEnZmEOIRjppqH0bt7eYibNPweev4LMPb8ftK2PCXmcRpIDyCjeB5o/4dOWTTNjrVKIl+/e6fJvdaYkJPmtZv7wrUFn/8d+ZNv9CCgrHEAp7iLtHQ6iZSKjddM5j9RAbDrUyfcES4u7JRDMURCZvu8fjscbsvJD1H/8dBw6mLbyYuHsCfncH0XD3DLXXHWD7uidTgs+Gre8Qi8U57IuzePWfW1KCsG49I9udTzkAYsRjpkRv1Nh98HhLWPvBrUydfyE7dgTwFXgoLPLi90NZcZia1Y/gLRjF1PlmCJDScifN2z7u1ttt/ZbXmTJ/b7ZsbGXitFG4i9uJhNqIx6NsWvUok+ecSmfrNsrH7ENHwIcDU2qJcyzhcDwlnT3pKbhbcuXBFLv9BGPm/LIDsViBg5LRh9Ky/d9d+7RgNM1tY4m6Urfj9PNmEmp+jFBnV9vsbeueZdT4GEWV+1JSodix8d+J7Q91NlA+eiGRWG63qHjckWh3nczl8kPcSWGRK+U6cVrtEJOrmqcLBiK0tEBxWeZ9lOnlSyDkxz9qPzqC4HQXEYt2vzkFo6VMX3gJ65bfQiTUypY1zzJj36UEwiVEw9GsLwKiRb6s52AmkagTp3N84jwAE3xGOmrYsvFfBNpqcHkKqRjVxqZVjxANd9Ba9yZer5uiyoOJxVOraqe/pLDHHe1oC/LE/Sbwz3aP9XlCrFv1YMp3Hc2baN7xHoUlqZ14CSGEEKJ/7Kq4Q92wG4bF5wmy/bPHaKlfjdtbwvR9LiEYKe2x4wx7uI6+DlNihkhYz8YVdwNxa8iWc3nmsQZ2bGtLmbYvy07u2tjt6GTZ7Ss57tR5Ax5CpS+87hBN216jeNRkiMWoXfssoYDp0aqwbCqT5pxNa/0n1K55MjHPpNmn4SqYTUtzNDFMi53hhMxBmt8bYsvq+2hv3tD1pcPJ1LlnU7f5DaqnHInDMxmnM06kcy0bVyzD6fIyZe8zcbq8xFyTMgaf2bicQHgzDqeLuHsCbhpZ9+HfGD/jWDyl81KGg3G7IgSallO79qmUZVRMPJU3Xo2zVnf18JV8fE09+iixWHJHPA48jgYaat/C5faxY9Mr1qa6qZx8Hk88tIMzlizAEV3LlqQOYpKDUI8zSOPWl2moNaVxHl8ZU+ZfzMZ1MTo6wjz/2EqqRhdx4mmV1G+8l3g8ittbyrQFFxOOlw9omIz04CL9hU3ycbWvJzMEjx937GN2bv4n3oLRjJt1Hq1tXkZVFBEMhhMlhk0N9UyesJbGrV1dhJt9cy7tnRUUlxZQVtqaGO909JQvUjL6YMIRT7c0pg8RZKfRXxBJ9BgLMFGdTsw1E6er+3mZfE8oLPLmtO3p6+/t3O+JwwE+VwubPrmHSXMWJYZ4SR5aKN1AhxryeYOEWtdTX/sObU3rAZi+8AI2fvIg0XBqDZFR446ksOIgXN6ul2LZ0nbsKXO7hrjJkkaXMw7hzaZXYKuGQmnVHMZMP5nS8ioZhmUIkGFYJN27w3BNu6R78A3XtO/J6e7p2TysSkCTg0+ASKiVdR/e0i0INZ0FxRLttuySslxKCP2eTqJxN+GIh2jUgcs/jSnzFrPpk/uYtuAi2jorOfgLozJmQPsjFPbl1AtvvoWjPirGLiTUuZPaz/6RCD4BIqFmQu01KcEnwObVjzBjv8soHTUu8V1v1X4DIS9jZ5xBjb6PYPsWK/hcxI5Nr9LRspn2j+5g6vwLiLgmEopOZtKcRWzf8DyegnGEooXk2CdTQjQGDscEgoEIJcUm+IxGOtmsH2P8rDj+8vmJIDQSdeMvX8j4mSSC0Imzz6K1fQJrtel5NL1Ex+l04IptJRJqxVUwI1G9MhaLE/NUUFg6gc2rH0mkJx6LUL/pHk4/76sUl8RY++4TKekNdTbSuPUtSscdSTjso2LiFwForV9NUfVZ3PCbjwgFIymd5zz1yGbOXHwhW9csY/Le5xMIluJwDyzv2Jcq3cklz80NnWytqWaf/U6luaWK1jZvosOqurrWxPyPL6vha/9xBA6Hg4batxLB55OP7KR+x0bAVEOese9XaW34lKLK/VOCz1zSGAp7E/sv7qgm4pzBLddlfvGUfE/IddvTp8ulyns28bgpCZ0yfynBsC/x8iB93/a15kY2Xk+Mhs0v0da4jrHTj6a9pYZ4LExz3SdUjN2Hus2vJ6Z1e4pweGcQDEJh0iqzpa1qbDFLrjgYHNnvg9GYA49vItMWXMD6j+6gtFIxZvrJ3Ya0EkIIIcTIN6w6IXIQor15Y8p3kVArwY4d2J0x+b0Btqy+n40f3Y7fa97q2xnH3koo/N4ANfoBmmr/jcdpSkSiUQcOzxT2OuBbtHVW4vV6EkFn8tAg/R23M9e02RwOKPQFcLv616mMzecJsWXNk+zY/BpjJh9GcqPWSKgNj7+KUWP2TZmncvwBONympCaXoN7uNGbDuhCOgi9TUDKRafPOYcemV+ho2WxNFWfDx3dAZDNPPbCC557qZPLcS6yB7/u3ba2tIaLhpkTwaatd8zjh1tUpY592BaEnMmnvs/EWK1yerm1K7jXWDj7XLb+VjSvvJdq5FpcrltjOYGeUgtIZ+AqrU9Izasz+eH1FBAIFKT2aApRVz6d83KGEw+b420HUlPmX8MBd6wgFTbXel55ZzfOPrcTtdbFzRzsP3r2V6ft+jZirGoc7v4U/vR3b9J6A33ltG07/XHyFFRnnsZcXjfspqTqc0uqDkoLPrrbI0WiMcLySwooDugWfmZaXKY2BTjeFFYcRik1jR21qR1nJHUolB5PJvxUWeVl69aF5fyHkcHTvzCseN+NxJpdcZ+plOfkcTO8gy+WM4/P03qlaKOykcuIRxOMxtq17kclzTsPh9FC/9X3KRi9gzFQz1qzbU8TEvS/G6anCX5D5BUB62vyFXkaPdVA6qnsVYZvLFSPSsQ6Pr5xZ+18hwacQQgixBxtWAWgoWpoyxibApL3PxuWfTjTaFXy2N28g2LkzJQjtjT1vR/MG6re8RtO2V/C6TY+0Lc1hfvfzt7jtj2/Q0R7qU4lqPjkc4HU1s/b9vxBu/zTnIDRTr66BkIcJ6kxikRD1295nkjoZcOB0eaicspjbrteUjTs6EYRWjPscE2YdT8jqhCaXwDl5uJSH712Lq+iEbsGZvWGxGMTisH5NI+vX9n1Q++RtbG7opHZzB6VVc1KmcXuL8ZdMIhZLjQQiUTf+soW4C/cikt5hjLXsQHsIR6SWdctvTbT13LTyPqKda4lGunpFDYQLmTL/wsR2llQdQEn14cRdheB0EKY6EYQWle/NqInH0dnp6daTcCBYyKKln2Pp1Ycmevs9edFCqseYXpV37mhn507HgKrdZtOXlyKJUrG4I+s8ycuLxv2Ujj2C9s7KRPCZ3HtzLBYnEnV1W0am5SWvL3H8W4L89bfvcP/tyxPtEnvqmTW9R1un28nEKRU9bntfr3+752mfuyURhPY0lJOtuMTLRVd9noICb2La5CFoIuEw8dBGtn32CD5v70MIBcJFTF2wNBGETl+whLEzzmHrVj/ekv0YN+MESsefQ1t7EYUl2YPJ5H1QVOLD62pk7XvX44zU4nR2Px9drhjRjjVsXHkPn71/I+AmHB285gZCCCGEGFqGVRXcWCxO2GnG2Fz34c1Mmn0KTv9MIlEnPm+YrWseSWlrGOzcycaP72DqgovpDGZ/2+51d1Kz+gE6kuat3/IaDoeD0tGHdps+l05d8s0OPu3hUzaveoBJc87CU7RXrxn25M5TkqsjBkKFTN57CZs+uZOmnauYuuB82ttctLaVc9Ki0USiXqqmHEdxxUx8JTPw+EqA7PXBk9sRFhZ5E5nU5oZOXnx6NVWj3ax5/2bGzzjGpKulBhxOqqYs4rEH6tlea9rVpnR+k+N+Tt5Gn9/NmedPp8A3mvjoBTTt+Ai3t5hpCy8lFM3cXji5s5v0jp062kNs2bCVqtJ3E8Gnbfv6lxg783ygq7OYWJGfKXMvoGXnxxSU70NzExQWx3C6ncTjEHZUM2Pfr9HcFKepwQEEE72w2ttsn2PV1SWJYTHsaph96XQqE0c8htMRJBzpOchwOnsPcJOvheTj73FlPifN+gooKOp6CTCQqqw2+/jbVZXB9Hj70jOrOensBZRXFqbsr556tM2W9uRtyJbe9GvA5XHhdTWy7sObcThcieYCdnrT26DaVYKdTnDGt1FW6qO5tSQxrW3ilFJ87lo2fHwXEIf4I/jnnQX0nPZAuIhJcy+itaGWl55vZce2NnZsNcMenb54AUWlhd1KPrPtg5LygsS2RcMdrPvoNqYvuBjc4xMveezgc9MnywCIRgKs+/Ampu/zVcLOil3yAkUIIYQQ+RcMBliyZBEXXXQpJ5xw0oCWNaxKQKFrjM1Zn/sG5WPmJ0qswhEPo6cejcOZnHlyMG7GlxOldtkEO8Hjn5L2rQN/8RTa2uJ9Gmh9V/F72lLG7gTYvOoBIh2fmQ4+Muht3ESAQKSQyfOWMG7GiQTCE3jkvloKi72JICgY9uIu2rvXfQhdQcCWDU20tQQTpcVlFQWcfu5Malb/nWi4nc36cSrHf46isslM2ftMissn8bnPT0ssp7fxTO3t6mwL4feEiEdjeLwullxxMBd8/RAuvXoe7TseoHbts/iLqqiaeDAz98sefKazAww7MGhu6OSlZzbSETmY4lF7JabzFlTjLTuZv15n2osml7QFIkUUVh1MczPceaP5zk53a1OA9Z/F2VIT5u6b3qJuexuTp43Kmp5M7RX7W+3b6YzjiNaybe39eHsYh9HjjuCMbMKbQ/VOW3LpXFtroMdpe6pG2x/28iZMLcfvd/P8YyupHmeG9yivKOy2v5JL5wHaWoJsr201524vafe4wnhcmcfrTd4HgUA4JUCz26y7Hc20NZt1NDd00tYSTMzT0R5K6Tl63Yc3U+Rv4vhT5xEKRmmq72D8pBKOOq6IjSus4BNobfiUjSsfwOfpOe0AwXAReKcxfa+x7NjanrjeikoL+9SZks/VlNg2AOIx1n10mxnv13q/4HWF2PrZMynzRSMB6ja9gsuR+7klhBBCiNzFYpnzKQNx++23UFpalpdlDbsAFEwQ2hH043IllWjEIOoYzfR9LrGCUAdT5y/B4Z1CNNZzG7n2Dgf60zGUjfmC9Y2Dyilns2NnBbf9KfeB1nelWNxDYdnUlO9cnkJ8haOJxTMfxvRMNmROfyBUSCBcgtvt5uRz9ukWEEQzDCWRkra0QNftdXH3TW+Z9bSZINTjL2XSnEXgcEI8xmb9OKPG7ktnqJK2NgfllV1dRie3ecu2XY/e8yHxyHY2fXI7Xk+7Kf10QFVVnC2r/54YR3Tb+peIRUM01L6P2xXJuLzkbUh+sZC+/5586DPaw4dSUDoLX+FofOWn8MBda4lmeBkRi8Roqg+klLDZgcaWDU10doaprCri2FPmMmGih6OOiXHU8VNo6qG9Yn/bGdsc8RiEtrBhxe10tm5k29oHcDvau63P447QtvMd1i2/jYaal/oUhObCLiUsLPL2ul3Zqqr6vKnVzzO1T3Tby81w+dsBq129uXpcCc8/tpJxk8ooLsleGutxR2hv+ID2hg/wuLOfT0cdP5uy0jibVtyd0sNsJNRKrb6feKyDo46fTSAQYevm5sTvgY4QjvCWxLBFsWiQTStvY9rMKM88vIIn7v8It9sB8e4Plmg0RPoYopk4XU78hd6Bt2V3evH6y1O+cnsKcHmKEp/r6x0Ujzkbt7drrM+Csr1o6tiHxoaBtWMXQgghRHcdTavZtvomOppW522ZGzduYMOG9RxySPeaof0xLAPQbJKD0KkLLsgp+ASTGd1736mUVh/I6ClfonLK2QTD4xhVZXp3tDOp0Hvp3K4SDPsYM+0rlFab6oUuTyHTF15KKDaKfA2l099Axw7U2lqCiZ5abU0NHXS0h/B4PcQc45k670JwOHF7ivAVTeXeWz7NWA0vU+Bhf9fRGuL0cyfQsOkeAm3b2Lzyds5aMoPWpgCtrVA16YiUZTXVfULFuH2IxrJXLUxvC5jNkw99RmfsUCbtvQRvYQXnffXAlDaayVUqk4PXx5ctZ+vmZo49ZS5jJ5bx/GMrqd/ZjtPRQdvOf1C38Qmqyj+mvaVpl7zgsEs+N6y4PTEMRkfLJmr1/bQ113dVnbWCz+3r/wFAQ+3bvQahmUraG3Z2ZK0pkOu+zjat39vO9rUPZW3fnWifWOzLeq063U4Ki7yUlPk59pS5dLSZNpStzQE62kO0NXVvh+xxR2ivf59t655l27pnaa9/PxGEZnoJc8ufPmDC7HNS2qy7vUUUVJ7Ac4+vx+118fxjK3npmaQHRLyD2jWPJsbMBYhFg9RteobzL1vACafPZ9P6Fl55OcIEdTZ2dF1YNoVp888jGM590OmBtmUPhAqYtPdiCkrGJ7bNVHMv6+qRvMCDy1vJlHlLcXtLKCjbi8qJJ1IxevSg30OFEEKIka6jaTUNm58iEqynYfNTeQtC//zn6/jGN76Vl2XBCAtAwQShEUaDZ3JOwSd0BV4OTwGe4n148dl2vH4vvgIPxeVdJSpHHT+bEqtqZnKQ5vd04nHnVtQdi8So2djQryq8dhBaMf5zOQWf6aU80PcAuquH1zAbPtuZMaiw12OXIiVnqJ+4/6NEANHaEuKhe7Yzdd5FlIxdRHtnEWddtH9Ke9H0AC458OhoD/Hwne9TXNxMw6Z7iEVN0BAKNNJR9xCFhR3c+se3aWqZwriZpm660+1nxj6XUlQ2qc/tzbLtvzETx9FQ76Kg0Ju1t9JM7J5s7eqJEyZ6KC98l46mVQC0N3zIuOqVfO37B+2CzHkch6P7OedwRJk0pZzCIi8OhwNnrCkRfNoaat8m0llDsCPcY0CZXNL+6D0fpBy/9E6iIHt19mzTtrcE8Lvb2fDRbbTUr2bjx3/PGITa17PL2/MLlY72EHff9BbPP7YypcOiTesbuPPGN1PSnxx82pKD0EwvYdpbg3y6KsaU+UtxuQtwe4uYMu8SnJ4qjjlpb0rLu5e0PrZsDf7K0/AklSz6i8ZQOek0/vrbd4hYg+KuX9NEzDmFyXPPobBsKhNnL8JXkL0adyb5KFm3g9CSyr26BZ/2OgpLfEQoY+qCS+mMfp6OTk9eSvSFEEII0cUOPmMR01wvFmnPSxD6zDNPMnfufMaPn5CPZALDrBOiXMXjEI87Uqr62ZkdhwN8ngiBUOZNdzj9HHXi3ikBgB2IxKJx7r7prZTOcfzeTjZ/cg9F5VMpH3sEoR6Gj4CuzHpfOthJFgz7qJh4HKGIu9eSz76M7dhbensabN5eT7AznMh820Fo8hiGHe0httW20dpRzYN3vctZF1WkLKe4zN9j5zDETbXKklIPDd2qGsYYVVnI4ssOJB4Hf+k8JioPBSXjCccrM25bcocx6evraXzIcCjKnTd2HcNMJUnJHTCljxlbUODl4m98ngLvVnbUr0xZftP296macAAO19i8dtASizlxeSYxbf4FrP/4DojHKCgez6S5iwmECnC6IR6PE3OWM27mCWxd+3Ri3upJhxFzjOPWP77W45ia9rYCnHrevpSU+RL7JLmTKFu2zqYyTfv0wys4a8kMNqx4mFBnAwDBjjo2fvx3psy/MDHmb28cDnC7YoQjpgR0yRUHE4vFaWkO0N4SpHpcCR1tXS897POhfJSDSLC52/LMd7HEPggFoyy79Z3E7889tpJXX/JxxnnnUV5RRIRyCktMM4JoNN7tevnyqfNw+wqZNn8p6z++FZfLxwS1mJXL24lGY0RCURYtPQC324nT6cXln8FENZlAyEdJWtrSO0QaSMCX6V5qC4QKGDvzTEJhd9Y21vE4NDR4eOqhdSy5cnS/0yGEEEKI7mKxME21LyaCz8T3kXaaal/EXzoDp7P3TgYzeeON16it3cLrr79KXd0OPB4P1dWjOeCAg/qd3hEZgNrSgz2HA3zuNraueZxxM08hEC7qNk+iNNRBt8xUa1LHIQCjyqNs/uQ+Olu30Nm6BSCnIHSgQmEXvbX1MqVsDuLxrjE7IbXn1J4ylYnMa9yRoVptapBmC4eiPP/YykQvpNDVc2s4HCUUjHLsKXOp395GoDNMU30HxKGwuGs56cFHcqna0msO5cKvzWPbZ48xafZpbF79CLFoCI+vjKLRZ9HaVkBRqentOBoHT/EcwnF31kAu16AoU6+4yTIFqunfpQf+Lq+XSGg05eOPo6n2ucT3E2efScxZRayXdrfp0o9lpmMbjTlweSYxZe6S/8/eecfJVdX9/33b9O29tySbXiChd5AiCooUqdIRfez+7AVExfJYHrvSRUFEiiBFpEjvkJ5sku29706fW39/zM5kZne2pQDR+3698kpy954755577uz5nG+jv+0pyhvPI6qmu2xqhowndzVlC6B316MUVR2FO+9wujvS535iLERZzHj/+YUenB4l7dzEGE4W5XOx9jpdMi6nTiDmT+9vbAxLjyAIXgzNmHY+w8TmkxRgbOBtsosPQ8WBb8IKKUoCsaieJh4hfT7kl8djxIe6XwagsOJwcsuPRdUdiDIZN2ES9yiIAqquIEi7xyPoj2V8X7zZTmKGk7qVl2MYAr/+4ZsYE5bPVO+Ci689DMnhwjAzZ/ienP06K9eFLJvEIsw4TjNda/JmgcsRQ9MdxKbZ0Evl3SpfZWNjY2Nj85+OKCrklp+YZgEFEGUvueUn7rH4BPjOd25M/vuWW35PWVn5XolP+A8XoKkkxGfrxlvRomOoE5aTmO5FENLLTYgiKMIISF5iqjOjKPrw+QsI9T9OLNSTPD7U+SKCIJFdfCSxmDQR+yiBFRdnCJktbcA+s1Qk+i+ZfYiSI279m6ZsxEzW2EyWzwQPT2O5SrUUT75Wf09g6nUm3B7nYg0WJQGfN0bXtj8RCw+gRYepWvxh+lqfpnb5+dz0i+186IL8tDaGObNQn6soSgismayz0z23mRbdgujEm7cSt0ehd9c/qFp8NoqvcdayOpmY/Cyne7aGKSDIlZQvOp+Y6kTM8A2QEKELDqpE1XP47Y9fTf4sdUNguucP4MtyoRm7Ny3mY43P9FxOfP9ikL3Ur7o8WYtVlJS4K7pVgGVZM87nhPhs3XgLWsyProXJrzgBVZ+7GFJ1B7nlxyb/nxCfqSiKREl5VvIdyHSPiXmU2NBKtWq63fHrWRZENR/B8WhSfO4NgiDglIOM9r6Kt+Bw7vzta3N67wzVJBSM4R+fugFRUGDRtf0eiquPRXLUzhry8G6Ur7KxsbGxsflvwZO7GCApQkXZS37V6cnj7yX+4wRoJrfKwFiUvDyN1o23oUXHgHiN0M6td1Oz7BxikTEkRzWGISRLIOzacBtZ+QspWXAmwQyf094aYPGihWkCFEHEl7cAw5IJh2JJAQdMEV+plhUgY53OPSEuPntp2XAbgijTsPpKNLEgTWDPJqSAeVvgIF2oTba4Vtbmct7l6xgdDqPIIo/ctylenzE/vT7jdK6rgiAgChF0NV6HVI2O0dv8T0rrT0LXVc66eA0uV+bdnUTcreKQ0kTifF2UZ7LOTvfcZlp0J2piOj2raDx0IZrhmbf4nO5ZzvT8LEFCt9wZxWcCzZARxTIMw+DCqw/FPxbh4b9uTHMlniyqU59/MBBF04x5b6hMZ5XPyXfj8jowxDLqV11O26Y7qVt5KRpFs5bWmSw+IR7XCiRFqMfroLI2l4s/fhgBf4wH73obSHchN3WTkXGT3NJjEEQyitfEGCTKrGRi8jyabNX0OaaK+lT35tksx5PnhMMpk+WL0Lohnh1ajQY4+YOr57SBEgrurlEL8TkviAJnnb+AyOATRAKdtG36E7UrLpqTCLWxsbGxsbHZfyTE5ljPU+SWn7jPxecVV1yzT65zQArQxAIrFtamiIpMbpX/+sc2zrmwIq2Gpig5Kak9luYNd6BFx6lZfgGKpx5L7U2WQPAPxxeGxfVnZBRFHk8tbo+DvtZ/gSBSt/JSTKGcwGgsbXGnqwYXXHUokiQwPjrV0haNapx/+VIe/3vrvO7f43XgcFo4FI1w2Ek0ouLzjNCy8TYsU8cydZrX3zxFhE4eo6A/RjSqo6sGFbW5APR2jnPh1YciiuKUOLUPnreK3Im+i2I83jY1HjWT6HLKYtJF98Kr42b73ALPvFxXVdNF/eqraFl/E4YeQVODKM58DKEYj2/68ZpL3O1c3ANniuvcG7dCXZfQp0TwzY3UZ5ko6xHtCSRdpifHtM4H07SIROKJehIbKXOJIZ7s+jldzGimMZv8rCafa5oWiGUsXPdpIjEnljXzhorX58Tr0wmMtCXFZ4LxgY0UVR0NxMfGKYs43Urca2GC1PsNjkfnHL890z3OR1TuSRx36vg7nDLnXFyfVppofHAjOXkm46GDpo3DTYxp4v1P3TSqbXDSu/OvRAKdE2dbEyL0YqQ5ZB6fyfXfxsbGxsbGZu/w5C7eq5jPd4IDUoDOtMD1eB1cePWhDPYHcTolHv7rxrj7nrLbfU8QRKqXnEX3rseSFtH2zXex5LDPsn1CfCbwD2/H6S0iv/S45LHUBaC3YC2lgog7qwJLriAwGrd8nnDa4jThdsJpiymryiFrol2q+PR5gnR33M0ZZ3+IYHB2V9zE/V/5ucPQgs207niIupWXo0YkujrvwzJ31yc09SjdOx+icvGFRNXME1F2SOiqQUGJD9OwCIxHk/FrWTmuKXFquRP3L0kg6N1IsndO5WASC2+3e+5iL/Ucy7JQzTzqV19F68bbqFl2PoZYCoDToRGb5v7mwlzcA2eL63xXSBnyRFmPVKYTGLMxWdQljxsWpm5mnJuZ2mQSwJnGekpbS8A/EsHplqe8C6ZpEY7ujnuczjLt9ihc9Zll7HrzDmqXX0j5gtPp2fUIAJLson71lcR0H5PdtH1Zrowx0/NhNsv3fEXldHHcM507PhLhzZdbkcXhpPhMEPXvZPHKEympLM14zcljmnj/Y7H4d6M42XwuCAiCOIcqpHufiM3GxsbGxsZmZt7L4hNA2Fc1JOfK4GBgjz8wdZGayXKQWKQmLBUXXn1oWtZaUQTJ6icwvA1dDTLS+1ba9bMLl5BXvIL2rX9NHnN5y6hefiFR1TPtzr0saZiWjGnuzrw7ORtmghNOW0xZdS6+rLj4tNQhxnruxtDCCKJCQfUFPPS3Pj5w7qppF2fB8SivPruD404S6W66HwBBVCiqu4jsvBzaN92atPY4PcVklZ1Nbo6FIOcQ0xxpCYb6e/0osoimm1PES7K/VTk43TK6ZiaTGilOEbQuWjfeHl/M7+OapDMhCAJuZ4yoGl80S0YvA53PxRNLqfExm+yKPdnqvL8ygu5rioqyGBwMpB2TJAFjwsU2FtHoahvD6ZQIBVSKyrKQZXGKy+x8+5p4hxKccNri5EZFRW1uxrk5W5uCQgsQiWlTk+ZMbpuIPT75zGWUlGfNKFQmfy+ccd4q8go95GRHaN98C7oaQhAkFhx0DaHxdvrbnqJ+9ZVoVkHGBFWTxzxxfVNX6esewpuVl2b53tM5sDdZajO1ndzvxJguXl7AMcdD944HgLj3R371BQhyCW7f7G68D92zgfMuX8c9t77OhVcfii/bicet0t10L6Hx1rj3x4pLJkpf7b6GKIIk6GiGPOP7mJfvTYsX3hOKirJs39+9ZG9+N08m0/fWgYDd73eeA7Xvdr/feQ7Uvv8393um380HlP9TpnqDD92zIVmvb3IxeFEUufDqQ1EcEqZuYppgCCXklx9BYdVJePMWJK8jSk6Ka05A9i6iaul5QLr4hOnr5umGgjnhdpY4x5vl4OQzl3HCaXHf60T9zfhC3IukiOTlRJLiE8AyNYY77uKiK2vxZaUv0lNrI8YiGkccIyfFZ6LtYOufsEyT6uWXoTizcXqKqV5+Cej97Hrrdwy1/xOnou6O1TPjovOR+zZNO+ZPP7YdURJwuhVqGwrx5bjSxCeWiaGFadlwMw5xFEFIn2uT/78vsCyLcHS3+GzZcCuB4SZ6dtyHyxGPvUvMldT5kjpX9oZ9UT9xT1FkDTPShFOOz4WhviBP/H0LHp+Tpx/bjiyL+LKd5BbE5+xstUmnY3IN1Kcf247LJVNRmzutBW5ym4RFtqwqh4ICi54df2Ow/XGcytTxT9aB/fjhSZdPAKcznsQrU73QBInnkRCFuQVu8vPVpPgEsCyDXW/9Hm9uLQvXfQqdAoQ52evic+m153YimrvI972BFvMn59bezKVEv/fk+aTO7+n6kBjTdUcvxOFbQmXjWYiSk9qVV3D/3d0zJjeaPKberPi1fNlORFkkqrmoaDwHX27DtOJTNHoIDr+GImszvo/BwPTxsjY2NjY2Njb/eRyQLrjTMdlt7M7fvYwoCZx57gIKSgsQZRemCeGog+B4lKh5NN48iPg7qV99JTqFmLqF4llI3cpLUNzFc64vOJnJJUlSXexy8z0MDgYQRAVJdicFKIAkO5AUF4YhpCVXSb03WZE4+6IGHK4C1Ohw8hx39gJ2bB3HMNwsXPIxHE4nEX8XQ+33Axaj/fHEKoU1pxDTHIjibnGoq0ayr5NLSEwWHE5ZpXnT38DaveI0tDB9LY9RtvCcZI1VpxIDM4BOPoaxb8WaKO4WnwmX6eBoMz077qN84Ucw97Lsx3sRWVTx97/KYMczZOU3ElAP55H7WgAY7A1w8pnL6O0cT4rEPSl5IYrgUkLosgNRnp+baCbXUkGA/AKLnp33ERrbHeNcVHMaMW1qpmH/SCTNEp/IlAyzuxEnXbw9DhAsFGdOety37AQkoqoHRRxDjQ4iu+rRZ5mbObkyx54o0N30DwByC0T+58vvZ9wvvmfnkiAIac/DsMCRtYRFhywgHHbyoQt88+q7phpTxj6quShbdA664cgoPhOx9JZp4M1eu0/uy8bGxsbGxubA54ASoHNJ3pH68zM/uoqaegfdTXcjm0ciS4tQY8Ju17J7m/n45z6Is95gPODB6TQQZRHdEBGVOqLqnnskJfqqOCQu/nhmIRDVvNSuuJS2TbejRoaRHV7qVl6JauSkiU9TN5PXSZRy+dufNnPNZy+iZ+efUCPDZBcsYzx6CA6Xj6wcFzf9/A2u+NQyurbfQ2qM22j/27izK3DlHozHlzmpjmlYFBR5WNDoRDcUtEkL9IjqoG7l5bRsuAldDcWtKis+iuIqIhLbLT4H2x5jbGBTPEOms2Yfi1ATXQ9jWelWHF0NgmDuUZzdexlF1pLiEyAw0kRWPlzz+ffz+5++iS/bOcUtNHGvggAuh0pUdcyYMVYUQbYGaXrtZgorjyCn5Ig966tDSsY/v/+sevqb74u7ak4w1r8BAYGCmlNRtX0n4FLvOaq6qVp6IZ1b/0wk0IOkeKhfdSWalYcijtG6/mZ0LUTV0nNRPIsyilBTNzH0GIbZnOZt4B/eCqJASd3pxLTd7TLVDt7XzBRnq0jx5EmiCDIDiLKPqLa7zqtuSPEsyyJzfg9m28iITXp+k8UnwED7MxTXwMe/eCihkDDl+2ZyyR4bGxsbGxub/2wOKAE6F1GR+LcoCUnxGQ320Ln9XqqWnIMh1KVZSX/3szdRFAlNNdIsLInYMEUGTWdeuJ0aMdGBb8KC5HRPHwicEKHdTX+jovEsBNEJKkgSJNZkmZJ26JpBIOSkdsWljPa+Sl7ZoXhG/ZiCF4dT5qNXrsMASutPp6/lH8nPy8pbiC9vKVHNmj6pjmlx/mVV7Hj955TVn4I7dzVaSnkQy4KYkU39qqto2/xHKhaeTue2BymoPBxv/kGIgjEhPuPWq2SZhn0oQk1TRHLVU7P8Ato33wVYuLwlVC+/hKjqTjvX43Vw+aePxOF896a7yxEByySme+ctUgQBJCGUFJ8JAiNN5Jasoqwye1pxHS9B4qdtw51ULTkXTchctiQhPpvX3xx35+54FoC8osPnnZBHixlJK+aSlQUcvHZpmgAFgZziFRjm1PfC63PGy76MR3l4jpmGBUFAFE0MI93dOyFCe3Y+QFn9+6eIT4DOrX+dVoSGQyovPd3EEUdl+ExRRhINHLKGqivIkoHEGKaQjabvv8D/TFm+E5txl3/6SNw+BdHooXnDbbizK6hsPC9NhM6X+dbuFAWN4FhzWiI3AP/QdqpL1iLIU79vEh4hNjY2NjY2Nu893nrrDb71ra9QW1sPQEPDAj73uS/t1TUPqBjQBIld+cs/fWRyUZoaaujxOvjklw5Ois8EndvuRTZbufKzhybj1M44dxUfvWJdxl1+h6wSHn09Lh7miEsJ0rH5dhRhOM3FdSaimpeKJRdi6lHaN92G2xHAiOxEj0XTYlrHRyIEx6PJLLJuj4Oo5iW/4gj6Wh6jv/k2srwjyA4JX44L2eFCdC8lr/xUALLyF1K28MNEtenLYoiigCL207YpXsqlZ9cjRMbWo0jpC0rLAtXMpm7lxXQ1PYQWG6ev+XH0cCvB4Q1J8TlxNm2b/oRT2bexXoYhIE6IUJe3NKP4hPgiuqzcg8sxiiKn7ya4HBFcsn+/xKqmfkbn1rto23gLTjnIfD5qbCRMYCxKIOCiYtG5aT8rqj4G5Bp6u/wZ24oiuJUxWjbcQiwyTMuGm1EYzPj5LiWcFJ8JBjueJTK+kdyC+cUpenxxwX/GeavYtnEYS1pI+cIPTfxUoHbFRQjO2imCEUByiGTnu8mdEJ0JkZKT70JSpn6+IAg4pDH04DZkaaoVLaq6KVt4DqqZhyzpDHe9kBSfCXp2/gOHnDmOsrlpjFdeEqlo/EjyWE7JKsrqTqJt892M97+Ey6ESC2xl5xu/JjDwMoqsZbzWvmBynC3sji/PynGmWR/D4x10Nd2DS5n799feohsK2UWHUVRzbPJYMpZe272RsCfu4TY2NjY2NjZzQzOnz/OwJ6xefRC/+tUf+NWv/rDX4hMOUAGa2JWvrMlHlEUcsopDHEaSrOTPJVnB4c5LaycI0kRyHnfSqpJY4E5eYDtklZGup+jd9Rid2+7OKEITiYESyVFcSpC2jbcRCfbSvP7mOYtQUQRTHaVl4+2U1BxD68Y76dhyN1H/Ft54ceeUpB2RiJrsr1OJ0bvrH/iHtmKZOi0bbkUye5OfK4oO3HkrqVt5CWULporP1PGM10L0x+MqU0q59Ox6BC20E8tMX+A75TAt629PK/HQvuUveHOq8ebWpZ1b2fgh1AzZT/eW3SL0YxnFJ4AsGQz3vsXON35FcPC1pAiNC8M/07z+Dziksf0iQhPiMxLoRo2O0bbx1nmJ0GAgnsn05p+/wpP/jJFf9WEAsoqOwJVzKBbOjIv5uOVzlF1v34auxq1LpqHFRagwNOXzNUOhuPqYtGMOdwG+giXo8/QAEGWRypr85Dsmyg5cOcuobPzwjOIzlVSRIksmZmTnlHFLiM+W9TfRuf1vxPxbMorQmKrES/hoEgVVJ5FdsLsos6R4qF99FZGUuTM2Ek7b+Nm5bYRgpIqKxo+QU7xbfEaDPaiRAUIjm+huimeYHWj/934VoZOTA8Hu7zCXI0rrxtvTrI/h8Q6Gu/6NQ3nnsp2rukJO8REU1Rw7JZFb6j3YNUBtbGxsbGz2PTHD5A/bulBnSDb4bnPArwASQnHnG7/BjDYnRWhMc1JS9wGyi+KJdQRBom7lpZhyBbNtCiSuOdIbL6MS8XdlFKEJd7hIWE2KTzU6CsTrbyZE6EzCRhDiro8tG2+natEH6Gt7hlh4CICRrkc4eK3KkpUFmfupmIz1voh/aGvyWEKEuif6KsoissMFjvqM4nMyhukkr2RN2jGnpxhXVjWCKE06Vya7cEnaMVFygKhQ0XhOUoRWNn4YR9bSePzZfsAwBCJqZnErSwYx/xY6t8cFQn/bkwQHX8ftDCfjAw0tTMv6m+YtQmVJQ5amn0wuh0Z309+IBLqTx9ToGG2b7sDlmFv21ERNyouvPYzla6p58TmThoP+h9zSI7FwZlzMCwIowjCx8OCUeo2CICEIEpB+n5qu4Cs6hJLaE4G4+KxeegnDQ9K02WdnI1VE6oaEw7cEHDWzik/YLVIcTlCD22jfcneaeE8Vn4kkXt07HpxWhCaIaU5KGs4ku2BxUnyqRm5a+aCE6E/Ntn3XTW/xzL8MSmpPTIpPSfFQUL6O7p2PpH3GQPu/0SMdc/aA2BOSWYNTNh8UVw41yy8EYfdccPnKKKg6DlV7Z6qUKBPexwkRWr3soj1O5GZjY2NjY2Mzf57qHqY7HOPJ7uHZT54jbW2tfPnLn+Paa6/g9ddfmb3BLBzQAlSLBVKEosVQ5wvIDE0RoTnFK6aIz+ncwAQBRMKM9L2Zdjzi7yIW7EKSplvIWVPinrDMiSQ5M1kfBARRIqdoCeFAT1J8Jhjr/SenfDDuc51wtUv0WdVE8soOw+kpTmtTufisKclBZiq5kIqqO8ivPJH8snVAXHzWLL+EqBZfRAoCyfFVdQd55cdRUBGPERQlJ/VrrkS3ComqLioWnUPdykv2mfgURQGPMzLFjTaByxHBKY8lF/6CICBaI3TveHDSdaBn59+JBHa7ZxtamNYNt+J2zs1NWJE0wsNvoIV3TCtCY5pCWcNpcVGeQBCpXHQm6hzjBHPzPUkLfU6+m5Ydo4z5vQiye1oLktsRoWX9TXRsu4+yhpNxuOKeAJLson7NVWhWfsZ6rQkRWrHwg1QvvYRf/3g9f/zNnpcamSyOdVPGNOf+lSNLJmpwG13b7wNIsyArss5o7+tpGaQB+lv/hWMW62NChDas+fgU8Qm7Rf9kN9fDjluEbjjImdh0MbQw/qHtFFYcktY+t2QVDk9lxhqj+4pMJVxEUUZQqqldcTEIIi5f2YQA3PMY0OmIbwKkH3M5ooQGX4pnvyYuQvcm/tTGxsbGxsZm7sQMk0c7Bnl7OB6a9fZwgEc7BontpSW0qqqayy67ih/84Kd84xvXc+ONN6Bpe+fpdcAKUFkWGOnbkLRSenOqyStdTV/Lk7iU3TFeMc1Jce3pUyyf07mBWRZoVi51Kz+WZkkoX3A6srsew7Cm1BsdG44wPOKgelm8/ibELYHxYveFMyadsSwLzSqgsOIIZKePnKLdFkVBlKlfdQXj/rhYyVTTMap5qFl+SVKEzpTVc64kRGhp3fvSxCeAQxpHDzUlrUwJEVpUfUxSfCYW3lEtbnndG/EpiRaSaMVjU4URdr7xK0LDb2SM5ezc+mda3v5D0vXZsiwsMYeiqvQsMmo0QHnDaciKd/dBQaR6yblE1ZTSIKKAx6UiThpKRdIIDb9BX+u/6Nz612lFaHwuFVK/+sq4CBVE6ldeiqVUzMkKOJlkmZEZkloBaLpMcc1xmIZG5/b7KWs4GXdWOQ1rrkAz82cURpqu4Mxdw+iYgq69u5lJHYpKz85/pB1To2OM9r6KhUBe+TFp1npZ8VK3+so0d9rpiGlOopovoxBPiP5Mbq666cBXdAjFtScAMNzzJjklB5NTGp9jucWrKKw6hdheuJs7lShuR3j2EzNgmAKCUk3D6iv2m/gURQvJ7MEh+ZMi1OWI0rX9Hvpan2Sg9REkK7zHlnMbGxsbGxub+aGZJjdv7+KF/jFCE79/Q7rBC/1j3Ly9a69iQouKijnxxJMRBIGKikoKCgoYHBzYq/4eUFlwU9F1i7yS5YwNbsUyYuSVrqar6WHAomvHo5Q1nEl0YhE42RqYCacSRcAiqrkxDJCUKupWfozWjXdQ3nBaWibYyZkoE656TpfMNZ+7jK7tf45nHE0Rn5JoIoo6mj61L6ZpoYkF+HJBkpwIooPxwS3Ur7oCQyzF4TSmWGtFEVyOGDHVmRShaqQf0VmzV+Izgao78BYeRlRLWBMhHOildcPN6GqIhjVX4HLkE1XdqLqD7JKjJyxc6Qv6uVpeMyGJFpbWgSDKKLKHlvU3Y+gR+lqeoBTwFqxF0+Wk+ExYNFvW3xwX/2IBmu4gu/QoBEFgoON58krWkF95HFHdSd3qK+MZUfUI9Ssvw5TLMc1E7KyAzBC73ryD2uUXo4tFmGa6+EwwUyZVywKNuAg1jRiWXL5H4hPmnpFUMxS8+QdTCvS1PEFf6zPUr7qEiOpNez4uJQqoxPScpBAzdZOx8cxlPhLlXd4poqqb+tVX0LL+FkwjblXLKV5BbtlRE+VPHBTWnAJAYGQHdauvzGjRnAuSaGJaYtpmUULwJ/6dQNMVHFkHk1NqoLgruef2dmoXVLBsxbl0djgRfeDL2bN7dipR+pr/Tiw0QO3Ky4lq3tkbTcIwBSyxHG0vykhNhyhaCHo3LRtvjwv+VVcgiA66tt9DeLwdgPHBzWiaQUnt6RjY7rc2NjY2Njb7G0UUuXJxJU91D/P2cICQbuCVJdYUZHFSRQHKZGvKPHjiiccYGhriggsuZnh4iJGREYqKimdvOAPCnizW9obBwcA++8CioiyC40NE/Lvo2HY/qa6uWQWLKW04g9gc4h6dSoz+1n9gaGEqFp2TjJWUJHAqYTTNmV6GxDCJRXWGB0Jp9ewAvD4HHo+eVnNREk3MaAuB0WbyK44nJ68gY9kBURRwKCqWaSIQRTVyM1qrRBEks5fWjbdTs+wiUKowzHj7feH251Ri6KYjKZQEIW75TIjPktrjiUWGMLQY5Qs/RETd97U1E+KzbdOdNKy6hLbN92Do6TG45Qs/SFbBCnp33Y9/aHvaz2TFy4K1/0M4Gt+EyM0RGB/aicNTndyQSMQRGloIUyqbIj5b1t+MacQQRIWG1VeiC0XIYpSB1n+kxd0CFFUehTP3MMJhMaNQS7gszncDqqgoa49LVCiSRtS/FW9uA1HNl/YzlxKlu+leouF+6lddiWrmYVkWwfHolDIfCVLLAO3PfqcSfxaDtKy/hayCRRTXvn+KddGpqIiCTlTz7pH4lCUDLbQDp7sQjSIKC2fve3A8yoZXm+nvjdDfGwSgqNTHYF9wXuOUfh9x8RkYbgLA4cqblwjdV2M+HQnx2brxdpiov+vNqaW45hhaN/5x0tkCCw66Fo2iWZ/Jvuh3UVHWOxPk+h/Mvv7dfCCW1rH7/c5zoPbd7vc7z4Ha93ej3492DPJC/xhHleTy/uqiPbpGar/D4RDXXfcNgsEAmqZx+eVXcfjhGWrUTb3GtL+bD1gLaAJVVxBEmclxlqYRQ5gx9jJOQnz6B+N1C7t33JsUoYYBYSN9B18QwOUKIQtjiKVx9Z9wzzN1k1BQxbIcJHK/JMRn+5a7J/po4fGcmrEvpmkRjSXcK51T7gl2i8+WDfEyKa2b7qBuxceQlCqMfSA+XY4oPTvuo6DiMCRXPYYhoEgGo72vpYnPsf5NAPTu+jslDR/aK5fDyaSKTywT/8hOcoqWMNL7VvIc2ZGFL6+BmCZTWncakUAPWmyiHIkgUr30o2nutIrDh+BcSEzbPUaWZaEaOQhSTlIYJhL4NL99c9LqZpkazetvpmHNVWhGESX1HwRIitDCqiNx5x3Ob3/8KpBZqFkW867/ubdohoIzexXRSW76CfGZqM3ZsuHmpAhNWP3GRyJJy35ig+XdKJthmha6WMSCgz+BhSPjPItvKDiYOdY6M7JkoAa307X9PkRJoX7VlViWb9Z2Hq+DVYc2ACTH6vBjG/Z4nJyKxkDro0nxCaBGR2nbdCt1q64mEtvz90uWDBQpjGZ49sod3uVQ2bXpr0nxCRAabyM0XkfVko/Que2+iaMChbXn0tfnwOF6d6znNjY2NjY2/62cWFFAayDCSRWZk5jOF4/Hy49+9LN9cq0EB/yKwDBFRPdCqpeelzzmza2bEJEzxz85FJWB1keS4hMgNNZKz46/4ZpIpJGKIIBTDtC64VZaN9yOS+nhis8cnlxwJlxzE0lbpopPGOl5jZ5d/8SlqPMu+yEIE5a5CfEJgGXSuukOxJTSK3uKyxGlp+lvBEebad98F2a0BUmyUHWJvPJjqVr8YWKR4aT4BPAPN9HX/OA+rfGpyCqDHc8mF7qDHS8iKW4KytcCcfFZv/oKYno2pgkxI4u6lVfE428FcYo7bYJU67Aoxp+/ZaVbJS0LBMmJ7Ei3OsmKB1FyYVlWPIlN/QfJLlxKYdWR5JYeQzC47w0we1IVxqWE0mKg9UlhnE5Fp7/10aT4hEQCpltwO6Mzlvl4twSEaVpEtSximhOnQ9tn2WVTxSfsLlMTGmufdexTkwBNLum0J+Ok6gpFVUcjSunxvaX1p84pYZVLiRANDUzptywZxAJbaHr1Z6iBzLVS50ok5qJu5eVI8u654c4qJ7d0LYp3MRWNZ4EgUlh7Lk89HuKe297izt++kvadaGNjY2NjY7N/cUoiVy+pxCG9d2XenHrW2Nj4s8bGxpcbGxtfamxsXDfpZ8c3Nja+0tjY+GJjY+OtjY2N7/jdGoaI5ImLUF9ufZob7YztTIW80jVMLkmRV3Ywujm5fMVu8Rmve2nRtulPuJQedE1LS0o0PhIhOB7FMvXkuamIsotYuB2HODovEWpZFqLsxeUrSzvudBciKTl75X7rVCbE51hL4tOSIlQUTWKag9ziZfjy6qa0zcpfiGHuO2N6VHVS0Xgunpya5LHQeCdF1cdRWndSUnwmLIqWtVuE1q+6PKP4TEUUQTR6GGh5KONGQ1T1UrvyMhzufAAUZw51q64gpu+2jMU0J8V1HyCn+ChGho0pMZOp9WH3hITbc2i8c86Cy6WEaN/8R9o23ZYmQlNRdZni2hMnCWxhSubkTGU+MjEfMTi5bu58cTki9O7465zr686GImsMtD+T3kdDY7DrlXnV8Zwuo/Z8sCwwxUIaVl+RFKHVy85HcjdgzBLT7VIidDXdw443b0qrlZoQn91NDwLQ1XT/XolQy7JQzTzqV1+FJLtxZ5VTtfRCoqo7XmbHs5jGQz5PVC2jq92fzNq9t2NjY2NjY2NjMz/2JubznWDW3jU2Nh4LLGxqajocuAL4xaRT/gCc3dTUdCSQBWT2L93HOCIB/E07kPo7kfo7oacbl1RJ+RzFJ8TrRwrOWmpXXERChFYtOQfFu2iKq5oiGwy2Pz0hKBNYdG77G4YWTKsb+NA9G7jzt6/gHzdx566mfMHpyRbF1cfg9pXSvvluWjbcPG8RGlXdVC35KO7sKmBqmZS9Qsg0HeJ9c8gqWmwcb+5iapbttjaXL/wArpyV6Ma+9eaOqi4qF5+HJ6cGT041lY3nEY558BYcliY+EyREqCHOTXy2brgN/9BWepsfnFGE+vIakuJz8mequovRUWtKzcjE899Tq09qzO2ON/8wJ8GVEJ+x8CBqZGRaEWpZoBo51K26ckKECtSuuAjBWZuWHClTmQ+Ii7aEtVsSLUSje1qxm8CpxHAp4SkeAvMhnmjqLoKjzbRM1NfdWxEaibmoXbF7owHiSY4qFp6Gqs2tTA5Mn1F7Pkiihal2MNj5Mg2rr6Bm2QXzEp/h8Q606BitE2VqJEkAvS8pPhN0Nd2PYAzs8dhJooolemlYc3VSfCYwkImoHhyuuNhMWITfTeu5jY2NjY2NzXuPuawKTgQeBGhqatoG5DU2Nman/Pzgpqamrol/DwL7xuF4Fgz/GJu+9FW2ff2byT/a8Egy8+2cr5MiQqcTnwCqJlFUcwrenN0WQFFyUrPiMu77885pr68ZUlKEFlcfg8tXSvuWe+KfrYX3SoTml67ZZ+IzprkoX3QWvrwFE0cEapZfiOiqQxZ1RrqeZPurvyIW6kHxLqR66Uf3m/hMEFVdVDaeS2XjeUl3as0Qp42lnC3OMlV8Jmq2BoabZhSh5YvOyyg+EySsX5NrRu6p1WdywidTj9I8i+ByOVQ6t95NLDyYPKZGRujYcidu51SxlypC61Z+bIr4nA5F1ggMvkrvzvtxOaKgddKy4VbaNt0+rQh1SFEGWh+hY8udZPlUJEmct4U4IT4jgW4ADD2aFKHzeW+UDNM0qnmTIjSneAXFte/H4UpPYSsIAoq8/0qKJGOeN/6RsYENDHS8iMtXOav4dDo0enY9SHi8I3lMi47Rtuk2HHIUyVFIbvHKtDa5JasRlYI98pZI1L4d730eA8+0JV72hUXYxsbGxsbG5j+XuQjQUuLCMsHgxDEAmpqa/ACNjY1lwMnAo/uyg+8EhiGAowbZ2zhjko6o5qKi8Ry8OXWIkjNe99Is4EMXrE4TIZMFSEKEFlQcSs+u9OExtDBDXc9PqWs5G1HVTUH16fvG8pm8ZlyEZuUvTIpPSdAY6XqSkd43SLgd65F2FF8Druz9Jz6TfdLc+6yYvYCJrgaT4jNBPHlRZrfEqCrPLGr3ccyk06HRtf1edHW3oDP1KO1b7sKZQSRDPAlPxaIz0+IHBVGmovGsaZNDJUSopVTPS3wOtD2NqUeIBlpp3fRHsEzUyHBGEepUYgy2P8r44GaioX56d97FRy5awCN/2zQ/S6ilo6vpGeQMQ8XQIwjC3ISUS4kSGX0DpzL1M6Oal9qVl2fMsJvIlOzvfw6nvO/jGFPFZ8JVf3xwE11N9+JUIjO21XQHpXXvQ5RS+iyIlC88A1WLJ2wqqj0tKUJzS1ZTVHPqnMpSTSa1/NBg5wv4+56f1k15X1iEbWxsbGxsbP5z2RP1MGW12tjYWAw8DHyiqalpeKbGeXkeZHnPMzEm8I9M7bqsyOQXZe31tWcmi7qV52NoETzZ5QAUlcR/0tU+AkBhiY/KmvyMrRcefDU73/x9UmBkFy6hctHpU6wue0J0YBB1dDTtmCMvD1fxfFIwZ+Fcfh6y4gVBYLDjxQnxmSAuQpce8QXcuSV73ed3kvyCHAxjBaIo0Lb5bgBcvjIWrP4YTk8BezNzFEni8k8fCYAvy0Vu/p5vDNStuICdb/4hmdVXUjw0rPoYnuwCpsvPalk+Fh50NTvf+gOWZbHw4Kvx5dYgZHSrnh+6Gqa/4yUG2p4GoGzBybRuvCstG6oaGWaw42mql3wYWXGjxQIMdfyT8cHNKecMAA9xzecvIhpzzmOcslh48FXsfPOm+JgIIgvWXE52/gIEcfbvEjUyRtuWBwiM7CSvpJuqxWfEE1ZN+oxUiia+R8KBHna+cTO6FsI0olQsOBXFue++Y0xDY3wog4i2TJwOmezc2T7Llxwb09RoWPUxsgsXISbScJOFa8mZZBcsIKdoGQ7X5PueHV0NM9D5Slrt28HOFxAEgdL6E1Acs2cNno2i/f69bTMb++p3c4ID9Zna/X7nOVD7bvf7nedA7bvd76nMRYD2kGLxBMqB3sR/JtxxHwO+3tTU9MRsFxsdDc+3jxmRtKkWQ13T36FaOzKQRWjSZykOiYuvPQzFIU3bD0HwsfDga9j55u/xZFVRWn8G4wERAnvfb2lgkG1f/2basSXfu4GAsDsmVlEsNC2zxcsRCWD4x9KO+coX4sutT0lOBOULTyeqOgjug7GWJAuXEiWmOfaqRMRspNYzklwNVC89j4GO56leeiH+kANCu+9FEMDliKHqjjlZBxM4PXELpGYYezUPBcFD3aoraN1wC6apU7/6SsJq9pT5NrVdQbyMCBaqWcTQ0MyxmXNFkiycnhLie08WndsfomrxmXRsewDLjFvBPNnVFFWfxOiYDgQoLPSSV7qOsf5NaRZnX8GhqLqM06PMa5wEwUvdyito23QbFY1nYYhlDA3P/l3iUqL07HqA4EjcTX60fwOWZVFU+/5pLYFFRVkMDQVxSGO0ro+LT4Dh7tewLCioOIGYvu/cSyWlmtoVF9G26U+AhSenmorGc/GHlLR5OR2iWED96iuwzCimWMHw8GTLqYDsW8F4wNqj7xlZ0jAzFLA1LZNQKIY2vnf1hfZRHdC9am+z7343g12v753mQO03HLh9t/v9znOg9v2/ud8z/W6eiwB9Arge+H1jY+NBQE9TU1Nqj34C/KypqenxverlPJGyc1nxoxvRU4SolJ07jSPlO0PC9WwmLAs8WWU0rLkGy1LmHbO6N7gcUcb6XiW35NCMiZoM/1hGAVu+6Gx6dsQz5O7LuE9JskDrZtubt1Ox6AycWcv2qwhNkMyavKyGqJo+DoIATslPy9u3Ur7wg8laqO8klgUxPYu6VVcgSRCOZWPNoYioZYEmxK3d1jxi/DJtPEjZuaju+BeHYQhIrnpqll9A++a7UCPDxCJ+GtZcTvPbt+L2lVG5+Lw0V2lBEDGlMupWXU7rhluxLIOKxrP495Mmhx4LyjynfTLT8epr5rwxIEkCWmwgKT4TjA1sorDqSASheNpxFUWTiL89KT4TjA9upqjqaOJ1R/cNhiEiOWuoXXERAx3PU9k4ewmpVBK1UvML3AT8w0iiiKqnD7Cu77lI1A0FX+EhAPS3PgmQLD80lxIxNjY2NjY2NjapzKoimpqaXmpsbHyzsbHxJcAEPtnY2HgpMA78E7gEWNjY2HjlRJO7mpqa/rC/OpxAdWdRVF2eps7fTfE5XyLq3rutzQeXI0rPjvsIjjYTGu+Yc6kaiMe+li86Gy3ai+Co2qfis3Xj7WCZdDc9SEUj76gINYxpxOeGW9DVAO2b76Jm+QXvmgiNalkU5WYRis59B2oOOnUKghzDv3U93X++L3lsyfduAPfunatUERr2d+MrWINuKiw46BoEMXOcrmkCEyJUi40iuxZx6LH6HiensSyIxOauXA3DQlYqqGw8i66m+xN3S83y8zGEwhlFumEIOLOWUb5Ao2fXI0DcFbp+9VVENR+TSyvtLQkRWtlYvkebUqZpocUC9O16EIe7gLzy41D3oZVW0+WkCDX0iC0+bWxsbGxsbPaYOSmJpqamr0w6tCHl3++cCe89wGzWovciqeITIDTWSveOe+ctQgtLVjA0FNzr/ggCKMIYOybEZ4LupgepXe5FdC7Yq5qms322Q9GJqVOnvlMO0rL+lpSEN/FaqLUrLkJy1GLMUN7lQMWpqAx2v4hVq1F5yTl0/fHeac9NiNBsV3VSfKhCPtYMOz8JESp7ijFMCV/O/k1aNRndkHBkLZkQoQ9Qs/x8RFfDnDYUdmewhv72Z6hffRWqkTsna3QClxJDEIxksjCXEsawZNQM7r/xTZE9+zp1KlHatj5IYGQnELf47hcRWrAOBMsWnzZTSPxulB0ORrtbcLpd6OEIssed/BtAD4WRvZ7df086Z8Y2s5y7t21GOsM459unPbmPfdzGP+JBCoffs2M8U59GuyI4D4Ax3tO5sq/H6z01V96pNrPMlffaGE87V97h8drTNgCCJOMfceBw+/abvvmvSVMoCOB2quxtXdaEm2rqn8mC9N1Cys5lyfduSPsj5+VjauMER1vSzg2NtWFoo/OqBzifkhczYVlgCd4pJSLcWRU4vOUZxadDVpGkvSuFkbBwDrY+jCtjhlEZl7c47Ygku3A4sjGt/7xXxamoDLY/ztjABsbHtqJVRai85JwZ2xiGgGbsFh9z0WJyKAC9PcmavVJ/J47IOxcPkRChiw/7wpzFZ4KECF148Cf3SHz2Nf+dlvU34ZRDExscNzHc+S8cGbLx7ilOOUrfrgcIDO9IHhvufoXRnn+j7OPMvZqhoO1DUWvzn0Pid2Nw+3a2fvs7BJt2su26G9L+DjbtZNv1303/e9I5M7aZ5dx3qs1e38c+b7PjPT3GM/Vp6wEzxu+N8XpPzZV3eIynmyvvvTF+b4zXnrbZdt0NbP3mt9n0pa/uV33zzpoj3iUEIW7datv4RyobPwxiGRlyahywJHaeUw1RCausAUiiJy3JSdwN8QJMqRTTsNLaLPneDWnX3l9xtTHNQVHNqQCM9a/HnVVB1dILMtYWdCgqw53/IitvIZJnwaz1Eacj1b1WiwWpaDw7zXU0qrkorz6Nbu1hQsF2JNlNZfFp6IMqVsH+sci+WzjkGIPt/2Ssf33y2PjYVnKqllL+0TNnbS+JFhZgzsEqPF1scaqLryRZOBWVSMw1Z5EniRYORSWqOmcVwrohoRt7lplYMyQ0w8183G4T4tM/vB1RcqJF+uja8Q+02DijvW+CZVJcdjyRafMazx3TkvHlLZiwfiYQ8OXWYZrz/4pXZMiQ483GxsbGxsbGZp/wHy9AE+KzdeOtaNExWjbcRv2qyw5IESqKE9bDSevg2Rb4hiEgOWvjInTzn6lZdj5ihrhG1Z2VJgpg/8bVJkSoy1NEdvHq6cVnxxOM9r3FaO+bVC/96LxFqCBAJNCXFJ8AofFWupv+NkWEaoMhssP1SHku8tzLaPnfm1nwxS/s/c2+y0xxHfc68WZXpglQgKzCBlxFFSC5p332kmRhxdoQRQfI5XMSoTMhSRZmtJldG/5O3eorUI28WUVoon5m69aHqF1xGTHdt0fxr5lc6qNWEQhzc03PeE1FY6D9cfzD2wGoWfqRpPhMMNr3NpLkJKf8BDR9776GNUPGk7+GClGge+ejgEDNso/Grb3m/DZrHIpKYPB1cooO2mf1d21sbGxsbGxsUvmPF6Cp4hPAMvWkCLWEUizrwIjrk0QTS23H6S4kpmfNe7EtBYNYqoclh3wOdTCIOdKFYw9jV/dlHGxMc+AtOpxoBk9BhxxjuONfjPa9lTzWsfUvcRHqXjDnxbUgCKjRUXQ1PX41GuoFSwXSF9qtv7qVJTd8DbV7mMqzPgyaGncdfY/H+s5Epk2K5T//EeULz6Bn50MAVDR+CEfWMtQZkkAlxGfbpj8hCCJ1yy9CCjgxVW2PxichPts33w1YtKy/mfrVV84oQhPis23TnWCZtG68lbqVl++RCM00Lit+dCPkl83vQinohoPCqqPwD23HNGKM9m+ioPwg+lqfSZ4jSk7yilahmQr7IqGRpssUVh6KaYHDmbPH4jOx2TPWv4ma5R+zRaiNjY2NjY3NPkeYT0zTvmBwMLDPPnAuNWpcSoT2zXcQCw8kj4mSk/rVV6BTNO9kN/tCfM23to4kmvFF+pa/oDjj5TlSRajU35nRAmqUVO2+xhzOmWu/98W15oJDidLf/HcCw01pxysWnoEjZznGPLLxFuS7GR3YFhctWEiyi/rVV6FZ+WlzIHFvdVdcRustt6VdY3/c42zsq/pR0z0zobyc2PgmEMVZMxA79RCa0Uvb1rhYBBAEicry0+n+w/3UXHVVcnwS/XZEAhjDA2y7Lt21e8n3bsAqqwS1LcU1fKKvioeGNdcQ1aa+U6JoIWidtG76Y1oCK8WVS93KK4hq3r0elxU/upHYJAE63/deFAVkYYiWt2/GNGLUr7yM8HA7fd1PI0pOKktPR5YK0Av2XOhOpqgoi9GRUSxL3CvxmcDpKd5vIlQULdyOGDFNIS8/d1/UGjswdhLfw+zt7+bUJERGOIR0ACYhei8mMJlbGw/6AZqEyAhHkA6IMX5vjNd7aq68w2M83Vx5743xe2O89jYJkeR0YO1lEqKZfjf/x1tAo5qbmuUfS4rQvRGf8M67qaaKT7DQYn5aN9wyRYTOleqLLkByTmTanKNlL7Gw8I/ISJoO2r5NbDIdquaitOFDwINJEVqx8AycuSvQ9fmVahElGcFRQ+2Ki+nc/jfqV12RJj5TF09LrvvmntUz2c/sjwzMuiHhzFmOhTBr+RtR0uhrfoZUsWhZBiP+DRS+75iMbQz/GKFdzdRdcVnymKuqEik7F80ScLjykR0edHV3vU13VgXT19kUkRQvoqhgGrHkUcWZzf7MqTaXONZU4rU5C6lfcyVqZBgx7CTw+BZKTz4Bh5hL209upeHzn9vn/dzTEkkiEcb6N6Qdi4UHiIY6kdyLMPbhl5xTC2EwyPa3/kzlwjMJBMtw4DhgvQts4iR+NxpA0aKJjbP8id+P+Sm/Jycfm+3vd7BNUeM0/X6P30f+xIbfe7Fvs5077Zi/F+9jT+bKPh6v//i5MkObWcf8PXof+3Wu7Ic2CfL2kQFkOv7jBSjsFqFd2/9C+cIP7rH43Bc4IgH8Tb1xIQfx3eJoFCslPW+qqHA6VHZueJDURb8W8zPU+Sz5VaehatK8kgdJTmdGy950C2lgyuI7VUzsb2KaMylCs/MbpxWfcxFnhikgOWpYuPZTRFVX2hx4N+9xrsxXBM2VuYoWdTBAobiaIY9FNNwHgMdXSU50IS233MySG67P2K7jT3dN6bPqzgILVCOHulVX0rrhZnQ1hC9/IeULzpq2FmZS2K2+kpb1ceuiJ6eaysbz3nPuoom+iq48MEIUn/J+JLcDUzNp+Pzn9luCrz1BNXKoX305LetvxZqoq1Ox8AxkdwN6Sif3dhNEFC0MBmnZ8iewTDp33E9Z6Ul4fQuAvZvHNjY2NjY2NgcG/xUCFOIitHLJRai6410Tn5BZ6KQKwuqLLsC7oAGnN4weCqLKMvXLL6Fl8x0YehSArPyFFFS/j5gaF2LvtFX2nSYuQs/EMJVpLZ9zEWeJxXMMEABnqvifsOpWXX4+429u2l+38q4hZeey/Gc/Qsn3oA4EkzGb85onFjT/5Pc0fOEahr3rEQSJ3NhiWn5xM/PJ6GUJcRdV07SwUkToUMezFNWcMq34TJAqQvtbn6C8+lTUriESM2M+gijT5o0jL4/YNOfPl/h3jZhmHUrwXnpHTRMQy5IitHzB6ThzVqRZxWdyp3ZARmFKynFBFJFLnOyYEJ8JevuepG55CaJY8q5+N9vY2NjY2Ni8M/zXCFCAqLpvEn7sTySnk23X3ZAmTB35edR94Qq6Bh7Fk11F6cKziKnzK1ifXGjvA/dZIxaLu6kqu90k97c1J6ZlzkqatMjMcF8Jq7MRDqctnlPHuO6Ky6j9xMcIZvdQdO4xCEPitPc4XyvQ/nCdnS+mz4sW7qb59ZuoW3UZllSFmqIZBQHcUgAzqqEN73aHndxPS9dp/snvWfa/14FlYYyrScvnXOfASGQUTA/FUQfG+BgAhiRRVHgUpl8F9+xzOyFCyytOZcM1X0gTwPOxCmfavHEVZRHYj24n+5opLvLs2fxKiNDFh34WbTiE0dOTJuoN/xjRzq6MbafdAILk8eqLLiA35yBy8hsZH96WPM/lKcUh5xOxxaeNjY2Njc1/BQe8AJ1pcT+fhf+7LRISsZnO4qIpP1NHRmn9yS0s/vE3sBTfvMRnphqhe9vHVBSfDy0YxPCPIU2M31zHbbYxn/zzTNdNLHxncpmdyznepXX0DT5HMNBCMNBCRfkpSG4fanZJWl+c0TB6MMC267+b1n4m0bMnrrOZRIUwDytj6thJHieqNEhn030AtG64jbpVl4FUjmlOlCqS/OzacAtuVynu4SI6/vCnKf1MtRYaobhYkAqKk88k0xwTcrPI+uq1aIZOjisLwzRps8b49/oX+Xz56Wz/+rfmNS6pmKaFOhycl/V1T0m9d9nhQA8FEUwTqb9zWjd6yGwV3NffKfvSNds0IdoxwravfxNnSQmx/v7d15sH1RddMGVTSHI62fiJL7Lsx9djaioBfzMuTymF4hrUgSCU5M27vzY2NjY2NjYHHge8AJ1p8TWfhdn+iq+bK4nYzOlEkjoyitYfwSguSB6bU9zjpPuqvuiCWa2Xk68rOxwsveF6MA22fvs7aZ+35Lpvzsslb6a+Jdom65dO+vmMIi8WS46dq6oSFMecLXI111xM/+hLBAMtE0csunv+Sc3S85DEIgxTnJOI3ZdkLA/y4x+mCYGE8JH6O5PHEmOc7O+1V+NcWkjH9vuS51iWQeuG21hw8LVoYj4O0Z+skRpQA1AA1VdflBShCfbE1dtw5ZK1cDHff+GXjEf9AJT7SvjC4dcg9IwCe5YYaz7si82ltHvv75zWkp5gsvUv7fh7cAMsrQ+aSvk5H8R36GLGnnmbgUeenPe1Uj05JhPY0ETxqqNw51SQl78ScyyG5fa9p1ySbWxsbGxsbPYfB7wAnQt7ssBN7OBnWtzvDVJ2Lit+dCN6ShKipTdcj2Xosze20jO2GpqaUfzNJJo7/nTXlHIikxd+0wlD2TldZtKpzCQu5+I2Ox1TFuoT10hNdJO4PykSLxkz6+eIIqY++RwLC4v3ksu2rqrpZWD6O9n2zW+nnTPl+Ws6ercfp7uEWKQ/eTirYBGIXpxilOa34uIzQcC/E6nURemHTtvrPlsWuCQX5b6SpACtz69BSclyO5fEWNMJtLmIlkybMN4FDUjK7uu92zVe3+0NsNQ+LP3eN7AaFTpa76Pg4EMo5qTd56Rs9MDujMaTn81MdPzpLvgTFBxzBN5TGshfvnS/ZtqzsbGxsbGxeW/xXyFAp1vgplnpMriLzVfczQXVnUVRdXlywZVYQCeEbmKB566qYMm3vwGCgOz1oodCSZe/hPB8JzO1WsK+E2J7Y02cT7bayZ8z2Uoqe31x8S+K5BauoqfrnwRGdgJQvfQ8JM9CDEOc9vr7gr0RVnPCsmj+39/R8MWPM+h+k1ikn+yCRkrLT0TrGkDyOCmrP5nOFAupJLvJcS6k5dmbyVt3xF59vCpGuHvLA2wb2kmhJx/V0Hih4zV8Di9nOpfN+TrTCbSZMkBPt9Gxv97t/wTKz/kg4+YuRkfXAzA8/BoFBx+CnO3CwoV3yZK085PhDkxy050Y87R3rrIire3wcy9RfMreb3LY2NjY2NjYHFgc8AJ0PiVIJpO6qE0skmaKxZyNvYo5zWDJW/6zH2Hl5aJ3909x+XunGY6Mku/OSf4/aVWeY73MNIvyPqwjOpeESNO558ZSnksEKF3wYWh+kLySNTOKz8lWIF/jQoyYNq21fKb4wems2Ik2siInreWzCavpsHQ9KUJjleOI7QIbv/N5IP5cslcvp2rRh+nc8QCS7KZ++ccwRgwWfPELey2GJUGmJqeSrvFevnD4x9EtnRtf+CXV2eVIrr1PjDWTW/A77TY92dPinWKmuZIgtc6tHgoC8ULTligm56rocOA7tJGO1vvTrj88/Br5NavRhWzMacZ68nNwRAJTvpcVny/jd7WNjY2NjY3NfxcHvACdaQE6n8yvCVHhqqxg2/XfndOidbKInI9L7GyxmZLHiaoME+pZT37ewbP2ZTqmE+jSPGPOArEg7dY4+V+6ilxXNl7Rw7brbqD6ogsyx15OvnaK1Wk6i2SirZSyWF5yXXyMBElGzHDdyS7FiWcipQi0TO65mURVTHNR2vBhdFOZIj6Ti/wMC3gjprF1BlfY2eIHM5Fok59SCHg+wmry3E+I0MavfZHtv/tB2kbL5i9+jdx1qyn/8Cl4i+rQpBLMAivtM/cUyVA4uuJwDq9ci1P3IAhw3bFfQDYdaIYEruykcM/kKp9IcvVOCrrZmPxOpbrRpz7bucRb7wtS58p4R0/cPX9SUrDUOTOdu7Opqvhf20zBqoMYHn4r+fPS+pMxpUJMffbNpkxJzxLPUAsGk8eSscp7dec2NjY2NjY2ByIHvACdicTCLNUyNR0JkZIQPLORqSbe3lhaUoWULJnEwjvo3Hpv/IemScVHP0T3Xx5MazOXxDvTCXSpv3PamLP0BbaAZmlsjHZyU8s/cMsufvy+b0BHf7Lfqe0Ti93J4jFTjOt0wnC6vqnurOSiejoM/xihbdv22Iodm6YGperOQvL6QFIxtJK0n81lfu0N01nLZ3r+iec+xRI10XZy0qux19ejB8JUX3Ypssc/JQlVpiyvM1n2U7P3OlLOtSxQNHdam1SxPGUDZyLJ1d68W1PGaS+Z/E5NdqPPlC16suCabJGUPe7092XCMjlfgZYQmql9mOs9S9m55B1yJHKOG9HtYbDrBUrr3oe3YC2aPrdfFRldpadJVGa7PNvY2NjY2Px38h8tQBNkslgY0eiMiX9mE3epNfH2xm13Sl8lEy28g86tf00eG+59jbwFK1j8na8Sa+9Liw8VJBlTEpCy81BdWcTEGBDDE1JntHBKrqlCy8JCFaPgzkLwZKMrMaJ6hBtf+BWj0XEAInqUP296gEtyD8/Y/2mTqYi7rUBJa/PEuCb6NpfFdkZL5IQ7a+IaCXGVap11V1dhycoeW6Ak0cJS2+jrfpWyBR8mOo1Q3R9MF/c6F8vuZLE0k1gObt+BpRsZP2+2JEHT9XWmcyFeAkbKdaF5qhD7pu9bamy0ZcUbpj73mRIIZdok2VO3/bmUBpocc55IeiQ6xhCsuVkkp7PSz5XJfZiLgE/MFQPI8R1NTvFSLKlwzuLTxsbGxsbGxmYu/FesLFKtQYZ/DD0UnNZ9NFFrca5umzB7CZX5IGCgx6ZmhDREFUdBHtu/dWPa8UXfu47vtt3Lpw+9nCxZ54mWfyOJEqfJi6atsehSIkSUfopPPymtxMK46ueJXW/z4cb3E9AD3LfhEdZVrmY0Os7J9cfwgcUn8f3nfsWG/q2YuYfu8T0mrc0prrPTjW3SkjPhkmkQX8Dr/rHMVpUMnwOw4kc3Essv2yvx2bbpT4CFtfM+yhd+ZJ+I0LnEsO5L5uOWvr8RBHBIfto3/4WqJedhSNK05yae5XzE8HRCc0/KySTPm0dpoORnTkp6NFtNTdnhgEkbBe90ll5VVxDFsjm53drY2NjY2NjYzIcDVoDqcgzD9AAgiBaaqCLrMwuCybFzmURmpuQZc05qNI9alNMujg0FT/4aSoG+5scA8GU34B4oItC9bcp1wlqY3uAA33/+lywpWoho6dRml02btdalROhq+ivh8XYK1sZLLCREaFAN8XT7iwxHRmge7SCohjiscg3fPu5z5CsFlGYV8MXDP07MiOGIOuZlVd5Tq9O0JTreISaLT4Dg6C56dt5H2cKziGmuaS3smZISzSiKJphtTCaL1pk+bzKT3dInz9n5ltTYUxLis3XDzehqkNYNN1O/7GPIWT70QHD2C8xApjjE2WIOUy2bCffh+ZZqmldJpRlIbJClsrcuq4k5I3t9c3b1lUP+ecWJZ0QQUEpyqPv0FbT+8tY5Jy2zsbGxsbGx+c/lgBSgmhzlzk33ctqi46l0VdEe6uCJ5me5eMU5KLprr649H+tIYvGecL2dLh5SmuSyB1kzfo6my3jz11BmGgSGm/GOltH+uz9mtLD6FB8fWHQi/9jxFKJl8MHSBciqH0euL/1EUcRR7KNzQnwCDA+9Rskxx7Pi1B+j+6NYuV6y+nxs6I8L3Q8seh+LchehmE4sI75wdBs+PIIP1QW4Uvo/UZNytqQ6me53MmkibZ6WOik7d5/E+SWwsLAsc+px0yAhSKfc2wz1OffG+pZgSi3XudQDncRMQlgIjMyzR/NjsvgE0NUQLVvuYOnPrkMfjGFNeCJMyZw6l4RiGdyAF3//O+DOQpOjRM0I2VZemhaayXXYEg10WcWpT4pdna6cizj3ern7CkckgL+pd3fs9SShl5gzsbwSyEuPYZ72+20PapNOnleOIh/dHY9BlsGq3/8UdTCYPM9OQGRjY2NjY/PfyQEnQEVRYDA6xJu9m9g4sJ3/WXsRv3rjT+iGzqkLj6fSUYVpzm+XfbIlA2bf6Zeyc3fXxJtmUTztAo7yWfuk6TJeRz36wDjtt/xx+hMF0A2Dw8pX8IGSevytcWumYJKWuChr8SJC4Y6k+EzQ3/Fv8g5ZhR5QMcf8/E/JyZimwYjDYGdseEKApY/nTEaM+ViBpyNVpM03wY/qzsJRMNVK6sjLIzavK8UxTRHJVU/N8vNp33w3YOHNqaOi8Ryi2sybHZmyuu6JK+XexCxOR+oYCwIIgoBqWoSlAJ1qL+Xf/n8UZhWiBvzIHg9LrvsGkFqT1kDs70BAQMrOJZrtQtKVOZUEiWNOEfaWaWJJMmZJIRP6M97Om7f7vmfImDvT2I5ExshxlXLn239j82AT3zzmM+QLhbMa5CzRYOv4Nm556y985ahPUiJM3YyYjJSdy+Lvf4eh8AhBNYTgzM94TiKWebJFMhEGMB9my6qd+Mz9LfpS55VLidG9636Co7sA6OYRyhedTVRz2eLTxsbGxsbmv5gDToDKIT9VfoufLb4SpdBHeGwzPzryE+yKjFPmKJ+T21imrJjzdXlLXWhN67a7l66MRiBG5y13p/U7bVEpwKASY2R4kDPLFuFv/Vfy3OHe1yhYfggrfv2/6GOReD89eRRVHcNg53MkLlC34iK0Pj/bvvaNtM8u+eq1IBUQbduFy5kNVtw10eH2zSvhy94mU5mOmURZJiujqyiLwODU2NrJCIIAWElhIkkChgGSq4Ga5ecz1PUyFYtmF58wg/vwPAXoXK2mk0WZIxKYVewKAgSEccJamBKlDN3SuK39CQKxIN+sOQf/jb9O73+GjKaN37+e3zc/ycUrPkKWJxdrmvIxCSwLVCOP+tVX0rL+ZgwtHK8/uvoq/IKDsDFEgViUcSNpxoy5M4ytPxbgun9ej2ZoVOWU45bcWHOYmCYWUS1GzFC58YVfcXX9B/B+6Sq8Dg8uOTtjm4jPyb09r/N8+6uU+Yr5WM3JuL50FQ5JoSyrFCkrNy3hz2SL5HSbLvOpMzzFSs7el9SZD04lRu+uBwiO7EweC4610LPjPsoWnT1ttmkbGxsbGxub/3wOOAFq+MfY9s1v0/C5qxgKPkck1IMn0M3qhR/G6O2esRbntKJlHkJRFIXkwlgQJhbT05U6mbjuZGHgb9qRFHKJayQQBCFpcczY35xc1AnXV1GxkPUxyoJFeEQR/+SxMmNYXh+GsxCACJBTeiQAg53PU7vyEsSgi/CO7VPus8xXghQaove7P6Y35fg7XT5hfySSmW4hr3myGDD68MgufOSgijHawj1UuavAkJFcDVQ0VhFVMy+ek9d9lxL8TBa8c3lWMTnMD579FUEtzJeP/ARtY51cffAF/OSlP6Aas99H9UUXYEQinO5YjN7WgegOIGXlAjN/rmVZaFYeFSsvpn/bfeQu/ABh2cX/Pv9rRqPjXH/8F/CSM6XddKWV0rwYphl/zdAA+OLh1yCrcXdaSzTR0Zic/ihxPc/wMIeEczl44ZXELJ3+yCgxr4OK2qXQNZDxc2TTwYl1R9I53sP/rLsMRVC4N/AwSwoWUpxfgWVOn2wJps/0PLnsE+z5+zgfMbsnlnzddFBQcQiBkZ0kXNVBoKDyMHTznXdRtrGxsbGxsXnvcMAJUBBo+NxVjEhbiIR6AAj7O+nZ+QB56mLMcW1Ki8TyZzahOBu6FGMgNkipoxQZhWFjEKfswGNktoTMZq0RvFkMG4N4FS9O3YMmRRnXxymUisAU0/priQbbxpvIkaBSzCIihHiq5XlOrTue4+qPo3Osjbyqowl2Pg+Au3AJw9kNuCyL1OWeqivklB5JfvlBqHoWZrQrc9+RKPUVM7eRmZub6HwWvcn+7oOYyclM5xod8lnc+O9f4nG4+epR/8NDTU/wQsfrXHHQ+RxcsAbDEDCM6S03qTUYU2ODYWo2X0i/9+nGZjYhlzhvTzPbyoaTjyx9Pze/dTfffe7/WFexirAWmXN7yelk1w0/ACAKDDB3N3PLtIiIXrTqE7j+5TsYn8j+fEjFGhzMz0ImOZ2EdjUjOZ24qypY/NUvITgcoMgMRkfpYLf1+/5tj3PWovcjWQpN/h00De/i7NKjafz+9QyEhiny5iOpRrL+6GQrtufL1zAcHaUyZ5o5b0GxVMrnD70aacLSd/aiDyChIM4iPiFlzvd37rM6w5OZS3znnlqbAQxDQHLWUbviQto2/RmAmuUXILrqMQxhn92HjY2NjY2NzYHHASdABVlCLskh0t6bdjzs76Ko5lD06FQ3y+kyws4HU9J4rPUpHt/1by5ZdTYL8mu58flfkeXw8tWjPoVD90xpM521JsGwOch3nv0ZdXnVfOqQy7hr4wO83rOeLx/5CWpctWkuiKoU5Tev34Eoinxy3aU8sP0xOsd7yHL6OKb8cCKGyfqxIY6vOhojMkSbs4TB0W6qchYB6ZbbeIkFB6ZpTbH8pCJYc18ozkUoTrfodUz8LJW5xkpaso4wUafQFA0sLCRz7tM6VRj6ese4ru48WsxRvvSv7wFQ4i1kccGCOblrJkgtGZK8n1nccecULyxaCJaYtJCLEpjG7PNsJkRTYk3xShryXmIgPMwxNYfyk5f+gFN2Uuorom3eV0wnYdEXRAEx5MccH0OccHMGyMnJJeIuSIpPp+TgklUfQYjO30qWaYzrb/gG32y5m6qccr5/4pf52cs382z7yxxfdzi5zhz+vOl+RiJjhLUIXf4+BkPDfPLQj6F0DE77OaZl8r8v/Y7vn/gVZFdV2s8S08SySIpPAMXcu+RosyFl57LiRzcm424Tx2aatmmWTZjitr038wrSRahlmbb4tLGxsbGxsQEOQAFq6Trdd9xH5aWn09X9CPGFrEDdsgvo/PldFB19zJQ2oiXMuBCbi/VOMhUOrzyYZ9pe5o8b/pY8/uElpyFZyh7di1fy0pBfw/ahZj71WFx8lPtKKHQXYBrpotlhuLh23SX85vU7+MWrtwBwUNlyDis7GHSJFflL6QsO8vTYIKXefDb17+Dagy8FVQbRokfrIc+Ri9PwoMoRhqMjlDnKQBDSYmJh9nIcqW7Cqf/eU/Yk2yZAVApy9+YH+eiyD+HGw9bRbaiGyuqClYhzFKGZREvhV65J/vvadZfgs7Ixmf89psXs7qVbriWa7AzspNRXRK5YQEQIsnFwGwcVrUQy9tyl0RA1Xux6hebReHKq9X1bOW3h8aytWEmWls2i712HXw2S68xGsAQUn4/G719PX3CAmK4iOQumvbYmRRnVxsgVi3jmtR6OL1Np+/bU+NHfbtz9PsUMlfu3PcaZC05FnsHaPOWd1VSinVOt+Q7RySfWfYyG3FrcppcvHXkt3YE+CuUiRF3iK0d+ku+98Ete6HgdgMMqDsIlO9FmmNPF3kI+c9gVKLprD2bF/kF1Z1FUXZ6Mu4W4GJ7Osm6w72KUZ8IwBERHLaKALT5tbGxsbGxsgANMgAqCgJnjoeLSS5CdLuqWXUjb1rupXX4BYshDcEcz+YccytLrvoEZU0FRECaySs6UkGUm613qAq5EEPh+w0Vs1/q5qeUf1OdVc2TFurjIS2HKom8a8eE0PHxy3aVJ8Qnw+SOuxq37ppwrmBIL8+vxKO6ki+QJdUfhNF0gwLjh56nWF/BPWJJkUaYn1EeVq4oetYfvPfcLGvJr+OS6S/nDG3eyc6SVG074IoobvEuXIFgQNWMoooyUU4DqysJBejZZWZExvG4GjF4K5WJERIb0fnyKD6cx1QK8L5kypgKE5Chv9Gyka7yX4+uO4O7Nf0cWZZafvBiHuudT20zJQvp/r97CV4/8H3xCzrxLGKYmgpkxZhFmFKiCAOPWGP/36i1kObx84YhruPXte+gY78a9zsXK3BWYhhW3gv34h2lxg7PF6+mixnNtr+JR3Hzt6E/TNtbBpoHtNA3soqjiCGRXHVmShjlhZTYAPcvD6+3bGIgNcqW7Knk/aXHOO3chBseJhgcxPOMcVyphZYgpjepReoL9HFqxhrOXns6PXvwta5xVyL29SNZu+/zke5j8zk5npROAFbnLMQ0LC/Ca2TRmZWMa8a0rWVLwKG7Go/EIaofsoCqnjEhWhOZpnodH9uB2VpGhOs9ekzbPJ+ZEYmzdVRUs+fY3kL0e9HD8O0AwTcT+TuRp3LWnt6y/c5im+I5+no2NjY2Njc17mwNKgAbFMW5441cUegr47GFXsqGvg6WrLqNLM6h2Ocn/+qcZ0CI4TINdN/4ore2e7uxnWsDlf+kqAFpGO3i19y3WFR2UZnGbqSSCJVgIAki+XGJyjLs23pd27T+8+WeuPfhjOCbVHIxKIX7+yk2EtQgFnjyGw6P8/JWb+dKR11LmKeHPb9+HPxbg9IUnUpZVws1v3cWvX7+d64/9InnOPBoL6tk2tIvPPh6vF3n12gu5c8P9bB3cyfnLzyTfk8tvXv8jhZ48vnH0Z5E1CGc5cPiqCEQMeoaD5GfBQ7v+wZt9G/nsoVfiUdz88MXfUJdXxScPvhRlUp8nI+Rk0/j96xEtERCwBBMpOwdjfHyPnsPi73+HI6rW8lLnG0nx+eUjP4FT98xomZqtzqhDUvjpKd/msZ3PUEs2clc/ouxPBhNPJ+jmUy5lcg3JmeL7LAu8oo8zG0/m701PcN2/fwrAqtKlNOYtwNR31yOV/GMZ4/WsLA+iIWFZcUFrCDqiKePUPXzh8I8TM2Lki4Xk5udSmV1GnpKPZChYWEkX5wSy6eSUmuOxBBM5qLPke98FLTblfhLWtYQ0rP/ml6fcm1v28P+O+DgV3nIcposvHXUtUkcfO7523ZR7mK3+5HT1XxPeBKniTgIkp4IWGOOSnMNwFTgZVjR+tfMBlhUvpNzpxvWlqyC3jPpvfjm+MSMrWKIUf/7zFJ8xKYyBjtfMxhIsImIQp+VCNNK9J1LneSKW2FVZwbbrv5s8J1Nc6uI5xt0mmE+93NR5bQkWFhaK1wf9nZiCiWCJCMzdbd7GxsbGxsbmv5sDSoA6cFCbW8Wmge18/onrMUyDLKePrx31KQwhD7O6jMe3P841uXNbWCWIl9qYiKtLiZWcjkJPPtcd93lufOHXPLLjKdaULscxg8tnsgh8eTGPtjxJh7+Haw+6hFF1lNd6NlDuK+HzR1zNzW/dxfahZrqDPSzwLsQw0le5AgIHlS3n0lUfZfvwTv7wZjy5h6grXLbqo2wY2MLa4tWIlsSnDrmMsqwSJMOBgsjH117MZybEJ8Cyokaqssr5/vO/TIo3URC4fM35KIaLmBThzk1/45SG43jhpSiLlpps7W7m8Mp1vNW3iZ+9clPyWifWHYU0TWbLxKLfwmJU9RPRopRVNDDitLjxhV9yxUHns5iZheu0WAJLChfwUucbALhlJ/mu3FnjNWerM1qWVYKleflAw/sQu7vZ9Y3vpP18shjSxBgSEqo7C9GbjSZFk/F/ia5kchlNZUqJHUDx+fA37UDSdCTgVGURpQ1Oft/8MADnLP0ADsONNYsjqCVYPN72FEdXH0qOmEu/1k/TcDOHla5FMhTchg+P4MM0LQQkiqUyLGPmaypm/P5UN3OOExSFuCUs1VoqqCoNfieSpRHJFrntrb/yQeeSjPcwE9PVf03dAJi8iZEq5KLAku9dx/LiRmRJ5puv/wGfw8v5xWdy+7Z70QyNG074fxQIRcwyNFOISWF+++YdjETG+MpRn6Qn0M/PX72ZC5Z/iENL1iKZmV34E7HEiTqhk0kbRy2Wll17NlR3FpIyNqf+J94XVYry121/p3mkjevqP0rT17+d1gdXVSWSMmYLURsbGxsbG5sZOaAEqGK4ufrgi/jiv27ANA0M4iUVcoV8TNOiVCnjilUXInT3z/maqhyhN9RHlbsaEYGOWBeFrgJchnfaNj6HD69UyteP/hQuyZVmcROE6RfLBjotYx3sHG7l5Z5N9Ad7uGbthRR5CnCaLq5eczE9oT5qPDVTxKfL8PKZQ65ERERSHSzPXcKPT/46iuECQ0BGYW3ZStzjMQz/GMvwQThEWB/ClV/A4wOvIyAkxcqvXruNTx1yOSc3HEuWy0uRN583ujdSk1VJ1AoyGB7hrd5NbOzfxok1x/LHrc9yUPkKijyFXL7mYm5+6w4ADqs8iJWFy7DUzG52mSyXjh/fwJ93/JOAGqJzvIcleWsylpvRJQMBOT6ek8LHHPn5RIwIt7z9F2RRpjK7jLaxTn780m/54hHX4jamujFnQkyzysafnZSTiy7GM8RKwjTxlaKFgIguqvx9x2PU59ewruQgBiL93PbGPXxy3WVpfZjNZbT34X+w4Ev/L61uI/2dU8Yu90tX4ZZdRPQoP3zh13zt6E+TI+Qn43DNDHMvasT4x44nebHjdS5ZdQ6/e/NOdFNnadFC8oVCLCu9FJBlWQiCgCTFN2NM04qXK5FiOHQPlmURk0JIloI8j5IaktdD/Q3fRIyZ7Pru99J+tuR7N6B4q/no8jOJ7No1JUGOoGqz1jXd24zJEhJXrbkQxSFzfN2RvK/uaPLlAkqPLGbTwHZypJx5JaNKvW5VTjk7R1r5xtM/QjU1BATKs0qQ9uIrODWG071oIXJJKZWnnozgyZ49Llsypy33ksltWxDBEkwqsssJaiqjThnPksUzxpEKgoUpWAimiCBAUPAjCiIKDkRBIGgGyRZyCMSCezwGNjY2NjY2NgceB5QA1UWVp1qeQzc0vve+b/HrV//A7evv5VPrLsOJF9MEQRAJ6SEAvAcdhNHfj6jIxFBxKBamJiQtnroc4+a3/8yWwR184fBr8Dnd/OCFX1OTU8lnD7sSl+HBFOJCcLLVRujrpCwnF82dRUAYRxQEfGTjF8bwB+IZep3FRcQG4tk0VUvFxOLkhmMREchy1ZDnKWY01MHS3CWIhoIThQXehqQ1djIJUSwIAqPGKN9/9pdctvo8Fucv5LFdT7F1cAdfqfoQTV//dlq7+hu/zeE1x+FSPCwrbuDezQ+DILBjZBd5nmwCMZUu/xirS5eyc7yFx3f9m2OqDuH6E77K9579X17pfZ1L1pxNVI0hyh58rnK8Dg8hNcyr3W9zeOXBNPgaEOYQ6yV5PQQ9+RxXfzLVORUcV3kkhunAcu2u+SiKAkPWCDsG36ahcDW6YZCt7y4NImdns+DHP0Qf7serePjs4VdS6i7m7q0PEtNVZEFGECAgjCMLMh4ll5Aaxi+OkkU2wkQpDF1UeWb0bZ7veI0vHfkZLAxueO6nXLb6XIxAN9XZlWRlsC4aGGz1b6UyZzGSIPJi5+us79vCwsKVPNX2Cq1jnewcbWF13krMOQgWZ3ERDTd+HwYHM8YApuJ1ePjCkVfTMtxOdV4lMUMFyUSTYuiCRjA0BEDWscei7dpJtLsHURD46tGf48cv/pL/e/VmFhY08IlDrkTWrLQ4xqgUQkRE0F10DfjJybfo6zWpr8imLbiT29bfw9eO+hRu2cUvX7uVpUWLOLnm+FlFqO+QdSi1tYwGR7kvvIHLaz6AIz8PdWQ07TzTtCh2FhMu0RGHdsw7QY4oCuiWjjgROypIJpYhZkyU5WlchNC4eMo1ZM1FYW4WZy14P5LpwNAtyhzlFFUWIU1yl0WwEADLEhAEAU0JI+kOBFNCl1R0NFyGF9lwclbj+2kZbadtLJ4o6bI151HnrZ+joJ1I+CXLWLqe8Qzv+ReiKg6iVhhVHEcSRWTDgSODW7iQn0NzqJMaXxmCr5RgRzOd1/0g7ZzUsRZE6NN6eXzXM5y17HwaClfg1xV8534Uutqn9MUUTAQROqIdBNUwS3IaiQhh7tv6OI0FNQyGh1lcuJCnWl7gzMUn81TTi5y7+AwUff9mCraxsbGxsbF5b3BACVBViPLIjic5vfE0Htrp59zlF3D/1r/SMt7OksJFSJqCJqj0CCFyv/4/OKpX4sAERcY0Yvyz/WmOqTmMltF2FuTU4xE8nLHkZCwsBiNDvNLdzhmN7+OQitXcsf5ezl72fvxikPrvfQtPVR1bLr8qbQG45Ps3EPEJfP+5X+IQFa477nMMjA0RdVoUXvcFyhetIdiyjQH/AC3GCEXDAotUJ7XLL+YXmwdYXuil2O3FEDSUibIoliAgTMSJmtPFmQkWQTVMVI/x69dupya3graxLnJdmS0f0ZwCblrfyyUr1vH0roe5Zu1FhLUoXYFhFhYsJ6ia9IeD/HnjrdTklLO6dCnVeZUMRt2cvewsjqpZx/1b/s6Cgjq2DAd5tSfEF4/8DN3jbdyz5WEe3P5PPnPIlbOWmsg/+2x8Rx7Jb3YOUZejUOTORxd0ho1hcpVcvEENLTCCBUTDw6ytWsqfdw2iWwYfrSuj/rvfoDcwQE7VEn66pZePLS7kE4degmmZyIaTcxefEY9P012EpQA3Pv9L1pStoiznWOpzTb777xv5n3WXsiRnMZgiJgZ9wUFGouO0BwIIgoEkiCiSzM9fvJllRY18suSkKffRG+xnfaCHptEiyjwOfrzyE4Q9Xn71ZgeXL3sf1dnFrMhbQkyIojB1TAQBrFwfi78fd+2NFpbws619XLusHEdfN9u//i0gc1yoR3Hzqzfu4oqDzuOnL9/Mpw65lILsPF7reZvFhQ1Y2V48X/04QvUq8gULcbATqaiEkajEqQtPpnlkByc0vJ/HWkY5s6YYwTKwLIGYHOY3r99OoTef85ZfiOUN8p0Xf81lSy/lmQ0jOEr7CKohvvf8L/A5PPSHhvA5fWhiDFEUEXO9yfsxMTEEWHT9N4gJBqHiaoI6BMa2sbOzhf4FbrIvvoSh//u/tHuzHCqDmkbMk0dJVeZ4xoSYTJSgEYS4aVwQLQb1fjrHe1iZvxxTMHiu62WOqFxHtjsfPaKSWlXIc975tEhuFt3wLQYiIxRWLQZpd9IjcSL+FcAyQSIuPpMu+qJFe6QNl+SkwlvFqDaEW8xmZ3AXi/Ia+Ffzv1nft4XPHnYVDsNL23gb7ePdXFX/AfJVCWVEw1LbUMoqEUKRpLVxsqu2IRgEZYvcr32KimWHEOtuxzBUar71JZxiXPgXnPFBnldlegI61zSWMxDq5c6N93NYxRpOaTgRa+LaoiigKmGax4bRTR9Pdz6HQ3KwNDZzAjFNinH32w+ypmw1T7cNsaY0l7/u7KHeLfOhBQtAFNO+rAbCw1iGhx+/+FtMLH56yreRDJkTG96PV5G488nreKL5eT53+Mf56Us3EdLCrCtbyeKsJbOGP9jY2NjY2Ngc+BxQAtRrZfGdE77OQETm2U1d5LnyuPygS5EEgzHNQLD8OCUf5Gfjy6riz1v6Oba6gGeb+zmmykOnv4c3ejZw16YHuWbtRWQ7fQTUIB9Z9n7e6NlGjquQnkAvN7/5F0ajYwTUIEXlSxhTQzzWOsyR55yNKMsM3PknAFRTJWbEWFzYgD8WJGLK5LoLKFq8mG2DHfz59WZOr3fhd7pwyAo+pYDOaIT7tg7hV3Ve6hmnMb+I6jzQtS5KfMVEDAcuKUR/eIhqd3XcNdKcWGRLFpgClglVzko+f9jV/Pil39I21oUsynztqE8h9fqT4+VpXITnvPP5Z28Yv6pz95Y+Llh2JorgwKMIlGUtwK+a/LOln5GoxiVrLiHXJXHrm39hacla/ripk0+vXckdm7r58KLTeaNviKfbxjAsi76wk0VFa/jWcauQBQtFjS/eRTneX1WO4NCdWAWFAOSefjraiSdza3M/QxGVoYjKiqIqlhgid216iByXl6vKTqLpa9/Gu2I5vmuu5d6uAFuG4+55fxMFTq4rh4JcnhsM0xeK8WjHCAeXOKnIycNvjOGzshAsiYA4hixKHFF5CAuL13DHpn6OqfbxgcbT4vGdsomgijhMN+cs/SAHV67jX21hfA6Ri1efT7mvhHOXnUGBJ4cNIx3UX/f/8ChuDNMkoIdx1yymarCBx1pGacj1sKChhGc7hgioOnc3DXD+0oMY0v38ZdPfuOagS3DobjQpii7oeAwfIdHPrU33cnrjiZiWmx0DAXqDUZ7rH+ewvDyUnBy0RGKmSYv7wdAwJ9UfhWroqIbKT17+Ax9YeCIeh5snW17hw4tPpM3j5LGdA6wqzuaI2gWMqCb3bG3jqlXrOKRiLU+2B9gwMMqakiyylSh5Yg6WZaGaGpU5dfx+fRsn1ToREDAsnVc3+Lm8dg3fOm4F3/n3DwlpYWpzK7ls9bncu/UfHFd7GD9/9RZWli7h/BVn8uiOp3mi+TmOqj6EDy35IH/fNshQROczaw/i0ux8/rS9j2PzSqlcsZzAps1AXGhtH2kmZJTy7w4/X1hZi/fQQwm9+mry3k3BYMDoJceRhV+L4HO4iKjRuLVPlPnJS79nPBbg2nWX0jHWySM7n6LAW8ZLW0b52PJKRI9Iw/e+jZ6Tw+ODOptahvji2hoUw8cGf4Rir5OaaAx/Uy/SpHqaqjuLqBSiN9RPVVYllqiztbODiDrOCQvKcEjZ3Lyhl0NKBX740q/p8veyrGgRvcMBnLLK7976EwICy5xltH73e0QB8ZRT2HXMyRyR68SQY8i6E9WdhZolEdLD5IuFaGKE296+i9KscqJbOzmlvoAfPvdDvnz0tciqk8LrrudZTeH1objXxx9bRzm1oZzPHfFZHKLJUMwgxwEuS6E/1s/L7espzDqMf7cPc9nKtaj6GNl6lDEg/8wzCT7/HOrIaNLzA0A2XVxx8MdpHYtQ4BO5v6mXkajKSBTCoo8zfvtb8gwNa3iQAXUcvbiUkOqiwJ3HecvPxGG4MCWJx1u6WFLo4hOHfIwnW17AEopYW3EwZVl5NGQ3TCk9ZWNjY2NjY/OfyQGVH1/xuHi0Jcztm+JubC90jXLH5mFMsvn9273ETBf9IY1cdzXPtgc4pLyQdr9K63iYh3aNc1zdGaytWMuHF5/MSGSckqxKRER++cptHFR+FNW5KwioQQzLoCKrlGJvDc91jtMXlnm5ZxSOOZ6BNYfiqq0FoC80xM9fuZkjq9dx4aqPcuuGLpxSDjtHwqwflBgMq4zGsjmo/BBebH+dcGScrLwccpwTLoJAkceBQxS5d+tDdAaC/PT1XbQFx/ndG3cyZo3w1sh6TFHHEFVeHXiDkOBHEEATNIqzynDKcbdg3dTp8Pckx0qQZSqu/ThPaw7eHIiXZhmO6vxlWx8aAgFNZCxmcM+2blrHI4zHdO5timFaBZy94uPcs3WQsxrLeanbj2lBULNoHdMwLIssh4xlQV9Q5c2+AF1BFZwSpkNl48hmhs0BNgzsICjp7NAFFv3sh+R85CwChkWqgUMSJGRRJt+Thz8axCipwFFYiFJTS1h2MBDRkudGdSjLyuWh5ggvdYcB2DESwyGXoMg+XunaQGu4FT8jfP+FX9IXClCQfTh/2jKOBTzbEWQguhhZyeeBpkdR5RC6w2BEk3i6XaI7GKNpJMILXQphw8WxdceT68rn9rZ/8uUdd/Ct5ru5O/A6odJidgUMnmwbQxEFzl5cyb86hnlzov7iQFjlrq29OGQvF606n6AeJKoEuWfbg3z/+V8QlMawBJOPrbmEBQWLeXCXxvOdcVfUJ9uGuXnnKIv+76fkfeD9mLV11P7gByy57ht4vnINxT++noBbJBALUeur4pPrLuV9DUdzcPkKanIbOb7+ZMZVBy91OxiJaNTlZrFxMMpv3upkcWEWWS4vN20YZMNAXNT/7u0OnmwPI3kUPJaPzx7+GaJmNX2hGP9qjXLDid9htC+LT5y3hOw8LztG4fCqtZy64DiGwqNopsqOoRbGYn5yXdmsKl2CLHk5tvYwPnXY1Zy08EPcsnGAnaMRanO8dARUXuhWGIlqPNQXpPXCK6j5w+9Z9rMfESgsYiCax0O7hhmJqnRqAq7LryT7yCOTc0A1NO7d8g9a/b0EdQ8vtL+BJZj84IVf89MX/8CnD7scp+TAqRRQnlPPl476PFGzjM5AhEdb+uiWJQaLS/ljZ4RX+8YJ6wY3b+5GEAt5vDXIc50hdMXBlm98m21f/2byjxEYQ5dj/PqN29gy2ERfJMRIVGdB4VpOazyD5tEwb/eH6PBHaPd7OHfFeXxw8elcsuZyHvv3AA//u5tLl1zONasvxyHF31fPwgVoRx/HIx0jdCMzpAaISSFMh8Yf3voz1z/7M/xCjKCucd7Ks6jOO5jNQyGeaR/hhpO+zWAoiN+ZhVBZyVhKfc2AGvfpfbR5GNV08pu3OhiMGrSFO1BxYQgreHhnP35V540+gyxnNWGvB0dhIaEjjyH7oosBGI/6sRwaoihgyRKqYTEYjqGIAh5lt6W42OsEp0CHJLM5S6N8+Vp6NJG7tw1y7sqP0ljYwDgGj7cP0jwW5vGWUUyq+ejKS7htYzfLSw5hYX4dsnVA7YXazIAkCRn/FsW4q7ogxPfV4n9nPjdzm/jf052b2ib1z0znSlJ6fxLtZ+8TKX9m/5ypbeZ377O1SXg+ZRrjuY7XXMc49bz53HuiP/t3vPZ8jOc7Jy3LmtecTFx7vnNyz8Zr+jbpc2X/zcmZxnj/vMPv3TkZz6ux/+fkvn6H9zfCrMkq9jGDg4E9/kBRFAiJ8HTHEC92j3BSbRHLCn3cs62b6hwvOQ4ZRRIp8znIc7l4vnOYV3tGku3dssRn1zWQ5YDhSISHdo6wrsSPx5HN460mEd3gipXFjEf6KfJVETUkHmvuY8tQgEX5PpYUZPFocx9fPriOoW99k5JvfA3d4yCgRmgeM8lxullelM0PX9nBeCwuni5eXk3beIgPLChheOcmWswc6soKuW1rD2uLszmmKg/NMtg1Ns4jzeOMRHVqc9x8pLGUF9qf4oldT3H+8jOJ6jEe2P44NbmVfPmoz9EfHODlXoNCZxf5Lje/feOPGKbBb4/8CtZ4gM7xHoq8BUTdboZc+dyyuYejKnNYUWiR7Srmto0dnFBbzHBE5am2AUwLTqkvYk1xFv0hlbq8bH7x+i6GIvE4REkQOHNRGaZlUeh20j4epsTn5O4tndTleDmiKp8Cl0FEG0SRPESNHAIxlZGoSXW2m7u2dKFbFucuqeDx5n4W5Xs5qtLNz178JdcecgmylMcdmwb4eKWXYVXn7v4Ip9aX8kr3MGBxQrWJZUWQpBx2jSo82znKxcsrGYnorChy0B+OMhjYSnlWCev7dnJc7RGEDYlHmkdoHYvgliWuWVNDSO3ngS0PcOrC4yj2ljESM3i2I0rreBSAxfluzlpcwa0bOjit3oOmD/Dr1+6gPq+a4+uOwLBMTBZQmZPF7RvbyZElrqj20R3WubXTz7EVubiVdnJcuXQH81hbYrF5YBMhNUxZVgn/bnuZQysOZZe/ko80ljAYMVjfP8abfeOsK/NxfLEXOntRCwoJRjWipkWh3s8vux/l8oM/w3CoHZdsUOQtoHmknZHIKLmufBRlCYIgUexx8MCOXg4uzWVhfhZd/gj/bO0nohl88qB6IobBAxMWrEPLPBxekUOx4sbp9nDH5nY2TmxW1Od6Ob2hlGKvgmXBv9p6eanLz1cOX0BUj/B825MUefKpy6vm/165jS8f9XFU08mft45xah3kKOB2lvF2f4hn2of44MIy3LLII7v6CGpxkdSY7+XU+jxe63yBo+tO4K/bemkbj3BERT66aTEUiXHJskpCg53Ehnopr2zg/t6XOLzmJH7xRiefXVfNU80P01jYgCLIFPsK2T7cQU+oiguX1/Kbt1ppHw8n3//qbDeXrqzmzb4xHm/u5311JeS6FB7Z1UdAjVs8K7NcnJ2voD/8d4Ivvxwfi+9+A6G6mp2jzSiSg+axLA6tKGIsZlCd7eZ3b7XSGdgdo1zqdfHRpRX8dVs35y7KYTg4yIsvRVhY5+PgrAh6yGKLO5d/DoTRTYsPLihFEAQOLsnBwGLH4Nvcv+1xTl10KYdVVHL31g42De5O1FOT7ebMReX8cVMH5y+rYDyqs3lonNGIxiUryhmNGEQMeK5ziObRELlOhYuXl+N1KDzRMsBb/X5EAS5fWYtDgmJJRdUtfrF5gFNq8jlIjiI7nLwe6WBJ0XJ2jsYYDLyO15nDtpFCjqoq5tHmPupzHJy+oIKAGuV3b3fxqbX1bB4M8FhzPzHDpCrbyaUratgyOMo/mofRTZPjqoso97l4vCXuCeFzyLyv1ktjXhY5lnvetXYTFBVlvTO/Mf+D2ZvfzQkEQcB0yeS4ZAIxAzQdXRYRdBNVEBBNi4RtXQKQBBwmWIqIqBlYioylaRiSBIaJBggWcXd4QUC2wJJEHKY1qY2OLomgm+hCvA2AJYDDAlMWUUwLZAlBNzBlETQDTRQQDAtdACxwOWWiqo7DAksWkXUTHDKCpmMqEpZmogkgmBbGRBsRsEQBxYpfX9INUGQEzcCQRSzdQBcEBMvCmLgXWRCwhJQ2hoEly6DpE6cGYwAAylpJREFUGLIEuhH/HAtMywIEJAEsQcBhAYqIqJlYigSagamImJqBPjFe5sS9KxN9mzzGaDqaJCKkjHFivBQLTEnEMdE3NB0UGSs5XubEeFnxxIYTY2zJIrJhxOuvqzqmI943VRQQDSv+OaSPlyWL5DqU+O8ETceUJdBTxnhiriTaOCwLKzHGDhnUxHjtbpM6v5JtFAlRM0GR0uakJgi72whMzC8BxUyM8fRzUlEkVN3YPV6mBYqEoOnJOamJYnK8UuexQnweJ+fkxDPMNCfFlOdiySKKYWIpGebkxPwCC1EQkm1IHa+YjuWUMVU9OSf1iRyPifm1ex4n5lfqnEyMV3xOyoApZp6TuiRMeofTx3jqex9/h6ebk5YskudSCKpG8t7RzFnnpKKbWBNzxXTEx1oTBTDS55eZnF8TbRQZQTcwJDHt3qebk7JuJD9n8nhJioSmGTPPycS9p8xJi4l3OGVOCpox8T5OHa/EGMff+4n5lTYnJ+aXaSa/K5JjPGlOEtUpLPAyOGFc2VNm+t18QFlATdPCrVucXFPEiqIsjq4q5InWIU5tKEM3Lf7VNsijzf0EYiZeRcIti3xsRTUAC/M8fGSRhFNSGQgbPNE6SrHXRZ53IfftUOkKRBiOqDze4qe+YBH3bOvjjb5RDinP47KV1ZR6XTy8qxfNtPj1pk7kb3yLZl3E6/Dyaq/GoRXFPN81xM9e38npC0pZW5rLGQvLaB4N8mLnMKNRlVhRHQ/1h7lpczfnLy5nXUk2ggEGMq/1RhmJxhfBbeMRXuwa5eQFJ5HnyuGfzc/yWvd6vA4PnzrkClrGIoSMbF7tGacqZzkrSlfz6bXXcPmqC9gQ6+GB8EbUqiK+svMOOuRREIZYVezjuOoiSrxZ5Isilywv4bmOAXqDUU6oKWJZYRZLsnwYusZTO++mx9/PqQ0lrCmJJwc6uDSLuhyLfJcjvlMswJ82d+JzKBxXW8Q9W7tpGjFwSl7cciE7RsLcu72PV3tGCesGp9YXoxkm92/v4azF5RxVlUNIk/l/R3+GbHcFj7WM0Fjow5+Tx23dIcZjOvc1dXNcTRHvX1BGXV4V+Z48fvvqb1lX5ubwijzAYuPgOF1Bk79uG6Yip4Hb3r6Hw6uPxxQ8/OLFn3D2onw8isQVqyoRBZN8l5uPrTmfkKZjCQ4sY5hT6mRqst0cUZHHBxcW8lbfGH0hlWc6onid5SwpauTg8lXkeSoJ6nU8tGuQu7d0cXpDKR9ZVMrobbeR/fJzrM73ckSRm9UlixkIZ/NC1wh+TaFltIeGvFpKfCWctuh0HEoDiwqyWD8Q5JYN7awryyPfpXBcdS5uYvSUVBD2ZnPfYJQHBiK4qpfy6cM/xd3bBvA4axkOj7FlYAcberdybN0piPJSHm8ZRBQEXuoa5f8duoiuQJRfvtHMc51DXLSsig81lrNl2M+ft3Ry9uIySrwOqnx+itwO0CUCsVF80hY+tDALhyRySn0x/2zpI6SZ3Laxg+c7x8l3K2weDPJMR4Dj6k4gqIYZioxyxuKTUC0Xr/XG36EtgxIOpYDnO4fxx3SOrylky+A41Vkan15bg0sWObTMS5Wvje/++3qebv03mGOcscDFJw6qxbAsXusdJagabBgMEPQV0VfoQsvK56DKU7ljUx8WcMemXpYUH41lKVTmlKFbbjSrno2DIX7y6k4+tLCYY6vzJt5/FxcuK6Un4KfHH+UDC0oZCcco8QpUZcXjOwVgeYEXeXwUvaMDACUnm97AAH94607cjgJkuZISXxZhzWTrkJ9fvdnCsTWFrCnJQQDOXFjKuUvKuHNzBz3BKJtGNHKzCvjoabUsrs+i3RxFqiyivDAXryKxpDALpyzyZGs/A+EYt21sY1nxSq5cey1PtoW4c1MHp9QVsrbUi1MSOWdxOcfXFLBxYJwPLizjL1u7uXtrF8dVF/GJg+t5um0MSZLZMuSnZTTuljsW03h41wCKKHBUBZxUm8dZjeW82D1M61iEYcvJrU3DBDWDB5oH+VdYYtjjoSZ/GZuGxrl3ezeryg6hfbSZMxeVkeeSOHdxCe+rK6N1PMLftg9yxsIyAqrB9uEAsYkM3v1BlS1DfpYWuLlsRS7ZTpnGAh9D4Sij0fjGVkjV6fTryJIruQtrc+CiSgL/+9pOeoMxfvDKDkYMk5vWt9EVUXmmfYBNIwFa/WH+1THAmK5z66Z2/JbJD1/Zybhl8cNXdjCsm9y+qYPOcIwXuobZMOSnMxjlsZZ+xg2Dmza04rdMfvDyDsYtix+/uoMhzeDPWzppC0V5tXeUNwfG6Q5FeXhXH2OGyW/fasFvmtz4chPjpslPX93JgKrz1+3dtAQivNU/xut9o3SMh3lgRw9+y+SXb7YQAG58uYlR0+L/Xm+mX9V4cGcPO/1hNg0GeKl3hIGoyl+3dxMwTX72+i4CFtz4ShOjpsGv3mqmL6bxSHMfTWMhto8Geb57hKGYxp+2dhIwLf73tZ34TYsbX2lixDD5/dutdEdU/tU6wNaRIM3jYZ7qGGJU1bhjcwcBy+RHr+zEb1n84JUdDOsGN69vozMc49nOITYOB2gPhHmidYAxzeCWDYkxjo/Xj17dwZBucOfmDtpCUV7pGeHtwXG6QlEeaelnzDD4/fpWAhPj5bcsfvLqDgY1nXu2ddIajPB63yhvDIzTG4nx4M5e/KbJr95qid/7y02MYfGz15vpU3Ue2NHDrkCYjUPjvNI3ykBU5W9N3QQMk/97vZm+cIzvv9zEmGnxqzeb6YupPLyrhx3jYbYOB3ihe5ghVePurV0ELIufvraLgGVNPBeT377VSk80xuMt/WwbDbJzLMgznUOMaDp3bunAb1r876s7CTAxXoYZH69ILH1Otg8wmpiTZnxO+ifNyY7Q7jnZPBbi0Ynxuml9KwHL5AcvN6XNybu2dtIWivBaX3xO9oZjPLSrD//EnAyY8fsYm5g7A6rO37Z30xyI8Hb/OK/1jdIXjXHfjh78ZnxO+i2L76fMyb6Yyt939bJzPMym4QAv9YwyGFW5Z1s3AdPaPSdfbmLMsvjVG7vojcbn5PaxEE2jQZ7tGmI4pqfPScucMiefbBtgy0ggOSdHNJ3bN7cn5+Tud9jg1o3tdIZjPN81zMYhP+2BMI+3DjCmG9w8MSfT3mHd4E8pc/KtiTn5j+Z+xg2T373dSl8oFn+HLSv5Dt+zPT4n3+gb5Y3+cfom5uT4xJz0Ex/jcSbGS9W5f0cPzYEwG4bGeaV3lP7EnDTjc9KfeIcNc2JOajy8q5em8RDbRgI83z3McGJOmhY/fS0+V258Od4mPidVnmiNz8ntw36e6RxiNGVO/viVnQSs3XPylo3xdzgxJ9sm5mTiezIw8Q77J97hYd3gj5s6aA9FebF7mPVDfrqCER5t6Wdcj7/D/klzclDTuXtrJ62B+Jx8Y2Cc3nCUh3b14jdMfjMxJ7//chOhWUrf7QsOKAsoQFQ3ae8PUFmdi2EECRlRTCGH13vHeL1nFK8iccaiMgQLHLJFidfJ022DrC3zUOJRsIQsfvzKDkKawaI8L+9fUMrGAT/PtMez1X56bQM+h4AoWGwfDvJi1xgXL6/hxa5hXuoexrTg8Io8DqvI5/dvt3FoWS7FXhfZTpmQZrJrJMhoVOMji8u5bWM7/aEY5y2pRDdN7mva7SJ7aHk+Sws8lHh0/OoYue5Ktg76eXDnAOcuzubt7meoyC4kqIY4quZoVENFN6KU5zTw8M4+3uwbA+DSlTU83tzPVatrGBwa5C877qLd38kXjriKezY/Qpe/B0EQ+MX7f4CsCZg6RKQgP3/1Js5cegGbBnUOL3eT587m7e4gZdlOHt5+K0uLllGSvY66XCc3beji2jWVuGQN0fTSG1HZNRpicWEWXf4oT7T2Y5gWZywswyHF1WnLWCg5XtkOmfOXFtM0EiWoqhxf7cNE4IEdfq5eXcuPXtnJSFRFAD6+pg4LeKS5j95glP+3rh6XYvFs+6sMBvs4bdExiEIO6wfCZDsV/DGdp9oG0EyLI8rzOKmuiFs3duAQBc5bmo9lRIlZOTgk+MlrrXxuXTWDYR2PIvBo8zCrC4cp9xWg4WNhQRG3rO+gaWS3tSnHKfPptTUookhvMMzfmoYYDMcAOLuxgiqfA2dkGJd/HE/dIgK6xW2bO+kKxM8p97l4f0MxJV4nXkXioV19nFZfxh2b2mkZi1vnSr0uPnVwPTFDZziiTrhGd6GbFoeW59FYkMUzbYN0BiLIosDx1T6WFXroD3ZRmrWEt/vHqMnx8GzHEG3jYcp9Lj66tJLm0RCv9Y5y7Zo6/u+NZoYnrNnHVBVySHkeRW6JFzpe5OCyQxAQ2Dy4noUFS+gPi+waCbKoIIuwZhDSdCK6Qb7LwYM7eojo5v9n7ywDI7mutP1UVTOjWswaaUjDPGZmduwkdhwHHdpkd7P0bXY3C8mG0QEnsZM4DpjZMcPMeJg1mhEzttRqNUPB96NaPRqPw7Drjd4/M+ru23Xrve+pvueec8/lykYfSwJ27jv8Uz626QN8cXcPE8ksi3wOzqkJ8nTPOEMxPSp467JqPBYjJVYD5LN0JmTQIlikDG2TnWyoWEV3ZICO6QEuXnQND3dMYDGInF0d5L5jg7jMRj62tp6sovJcb5jdo5HC+itsqXSzpdKNgEzvLDzcMYZcyPO2GyXuWF3NT9pGuX1FJb0z0zzTm2A2K/PeFTVYjQLjsXZKHeU80pVhacDBOVaFzk/+E81f+wrD3/wWlZ/4KwZ7DzHpt2Mz13JiKsXioJtXB8KYJJFNlX5+dGSAO1bXsXdshgvrQnxtb3cxyguwOuTkysYS2ic68dltPN35Am9vvR5BdPHq4DQa0ORz8ETXGBfUlaBp8FDHSDFd3SAK/PX6Rh7tHOX65krawlHqvA7uOthHWtadvUU+B1srffisJsYSaY5MxlkV8vDjtkEurg/gM4fpnu5gOpXgysU38mjXOH3RFJc2hHCZjTzTM85sVl8Au6DGw5ryEl7sD7NvbAYNuKyhlOUlLkyCjIACgoGcJnF4fJa15V6+tb+X6XSOrVV+jKLIK4Nh/mHTIkZnTyCKIq/27WJJ6cUEbVDnDjGdzvPVfb3ctryaRT4jQlr8vaOfsBAB/WPgD/ltFkSBtChwdCqGy2JkPJmh3GFlPJGhxG5mOp3DYzGSzMkYJREBgYws4zKbmEplCTksjMXTlDv1NkG7iZlMHpfJSFpWMIgiogCpnIzbYmIqlaHUYWU0nqHMaWEykSFgNxHN5HGaDGRkFVEQMIgCiayMx3qyzVg8TanDwmQqS8BqIpqVcRj1NHMNDbNBIp7N4bOamUxmKS30rdRhIZzK4bOaiOXy2AwGZFVFUVUsRgOzmRwBm5mJZIYyh5WxeIZSh5lwKqdHbvIyFoOEomrIiorNZGAmnaPkjfduMxPJzPGlYJYENASysozDbCSS0tuMF+59Psdus5F0XsEgCQgIpPNzfOn3MRpPU+a0MlHgOJqRcZokMrKKIAgYRYFkLo/bYi62GZtrk8wQsJqYzcrYC3whaJgkiXg2j89qOnnviQyldvNJvrJ57CYDOUVFfQNfc1oZS6QptVsIp7L4rGbiuTxWg4SsauRVFbvRwEwmR9BmZjyZpdwx795TObxWI4mcjEmS0NDIygpOs5FIOkeJ/VSOT+VLxjBPk29sM8dXiV0fF5fJQFpWMRRSF+c0GU6dHPcyp4WJN9HkHMeJrIzXZmKywNdoPE3ZPE3O53hOk7FMDr/NzEQiS5nzdE3O8ZVXNRRVxTaPr/maDDkK9mg+qUlV08jLKnazYZ6+9Hufr8m5COTcPK/IV+pUHev6msexrGAQBURBIJ2TcZ1iw/p1JpMZAjYTM2kZl1k61YZzebxWM+Hkm2syWuArX9CkURRJ5PL4rPPv/c1tOK+qaKqG2SidrsmiDWfxWkwk8nJRk7KqYjcZiKQLmkxkCvpKE7RZiKRP12ROVnCYjUynsoQc1lM4/nWadJlNTKezhAqaLH2DDbtMBlKyglTgK5k7afdvfLYGbCZms2+iyZyM12ri0HiUI+EYLT4Hb1tShUVWfuO58L8O/2cioFlF4+sPHOZz9+7ngWeOc2Kily/t+BoOo0qpzcTNSyu4eWkVz/RM8GDHKGV2GyZBYWulFafJzPbhOA+eGOZtSyq5oaWClaUevnuwn2g2z6YKHze0lPPSQJixRIrHOiepdBqxGw0oapIzq3zc2FzOdc3lNHod/PjIIFc0liGJEr84PsLxqTjHwjHOq/UTzeYwCirXNZfjNBm4//gwfquRv1rXgEkSMUsia0ptHBx9gW/t+QEWo58v7OqhJeBkQ7mHvshBypw+skqWDZWrGE/I2Ix+ZnJBXhmYYnHAyfKgk1uWVbNrZJrxZIZ9YzNMzghcUn4d71p5A7JmYX3lRuwmvcLlx5/5J7rj3QhGmV/2vMxwbIzZ1AiXN5TSNnGAcCrJi8NTPNI1wa0rPkAZi8lOpNm1b5h/3LQIN0bKnCWIOZVKoxGXWSIvK/itBhxG/diTUOEH52ftQ0ync1zRWIZBFPjImmpGYp3Uu/Nc0lDKZCrNL3sTrAi5eXkwzLm1QS5vCHHr8mqe7Zvg+4f7ubwhxHm1Pu49fA+R1ASV7lZWlK3nGzvvISunKLEKuM1GBmIp8qrG+nIvq8q8fO/QIMPxDL2zae5tm0YRXKiawr1tw4TsFlJ5EQQDD56YpH82TaVnCTZLGQPR49y56/s0uEa5pF4/v3NdqZtPbWnGIAjsHYsRsMDtywM0eu14zEaWBx38rO1uvnH8Jxy1xLn36ANk1ASXNARxm/Wo2uWNpdiMBl4dDPOTY4OcU+WkLzrNhnIfWyr8ADhNIlOpGVJynhcHwsxm81zVpHNX6bSRlZViKrSsakQyIpJkQRUq+f7hPqpdVmxGCatB35s3msgwHEvR4jdjkgTiuTTvWl5Gg8cKQCqfxWkSePT4U8xms/REE/TMxskrkJVlJpMZNlcFeLRzlPuODSGrGvUeOw91jBYdnie6IxwJZ3jnipuYzSQ5pybIuTUBRuJpZFVmS4UHs6Q/XnojcZSMjJxRETSBgDWHRcrxrb33ksynEBAI2n2cmDqBiRh3rKplWdDFPUf6ScsqSwNOhmIZXuwPE8/J3LSkEoD3rqxkY5nE3ft/wN7hA0TTOd6/sg6rQaTKaeYja8q5e9+3+PCaalQNXhlMFZ2sRzpGmUxkWVG6Gr/NywW1NmpceeJqisDnPs09QzFcf/u3fO34BJaqBvw2LweGn+HcWg9PdY1zRlWASCZPXpE5s8qDrExzXXM53VMHee8KP80+vfrx+1ZWYBKO0jUTxm7x47SU846VNzMYh7ySobXEzcYKHw+eGGEmk+fJ7nHyqsp1zRUI6M7nDc0+BC3JTYvLUZUE1qTMZDLF9S2VNHntCMBZVXbKnSa+d6if6VQeUQC/FTZXeCm1pYhlpmkNLeb6pVcgiQpBq74X9emeCTqmZ/nQ6locRokPrqqlyedmOJbGazEiiQIOo4TLbODJ7nH6ooPYzFYe6Zzks6930hNNMpnMcnlTGU0+B9uGpmn02riisZRdgy8zEh/n1b6dHBg7ilmcIp2b5dsH+zFJcGFdCfVOK0G7+w9yPhfwPw+T3cTT/eO0hjwcC8dYFfLQM5OgwetgpuB8mkSRlKxS67YzMJtkRchD+1SMdeVejoVjrAx56I8mqfPYiWdlHEYDNqNELCtT77HRF02yqsxbaOOjPRyjNeRicDZJldtGKqdgMUg4zUZmMnmafA56oglWl3s5Fp5lTZmP41Mxlpa4GYmnqXBaySoqBlHAazUxmcrQEnDSNZ1gdZmPo5OzrCnz0jEdZ3HQxVhCn7wrqgqaXr9hLJlmadBN13ScteU+2sKzrCn10hmJ0xxwMJnMErDpWUOyqlHmsDASz7A85ObEdJx15T7aJqOsLvXSHUnQ6HMwU3A+jaJIWlaodNkYjKVoDXlon4qzttzLsclZVoTc9EaT1HvtxQml1SARz8vUue30z/EVni1wPMuKkIeBaJIaj41kVsFiEHGY5vE1k2RVmY/2qRhry7wcn4qxrMTN0GyKSqeNjKxilEQ8FhNT6SzNfiddkQSry7y0Tc6ytszHiakYSwJORhMZSh0WZFV3JPxW3eFaEnTTGTnJ19pSneMWv4uJZIYSuwUNPZ00ZLcwltCfkx0Fvo6FY6wu9dAVidPkczCVyuGz6WcLZxWVSpeV4ViaFSEPJ6birCvzcSw8y6pSXZP1XjszGX2ib5ZEEnmFWred/tkkK0Nejk/FWVt2Kl+1HrvuRBsN2I0GZrN56r12XZOluibXFzS5rMTFwJwm8womSddkJJNjkc9B90xBk/P4WhZ0MxLXHZisoiKJgr4AksqwOOCiKxJnTbmPo5Mx1pR76CxocjyZIWQ3o2oqmqbvyR9PplkWPMlXW3iW1aVeuiJxFvkdhFNZ/Fadr3xBk8OxNMtDbo6HT2pyVamX7plTNWkoaLLKZWOwwNecJtvDs6wMeegr8FXUpFEintM12RdNsbL0pA3PcTw4m6TaZSOZU7AaRZwFTTYWNLm6VP/s2jJvgWM3w7EUFU6rrklRxDtPk90zSVaX+U5qcjrGkoINz2lSAAKFRYDFQRedBRs+OqlrsnM6TkvAyUQyS4ndAgIoqqY7wIkMy0vcHJ+a4zjG6rI5G3Yync7htZ7UZFVBk60hD8en4qwv9+v3Xuqht6jJPC6zEYvhdE22T80WNdk6T5OJrO4Q2wqabPDaCzbsLT5bj0/FWF7iZnA2RbXbRlrWNekym4hkcjT7HPTM6Db88kCYI2G9kOmJSIJvHehBsBj/ZHtC31IO6MhUkhMDesGW1w6Msn1bno+tuYPJsThnVAewG43cfXiAmUyerKLy2Z1dHA3nCFg95JUcFoNGz0yKwxOzVLqs/LJngrSsMBRLsbnST0pWKHNYmMnAkXCcJ7sjvHdlNQ+3P0xf5DgeQcCKgMdo4I419cxm87w0MAnAjuEIF9WXgAZ/s76Jrql2fnroTi5rcBCwmrAaBKaSKa5oDHFeRQCfUdFT9pbczAMnpsirGr9oH+XyxhDrKlawuXojaAIadp7tT5HICzhMRj0qOzTNTUuqeKRzlBOFKrHP9E5yIJtmVVMNfouXqbQFv72Rfzn7H/inMz5a2HguEMnPcGnTubx9+TXUO2sxCiJe+3q+f1iPIkazeb6yvw+Tx8VMLEPI40TKq6ecZ6mpGot9dmxGGVWLcOvyEFc2lXFsKsbRcIx3Lqvi+HScFr+N65tLUDQVh7kWkSSqliclm7lpSRX7xmZ4tneSY1O68f68fZjeqL4v7uBEjEaPm/eseScJWeCRzjBtUwIXNp3PaKyPXxz5NrKaJGAxcWlDiFqnrfhAmcOqkBOnycyesShnVJVwXk0Qi8HAz44NMZnK0eJ30j6V5JGOCc6u3cpkchKTwYRRmKDBY+OShlKe7wtzIpLmye4JYnkRm1HgjEoTVzX5ean3Wbqme7lt1e2MJaPUeCuRNBGTqO+5u7qpFJMkcjQcY8dwlPapFMenM3jNIp2ROFurXASsJq5eVEI4McDuwRdpDUSJpNO0hWNcVBdkND5LvVvgw2sqMYoCF9T6uLDWzmwmxtFwknhO4cdtQ2RklUsaQiz1O2j0WmnyioxNjfG2xgrsosDYbAdvW1yB02Tg4voStve/wvmNF7Kh8gwe65rm+b4olZ5lWIw2tpR4iWdybKrwc3Z1gCe7x7EZNP52QxOldhNGUeDdrT5U+TiyZuWRzml+3j5Mqd2C02QgYDHizslc1eTHZzGyPuTk09/cwVg4SUZM89nXvkhGznBVy+XsGT7El3d9j5+3Pc4H172T6GyeT31zB4v9Tq5pLueC2hIuqAvx0kCYHcMRjk3FmE7nOLs6QKXTwct9O3j36vczK7fwXP8UD5wY5pL6Uq5rqWQqNU1GyfNI+yM82vYzPrSmlrOrfQC8Y2klS/0mJhI5xhIa2XwYi5jj5WgXfZqRFSUenhuYYjSRISk4yKt+VpQuJpmd5KpFQUyizNuXlFPtMHNOjRefycJDz53AZrLyH698lg1lEqtDDjK5IZaXLOWlgQxJ2c7TPWFk1cL9JyYZSyqoyhjxTIxrF5Wz2O8glVdo8FhYHnSwodzBOdVO6jwWkrkI39n7Hb6y65s01diwSLOMJVJcvaiU21trUDQzX97dx2xW5tm+Sc6pCSIKIlc0heiebiMtp0nkBV4fzfBC1zNcWGtnbambWreVaxaVYRVyvG1xGUGbmYOTs/zk2BAd03Het6KWa1sqeLpnnLZwjMm0lZl0ki0VAlc2+emIJOiLJumPJrm+RV9wK7UbCFljlDkDqJqKz+pja81GajzVRHMBRhNZftw2zNnVAX2/yQLe8sjGs1xVW0p/NEG508rRyVnKHFbaw1G8VhO9MwkQIJbJM5XKYpREeqMJ/FYTxyZnqXBaOBqepdRh4djULC6zkYHZJKoGyVyeiWQWi0GkOxInaDNzdDJGuctK2+QspQ4rJ8KzOM1GhmMp8opGRpYZi2ewGQx0TMcodejfX+G00haOUWK30DEVx2Y0MJZIk5EVFFVjJJbGaTbQMRWnzGHlyGSUcqeVtolZgnYzXVNxLAaJiWRG38ahwWAshdNs5Hg4RrnDytHwLOUOK22TMfw2Mz2ROEZJZCqVZTarLw71R5N4LSbap2Ypd9r0Nk4rxyZn8VlN9M0kEASYzeSIpHMYBOiLJglYTbSHY3qfwrOUOSy0T8b0xdhoCg1IZPOEU1nMBj2TJWi30DapX6dtcpYyp5UT4RhOi5GhWf33Ni0rjCcyWA0SXdNxSuxmjob1z7ZNxgg5LJyYjmE3GRiNpcgqKjlFZTSWxmGS6JiKE3Lo4z53nRK7ma7pGFaDxHgiQyovo6gaw7EULpPOl87xbOF+ogRsFroicUySSDiZIZ7Lo2ka/dEkbkuhjdPK0blxCcfw20x0R+JIosBMOsdMJockQN9MEq/VxLEpfTxOanIWr8VEX1TXZDyna9IkifRE4/itJtrCs1Q4bRyd1DV5fGoWt8XE4GwSRYNUXtE1KYl0z8xpcpZyl5Vj4YImp2ZxmoyMFDSZlRXG4hnsRgOd0wW+CuPeNjVLyGGms6DJ0XiatKwgF/hymoycmIpT5rTo9zGnSZuFzuk4ZknXZCJX0ORsqshX+bzrHAvH8Ft1TRokgUhRkwL90SQ+2xs06dDvx1ewYVEQTmqyYMMBq4ljhbGcs+H28DxNahDP5plMZbFIwil8VRS0ovMVw2XWNZlXdRueSGSwGSW6InFK7BZ9XFy6JoN2Cx3TcV2T8d+gSYd+naDdTGdBkxNzmtQ0hmJ6Rt3xgm3NafJYeJaAzaxrUtRtOJbNA9pJG55rMxGlzGmhfXIWv03na06TkXma9FlNHAvrWpy79/bJWbwWI/3RBBonNWmWRLqjCQK2kzY8X5OuoiY1UnmF8WRWt+HIPE069euECm3mNJlTVLKywmgig62gyeVBN5fUhwC4oDbI325YhJbKofyJKtS/ZRxQURQYGNc9c0GAa85u4IwV1fT1QjIpkJjNUmuz8P6VtZgkEQG4oqYEQyLP7v7D3HPgHlzGMNcusrN/PIqmpfibDU0s9js4v7ZEX2Es8TCRzPJIp54q2zWT4t+3d3Ld0rexb/QQGGZxWU386NgQdx8eoNRm4qNrGzCKApVOCxOJIV4feImX9/YgZd2oaFRabXxwdT2PdU3wwIlxmjwOlgZtfP/AfWyt3cKxKYGhmJ6u2Teb5t6jQ3itpciqjZbQOTzTk+HyxjIOT87y02NDXNoYYjSRYSqZ4iNr6lji1yOc51X5ubLGz1OdLyALLp7vj7F/PEvfrIJB8vKVi/8VRZP555e+wHPdr7Kpcg13H/kxn371v2jxmHhbYzkCeqGmm+rL6Dk+xfI6PyDw4192cKg3wkRE31OWM6S5+8DdfGPXNzCSJmhzsHMkwgv9YYbjaXqjKa5tLsdtMrI44GTHcIwnumcIWGsZGp3Gns4STWTYUuHnzCo/x6fiHBqf4e82NlFXiNKF7BJWQ46huMqDHRniOZlDkync1sUE7PW8d+0tVDmsrCn10Fri5sRMnDv391LlsrHI52B1yM0in4PO6W42l0lUuSwMxlL8vH2IW5ZVc3trDdUuK68OhumJJnmye5xbVt6KJpTjtZTwruUVJPIK4XSOn7WPoAHfOjDM9uEYJlEhZBfYM3yISxddzAv9GZYEN/JC7zaympFneiewGY0IgkA8J3NkMoaGHs3y22xIkoNrmytwGkT+al0tLgMs9S7morpzWVPeysoSI8uCJlaGHJxT46cjkkLTNK5ZVMq6MicZxUA6F2VrZYBLG4KIApQ7jHiNBi6o83NZfYgv3d3G9346xJfu2cv3HzxBq68Vpybyj5sW8VTHY9T5muiJZvnK3l5SssLZNUF+3j7KvrE4gkHAJMYJp9JsrHDR7LOjqnGmEwNc0ejj3BoXTgS2VG9lx0iE9il9EeSpnnE+urYRVRZ4escIjrzEO5dU8pnv7EVW9EoHYt7KbSveRsgeosS5nMuaL2M2E2M8MYlLDDAwoDIaTvLjh9tYFXAzk8nxqdfaqXJZuaKxFIB0XuGShhDh+AB5VSOvisW06HAqh90kYZFgNuvk3atvp9pdwWUtV/DKwBSbyn2cWemnzGJGw8rPT4xw/4kRat2LCDorUYQVLCsp5bm+CfaORVnkczCayPOTY8M0BloZnYmSjWbxSkZe3jbIF7+/n217R/i3bx7lUNcU+axIuasUn1ni2uYqLMZyXh8ROL+uFKfZwOKAm+8e7EdWNX7WPsqxiIGQw4nFIHBujYP15Q5i2QwHJyJsqnATsCYYimXQBAcei4saTw2DCZm2icO0BgWmwlGcmoAxDxvLvcXn41g8jUFUuffATyh1Bjm79jwmUg62Dc2wtHQT9x15iAvqgtzYUsHAdJq4LDGV7GRk9gSpzOvcuryccqceWf/5saFi5PjZvji7RtPUeipYHfBQ77ZRIhk4p9LHTx9r55Prm/hl59N8YcfXcBid1HkXsbH6TG5ZcRMv9Md5plff6jCezPEfOzpIS6IeUVrAWx6SrNLktHF8OsaaMi+7RyNsqghwYGyGLRV+xuJplgddSAIELCbK7VaimTxLgy7aJmOsKfWwcyTClgo/RyZm2VTuJ5zMsCTgwiIJuIxGqhw2wsksywIuDk9EWVvqZdfwNFuqArRNzrKhzEc0nWORz4nNKGKVROrddkbjGVoDLg6MR1lX6mHXSIQtVX5OTMVYX+ojkZWp99jxWoyIQIPHzkAsxcqgm31jM2yo8LFnJMKWqgBdkThrS71k8wo1Lhs+sxFN04oRxBUlbvaOzbCpwsfe0Wm2VAboi6ZYHfKgKirlDgslVjNZWaHF56RjOsaqErfOV6Wf/WMzbK4MMDKbprXEXaiWb6HUZiGezbPY76R9KsbqkH4fmyv9HJqIsrnSx0QizdKgC6Mo4LUYqXJamEplWRZ06RHdUg87h6fZXBngyESUTRV+ZlJZWnwOrJKIw6TXQxiPZ2gNujg8HmVdmYedI9NsqfDTHtYjfbFMniavHYfRgFEUqffYGI6nWBF0sX98hvXlPnYPR9hcGaBjOs7aMg+pnEyt24bHbAQ0Fnnt9M0kWV3qYd/YDBvL/ewenWZLpZ++mSRrSj3kZIUql5WA1UReVlnkdegR15CHPaM6x/vGZthaGWBoNsWKkBtN1QjZLYTsZlI5mcU+J+3TetR092iEzRUBDo5F2VLhZzyeZllA16R/viYDLj16VtDk5go/h8ejbCz3E05lWOJ3YjVIOE0nNbm8wFdRk5UB2sKzbCj3MZvJscjrxG4UsUgitS4bI/EUK4JuDo5HWVfqZedwhC2VBU2WeUnl8jR49OKaItDosTEQTbGy5KQmd49Ms7XKT/d8TTpt+CxGFFUrRFyTrCxxF/naO6qPS380xao5TdrNlNjMpPNzmoyf1GSFrsktFQFGYilaS9yIQNBqpsxmIZbNs6SgyTUFTW6p9HFoYpZNlT4mkxmWBV2YRT1rrcppZSqVZXnQzZGCJncNT7O50s/RydmiJpt9TiySiM0oFTW5osTNoYImd83T5IaCJhu9dhwmA0ahoMnY6ZrcUhnQo51lXl2TLhtekxE0jaaCJleGdBveUO7TNVnhpzeaZFXIgywrVDisBK0mcrJCs89B53ScNaW6JjdW+Nk3NsOWSr+uyQJfJXYLpTYzyazMYr+T49MxVof05+TmygAHx6NsLmhyecCNQQCfxUSF3cJMOld4Tr5BkwUbnkplWOx3YBUFnCYD1U7rSU1ORFlXpmty6xs02eR1Yjfomqxz6za8rsxLndvG5jJ9S8+fMjvpLbUHtHs8zmd+uJebL2zmcFeY9r6TFW5XNAb44DXLUTWNvVMxZnJ5Rg5NcsX5Af5715doDS1mfeVKuqaHWRI6i33Dv+Tsmg14rNWciCRY4XagGgU6oklSeYWneyYoc5h517IqsukE4ew4Xls93z7UV9xjduPiCiqdVnpnkvgMEoIwSWLGxNd+chy7xcAn370KzWzmvhPDxT1hdqPIRbUleC1ROsInaAmdhaKq3HN0iGsXlbLcZ6MrlmH7UITrFwcRBTNHJmO82D+JokGp3cxljWX4LAKSlmEsFePZPpmbW7xIspXudJpHO8fxW01c26xXylxb5mGj342sRfn6/u8QzcSKZcSX+FtotZzL/rY4DevLKLdbWOZzkM8rfOaevYxHTlYRrQja+cdb12Exq+ydPMDB8Tbeu/Jm0lqWqXSWvqjICwNRVpY4uKwxQF4Veaxzsrin0m02cF5ZgJmxBIsbjfSlocVv4yfHwlxab8QkpnFZqnm4c5J3LSlDRCWlGHi0a5QTkSTVLiubKvzUeUzcs/97nFO7mQpLC5G0zJFYkv0TUUQB3rOilpDNxL1tQ6woMdM5+QJXLbmCo2E9wn10Ms7mSh8/aRsqprbWOK3csKScHx8d4iNrG/jRkQFaQx4UVeP5vgnSskrQZubCWisT8S7OrVlPRhM5NpXk8a4JLm8sxWc18cDxEcwGkUsbShlP6JvDr2oqZ/vQFBsrfOwajVDntnNJpR8lr2Iwicg5fQKelASe7Blng8eK12Pi4NEp1q+u4kt7eii1m7lpUQUqKo/3TnBGVYC7DvXzD5uaODoZZUPIzuhYnhf36ymzOw/PO5JHgK9/4izsJgnRIBLVZF7sD1PhcuC3GpFVrbh/VADOqvazpdJLXomjKFnK3ZXsHd7L7uED3LbqnQgYmU7I7ByfISnLrC3z8qOjg5xTFeC86gDbDgyzvrWcf/3WDpY2BkDRCHqsLKn386X79tNS7+b6S5Zw55EBrm50UuGS2Na/m3MbLmJ8ZIZYDKaiKRZVeamscXN8Os5DHWNc3hCiaybJmVUGnjrxKHesvY2UauBHR4fYUPghiudkLqxRMEg2ftQW44wqD27DKA5rHfe2jfP+pVWEnFYGY2ke6BwlJet2aTGIvGNJCI/FxJ7RKIt8HgyiwIlIgu1DUygaLA86ObcqSHQqTSKe5c4HD5/2jLpoczVvv3QJajpHXsgzkU0jCDY6I0kMooDDZOC53kmi2TySABfUldDgVhhLDFPnKcdi9HP34UEiGZm/WVdDPBfj3mMx1pZa2VrpoSca5d5jMW5Z6sIjGPj3b7eBBtm8ws2XtBB2S5Q7LJxb6iWtxXm085dcsfgGftI2RH+hIrC+d9bDJQ2l5HIa3z7cR5XDylJfgqnMGBk5x6qy1RyYVNlaYSWWk3nwRITRRJabFrsxiwnqnVX0DKXx+m08u72Pl/cOAXDVWQ2ctd7HaHqIgKOOaEamM5JEUVWqnFGsxiruPTbOUr+T6xeVY1VV/H7nn7TS3gJ+O/wxquACmBxmnBYjyaxMLpVFsprIpfNoBhFVKdTPFEDUQDJKaDkFs82Iks5jsJrIpbKIFiP5rIwqCSf3H4l6FV2DSULNyphtZpR0FoPVTC6dRTAX2ogCcxuohbk2ZgNaNo/JaiafymKwmcmlsghmA3JOQdHPSsBmNZLNKQiKitFsQM3ImGwm8ukcBquRXCoPJgklrzB3+pGogWAQEWUVo8WIkslhspnJJQtt0jkwSqiKerKCpgaSQYS8ismq37vRbiKXyiFZjOQzeVSDiKaoJ6u6aiAaJcjJmKwmlEweY4Evo91MJpVDk0RUVU/HnOPYYJLQsjImmxklncNgNZFNZxHNRuSsjDKPL0QBaY6vTB5joY1kNZFNFdrk3sCxpFe5NZoNqKdwbCKbyiPM8SUCaqESriQiyAomixGHxUQ6J5NP6/eey+TAaEB9A8dioXKtyWJEzuQxWXW+DFYjuUxBX7JarGhb5CsvY7KYkNN5TDadL51j+RSOBRFE9bfXpNliJJuTC5os6GseX/l0FsGk86X8HppUdUkWjswQERQFo9mEWtBXka90Dkyn8iUU+HozTZocJjKJHBh1vuZzLBWqQ5usBb7eTJOyOnc0PVLBhskpmGxG5PScJnOIFsMpfOl2LyBq2hs0qdvwfE2qooCmnmr3RrMBV2GPs3yKJgt8/UpNyoX7yRbanNTkHMciIEgFfVmNKOkCX6l5Nmz6FZqcs+FMHqPtVL7mNGk0G3StzPFV0KSSnmszp688miSdtHsRpN9Bk1pBX5KqIf0empxvw7lkFr/f8Sf9bX5LOaAZReVbDx1hzeJSfvRU+ynvSaLAv7xnI4KgMRxNY7cb+co9+zhrbYiGpUkqvAG++Pp3MIpGPrH5Dr6445tomsanz/4HknEr//bt1ykL2Ln8qhaWl3m4/8Qwl9SG+Or393LVmfUc6w8zGcly9YWLeHk6yngywy1NFXgMBkYjSY51TWMUYWgiUXSMywI2Pn7LWqbyMvd3jpBVVM4o9VKChNuq4PF5+NqBPm5vraVzJs7agJuOaJJf9k/q+0XsJt65rJK2cJxGn5NvH+ijyWvn6kU+0tlpXt2Z4NxNJficXmYTOdKqgNdsIAt0RJI81zdBquD4NnhsXFgZxGZK8S+vfgYAs2Ti4yv/mn/79iEAPnHbWhxmI4GAjdhshk99c8dpY/Ch61pZ3xxEJo8s5DEpVjRRoSvRRaW7gXuOjHPb8kp6p9to9C9n9/gsz/dNogG1LitbAh527RthSaOVkgqRZHqW1VWrGZnt57v77uXdS9+Hw+LmSz/cw4euW0GF34ZqEPnR8SEubyzj6/t6uLgmSItPZGgow9d+dhSAizbXYq5xklIVrlxUyquDYXYMRzFLIpc3uFkScOO22MlkZY5GEqz021FEiXsOD7Chwo+qqTzSOUZWUWnw2Dm3NsiukQjjyQyX1pdyX/sQH1jpZ0f/Nl4d2M7XL/1vnuqZYddoBKfJwLXN5fRGk+wY1gsviQJcu6gERRMZiWc4szrAL3smaJvSjfmc6gBbK3zYCrW2cwaBJ3om2DcR5ZqaECVmI6O5HM8OhsmpGq0lLjZX+FE1jePT8eJ1Suxm3r28hoGhKGpG5uv3n+4UmQwiX/6rM7EZRRAhKcJzfZPsHZ/lxsWVWA0ij3eNMZPRjw5q9tq5tC6Ez6ZhyElomoAmysiCjFGxkBYFjkTiPNUzjqxqrAp5sBlFNpf7cQoCGQHuPjrABX4vszMZth0a4eJNNXz7wcNceV4ToSoXz49ME83muaA2iAYsDTj4/uFB7lhZzivbRigNODHbsxxJbOO65VfwYMcsG8tMLAuVce+BnyFJJi5ovIKv7u1D0TREAW5dXkPIbmYknuKhE2OYJZFrW8o5PhVn14heuEgU4PzKAMuCLnpjaR7rHkMDzq9x4bfEqXNVEJfTPNmT4u1Lq3h5YKpY9Oj21hokUaDWbmZwJM6nf7D7NK7/3x2beHRoko+trMMoq8hSFsFg4OXBGIuDLn56bIi3L63iuwf7ePuSSpa6bKTUBL2xEVyWOr5/eICsorKh3Mcin4NXBsKMJzNcXB/CaTLwePc4iZxecOGiOic1Ngf/9e39xFI5RAE+//fnYDNIWGRVL5AhqQzFc6QVlae7x4nlZJp9Dq5vKSedV3ngxEjxCJkVQRfry0VCjiAv9DzLVS2X8Gznczzd9RKfPOOfaZ/KMDzzLIPRQT6y9oM8v22Kw11hJmf0NKubLmxmZDLBgc4JPv2hTURVjeF4hmd7JwA4v9bJsqCdlwdSXFpfiqPgWASDCw7o/wb8sRxQ+OOM6f8EFvr958dbte8L/f7z463a97/kfv/BRYiam5u/0tzcvLO5ufn15ubmdW94z9Lc3Pyj5ubmfX9QL38LWCSRj9+0io7+yCmvL6nz8ZEbVvLsrn5mEzl+/tRx7nv0GACv7pvg6H4ziYiF1tBiPrrufUyNGLht6btYEVrG0GiaT3/ndQDGppIwm+fVnYO8a1kNJ06ECUfT9I/HqS7xMD6dYue+ES6pCrKxxMPTL3Tz+qFRtu0d4qU9g+w7PklrU7DYpw9dv4Jv3HeAnTv6ubwuRJPHhnVWpjbkZEaycOehARQN7jk6wDk1QUxmA6PJbDHCGsspdEamaC1x4THBxXUlbA54yGVTvLwjxsH2CDbNjSGvMplVue/4MKm8iqTp5xlWOPVCKJIgUOew4jALeB1eypx6jndWyXFwZifvv34Ry+r9WDSBqhI7Pzw6QDgvE/LZThuDQ11TSJKIqBowKXq6rKBKNDmacSgmPr6uEYcm0upbjlWGc0u9XNFYSsBq4ral1bz4Si87Do7ww0d6UBMmmr2LIJMnMm7lqop38tm7jvC5H+xmdCrFp3+wm3hGRlY1Npb7ueugHn1+sm+S10YyWJ12KkN6waBnX++nwWLh8oYyjocT7B6dLdyjykuDCWZSAtHZLFJeY1XAhZbVCE8k2eT3YFTBLUgs8toBGIilmIylOa8yQDKvp9vesrQUVZU5q/5SvBY3f//8p7m03s37ltcQz8m82DfJEpuNtzWUA/Ce5dWU2lIsDzg5pyZIMi8zmsgWeeydTZLMq0QzMhmjyFf297JvIgrAIwMTtCdTLAt52FLhw2IQOa+2hEMTUSZTOfxWExZJLziUySv0huNMzaRx2k2U+e2njdklW2qxm/XPayh0TB1ElfewtdLNS/2ThGwCd6yqxmkysLHUgzci8/m7dqOmDcymFcajGVJZEbNmRZAEcmgcC8d4z4paTKJAJi9zSV2IVCTFVDrPY11jjCezjKOgSLpdJdMyeUXDYjaQVVTyqsryoItmv5OQ3cK9bcMk8wrP9EU594x69ndMMh3Nomjwcvc2blpcTqXLzude+wqXt5xHo68Kr1Hi7zY2EbSaUDVwGCQckkipzUyp3UwqLzNZqMzrMBkA8JiNuCUDuw6O4svDxpCHNUE3LS4TfsnFTM4AWRu3tVbTPzDFlY2l3Li4ggvrgnREEtx/fARNECkP2KkpdRY5bqh084nb1rIrMst0OscrI9NkDQImzYKUlVhf5sVvNnJOdQCf2cgtS6todNlQ8ipmxcYSdwOlZhO3La/GLIm4zQZEQSOR16uGOs1GptI5MoWIbUZWiWQUJKOI22nCbjVy7TlN5BM5svEsSCIGu4lvHRzknqODPNk9zpWLyrAZJd6xtArzm2S95jUZt8XDV/b00uRfwf97/j/YVLWWv9/yEQJGC+dWl3BNy4V8fOMH+dz3jhHy2ZiI6M5nmd+OoqhkFYWP3raO7kSWlKzy6uAUGvr5ZNuHk8Rz+v5vx+mXX8ACFrCABSxgAX8h+I0R0Obm5rOAT3Z0dFze3Ny8GLi7o6Nj07z3vwH0Au/o6OhY+5su+IeuskqSyBM7+3nwpW4AnDYjt166hG89dBhNg82tZYiiwPZDoxgNIltXVNBY6aYq5CBUYuC7D3RwoCNMQ6WTd13VxL/ceeCU7y9k4nDnJ8/hkVe6eaGQWlYdcnLxploaKt28dGCIlYtDfO4HewC48bxFOGxGIrE0W1or+OmzHWxdWU4mK/O9x9oA+Mf3bcDvs9LbFaFzNErr8lJenZhhJJnBJIlct6icFo8dg6jw6miElwdm+MS6ajQlwU+OPITDbOOdK95JOi7TMxzFYzdTHrAjmiW6ZpM80DFKyG5mWdDFSDzDuRV+LEaJu44OsLXMR3/bBGedEeLeY9Nc02jBYzLxld3fIp5L8pnz/gEHXuKaykuDU+wem8FqkLioIkBsMskjz3chSQJ/9fbViKqGx2nGKIlIgoDNJDFfQ6IooM4rLKJokBIhISv4EDAZRBIZGVEQcFgMoGnEsyqf/fFefQGgAIfVyPXnNtFc4+XYwAzV9V6e6J8gnMoiCQLn1wTxyvCTx44xFc0AUFvuoqHawxnLyvGF7HxxTxfVLivLDFZ++mQ7qYzMZ+/YTNBlJp1XSWVlHnili/oqLw8/38m/fnAzP+sbZY3fzbYXern6rHrqan0c7x2hqtLEUNzMi0NTfGhVBelchJCpjJym8VjvJC0OG1+9ew+XndWAu87NCreD2dkMHocZp8OEUdPIG0W+sq+XcoeZLV43P33qOJdurmM0kmTF8lJ+0TlCOJ1jdcBFk9nC4893ccuVS3h5aoYau43MWILqRj/PDoW5oaWC7x7s49bGCn704FHefmEzD77UxbXnNPLS/iGOdE1hMohcuqWWi9bXYJYEFA3GZuP0pk7wSNej/MvZ/0paFni64+eU2kppDp2Bx2ikq2uaiqCdtp5pHn21B0XVsJgkPvPRrQxmc/zi+DAaUOG0sjzoYknASWQsQXWFmy8f6CGRk4vjWOu2cdviKo6cmORbDx0BoKHCzUfftYbD4RjNficPnBhhpBCFA1hf5mWD18Wnv/06V19QickgcLwrSSIl8/FbF5NJSoiCSM4ocX/nCFc3lfH6SIQrqkv48ZPt7Ds+wR03r+TpqRmuaixlidNORyTBj7tGeGd9Od/72SFuurCZsoCNmZyMKAr86MGj/L8PbuSbh/s5t9xPdDDGgy92sWVlOddd2sJTPeMcK0SvA1YTV9aVUmY3s+fwGD0js9x29TK+tK+ruFcSoMpl5RNrG8kmMiiiQCKTx2QxcaRjgoDHhpxXUBUNr8uMz2nBJArkVJVj8TS90QSX1nlQBQNf3tfPmhI359W6mEhqfPvQAO9rrcZCkm/e20nQbeOG85v41oNHqKtwsbq5hOlohtpyJxWVbl4dnmbb8DTvWlZFid1C94kweUVj55Ex3nnlEn7eO8qaUg+NXgMvDkQ5NpUiZDdxQa0Fhyjwi0eGOTEY5W9uXk02L5PKKvzg8WO896plPPZqD+FomivPqGdP+zjZnML1F7eQt4kcmolzaUMpj3eNoWoaH1vdgElREQvP2LkUq4UI6P8OLERAF/r9P4G3at8X+v3nx1u173/J/f6DUnCbm5v/HRjs6Oj4fuHvE8D6jo6OWOFvJ+AHHvxzOKAA0XSev79zB3lZ5Yoz6jnUGWZo4iRJ15/bhNthosRr4/HXejjWF8FuMfCxt63i4Ve66ShU0v3ANcv57iNH3/Qan//wFhAE/uHO7agamE0SH75uBclMnrsePYrFZCA9b7K5YUmIDcvL+P5jbXzg6uU8vbOfVc0lPLdrgEgsg9Nm5I7rWvnyTw8iKyomg8iH37GKx8anuaK2hJUBZ3GvS8YIXdEU3pzK139xhHffUEU6JfDdX3TxV29bzfJaD4qiIUgCMeCRjhGaAy5EQeCJbv0cxGubSml2O5jO5BFyCpFEjp58hgPhGBfXBTmruoS+sWHicgyrHMJkMdKZTPHq6DRzW26CNhPX1JXy1PPdXHtBE9OKjBbJcqR7itcOjqCqGmesquCGcxqxGk4PpqdllTsfOoKqaVx73iJmZtJ4nGbKAzYcZglNhdmMzPYjo2w7OMLkjO6E2CwG7rhuBbFklgdf7GI2keWjN66ktNzFd9sHuKA8QPfRCZxWE49v6z3lmqIo8KWPnUE6K3MilSZoNPKVH+wpbnF59+VLsJgN/PTZEzTX+HBajby4T19keN9VywhVuxgfS/D89j5am4KMhhOsaS1DcRh4bihMXtVo9jm4tLaE5EyGofE4q5eXEZ5KsqdtjDNXVJDVNP7ze7tQChe96sx6LttYg1ESGMrL2AwSf//5l/nojav4+v2HUFWNlYuCXHHRIh7qHWOD2cY9D7exeXkZF22sIS1CMpnDqOjV0UZMGmeX+Ymh8swzHVQGHRzsDDM4rle229xaTnO1F6NRZHVTEFHTkCSBE8MxPvujvaxZ4ufKcyt5/IUxrj63kan4FAISFqOTB57rYGI6xY3nL+LuJ44VeW2s9HDFGXU4XBYSosYvukaQBIFPbmgin5H5p69tp8Rn45qLFnE0leL4TIIzSr040xoPPtvB9ec28eBLXcSSOdYuLuHGi1uICxqPd42yqtRLKi/z2tA0715ShSGt8J8/2H3a5vfrzmkknsqxsrkEo93IsyNhhpNZbl1SSZ3Pwfd+fogDHXqRG5/LwvveuQqTCk0lDvZ0hHGX2mk/MsHSWh8HOibpHIxywfoqIskc1XVeXhydZjSZwSAKnFnqw60I7DkwwvWXtHBgJsb2If3MziqHhTNKvOw7MMrW5aU0luvHiKQFeGEwzK6xGa5sLGVtiRujrKJqsPP4JLKi8vSOPjYsKyMym2HHkZP7dLe0lnHN2Y189+Gj3H79cqLJHF++Zw8fv2k1aauImFX50cNH2biinLIWP60eB5+7Zy/nr6umosTBD588RnWpi7KAnSe29bK41sflW+swSCJZNF6IRLmpvoz9R8fQNHj4ZX0Bz2o28Pd3bKTG5+Cn7YMcnfdjE7KbubWlijvvO0BdmZOz11Tx6e/v4n1XLefbDx/Bajbw7suXMDSZwO+y8NzuAUYLi0jN1V42nFNLTyLFRXUhEuk86XCKkXCSw51hQn4bV26tJ+gyU7LggP6vwIIDutDv/wm8Vfu+0O8/P96qff9L7vev+202/BbtS4H98/4OF16LAXR0dMSbm5v9v21nvF4bhsJ5hb8vfKrG5z5yBj/95XHqy108uf1UJ+TBl7r4wDXL+dZDh5lN6EVmMjkFFY2rz2zgc/fq2cLdw7MsrfdzrHf6lPbVpU7Kgg7sViP/+cEt3P1EGw2VHp7c0cfq5iABt5VwNH1Km02t5Xz15wcBGAknGZ9O8tLeQa4+q4G7nzhGPJUnGs8hK3ruW05W+ekTx7n97Svp642Q8zkpD55M6TOJBj782RfJ5hTuvLePbE4vE//dR47w1U+cTUnQRjankIokuamlktF0lp8UzmwEeLxngisbBOptFgJlDh7d181EUk8BDTmsfOtgL+9dXsv+o/Dg6ycYmoizuM7HOy9cxE96RmgtcXNJdQk7DwzT2uRnMpfnoZ4x3r+4mv1PtJMvnAf5yv5hpmbS/NNt6xEESKTzmE0SdouRnzx4mOHJBLdfsZSv3refVEZ32M0miX9770aW1vt57PE29h2fZOvKCh5+uZuQz8aHr2vlrsfauGxLHTPxLNed08gvdw1w9Vn1XNdQRnQiSUu1jxKfjeFwggMn9KNwrGYDf33zamrKXDy/ZxCnSeKVvQNF5zPgsaBp8O1CJG7PsXGuP7eJWy5pYfvhUV4/Msb7GgP0xbOsX1LKnvZx7HYTAb+Nl8anyRe+qH82xcBsCrsC9zzZzv0vdKJqsKYlyOHuKX7xQucp2njstV62tJazuM6POZtn99ExGiu9HOmeKkaLD3WGufyset63vIZ/+fp2ltX7qShx8OzuARoq3QTcVr7zyFGyOYX//qszmJhMIIgC2axCyGdncFy3AVnReO3gCK8dHEEQ4KufOIt0VkEU4GfPdQCwv32a/e265vOySmtTAI/DxH/fq0f0t64oZ/excUDfM3nVmQ001/r4/L37UFWNCzfWcHZLAKfZiM9o4K6nTpDNK6iqhpTXOLPUx2xexpOF7z2sL/A8/HI3771yGV1DM4iiyN9/9TXef30rF5cF+HHPKH+9poFUTmb3nmFSyRxnr67k5f3DRQ6tZgPVpU72d4SprfHwpb3dJAv7m+87PszKkIf3XNPKkS+8jKyoROMZtGSeSCLHQ8cn2bSslM7+KEGPlcmZNM/tHkBWNKwmiXdcuYSJXJ5oTt8DK6sak9kcjUEPF2ys5udPtnP1OY1oZV5ORJOss9r5xj37yMsqk1MJ3n7RYr73mL4o9d4bVzCUyLCmxEOZR09hHxiP8eOn2nnXZUuYTeQo8+tO4nw47Wa++8hRtqws52v37sdolMjLGvtPTLJqSYgHnu1kNpHj+Z0D/H1LCQ6Tgc98aDMPvdiN3WZkcibNjecv4psPHGbt4hANFW7yssqX7ttPwGPlcx8/i//63i7OXFXBfc+eKF43nZV59fVBorMpPnzjKjZVZLjrUD9bSr1YYjJf/MFu3n5xC+GZNAPjcWRFI5WVKfHqPH7roSNUlzppbQxw+dY67npUz/joGJzh7EwNl9SE6O2JUB6w8/PXehkcj+OwGlnW4KdnZBaTyU8J+g/dAv5n8cf4bZ6Pt+qYLvT7z4+3at8X+v3nx1u17wv9Ph2/jQP6RvxBK80zM6nf/KHfAh6LxN/fupasBpvaJ3j96Ngp7wuCUHQ+z1hZwRVb65AtEj09EW6/YimPb+th97Ex/v6Wtfz8+U6O9U7TVOXh7NWVtDYESKRytPdF6BmOcuslS3A5THz8K68yGUnxrsuW8J1HjpDN6RPgunIXw5OJ4rW7h6MsrfPz+tExjnZP8ZEbVrDz6Bg2y6l0T0RS7D8wyv62Mc5cUnrKSsNkNMPG1jKa63zc9cCR4uvxVJ7paBo5L/P07gGe2NbHDec20dTo545Vdfy8fYhIRuam2lIeeOoEyxv8rG0Jcb7Pw6RPIeS2sm9shqFYmm19kyyu9BCZ1Sekx/sirB+e5byqIAFB4tPffp3br2slLCo82D2Gomnc1z3C29+2nFw0i0HT021tFomB8Rg/fLKdjsEZNiwt5W3nL+LVA8Nce04jP3uuo+h8AmRzCp+/dx9f+MgWuodnGQknsFuMnLmqgjUtIUankwxPJopFY0p8Njpe7ubx1/p4+6UtiBYT33u8jdlElnPXVnPHta2IosCiag8us4HoTIoyv41/uWvXKXyfsbKSZ3b2n/Lagy914XNZ+Mdb1+J1mpGAC9ZUImswMBFnz7FxOu/axV+9YzWlNjP7J2d5e10Z+USOL9ynp28nMzImg8hZqyr50dPHATBIIledWU+J14aiaqSzMpGZBAgCuayCw2YkGs+e0pcv/HAvN13UzIeuW0HQY+Xv7tyOqmp4HGbMBqnI4dOv9TI+naJ7OMpHb1hJNq/wZrjunCZ+/HQ7Z6ysZDScOO16AEe6p7j27EYm5tmlqmmIgm7mt1+5DEkUuOeJY2iaxu1XLGV8OkkpBtxGIz9++jh+txVRgBvPX8Q37j9EXYWLv75lLZ290xgkAVnRiCayfPvhI/zjbev4l+/uBOC7DxxhzZIQH7q0mW27B9m6soJ//FkbmqYfs/Suy5bQ3jvNuiUhFlV7+dlzHQQ8Vr7zs0NcvKGa9kyK49Ekl1SXUG218NdfeqW4wHP9eYt4/NUeTvTr2Q6/3NnPP9y6jm8/dJirzmzQj4UBjvZO8w9f3UZ1yMnH3rWWrx7s4YxSH5GeKDOY+OYDh9A0WLeklHK3mZqKAN/50f7iAsyFG2v59Pd3cfaaSrxOC/c8eIS/e/d6Dh+foNsoUV3iIJlXsJgNzCZz1Ja5ODFw6h72yhIHS+p8/HJnP2etrmR8+uRYvLRvCFXVuPLMegD8LgulPhsGTSORknluzwDvuXIZoC+yAWxaXsazuwaYmk2jajA5k2bf0VF6R6Kcvaay+NwC8DjNaLKK3WJiMpykOmBjZYmberOFrz2zj4/csJJYMscvXujkPVcsBeD+Fzp5/9XLOdg5ycEOffFnWb2fmlInV51Rz1Ov9yErGs9v6+ODNyznh4+28YFrWhkcj1Nb5uLKM+t5+OVuhicTBDwW3nvlchrLnX/QmWBv1R/3/034Y/02w1/2iv//BN6q/Ya3bt8X+v3nx1u173/J/f51v82/jQM6ih7xnEM5MPYrPvtnRUxW+OreHt5z2WL2HZ8gJ5+srGE26tOZ89ZVY7dKyAaRu472c211iIeeOM7NF7ZgNUv84vkOltb5ue3yJbx+ZJT7X+wkL6vsaR8vVrO9/8Uu3n35EjwOM9FElp8/38G7LluC1STh91gxGUT2F6JwAAc7J/n4Tatp651m7/EJDnWFWbkoiM9lobbMRf9YrPjZ517v512XLcFsFIkkciTSedx2MzaLkXWrK4jk8lQEHYyEdQfXbJJw202cGJrhsVf1KMrzewapLnWiWY2cU+onJ8I99x/RnZShKE/t6OOD17Ry1tIQn93ZUYwcvTA6TW8qwxf/+iw+/gV98m6zGLFrEk+90oMoCmRlhbyoohd41qs2C4JAXbmbf//uTrI5hQ9fv4J/+94u7FYjH79pFW290/SNxTBIIh6HmYnIqRObDUtLWb+0lO6RGKuagxzrnebeZ47zweuW8/hrPVywoQaAfF4h4LESS+oLCcf7Izz8Yhe1pa6iM/Xi3kFe3DsIwCffsYalNW4EQSTktbG6uYQDHSfHxWkzkkjlTtNRJJYhPJvG7zDpBVMKZbmvPauBve3jyIpGPJ6j1mWmvKGUnz3Wzvnrq0/5jlsvXcLhrik8TjMj4QR3XNfKE9t6i2N9zdkNZGWFSDSDJIkMjse4dEs9BzomsZoNvO2CRRglkXgqh89tYTqWKUZH23qmT9lX63FaONw1RV5W+d5jR/nojStpbQxwpHuq+BmLSaIiaKdzaIa97RNEE1lWNQd5ef8wggAbl5XR2hhA08DnMpOZt2/zYEeYd17cQjorMzKZoKLEwUQkxVmrKznSPcW+4xPsOz7BzRc189zuQT5ywwrWLgmx+9gYsqLSNRjln7+5HafNxB3XrSCZziHLGiubghztPdlHgP3tEzRVebCZjPzD17YVX3/klR5WNAa46cJmvvrzg3hdZkI+O6mMrGcF3HeAv759HXkBJvuiqA4LBoNINq+wZnEJVSEn98+LRGdzCiPhBJMzaVJZGa/TzMw8h3xwIs5rOwe4dnkZaizPZF7huV0DxTRgURB47Lku6qvdJAsLAS21PvpHY5iMEg0VHu569Cgfvn4FX/zhXtoLhdI+dssaysocZPMKQY+VZEa3bwCv08w7L1nM4HgMoyRiNIgYpVPdsMW1PkI+G0MTcS5aX43dbEBWNEQJZEVFVjSmZzOUB+wYDSIBj4WRcAKLWSKeyhe/51DnFCuagiTTeXwuC5FYhhvOa8JiMrD72Dgmo0gikyeQV3jn0ip6+mfYurKCX+7qZ3NrOdmcQsdglDUtJew/McnXfnGQFU1BLttSR3O1l/pSB4qicfXWOs5dW0U2p+C0GRmfSWEySsQLdnflmfXc+cDhYnr6VDTDf/94L//5gU2Ue62n2eYCFrCABSxgAQv4v4ffZtH5OeB6gObm5tXAaEdHx/+oKy+KAlmDyLO9elGaF/on+Y+PncGtly7msi11/Nt7N1Jb5sJgENm8oozW1jIeHxgnI6s8NTLF1Vcsxu+38pWfHaStN0IiI3PPE8d45JUeWhuD+N2WU84YBfjlzgFuOK8J0COXj7zSDQh88Sf7+Yc7d1A6r/qopsEPHm/jpgua+djbVvKOC5u5+swGQh4Lf/uO1Vy4oRqzUcLrNPP+q5exfnEJ9z7byd9+Yzv/9v3dfOZHe1CNAtvCM7w0Ns0t1y7j4s213HLJYv7tvRsYmU7y9Ov9xetFYhkefbWHyckEIauZCrPplChKLq/y9fsP8eNH2/ibDU00efS+bg15uaTcz+d/uJdswdkbmUzwxR/u5XhfhPBMmq//eD/hjgjXN5YjCQI31ZVBNMt/3rWLbE7B6zQzPZsmm1d4x8Ut3PXoUQ6cmMRuNXLB+mpEUUCcFzNfv7SUUr+Nb9x/iMe39bK4xlestivLGj0js3QPR1lW7+ex13p5+0Ut+FyWYnunzXTa2Mwhr6icGI7x5fsP8Z2Hj3Lj+U383S1rOG9dFe+9eikblpayZUXFae0EAUrfpOJvidvMf31wM8vq/RhEgcef76TWamF4MoHZeDJVze+2kMjkeX7PIOesqWJlU5CDHZNF53PD0lJmEzlm4znueqyNB17s5J2XLMFmNtDaGOC9Vy3jqR19fO+xNg52hNl5dIzZeRVzR6eS1Ja7i393D0VZ3qBnvcdTeT73432cuaqC1c0lCIKervqp92zgxEAEl83ETDzDsd5pljUEKPXbeM+Vy1BVjR8/3c5EJEX38CxBrw2X3QToaZl9YzGuP6+RHUdGSWdkPA4zS2p97DuuH6mRk1VGw/p+v58+28EVWxuKfwNMz2boH4vxjcIe1wvWVuBzGPG6zKfx/PNnO7CaDdx22RLshSyBlYuC3Hb5Uv79B7uZiKQYm0pyxopy9rSPcc7aKgCeerGb25ZW88y2Xp7c3svtVyxl3eIQqxeVnJZWD3o13toyF8/u6uftF7UgzROmKAqsag6yOuRmZY2PyzbXnRIV3n54hBVNAV7eM8SalhI+csMKzl5VSV5WWdEUZNexMZbU+TgxECk6nxuXlzGm5XmwY5Q7blxB19AMdeVu6ipcGCSRd122hLsfbyMaz5JXVM5fV017nx7xNUgiH75+BeVBB8/s7KdjIEoslefBV3v5zL37eODlHkwGifoKF0/t6OOmC5rJ5RXK/HbMRomuwSitDYFi/3e1jXHBhhp2tY1x0wWL2LqinLGpJPc+c5zOwRnaeqb5zA/3cqBzCjmVo8xv44L11bT3RcjLKk6bkRf3DrK41seN5y+iptRJJitTU+qiImBHVjVmMzIjkRSgEXCZMUsCfpcFRdVwO8yU+e0MjMWLzud8PPV6P5L0h8RAF7CABSxgAQtYwFsFv/EXv6Oj43Vgf3Nz8+vA14EPNzc339bc3HwNQHNz8wPAz/X/Nr/S3Nz89j9ph0VBP17gcB+vDemTzH3hWX7SNczWNZWMTyVw2Yy4rQb+6Za1eDxWjs7EGYjpezZns3n2RWJIJgNlAd0Rqwk5ae+LsH5pKXXlLtrebPI6nSQSz/D3t6ylvsLN9ec08f3H24rRudcOjvDuy5cU02zTWZlUJseyWi9nryynzGPBKArYDCIfvLaVr378TD57x2a2LiulYzDKKwf0/W7nbazmPe9czbfaBhiIpcnIKj/pHaVmWRC3x8L4dJpXDgyfMnkG6BqK8sX7DjA+kcBuNFDmP92hWlLnw6GoXN9cTshuxp5S+eI9e3nb+YvwuSwkUjk8ztMdhOd2DlBuMXFDcznkFBSVYgGmy7fWk5dVastc9AxHyWRlbrtsCV//xUF8bgvZvMKm5eXF79qwtJTHXutl0/Iyltb7+a979nDZljreddkSAi4LHoeZl/cNcfaaSurKXfzoqXbsVgMrF+nH24xPp6guPT2kv6zBz9BEnP/+8T6OdE9xuDvM135xiEQyz22XtLC2JcR//GA3zTVeqkIn24uiwIevW4HbZiSRU+ifTDIWTZPMq7T1z7D72Dg3nNfE8kY/1aVOfvDQUa47p5G2ninOWqU7s1UhJz1DUbJ5hVcPDnPduU3sahsvXmN1Swkv7x8iV9gnOTmT5s4HDtExOMNNFy6ib2SWcKEA0xkrK3h6Rx9tvdNsbi0D9EjX0ESczcv1v4/2TLFpeVnRMVdUjW89dIT1S0J85a/O5L8/tIUfPtGO12mhY2CG1kbdEbnr0aPcfGEzfaOzHO4K88FrV3Coc5Kv33+IT39/l37G65IQBkmgrWcKv8uK2Sjx4r5Brjm7oZjeCpBI5fEWjvmJxDL88KljLK1/863glSVO8nmVtChQX+vDaj498aKqxME5K8v4wke28o2/OZuPXrecSCxNOitTFXJy22VLefXgCLdesoS+0Vluv2IpU9E0P3/mOCuagkzOpHngxU4u21rHT5/reNMjhF7eP8TNFzYTjef0rIBrW7nlksW8/+plfPmvzmQikuLzP9zHz57rwCAJrC5oDqC9L0Imp/A371hNS62Pbz5wmO8/fpTaMheiCKqqsbwhwN72CSqCDj526xoqVwTZPjbDSCLDkVyarRtrWN7ox24x8p8f2ERbzzRmk4GGSg9f/ukBXHYTHqeZ1sYAf/OO1TyxrZcX9w4SS+Y4b10V/3nPHp7Y3kvPyCxPvd7Pv3xvJ3dcuwKTUeTOhw4zEUlz0wXNLKr2ICsq4WiarSvK8bst3HFdK/2jMa4/t4mgx8plW+rYfnj0NI7u/eUJMrJKJq9gsxjwOM08v3uAG89fBMBPfnmCV/YP0VLr420XLGJxtQtN03h61yB/8/Vt/PN3d/I3X9/OjrZxFA0cZolP3LSKrqEZNiwNkcrkT7smQCyZO63o1AIWsIAFLGABC/i/id9qD2hHR8c/vOGlw/Peu+GP2qPfAFXVkJM57lhRy9PdE+wLz7LK76TWYOZTd+5gIpJizeIQmxaHqCtzsq9ziuFjE7z/4kV898gA55T5WWS38m/f2F5cic8XJtbrl4T40VPtXH1W45teO5bIsaTGzT/dsoaR6RTJ9MnJ1OGuMJFYhredv4imKg8OixGn1YCmaqekTwIYDRJWo0giqzCdyPHcnoHie7sOj1FV6uSy2hIe6R4jp2psKfViSMrsOzqGzWJk/4lJbrpg0WmRQFGAsoAdmyTwT7et54GXunj9yChOm4mbLmxmZYMfWdZwSQKfWNdIKpZhTb0+If6vD2wiEs9iMUm4Habi/lnQI4SCrLGuwsdMJIW1EP27cEMNXUMzrGkJFQsCrVxUws62MVIZmR8/fZw1LSVcfVYDQa+Vl/YNkUjlEAVY3VzCnQ/qMrr7iWPYLQaaqr3cfFEz337oCN966Agbl5Vyw/mLyMsq77tqGQPjMXa1jXPGygp2HBkt7olsqHRz84XN/Otd+t7CM1ZW0NoYYGA8RjKTZyaR45UDI4xHUnzn4SNcc3ajXiFUFKiv9GA1iXSNxPjSTw+Ql1Vuv2Ipz+0eKO7rfey1Xsr9Nv7p3Rt4+OUuBifirGkpQRQE1i8tZTgcR1Nh7/EJjnRNsXpREKtZIp5SiwWZNI1TIjw5WeWlfUM4rEb2FqKKOtn6e68dHOGG85q45ZLF7D0+zkg4wdvOX8TVZzciKyr72se59dLFKKpGMp2jscKD32XGKAr0TSboGo5y/oZqMjkZi9lAU5WHrqEo8WSeVw8Mc9mWOh5+uYuBcT2ZIZbM8YWf7OeKM+p516WLMYgCVpPENWc3ctejR2nrneaqMxpw2U3EknoxrXRWLqaH9wzPcunmumJ65xxWNgWoCNgRJIE94zP4rSY+e8dm7nqsjfa+CEGPlXddtoSqoA1F0bDMVVPWKDokV51Zz50PHkZWVNp6pgpp9QY+dfsGjJIAAtjMRl4/MsLQRJxkOo9REgl6rUXHHkCWVcp8Nj7/ka0c7Z5idCrB2pYQPpeZr/3iECcK1bHb+yK8cmCYz314K/s7Jou28NzuAdYvDRWLOcmKRudQlIDHyuJaH5MzaZw2E6VBG2argaGJOHOWP5LIMp3J4nSaGRyNc87qCnpHZzljZQXPFLIZfvFCJ/UVbra0lmM0iAwWKnuX+m2MTiVJpE913iKxLG29U3z2ji1MzqQRBD3N3G2z8a/v3ch3Hz5CQ6WHv377av7z7j3FRSNRgA9dv4I3w+Vb69jdPsF9vzyB12XhqjPq+dHTx9lzbIKP3riSnuEoGnDGinKCLguaCv3jcR4qVNXVeVH5wRPHqK9wU+ax0FLlpjxgJ51TSBYyBd6I89dV85sqsi9gAQtYwAIWsID/G/h9ihD9j0NVNUwqNNus9FvT1BrMfPunB0/7nKZqNFd5uOfJY1QeGmdzlY9qo4lDJyZZVO3heKFAiSgIWM0GUhmZeEqv4hrwWIrnSwKYDCKXbKxBkTVEOC0CCTA0EefeZ07w1Y+fic0oFs+5eyNkWaFjJMbXf3GQZQ0BrCZ9GAQBNi4tpbncw5Pb+zhnVYihdIZ4X4xfbO+jsdJDTZmRZDrP0ESCq89q4OkdfeRkFbfDxIeuW4HPbgTAbhR598Ut3HReE6IoYDGIqKqGIEBe1tASOcwGEYsEqCpmSaDMY0EQBD79vk08ub2XAx1hKoJ2br6gmYDDhMtsJGsQMbnMNFd7aarycOeDh7GYDNSVu1AUDVlR2TEvsrL/xCT7T0zSVOXhk+9YQ05WqShx0jsyewonyYzMoc4wi6o8/L/b1vPQy10MTSRorvbSUB7AIgksrnSzvNaHpsFn7tjCtkMjjE4lOWtVJX2jMWRFY01LCR6nuejcfvj6FTz9ej9dQ1FAr/p6/wudXLq5Fr/bypfu28+1ZzfyrYcOIyv6GafZnHJKUanqkJNrzm7khb2DVIacLK71YTZK+BwmBGB5rZdoKs+T2/tIpPO8tG+YizbW8vhrPdxxbSuyoiKJArm8cppzH01kKfHaivtkM1m5uNf4gRe78DjMtDYF0DQNl81IXlb517t2F50Js0mi1G9nVVMQY0GTc1H5nz3bwXuuXMbBzkk2LS/jijPqCbitqKpGyG9nYPzUSqyKqvHoqz1sbS3DZzchyyqrmwK87fwmHn21l+GJBB+8tpWv/Ex31H/xfAfvuWoZiVSeXW1jdA7O8M/vXs/AeJyRqQQt1V4qAnYMZomBdJbn+icxSiIfXFHHX79jNflCMRxZ0VA1AYMonOKElHitlHitTEXTxejrTDzLgy91AbBqUZD3XbWMcDTNJZtruPqsBqKF1OX7nj3B7VcsZXAizon+COVBO1durcdp1Y//OWtFGYIgoCgqI5F00fkscqFo/Pz5Dv7jA5sZGIsxHU3TWOUhJ6unLCi9uHeQdYtDrFpUQiarcNHGGu5+4hhHOqf49B2beXE8wlAizZWlfr533+Fi/zYuK2VJrU8vRjUv3bp3ZJbekVned9Wy4msBt/WUM3Lno61nmvNXV2IJ2IoFAxRZpcJr4VPvXk9e1Xjo5e5TjoxSNZ3zuQJRoJ+7+76rliOI8OWf6sW1JiIp+sdivPeqZbywZ5CfPXeCq89s0KPkhe8SJZFndw+8sVuIosDoVILg3HNU0/e8+p0mbjyviQde6iouMJy5qoKWas+CA7qABSxgAQtYwF8I3pIOKIAkCJgUjY+urOdTd24vvi4K+hl0c5MZl9XAf35gMz997gTXLivlUPsEW1vLOKO1nE/dtZN0VubZXf284+IWjIXoy32/1CevA+MxOgZmqAjauWJrPV6HEa2Qheh3WYpHEczHhRuqsZulX+l8AgyHk3yucKTFoc4w771qGQc7w9x22RJyBQfpYGeYpS1BLqou4R8feBWA3pEol2yu5cW9Qzy3e4DmGi+3XroEBGiu9hB0mk+ZHGvayYiSqmqowOBEkh8/3c7YdIrWxgA3X9iMz24sttM0DZdZ4h3nL+L6sxsxGkSEN0wMDYLAx25cQXth0v7KgWHWLQlx9ZkNvHZohMqQ47RjarqGouRkhTKfHafNiMn45uX+e0ZmuXRTNX/79lWoKpgNAooy1ze9MBGAyyxx5eZasorKv3xvF5dtqcNikti4rIxvPaQ7nyVeKxORFKPTSUr9dnoKTm9DhRuL2cC9z+gVazM5pTgRrww66B096RybTRLXntPINx84VPwM6EeV3HpxM4ZCtVin2cB/fXAzrx4c4VjvNPXlLj5+82oee60HSRS4+qwGHnypi/deuYxf7uqnvXA2bVOlh9pyF0d79OI8z+0e4KYLm7nrkSOomu6gvnZwhI/ftAqX1cgj2/pOcSayOYWBsRhtfRE2LS5BVTUqgg5Ab/vVnx9keUMAly2LySiyrM7L5tby31DK+uS7Jkng4vXVbF1RjixrOK1GvvTRM5iYSSEIAiGvFbfNyNkry5FEUBUNb72X89dXEw7HkaxGdo1HeaRTX5RQZJWv7e/h9hU1hAxGPnv3HsamkpT57bzv6mXUBk/upXZaDHzi5tXsaZ84rYeiKHDhxhr+9fu7ilFOURT4zw9uLi4e3fngYWpKndSWuzlndSV+h6moc/1f/f/zI7bzcaJ/BqMosKzGg1Dr1dOn36SS8N7jE3QOzfD5D28lm1f58PUr+NlzHfQPz7LK76DFbed7vzhyiqOZyyucv76anz/fwZqWktPSYU1GCVHQncXhyQSXb61jV9vptd/WLg6hzEuNnoOmgUHQh/JE/+l7pl/eP8Q7L1nMD59sB+DtF7Wwp33sFI0DvHpwpPhsWlbvwyQJqG/4zBtteXlDgPPXV+Gwmfjn7+4sPiODHiv/+K51XLS+io1LS4kmsjhsJqpCTtLJ03ldwAIWsIAFLGAB/zfxlq36oGkai+v8bNs/xPSsPoF02oz83S1r8RaigKBPND1WA3dcvRyPxcgFa6sIOEwEnCb++0Nb+PhNqzhvbRWLa7201Hgp9dtIZ2XufPAwbT3TVAQdXLi+Bp/dVHQ+ASwGPc11ca0P0COiF6yv5ootdb/W+QToH50tToSzeYX9Jyb42NtWMj2bwW4xcqgrDMD9T59gajKBUHByVA12HR3jlksWYzUb6BiY4d5njqOpGm6b8bRU3zdiLJLm3+/eTf94nGxeYe/xCT713deJzTsiZT6/Jkk4zfmcg9UgUj6v8NLe9gn+/e7dVJY4uPrMBgxvKChSX+Gm3G/HahS445rlLGvwI75JFPnyLXWosoZYmEAryq++J0VRSWVlxqdTvLh3iBvPX0Q2rxQjKz63hYlIirbuKTYsLS326cxVJ9MegVP6EY6miw4cwJkrK3j69f7TJubbD48SiZ+MZGqahtMsceWWGv7+natZUuOhzG+jY2CG9r4I49MpbrlkMccHpjl/XTVf/NgZfOEjWzljeSnlXiv/8YFNLKv3o2oaiXSO//7IVt5zxVLefcVSvvCRrSwrOECdQ6dG6ubQMzxbvA+v3cTbCnv2QN8zuqttjBWNQVA0br5gEbm8QkOF+7Tvaanx4p5nP6BnEtiNEm6rARENh1miodRJfciB3SQhyyqCphUdk/mSUdJ51vmd/O26RkyigNNk4B82NlEiSHz8Cy8XI3tj00n+4+7dTM2LDmuqRpnHwvolodP6uX5JKS/vHz4lxVZVNT5zzx7+320bOHNVBWajRCansKY5SLnP9ivtI/grqq8urvVhNghoGsW2PoeZlU3B0z57y8WLMUsCDpPIukUBPvPBTaxo9HP46DjjA7OnHIGztN6Py2bEYzVw8wXNXLyp9pQ9q3ohKYn3X70c0BcSDAbxtL3PlSUOltf7f63dGw0ii6q9p73eMTBDU6WHz314C7ddthhJFEikT38OgB5R7x6O6lkUb7ADRVa5ZFNt8W+fy8Lm1jL6RvVjmeYv0IWjab54335kBTw2I7UlDgIOEw6b6Vf2fwELWMACFrCABfzfw1s2AgrgdVo4d2UF61pKSGf1sv92k4h6ekAAQdOwSPoEXdNOOgwr6rwIglCcxP2/29bzy539vH50DEkU2LqinBKP5bT0ME3To3B/fdNKEhkZSRRwWgy/0fkETnO8drWN01Lr47VDI1x/bhOiIKBo+tmJj77cwzsvWcy9T7ejanq0JZOT+eyHtpDNydjMBhy/zXVFgYdf6T7t5WRGpmd4lpUNvt+5CEjAZWZFY4DDheM/sjmFe55s5/Mf3srnP7KV5/YMMDyRYEtrOa2NfsySPpm3myQaypz8823r+c4jRwp754y869IlVAbsv+Gqp8JkEPG5LPSPxfA6zVx5ZkPxvaGJBBuXlbHt0Aj3v9jJx25cyetHR3HYTKdEEZPpPEGPlXA0zUQkRYnXWkyVrShx8PL+4Te9djSRpeQNVV3nJugqehxREHSt7Dgyys62MapDTo52T/PR61dgKSwaCECF18rH37YCWdEwG/T07ZLlpfj9jnnnMGmsbSmhref0Ilmtjf5iJEwS4Pw1laxpKWEknMBlN1Pms2I1imiavniweWkpyxsDfOfhI3QORgHd+fzw9Sv44x1FX4CsEhBFrmwqw2s24hMlfrGrjzdKVtP0aPpN5zYiF45UUlWNgNPM+65ext2PHyvu2z5rVQVf+Mm+0y6VSOeZnk3r6efn67Y0l37+qxBwmdnaWs72IyejkBaTxE0XLII3NDMI8P6rlrK7fYIX9g5htxi47twm6kodp0RXTaIefrxiSx3ffPDkOb5L6/3ccc1ypMLnnGYJj83Ap9+7kYmZFOmsTInXhsuqP5q/9LEzGA0nsVkN/O071jAymaB7OEp9uZu6MufJPbO/ApqqceUZdexsGzvl/M+GCjc+p16ptmxVBU/tGqS9b5r3XrWM3cfGT/uera3lxTF5I8p9Nj50XSs/eqqdc9dW8cgr3Vx9ViNDE6cXSx+dShJNZgm+SbGzBSxgAQtYwAIW8JeBt7QDCoCm4TQbcBYqa76Z8/kbmp/iXNqNItef3cDlW+owSgKSwK91zCTAXah8+9s4nwB15W6MBrF4mD1APJnDIAnsPzHB1hXlvHpwBNBTVyVJ4GNvW4XFJGE2SYQ8BWfCLP3W11UUjelfkWoYiWUQBOF33oNlFAU+cM0yjg9EefXAMCGfjQvXVxf3od58bhMIvGkhJlSN+lIH//7ejaRzMiajhN0k/cYo7hthM0rcfsVSvnjffg52hin121nRFOBw1xTJdJ58XmVRtZfOwRm++ouDrFoUxG4xUB1yFou8PPRyFx+4ppWX9g1xuCvMgy918TdvX8PRnilkRa/w2z0cPe3abvuvj9w4rUbWLyktTuhVVaN/LEZNqROP8/S2ogYmUSiO5xu5UBSNtS0hnnm9n4l5kaX6CjcNFe5TdCoJ6JF+h6/42hvf91gMfPLm1cRSeRDAZTUi/frc3N8bqqqx3OekEMw/5ZiZ+ZiJZ4sR//l93bS4hKW1Pj1t02rEZjHisJmK+13nw2yU9PRz6WT6+a+DQRB450XNnLO2kgMnJikLOFhW78NtNbyp7VsMIueuKmfL8jJEUUBC+5XPCIdJ4pM3r2I2lUcQwGUznubgK4qGSYSqN6lc7bUZ8dZ4in+3VLpYUu1BVdXfesHIazPy3x/awutHRukdjbFpeRmLa7yYC4MtyyotNV7yssqx3mluPG8Rj73WQzavYDUbuP3ypQQ9ll/5/ZIA65uDLKndSk5WefClLoRfoyOD+JZNvFnAAhawgAUsYAF/BLz1HdA/ATRVK07O/hR1McqDDv7l9g18/f5DhKNpDJKI027iqjMb+MHjx3jvlctQVI3Xj47pk2cNastcuC1SsT+/a7+MksCZKyv4yS9PnPZeS63vd3b85mCRRNY0+lm7KIAAp0RJ3mxv2nyoqp7ma7Iai3//rlBVjZYqN//5gU08vbOfsXCCmy5sZtOyMl7YO8SJgWnef/VS4imZ3pEolSVOqkMOPnR9K//2vV1kcgqpjMw3HzjIp27fyPuuXIoogM0sUROsRtP0VMxPfXfnKf1bvySE3/WrJ+WgR91vvaQFQYDdx8bRND0C9oGrl2H8dTP0XwObUeRTt2+ge3iWntFZWqq9v1Uk7FdBEjglZf1PCZOiO0159DTobW9yDMjZqyqRZeX0xhq4LAZchcUeSRK46YJF3PVo2ykfK/PbCLh//bi8ad8kgboSB03lLrxeO+Fw/NfamKJo+h5LTXtjkPQ0SALFRZk/FJr2m+3qzdq4LQYu31SLKOqFl95oa2V+GxuXlfLawRGaqjzccsliTEY9fddjNfxG21RVDZtRxGQQqSxx0D08y7IG/2nR+mX1/tNSvBewgAUsYAELWMBfFoQ/d+XBcDj+R7vgXNXHtxqCQSfT0wkyslqsuuu0GMjkVZ7bO8iT2/tYuSjIxqVlVJY48DtNf5TNumlZ5cs/O1gsxgP6EReXbaopFtP5Tf3+38y3ZBBBA1VVEQQBWdOQBD2iOMf53ERaECCeURgOJ8jlFapLXbhtBoQ3U6cAkUSel/YPMTmT4qxVlTRWuIuLFL8JmgDxtIymgdNq+J3G8ldxLggCoij8TpGwPyd+k1ZyqsZj23p5ZufJCqoXbqjm2jMbMP2WvOZVjQNdU/zi+U7iqRxbWsu44bxF2I1/mLX8b9f5r8If2u+cqjEZTdM3GqPUZ6eyxI71d1zYEASBoekk/3H3Ht5/9XJ2tY1xoGMSgHWLQ9x66WJsb/jOPwbfwaDzTxS7/8vBwm/zQr//J/BW7ftCv//8eKv2/S+537/ut3khAvo/hLl9Yn6Hnoo5F3W9cnMt56yuJJdXcVoNmCTxj3Y8gdUg8sl3rCYczZBI5/C7rXjtpj9Z2uWfG8q86Kum6cflzOfu1ArB4DBLtFTOK8Tzq2jW9AjWTec2Igh6lPd3GRKhEL37Y0LTtF9boOl/O0yiwLVnNXDe2ipmkzncdhMe+++20GIUBTYvKWFVUwBVA4tR5LSNpQv4rWESBSp9NqoD9t87I0LTNCr9Nv77Q1vYe3yCtS0hbjhvEWajiMtq/JVFzRawgAUsYAELWMBfDhYc0P9l0FQNh0kCU2F/5x95wmYSBSp8VuDNK38u4FfjVxVhWcDvBwnw2U34fsNe2l8Hff9kYQVlwfn8o+D3dT6L0PR9p5esry4u2OivL4zPAhawgAUsYAELWHBAF7CABSxgAX8C/K57VRfwfwMWU774b042YjLkycsGJCmPqkoIqCBoaJoBSZTJKyb9M4oJo5QjJxsxGvLIigFJyKNqIqAhCBqqZsAwr01ONmEy5MjJJoyGHLIsIYlyoQ2IgoqiGTGIefKKufBZMyZDVr+OlENWDYiCjKYJyPk0JkNObyPJ5Of6P79vUg5FlRAEBTQBDRFRVFAUI0aDfPKeC23yshFJyqGqBgT0/e0n25gwzn3WkCOXP8mXQcyjaCIC+pnFGpLeRjVilORT2uSzMSRJQxLk354vKYusGoscC2ggaKiqAYNBKd77KXwZ8siKVOQLhN+KY0U1IAhyYQ3q1PvQNA2LaR5figFJnNOKohcy1CQkQUFWfw3HYg5VmxsX5vFlwiidOoa/lyal3Cl8ybkURkNO51h6M75OalIU5YJWfju+5mtyPsdG6fR7z8kGjFL+DZostJnPlzFPXjaRz8aRRAqaLNz7b6lJSTxVK5omIYkKecWIySCfzvHvasO/QZOaphaeK7+LJt94nVM1+VvZsFLQ1xs0KQoFfRneXF+6DUvkc0mMUu7NbfiNfBW0D0rhFIVfpcnT+TqF4zfVZIGv30KT2fyf/ni0hXKEC1jAAhawgAUs4A+GxZhmrOsRktFBxnsexcgEU8MvQr6fZOQI2dgRlOwQs2OvITHFZN+TmKUoY90PYxKnGe99HCPjzIy8Atle0tE2MtGDkB8hOvoyRiJM9j6BWZphrPshzOI0E31PYNBGiY5uQ8v2kIkdJz2zH/KjRIZfxChMM9H7aKHNw5jEMBP9T2NQR5md2Ima7iKX6CI1vY9kdIDpoecxihEmuh/BLEUZ734EI2HCA79EUoaJTe5BTp4gn+wlMbULUZlgauBZTIXvN0vRwr1PEh54HkEeJBHeTz7RjpzpIz65A1GdYmrgGb1N18OYxAjj3Y9iFCaZGnoR8gPEI4fIxY+hZAaYndiGpE0T7nsSkxhlrOshna/uxzAywWjPC5DtJxU9Snb2CFpumOjoKxiYZrLvicJ9PIxZmmait8DX2Da0TDeZ2eOkZw6i5UeJjryIUYgw0fPovHEJM9H3FAZ1lOj4DtRMN9l4B6nIPgR5nOnhF062McwwXmgT7n+mwNdu5FQH+UQ3yak9CMoE0wPPYhJmGOt+hFRsmPGeOY6fRZCHSIT3kU+eQE71Ep/chahOEh54GlOhT2ZphvGeRzEwwdTgCwjyAInIAXLxY8jpQWKTO5C0KcL9T2ES58Y9wnjPYwVNvgT5flKRI2RnD6P+Bk0atHFmRl9Dy/aQjh4jEz1EfKaX6IiuyYmex4r6MotT8zjejpbtJhs7QWrmAOTHCpqMMNH7GGbDSU1O9j+NpI4wO7ETJdVJLtFJanovgjKua1KYp69TNDlS0GQH+WQP8aldiGqYqcFfFvT10Lw2kwx3Po0gD5KcOjBPk9sR1akCx2+iyQJfyZnDZONtuibHtiExXeBr9qQmex7DyDjTIy9DtpdUtI3M7GG03AjR0VcwMn26DZ+iyZ6CJg+g5sd0TYozTPQ8Qio2wlj3Q6drMt1FNt5JanpOk88XOH60qH2TOHWqJpO6JhPTexCUcd2GRV2Tug0/UrDh5+Zp8jhyuo/45E6d4zm+ut9owy8gyIPEIwfJxduITXcRm9g+T5PR0zQ5Pfwy5E5qUssOMzv26jyO52xL58vIGDNjBU3O6pokP0J05KV5mozO0+RTGLQxomPbUX+DJoeP/wSTFP2T/14sFCH6H8BCv//8eKv2faHff368Vfv+l9zvhSJEfzj+0N9mizHNcMcDlFRtZGJgOyXVW5ga2Y2vdAXxSA8WewmqkkPOp7A6yohNd+IrXUl4eBcl1VuYGNxOSdVmpkb24Q0tIxntx2T1gga5bBS7q5pouB1/+WrCQ/PaVG5ieuwg7mAL6dgIBpMDUTKQSU7j8NYSnWzDX76W8NBOSqq3MDm4g2DlBiLjh3H5m0gnJ5AkC5LBQjoxgcvfSGT8MMHK9UwOvq63GXqdQPk6ZibbcHpryaZnEAQRo9lFcnYIT3Ax02MHCFZuZHJwByXVm5kc2kWgfA3R8HHs7iry2TiaJmO2+olH+/EGlzI1uo+Sqk2Fe5/jayWx6S6szjKUfBpFzmB1hIhHuvCEVjA9sodg1eZ5HO/BG1pOItqH2RpAU2XyuTh2VyWzUyfwla4iPLxb79PADoLVG5ka3Y83uIRkbBij2YUgiOTSEeyeWqKTx/CXrynyNTGwg5KqDUyPHcIdbCYdH0MyWpEkM5lkGKevnsj4kQJfOyip3srk4OsEKtcxM96G01dPNjWFIBowmh2kZkdwBZuJjB4kWLVhHsc7C3y143DXkMtEATBZPCSiA3hKljA9up9g1aZ5HO/GX7aK2HQHNmc5cj6FquQw24LEZ3rwhlqZGt5DSfWpfPlCrcRnerDYg6hKXteks4zY1JtpchNTI/vxhpaSjA5isnoAyKWj2D3VRCcLmhzeTUnV5pOaHD+IO3BSk4JoIJuaxumtY2byKP7ydYSHCvc++DqByvXMjB/G5W8kkwwjSiYko410fByXv4nI+KFTOS5oMjrZhsNbRy4dgV+ryS1MDu3CX76KWLgDm7uCfDaBpsqYbQVNlixlaqSgyYFthGq2Eh7WbTg23Y3VUYoiZwqaLC3Y8AqmTtHkSRtORPsxW31omko+G9M1GT6Br3zVSRse2E5J9SamRw/gCS4hGRsqajKbjuD4FZoMVm0gMnYId6CZdGIcyXC6DQcq1hMemtPkDgIV6ws2XEc2NY0oGTAYHaRib9DkwA5KarYyObiTQIWuSbu7mnw2BpqKyeolMdOPp2QZ06P7CFZtYmJgO6GaLYSHduMrW0VsurNgw7omLfYgsUgP3tBypob3ztPkZqZG9hY02YvFHtA1mUtidVUQm+rAV7qC8JyO556To/vwlszTpAa5zHxNrtF1XLWZicEdlFRuLGhSt2GD0YYoGckkdU1GJo8QKF/PWO/z5NIRDEY7TWvfTyrr+oO2Av663+aFCOgCFrCABSxgAQv4vaE7n/dTUrWR8f7X9In+8K7ixNViL0GRswXns5TZ6Q58pSuZLE4otxWcz736xHWmD5PVi6aqBeezipnwsYLzqbcZH9hGSeUmpsb24w62kIoNFSb6EpnklO58ThzFX76WyaEdxclusFJ3plz+Jn3iKlmQDGbSifHCxLUw0R/YUXRYA+XrmJk4qjufqWnd+TQ5Sc4O4gkuZmp0H8HKjfp9VG/WJ67la4hOHtOdz8ys7nxafMRn+nTnc2RPcaJfUrWF8PCugvPZUZi4JgsT/RJi0514QiuYGt5dmOhvo6R6C+Hh3brzOdNbcD7z5HNxbK5KolPH8ZWuKnCstwlWb9Sdg+ASkrOD+kQfoeB81hT4WkO44BRO9G8rOJ8HcQebScVGkIxWRNFEJjmpO59jurOuT6a3MjGwo+B8HsHpqyeTmkQQDRhMdlKzw7iCzUyPHiBYtUGfGFdvYWLw9SJfDncN2cwMAEaLu+h8To3oE/3JOY6HduEvW8Xs1AlsznLyuWTB+QwQj3QXnE/d8T5Fk6FWYpFuLPYginxyQWR26s00uamgyaUkov2YrB40TdOdT3c1M5PzNDk3LpWbmB47gDvQQio2XNRkNjWlO58TR/CXrztFk4HK9UTGDuHyN5JOTOrOp8FCOj5WcD4PFjRZ4LioySM4Cs4Up2lyf0GT24tOrr98FbPh47rzmYkVnM+CJkuWMjWyl5KqTYz3v0aoZiuTQ3M23FVwPtNFTc4WnM/wKZrcTHh4T8GGe3XnU5XJZ2PYXBVEw8cLzuc8G67exNTIPt35nB0oOJ/CSedzog1/+ZriQsVE/7aC8znnTI0WnE/TSRseO6Q7n8UFke268zlxpOB8TiFKBiSjnVTsDZoc2E5JTUHHFXM2XE0+EwVNxWjxnHQ+R/YWnM/XCNXoiyi+giatzjLkeZqMTXcXnM89BU1uKzife+ZpMqBrMpfE6iwvLCCtYHJoV9GGi8/JkqUkogMnNVl0Puc560VNbixoUrdhg9GGIBrIJHVNRiYOn+J8Asj5JF377sIkRX/tud5/CBYc0AUsYAELWMACFvAHQEGVswAICGhqHlEyIefTGIxW8rl44d8EksGCkk8jiBKaKqOXHxdQlTySZETOJfXPZhNIhX9FgxlVziAIBlRV3zcoIKIoWQySudDGRj4XRzJYkfMJJMmMImcQBBFNUdA0BUEUUeQsBqPl9Da5BKJkRpGzen9UGU2VEQQJRckgFdpIRpu+j85gQc6lECUjqqLve9U0FVVVEEUDcj6NZLQi5+JIRhtyVr93OV9oo8qFNprOl2hEzqcKn40hGWyFPllQ8hlE0YCq5pkr164qOSTJhJJP621y8cL1Cveez+gca4rOlyDobQzmedfR2+QLbWQ5iyCIqJqMpqkIooSiZPU2uQSGwn3MjaUomVHVnM6XpqCpJznW+YljKNyHwWAhn08giiZURW+jKQqqKiMKEoqsc6xrZW5cLMj5JKJkRFNz+n1rGqoiI4oGFDld7MucziSDBVlOF/iST9eknCrqy1AcSzNKPoUgGtA0eR7HeZ2XXAqDwaa3MRTuvahJCVXRNYkgFvgyvbm+DKaiJvU2OsdqQZP5Oe3PG0tRMqHIBY5VBW0eXydtq3AfBY3qmswV9KWgqnmdr3xa7382UdBMAkkqcCwaUeVc0aJVZU6T6ZP3UdCZaLCg5tMIp2iyYMMGE0pBXyfb6NdR5vhSdU2KgoAqz2kycVKThoLdSCbkQhtNnceXMqevefdhOMmXqmR1vRc0iWDQx8V4sk0+Gy9oMlnQpG73ug3LiJKur1PazOmrwLGiztk9BU0aUQr6krOFZ97csyKf0jme06RAYVyMBU3aTmoyl/g1mswV9JUqjruuyTiiZEbOpwv6yv1GTeZzcV3HSg5BEFHkzClPdVXNoSk5hD+RB7rggC5gAQtYwAIWsIDfG1nZQfXSm5kc3EGoditTo/vxhJaRnB3CZPUiCAZy2Vmc3npmwu16WuDQTkrrzi5GaCLjB3EHl5BOjGMwOZEMFrKpadyBZmbGjxCs2kx4aAeltWcXUgo36VFJfxPZ9BSiZMZocpJOjOEJLiUyfrCYeldadzbhwV0EKzYwEz6Gw1NLLjv7/9u77+BIzjS/89+y8N4VUCjYBhIeaO+7QbJJNv2QY9YMRytppVWcRhdS6FZ3e6c4uV2Zk+6ku91VaGd2xw/H0dtukk229wbdsJ3w3lXB+3J5f2RWodCOTQewd55PBANNAG/Vk0/93kpk1ZuVYDITFZPKwuwAKY5aJoavkJW/nzFjzPjARdKc25hxq8QluvD7FtG0gL4kdqqHtJzNuAcvkZV/gPH+MzgKDuIZvEhqzmbmJruJiXcQDPgJ+JeJTcxldqKDdOc23AMXcBQc0GsrOIBn6AqpjhoWZvqJikkDTPi9c8QnFzDjbiM9dwfugfM4CuoZ6ztLVv4+JkaukZxZyeLcEPaoRMwWO96lKRJSS5gabyLDtYvx/nM4Cg7qy45de5kcbSQpTWF5YRyrLQarPY7l+TGSMsqZHL1BVt4eo6Z6xgfOkeHaydRYCwkpxXiXpjGbbdijk1mcHSIls5qJ4avhJcrZBfWMD54nw7mdGfdN4pLz8HsXAI2o2HTmp/tJc2zBM3yJrPz9xuNyEM/gJdKcW5id6CA2IYdgwEsw4CUmIYe5yS5jKeElsgoOGj0+gGf4MqmOWuaneoiOy0DTgvh9i8Ql5TPjuUmGcwfuwQvhbY/M5OLMEPboFExmK97laRJSi5kabyEjdzfjRr5C7+ZOjl7Xl3bPj2K1x2GxRrO86CEpvYyp0RtGJs/pWek/S6ZrN1NjzSSklrCyNIHZYscWlahnMrOSyeGG8Dty2YX1jPefIyN3h77sOLlAX+JpMhMVk8bCTH9EJldzHM6kRyU2MZeAb5lg0E9MvIO5yZ7wcuC1mbxEavZm5qZ6iI7PQgvemsnter4KDzLedwZHwX48Q1fDmbTHpGIymfGtzBKfUsjMeOsdMrmXyZEGkjMqWJwbwRaViMUSxcrSBIlpd8vkHibHGklMK2V5wYPFGpnJCiZHr69mMtSvcCaL8C5PYzZbVzPpqGFi6IqxfPasfj+DF8hwbmPGc5O4pDz8vkXQgkTHZTA/3UeaY7ORyYNr+pWWs8VYdryaydgEJ3OTnaQ5t+Mx5vBYaA6HM9lLdGwGoOH3LhCXnM+M+yYZuTuNfhmZzN/HxHBDRCaTb8+kazfjA+duz2R6GcsLY1htsVhsMSwvuklKL2dq9DpZxqoNR+FD+rvsazI5aWQyiaX5YVIyq1bncP8ZXMqzWGyxAJgtNkq2/BE+Mj7/J+PfhRyACiGEEOIz0zTwBhLILfsG7oELODcdZnq8hXTnDrxL08TEO7DHpOH3LpKWvZWZiXZyih/HPXgRl/Is7oEL5BQ/xrTnJqnZW/B5F4iKTSMm3oF3aZr03F1Mj7eQs+kJ3AMXcCnP4Bm8RHbRIeYmOknOrCEY8GGNSiAuKY+lBQ8Zrr1MjTXhLHmK8f7zOJWn8QxfIbvgYeameklKLwcNLJZoElKKWZwdJqvgAJOj18ktfYrxgXPkKk8xMXKNrIIDLMwOkJBagtlsB5OFpIxy5qcHcBQ+zMTwFZylT+PuP4ez9CkmR26QmbeHpfkx4pLysdjjCAb9JGdVMzfRTXbxIdyDl8ktfZrxgQs4S55gcqyJdOdOVhYniEl0YotOwe9fNpb0dZBd/JjRr2cYHziv99jdSmrONrwrc0TFZhAdm4XPO0d6zg6mx9vIKTnMuNEv9+AFsosOMTPRTkpWHX7fCraoZGKSXKwsTpLh2s3UWAvOkidxD5wnt/QZPIOXyS56mLmpHpIyKglqQSy2WOKSC1laGCMzbz+TIzdwljzJ+MAFfczwVbIKDrIw3U9CWikmsxWzxUZCWgkLs0M48h9iYriB3NKnjPt5komR62Tm7WdxbpS45EIs1hjQNJIzKpmb6sNR+DCeoSvkloa23eiXazdLC27iEl1Y7YkE/D5SHJuZneggu+gQ7qFL5JY+syaTac5teFdmiI7LIio2Hb93gbScbcxMqOQUH2Z88CIu5TncgxfIKXqMaY9KavZm/ROSY1KNTE6R4dp9l0w+wtxkJ8mZVQQDfqz2eOKS8llacJORt5fJsSa9X/3nyVWewTN0BUfhQ8xN95GUXgYamC1RJKSU6JnM1zPpDGfy6YhMDpGQWozZEgUmc0QmHzEy+cxqJo0D5qWFceKS8u6QyUf1TCrPGJk8zORY82om43OwR6fg9y2Rmr2VGU+7kckL4UzmbHqMabcxh1dmiYpNJybOgXd5lnRnZCbP3zaHU7JqCPhXsEUlGZmcIMO1h6mxZpwlET0eCmWym6SMCiOTMXom50bJzD/A5EioXxfILX2KieFrZOUfZGF6gIS0EkxmK5hsJKQpLMwOGpm8pvdr4DzOcCb3sTSvZ9JsjUHTNJIzq5ib6iGr6BE8g1dwlT59WyaXFz3EJOZii04i4F+JmMOP4h68SG7p07gHL+Lc9Lh+vubdMum5iTOcyWeNTD7KtKedFEednsnoVGISclhZmiI9dzdT46tz2FUamcmuWzJZwNKCWz+oHWnU+9V/nqLaP8AWnUxR7T8gLjn/S716mnwI0QaQutffg1q71L3+HtTaf5vrlg8h+vw+z77ZbDYxGfQQZ40lxhIgYLFjCazgw4oVP37NjEnzARY0ApgAzWTBQpAANmymAF5s2PHhxYpN8xHAAkEfmM36H5kmE0HMWNEImGxY8eM12bBrPnxYsGh+gphB8wNmNDTMaARMVmwECZhtWDU/XuzY8a4Zo2l+TKExJv0SHhY0/CYrNvwRtVmwaD6CWEDz60s7jZEBk74dfpMdm+bFZ7Jh1Xz4sWAO+gia9O0xmc1omgmLSSOITb+8CHZsxu3b8BPQzKD5wGTRl7WaQDNZsRAgYLKvqcmHFavmJ2Ay6/0ymfWlipgg3GM7VpMPHzZs4TE+AqF+mcwENQ1zxOMSNFuxakG8WI370fsVMJkxBf1gMhHU9Os5B01WrATwm+3YNB8rJhtRmn4/ltD9BP2YTPpFZcxA0HgMg+YoLJo3XJtX03usmc1oAb++hBozZoIETXasJr/++GtGVox8mTU/mslsLOk161kxemw1+fGa7Ng1bzhffiyYNB8axiUvwtuuGZn03yGT+nZgNutLSIGgyYwFLbw9PuPx92PBrPkJEOqXmSBa+HG3EiBgthvboWfSiwWrkS8t6NOXnmoaZnNkJo0+hWrTLFgwMhn0Gf3S8+UnMpPG444PP2bMQT9Bk/74h8cY22FhNZM+LOE5bNZ8aCYzWjC4NpOhOazZsJuMHGsB/Bjz/g6Z1Lcjcj6uZmX1uSLUYwtWggQsNqzBACtYibpLJjUtlC8jk6H7MVmxa36jx37jsQz1a20m/eYofQ7fmkmT2ZiPpnAmNZMdi8mv95rITFowaV59DmsBTJgImoznr1C+jOcvL7ZwZu6WyaDJjpXVObwmx+HnSc2Yj6FMWrESNLbdF85kMCLHq2P0fvlMVqIIshS0MuefI4U00D77e5X32jfLdUCFEEII8ZnNMMV/v/xjvlH5FEfaP2Zv/nba3J1kxqVhNpkZmh2lxlHOx91nea78cX7V9CYv1r7Ar5re5vnyx/mw8zQ7XZvpmuwjwR5HrD2G7sl+tjtrONp5km9WPsVLjW/wYs3z/LrpbZ4tf5TjPefYkl3N4OwIdouN5Ogkbno62ePayjvqR/xezbP8/MYb/H7Nc7zc/C5PKY9wpu8SVZkK7sUJNE0jKz6D66Ot1Bfs4s22D/j92q/x8xuv8XvVz/F661EeKznIxcEGStIKmV2ZY8m3TF6Sk8tDN3i0eD+vth7hxdrneenG6/xO9TO80fYBh4r30TDSTF6Sk5WAl6mlGUrSCjjXf4UnSh7m5ZZ3eLH2BX7R+AbfrHyKd9RjHCjYRct4O46EDDQNxubHqcgs5WTvRZ4te5RfNb3Fd2qf55eNb/JCxRO833mS3a6ttE/0kBKdRJTVTt/0IJuzq/iw6xRfr3iSXzS+wYu1L/Drprd4rvxxPuo+yzZnDX3Tg8TaYkiMikf19LAzt44j7cf5VvXT/KLxDX6/5mv8pvkdni17lJO9F6jJKmd0fhyzyUx6bCrN4yr783fwVtuHq/2q+RqvNr/LE6UPcX7gGmUZxUwtzeANeHEmZnNtuJmHi/bwWssRXqx7gZ/feI3frX6WN9s+4FDxfq4MN1KY4mLJt8zsyhxFKXmcH7jG4ZJ6Xml+lxfrXuClxtf5VuUzvK0e46HC3TSOtZGTkEVAC+BZmELJKOZ070WeVh7hN03v8GLd8/yi8c01mbzp7iI9LgWLybImk18rP8wvG9/gO3Uv8MvITObW0T3dT7wtjjh7DF2hTHac5JtVeia/XfM8Lze9zTPlj3K85zybsysZmh3FbrGREpNE63gHe/O28bZ6jN+v+Ro/u/Ea3675Gq+0vMeTpQ9ztv8yFRkleBYnCWpBHPGZXB9ppb5wF2+0fcC375DJS4PX2ZRawJx3nkXfEvnJuVwavM6jxft5pfU9vlP7Ai/deIPfqX6aN29+yCNFe2kYacGVlI0v4GNiaZrStELO9l/hyZKH+U3L23yn9oVwv95TP2J/wc5wJgFGZsepylI43nOe58of45dNb/J3al+IyOQpdrm20DnRS3J04p0z2fQGL9a8wK+b3+a5ssf0TOZU0zczRIw1mqToBFRPD7tcm3lX/YjfrX6Wnze+zrdrvsbLze/wtHKIU30XjUy6MWEiIy6NpvGbHMjfwZttH/Dt2ufDmXyt5T0Ol9RzfuAaSnox08uzrPhXcCVlc9XI5OutR40xr/O71c/wZtsHPFK8j6vDTWszmZrPhf6rPB6RSX0OP33HTLrnJyjPLOFU70WeUQ7x66a3ebHueX7Z+BYvVDzBkY7j7MvfjurpIjUmBZvFysD0MLXZFXzUdZbnK/RMvli72q9j3afZ4ayjd3qQOFsscfZYOid72eGs5UjHCb5V9TQv3Xidb9e+wG+a3+bZskc50XOeOkclQ3Oj2Mw20mKTaRlvX5PJUL/+8uKPKUjO5feqn+O9jo+5OtzEn+z9LnnR+V/KMlxZgiuEEEKIzyzaHEVOfBYr/hUwQbw9DvfCJLlJ2bR7uqnKUmgZb6fWUUHnRA+bUgsZn/eQGpOIP+gnoAVJjIpnZG6cwhQXqruLGkcZLeMd1Dkq6JjopSjFhWdpiqToBP1THwN+UmKSGJwZpTg1n5vuTmqyyml1d1DjKKdrsp+8pBymlmaIs8diNplY8i+TFpdC//Qwm9IKaBlvp85RQZunkyqHQu/0ILmJ2cyuzBNli8JmtjLnXSArPp2eqQHK0otpHW9nc3YlNz2dVGaWMDAzjCMhkwXvIlFWG1FWO1PLM+QkZNE50UtFRom+HdlVqBNdlGVsYmh2lIy4NJb8y1jMVmLtMUwsTpKbmE2Hp5vKTCVcW7unm9K0Qkbm3KTFpuAL+glqGglR8YzPe8hPdqJ6uqh2lNPqbqfWUUnnZC/FqQW4FydIikkiqAXxB30kRycyMjtGYYqLtvEOah1ltLo7qM0up2uyj4JkF5NL0yRGxaOhsez3khabwsDMCJtSC2hzd1LrqKDN3UlNdjndU/24EnOYWZ4l1h6DxWxhwbtIRlwafVODlBr9qnVUcNPTRbWjjL7pIXISspjzLmC32LBbbcwtz5Mdn0n3ZB/lRr82Z1eieroozyxhcHaErLgMFv1LWMxmYmzRTC5O40x00DHRS0VmCS1jKnXZlbRP9FCaUcTI3DjpsWnhTMbZY3EvTOBKyrktkx0T3WxKK2RsYWI1k8EAidEJ4UzedOv1h/rVOdlLYbKLiaUpEqMT0NDwBnykxiQzODtCUWo+reN6v1rdHdQ6Kuia7CM/ycnU8gyxthgsJjOL3iXS41Lpmx6iJK2QVncHddkV3PR0UpWl0Dc9iDPBwaw3MpPzZCWk0z3Vj5JeTOuYamSyi6rMUiOTGSx4F7FbrERZ7Uwvz+BMcNA50UtlRqkxtyppn+imPKOEodkx0mNTWTE+iCrWHoMnnMmecL/qsivomOhBSStidN5DamwK3qCfoDGHx+bdq5nMKgtve+dkL0Up+XgWJ0mKTjQy6Sc5JknPZGoebeMd1DjKaHXr9xPq8dTSDAlRCWCCZb+X1NhkBqaHKUkroM2tP0e0uTupcZTTM9VPrpHJGFs0VrOVBe8imfFp9E71o2QUhx/3m54uKrNK6Z8ZwpmYxbx3EZtFn8Ozy3Nkx2fSNdlLWcYmWsfaqcuuRPV0U56pz+HMuPRwJqNtUUwsTuFMdNDp6aUiq9ToVyXqRHc4k2mxKXgDXkzoz5Pj8xPkJeeguruocpSt6fGmtALGFydINvoVCARJik5keHbUyKS+zZH5KkzJ0zNpzGGv0a/B2RGKU/NoHdd/t82jj+2e6icvycn08gx5STl0TPTw7078v1wZaiQ7PpO0mFQ5B1QIIYQQXz02fwx/t+5b/OzGa3yz8hleuvE6z5Qd4sPO02x11tA12Ue8PQ67xU7P1ACbsys52nGSZ5TH+On1V/lm1VP8sulNnip9iI97zlHtKKN/ZhibxUq8PY72iS52OOt4u+1Dnq94gp9cf4VvVj7Jb5rf4fGSA5zuu0xZRjFjC26CmkZ6bAqNY23sy9/Oa61H+VbV0/yo4Td8veJJXms5wsNFe7g4eJ3i1HymlmdY8i2Tk5DF5aEb1Bfu5jct7/Ctqqf58fWX+Xr5Yd5s+4CDBbu4NtJMblI2C75FZpbnKEzJ42z/FR4r3s8vm97im5XP8NPrr/J82WHeaT/G3vxtNI+rZMal4Q/6GZ+fQEkv5njPOZ4oeYiXbrzON6ue4uc3XueZskc52nGC7a462ie6SY5OxGwyMzAzTE1WOR90neJp5VF+2vAq36rS3618UnmYj7rPUpddSe/UANHWaGJtMXRM9LLVWc276sc8X/44P2l4mW9UPs2vm97i8dJ6TvZepCKrlOG5McwmE8nRSbS6O9jt2sIbbR/w9con+UnDK3yj8klebnmXR4v3c27gKpvSCvAsTuIN+MiKz6BhpIUDhTt5teU9vlX1DD9peIUXKp/g9dajHCzazZWhRvKTc5nzzjO3Mo8rKYcLg9c4VLyf3zS9zTernuGnDa/wXMVjvKV+yN787dwYbSU7IYOVgBfP4hQlaQWc6r3I4ZKD/KLxDX6n6hl+dv1Vni1/lCMdx9mVu5k2dwdpsSkADM2OUplZyrGuMzylPBzO5C9uvMHTyiMc6zrDlpxqI5OxRFlXM3mk/TjPlhmZrH6aXza9yRMlD3G85zzVjjIGZ4axmq0k2OO56e5ip2szb7V9wPMVT/DjhpfDmXxs0wHOGpkcX/AQ1IKkx6WuZrJFz+QPG37N1yuf5LXWozxStJeLg9cpTHExvTzLom+Z3EQHl4au83DRHl5uXs3k8xGZbBhpISfJwaJvienlWYpS8jjTf1nPZKOeyZ9df43nyh7jnfaP2JOnZzIjLpWAFmB03h3O5JOlD/PSjdf5VvXTxhx+lPc7T7Itt5b2iR6SohOwmq30TQ/pmew4yTPKo/zs+u2ZrHVU0Ds9SLTVTpw9lvaJHrY7a3lH/UjP5PVX+EblU3omS+o53XuR8sxSRubGMGEiJUZ/p263awuvtx7l65VP8JNrr/CNiid4teU9Dm3ax/mBa2xKK2BicQpvwIsjIZNrI80cLNzJK0Ymf9zwMi9UPsEbre9TX7ibq0ON5CU7mTcymZ+Uy/mBazxStI9fN73Ft4xMfq38cd5Wj7E3fzuNo21kJWTgDfjwLE5SklbIid4LazL5c6PHRzpOsMNVx013FykxSZgiMvlh1xmeVh7hZzde55tVz/BS4+trMtk92UeckcnuqX62ZFdxRD3Oc+WP6c951U/zq6a3eKL0YU70nqcqq4zBmREsZgtJ0Qm0ujvCmXyh4kl+3PAyX696ipeb3+Gx4gOc7b9CaXoR4wsTBIIBMuPSuD7SEn6e/HbN82ue1/947z8iJhD/pe035BzQDSB1r78HtXape/09qLX/Ntct54B+fp9n3+y3rPBW5/s4k7K4OtzMgfwdfNh1isMlD3G0/TiHNu3nTO8lNudU0TM9QFKU/ofs2LyHsoxiLg1ep75wNx90nuJwST1HO07wSPE+zvdfpSpLYWh2lBhbNHG2GPqnh6l2lHGu/wqPFO3j/Y4TPF5az4cdpzhYtJvLg9cpy9jE+MIEFpOZ5Ogkuib72JxTyZneSxzatJ/320/yeOlBjnWeZn/BTq4NN1Ocms/08gz+YICs+HRuurvYnlvLiZ7zPL7pIEfaj3O4pJ5j3WfYm7eNxtE28pOdLPiWWPQt4UrMpmmsnd15W/i4+wyPbTrI0fYTPF5ykOPd59jp2kybuxNHfAb+oJ+ZlTkKk11cH21hb952jnWd5XDJQY50HOex4gOc6r3IVmc1nRN9pMYmYTaZcS9MUJpezJXBGxwo3MkHnad5oqSeI+0nOLRpH2f7rlCXXUHf9CDx9jiirVH6H79ZpZzvv8YjRXs52nGCJ0of4v2OkzxUtJuLg9epyChhdH4cm8VGUlQC3ZP91OVUcqbvMoeK9nG08wSHS+r5oPMU9QW7uDrUSEl6EZ5F/Xqd6bEptE/0sC2nmlN9FzlUvJ+jHSc4vKmeY12n2Ze/g+ujrRQk5zLvXWAl4CU7PpNWdwe7cjfzcfc5Hi85yJH2j3m8pJ7j3efY5dpCy3g7zkQHKwGvfrCQnEvjaCu787bxUdcZDpfUc6T9OI+VHOBUzwW2OfUDpfTYVEDDszhFaVohV4abjEye1vMVkcm6nCp6jUzaLDZG59yUZ2zi4uB16gt38X7nKQ6XHOT99pM8UryX8wPXqM5SGJwdJdoaRbw99rZMhnr8QcfJ2zJpNplIjUnWM5ldxeneixzatJ+j7Sc4XFrPsc7T7CvYwfXhFopS85hensMf9OOIz6DN3cmO3FqO95znsU0HONJ+nCdKHuKj7rPszttC85iKKymHJd8yC75FI5Mqu/O28nH3GR7ftNqvE93nb8lkQD+ATc2jYbiZ/fk7+LDzNIdL6znScZxHi/dzuvcSW536wXtydBJWs4WxeQ9KxmomP+w4xeHShzjScZxDRfs413+VGkc5A7PDxNliw5msylI413+Vh4v28H7HSZ4ofYijHSd4uGgPlwavUx6RycSoBHoiM1ms9/hwST0fdpzmYOFOrg41sim9kMmlaTRNIz02jfaJbrY5azjZc4FHN+0P9+tY9xn25ekvduQbmVz2r+BMdNA8prLLtZnj3ed5vOQg77Uf53DJQY53n2eXazOt7g6yEzLxBnzMhudwK3vztvFR11kjxyd4rGQ/J3susM1ZQ8dEr5FJ8CxOGpls5EDBTr3Hxhx+dNM+zvRdZnN2Jb3TgyRExWOPyOSFgQYeKtrN+52neKKknqPtJ8KZDD1P6pmMo296iFpHOWf7r+jzvvMkh0sO8kHHSeoL9ReHStOL8SxOYDKZSItJQfV0c320Jfy8rqQV84+2fIeoQOxn3q/ca98s74AKIYQQ4jNbZolWdwcJUQkEtSDTy7O4knJoGW9ne24dJ3svcLBoN0c7TrDHtY2z/VdQ0osZMM79spgtuBcmKUxxcWO0jV2uLXzcdZaDhbt4v+Mku1xbuDx4naKUfEbmx7GZrURboxmZH2dTeiHXhpvZna8flBws3M37HSfZ6azj2kgzeck5eBYnMWEiPiqewZkRyjKLuTR4g7352/mw8zQHC3byYecptjlraRq7SXZCFjMrc/gCflJjkumZ6qfaUcb5gascKNjJ+x0nOViwi4+6z7LZUcnN8U7SY1NZ9C2y6F0iMy6Dzole6rL1P5gPFu7iaMcJ9ufv4ETveaqzyoxz5ZLwBvzMrszjTMyizd3BtpxavV+FuzjacZK9+ds403eF8vQSeqeHiLPFgAkmF6cpSHbSNHaTXa46jnefo75wF0c6jrMnbxsXBq6xKbWA4blRoix2oqw2RufdbEoroGGkmd15W/io6yz1Bbs42nmCnblbuDrURF5yLu7FCcyYibPFMDQ3Sll6MVeGGtmXt50Pu05zoHAXRztPsjO3jsbRVpyJDqaWpo2l1An0Tw9RlalwYfAa+wp28EHnKQ4W7Ay/09My3k5WfAbz3gWW/Cukx6XSNdlHbXYlZ/uvcKBgJ0c7T7K/YAcfd5+jJqucdk83qTHJLPu9zK8skJ2QierpYktONad7L+k1dZxgX952TvdepCKjlJ6pAeKj4tdmckzP5Ime8xws2s37HSfY69rOuYGrlKYVMTAzTLQ1CotZP+AvSnHRONKm96v7LPWFuznacZLdri1cHrpBYUoeI/PjWM0Woq3RDM+NU5pexNXhJnbnb+NY5+k1mWwYbsGVmI1ncRLNWEo9MDNMRWYJlwavs8848DtQqB+cbHfW0Dx2E0d8BjMrc3gDPtJiUuiZGqDWUcG5gavsL9jBBx2nOJC/k4+7zlDnqEB1d5Eem8qSfzmcyXZPN5tzqjjbdyWcyQP5OznRe4GqLIWuyT6SohLwBwPMrMzhTHLQ5u5gu7OWU0Ymj3ScYG/e9vAc7p8JZdLE5OI0+SkumkZvsit3C8d79Ewe7TzBbtdWLg40sCm1gJG5MezGUtexeY+eyeFm9uRt5VjXGQ5GZPLKUBP5yU7ci5OYMemZnBmhLH0TVwZvsLdgGx92GT3uPMV2Zx2No204E7OYWprGH/CTHJ1I3/Qg1VllnB+4xv58PZMHCnZyrPsMm7OraHV3kBGXxoJvkWX/ChlxaXRO9lKXXWFkcsfqHO45T01WOZ2eXpJjkljxe5lbWSA7MZOb7k62Oqs41Xsx/Py1Lz+UyRJ6pweIt8ehaRpTSzO4knJoHlPZYbzYFerxnrxtnB+4SklaYTiTVovFyGQeN0Zaw5kMPZa7XVuNTLoYm3djMVuIsUUxPDdKaVoh14aa2Ju/Xe9x4S7e7zzBztzNNAy3kJvo4MZYK474DP5k/3fZlFqAOtHF8MIIFsuX8/quvAO6AaTu9feg1i51r78Htfbf5rrlHdDP7/Psm01mGPEOkRSdyNi8m5zELLqn+ilIzqVvZghXUg5j8x7SYlNY9C1hMZmxW2zMrMyRHpPK8NwozsRs+qYHKUjOpX9mmNxEB+7FCVKik1nxr6CZNKItMUwtT5MZl87g7DCuxBx6jTEDM8M4Ex14FvXzRL0BHwEtQLwtFs/iFI74DPpnhslLWh0zODtCdkIWk0vTJNjjCGpBVgJeEu3xjC9OkB2fQd/MMPnJTnqnBslPzmVodoTshEymjXPM0GDJv0Kyse3ZCVn0z+i/GxozMqefL6af92jHYjIz71sgNTqFkfkxnAkO+owxfdOD5CU5GZl36we13iWsZjM2s40Z7xwZsakMzY6Sm5gd3o5Qj/XzakP9gmhrFNNLM2TEpTE4O4orKZveqVv7pZ+Td6d+DdyhxzmJWUwuzZBgjyMQDOAN+kiwx+NZnMARr297XpJzbY/jM5lemSXGFoNJ01gKrJAUlcjYvAdnQia9M0PkG2Pyk52MzI2RGZfBrHeOaEsUJpOJBd8SqTFJjMyN61mZGtD7NTOIK8nJ6JybjLhU/Tw+swWr2ca8d560mBSG58dwJmbTOzWw2q/EHMYXPKTGJrPsW8Z0v5lcmCA5JglfwEdQCxJti2Fq6e6ZzEl0MLGon5PnDwbwa/77yGQmU0uzxNljw5lMCmUyLpO+2dV+FSTnMjQ3QlZcJrMrs0TbojFpJhb9SyTHJDE2p8/Hvukh8pOdq/maG4vIpA2rycLcnTKZpPc4L8nJ6Lx+HvKid1nPpNGvu2cyG/f8BClGjwFijH5lxKUzODuCK2JMZL/uPIczGZgdWtvj2RFyIuawnkk/CfY43IsTeo5nhsOZvH0OG5n0r6w+fyVk0XfHTKbr5+JaojCbzCz4FkmLSWZ4zuiXcfvhTM67yYhNZcG3iNVkxWqcv5seymRCFr3TQ7fP4YhMRllsTK/MkhGbtqbH+Ua/IjPpNTIZa4tlcmnqtkzmG/nKScgK99gX8OEPBoizxzGxOElmXBojc26cCQ7GFsdxRedjDlo+837lXvtmOQDdAFL3+ntQa5e619+DWvtvc91yAPr5fd59s9lsMi4ZYSI1NZ6ZmUW83gB2uwWfL4DFYiYY1DAZj1QwCFarGZ8vgM2m/47dbsHrDWCzmfH7g1gs+uUudCaCQe0Tx5jNZkAfYzKZCASCWK2We4zRawaN1NR4pqYW7jrG5wtgta4do2lgNpsJBAL3PSa07X7/3cfcrV+RY0LbkZGRgMczd8uY++tXZI8/bb++iDHJybFMTy9+Yr8slnv3WP+5fsmSu/UrNMZms+D339rjT+rX6hhNi8zKl5vJTxrzaTMZysqXncnP1uN7Z/LWrHxRmdT79el6fL/9CgQ00tPjmZyc/xL6tTaTq9v++TKp1x380vfNchkWIYQQQnwuoU9KDAT0r15vYM1Xvz942xifL7Dma+h3fb7gHcZo9zUmEPgsY1aPvUP3+WnGBIOBTz3m1t+9dcyn6ReApn22fn22HmvrPsbvv79+BVZbctceh75+um2/fcz9Z2X9e3y3TIKelS87k5+txxuXydDz15c1h0Pjvth+ffYe3yuTa3/25ZFzQIUQQgghhBBCrAs5ABVCCCGEEEIIsS7kAFQIIYQQQgghxLqQA1AhhBBCCCGEEOtCDkCFEEIIIYQQQqwLOQAVQgghhBBCCLEu5ABUCCGEEEIIIcS6kANQIYQQQgghhBDrQg5AhRBCCCGEEEKsCzkAFUIIIYQQQgixLuQAVAghhBBCCCHEupADUCGEEEIIIYQQ60IOQIUQQgghhBBCrAs5ABVCCCGEEEIIsS7kAFQIIYQQQgghxLqQA1AhhBBCCCGEEOvCutEFCCGEEOLBZjKbWFgJsOILMDM4TTAYRNPAbDYRDAaxmC0EAkGsFhP+oIbFbCIQCGKxmAkENcwmE6AR1MBiNuEPBLFazOGvgYjbMJtNaGiACRMQ1LSIMRb8gYA+5pbb1zRNr9UEgSBYLSYCAQ2LxUQgGGRuaAavz4/VYiEQCGA2m1fHmI0xZjN+fxCrdXVsuMZAMDxGI7TtGhaTvs1Wq4mA/5YxoW3XQEPTa9OM+zH6FVjTLwtBLWhsud6v2cFp/IEAFrN5dXtC2x4IYraY0YIamEyYjDFm4/ZsFjO+QBCbxYLP78dqtYTvL6hpoOmPbSCgYTXrfbJazPiCQazmiF77jfvRVu/nTj22mNc+pqGsoIHJZPTLYsIf0NaMXe2xhtlsAqPHplCPzXcYEwxiNZkJahomk56ZtZnUb89q3F+4b2YzAW1tJkP9CmVy3jeN17fa8ztl0myCQFDDZrXg8wf03voDnyqTq/0yMhl6LCPyZf6ETJrM5nC/9KwE12TS7zd6EAxiNX8xmbSYI+sPPS4RmTSb0bQgYMZkur3H4e3wB7Fa9ZpmB6cJBINGv0zhxy50u/4vIJNBo1/hrNyayXvOYSMB4X7pY+a903h9wU+VSUtkjcb2Be8yh0OZtFks+ELbHspXRCb1x8zIZMQcDgSMTBo5Xvb6iYu2kuwPfKn7jPs6AFUU5b8BuwAN+Keqql6O+Nkh4D8AAeA9VVX/9MsoVAghhBBfPRrQ3DtFU6eHxDg7FrMJ9/QypXnJXLs5xt5aJx9fGeDQ9jw+utzP/s1Ort4cQ8lPZXRigWi7lZgoK0PueSoL07jUNsqBulyOXern0I48jl/tZ2+Nk+vt4xQ5k5mYWcJiMZMUZ6d3ZJaaTelcaB6hfouLDy/38ci2PE42DLCrKofmLg95jkRmF1YIBCE9KZrOwWk2l2ZyrnGYh7a6+OBSL4e253OqYZDtFQ5u9k2SnR7P0rKfFa+f7PQ42nqn2F6RxamGQR7ZlseHl/p4eFseZxuH2FyaSdfgNOkpsfgDQeYWvOQ5EmjqmmBXlYOTVwd5ZLs+5qFtLi40jVCzKYPe0RmS46MxmWBiZpliZxIN7ePsi+jXsct9HNzi4nLrCOUFaQx7FoiNthJlszAysUh5fgqX28bZX5fDx1f6ObQ9n4+u9LGvNpdr6jileSmMTy5gs1pIiLXRNzZHdXE6F5tHObgll48u9fHIjnxOXB1gd3U2jZ1uCnOSmZpbBiAlIYru4RnqSjI52zjMw1tdHLvcz8PbXJxqGGRHZTat3R5ysxJYWPLh9QXJSo1F7Z9kW7mD09cHeXirvh0Pb8vj9PUhtpZn0d43SVZqHF5/gIUlP7mZ8bR0T7Cj0sGphiEe2e7iw4t6v841DlNXmknP8AypidFomsbUnJeinERudLjZXZ3D8atr+3WpZZTKojQGx+eIj7Vjs5gZn1qkNC+FqzfH1vT4oyv97K/TM1mal8rY5AJRNiux0RaG3At6JltHObD57pmcnF3CbDKTFG+nZ3iW2pKITF7q49COfE5c62dXZQ4t3R5coUwGNDKSY+gYnGaLksnZG7dncluFA9XI5PKKn+WVWzJ5bTVfD2/L4+yNITYrmXQNTZOeFEsgGGQ2lMlOD7urczhxdYBHduRx7GI/B7fmcrF5hOpN6fSNzpFkzGHPzDKbcpNpaB9jb83aTB7YnMuVtjHKC1IZ8iwQF5nJglQut46xvy6Hjy738+iOfD6+0s/eWicN6jgleSmMTy1is5jXZDLUr8hM7qrOpqnTTUF2EjPzKwQ1SEuMpmtomrrSe2SyZ4LczHgWlnys+II40mJR+27P5ENb8zhzY4itZVl0DEyRmRJrZNKHKyuB5s4JdlY7OHF1kEM78tZmsiST3pEZkhOiAZiaW6YoJ4nr7W721Bg9vksm42Ls2K33zuS+WifXbo5Rmp/K+OQidpuZuBgbg+P68+TFFmMOX+7nke16JvdU59DY6aEwJ4nJ2SVMJhMpCVFGJjM43zRM/RYXxy718/B2l/48WZlDc7eHvKxEXvm4gxVfAKvFxO8cUjhQm43NbPpS9hufuARXUZSDQImqqruBPwT+/JZf+XPg68Be4DFFUSq+8CqFEEII8ZU0teDlv798nU25yZxqGMJqNeOeWqRjYJqUxGiOXuilZlM6P363lT21OXzv9Sa2lTv45Qcq+Y5EzjeNEAxqzC54aemZICsllrdPd7OlLJMfvt3Mnuocvv9GI1vKsnjl4w6cGfFcuznOsjfAsjfA9XY3uZkJvHaik21lWfzgrWb2VDv5mzeaqCvN5I2TXWQkx9Lc5WFm3kswqHGpdZSCnCR+81E7Oyuz+es3mthdncMP3mqmujid9872kJIYRcfANO7pJawWE2dvDFOal8IvP1DZVZXN999oYldVNj9+t4XywjQ+uNhHfIyNvtE5hsbniY2ycuLqIOVFafz8aBt7avRt31mVzU+PtFLiSuH41QHsNgujEwt0D8+SnBDNBxf7qC5O5yfvtbK3xslfvdbI9opsfvG+SmFOEmdvDOt9n13mZt8UGSkxvHu2h9qSTH74Tgt7a5x87/VGtpVn8esPVVxZiVxuG2PFF2RxyU9TpwdnRjxvnupiS7nRr5ocvv9GE5uVLF493oEjNY4bHR7ml/z4/BpXb45RkJ3IK8c72FaexV+/2czu6hz+5s0makoyePt0N2lJMbT1TjI5u4zJZOJc4zCbclP41YcqOyqz+d7rTeyuzuZHbzVTWZTO0Qu9JMZF0TM8Y7wQYeFUwxBl+Sm8dPQmu2ty+P7r+uPyk3dbUfJS+OjyANF2K0PuOfpGZ4mPtfPR5X6qitP46ZFW9tQ4+d5rjeyodPDzI20UO5M53TCE2WzCPb1Ee/80qYkxHDnfS21JBj96p4U9NTn81Wt6Jn/1oUqeI5GLLSMEgjC34KW5e4KstDjeOt0VzuTeGueaTOakx9PQPs7Sip8VX4CGdjeurARePd7B9goHf/NmE3uqnfz1m03URmSypXuC6XkvwSBcbBml0Klnclel/njsqcnhh281U1WkZzI5Qc/k+NQSVquJMzeGKM3XM7m7Wh+zuyZHz2RBGh9c6iM2Ws/k4Pg8cTE2Pr4yoGfySBu7a7L5vpHJnx1po8SVzIlrg9iseia7hvQXSd6/0Ee1MYf1fDWxvcKhZzI7kXONI2iafhDW1jtJppHJzUomP3y7xch+I1vLs/jNsXZcmQnhTC4t+2ns8JCbkcAbJzvZGpHJvzYy+fqJTrJS42js9DC35MUf0LjSNkZhjn7QtL1Cz+SeGiOTm9J5+3Q3qYnRqH2TTMwsYzaZb8tkqMc/eruZisI03r/QZ2RylmH3AtFRFk5eG6K8IDWcye+FMvleK6V5KXx8ZYBou4Vh9wK9I7Mkxts5drmfyrtkssiZzJkbeiY908u090+RlhTDkXNrM/m915vYVuHQ57AjgYsto/j9WjiT2elxvHWqi81KJj94K5TJJjYrmbzycQfZ6fFcb3ezsOxnxRvgmjoezuS2iiz+5s3m1UyWZPDS+zdZ8envevoDGi+9f5P+8YUvbb9xP+eAPgK8AaCqahuQoihKIoCiKEXApKqqA6qqBoH3jN8XQgghxN9yZrOJlp5JlPxUGtrdbC3P4syNYbZXZHH6+hAFOUnc7J0iNsbG1Nwyfn+QtKRo+kdnqSxM4+rNcXZUOPR3xsr0dyVzsxLoHJwm2m4x3sEIkJUaR9fQDNWb0rncNhZ+N7KuNIMLLaM40uPoHZnFZrPg9QeZX/LhzExA7ZuitiSdSy2j4fupLk7natsYGSkxDI7PY7HofwrNzK9QkJ1Ea88km0szuNA8wnbjHbmKwjQa2sdJSYxmZGIBk9mEzWrGM7NMcW4yTV0etiiZnGscYWelg5MNQ5TmpdBovCs8PrWEBsRF2xjxLFCal8KNdjdby7I4e2OYHZUOzlwfosip339crI2JmWUCQY2UhCgGxuaoKEzlmjrOtgoHZ24Ms83odZ4jgY6BaWKircwuePH6g2SmxNIzPENVcTpX2sbYYTweW5RMzjeNkJ0RR/fQDHabhaUVP4vLPnIy4unon6JmUwaXWkeNMYPUbNL7l5kaS//oHFarOfyCQb4jkZt9U9Qa/Qq9g1lVlM41dZzUpGiGPQuYzSasFhOTs8sUOpNp6Z4w+jXMjgq9X0pBKjc63CQlRDE2uQhAdJSVsYlFSlzJNHZ69Iw0jbCzMpuTDUNsciXT3D1BfKwdz/QyQU0jKT6KIfc8ZYWpNLSPs63c6HGFgzM3hijISUTtmyI22srM/Ap+f5CM5Bj6RmapKkrjatsY28tDmczifNMwuZnxdA3OEGW3sLDkZ2nFr2dycJqayExeH6KuNIOLLaNkpcXRZ/TLZ2QyNzMBtW+SupIMPZOVDk41DFJdrN9verKeSbNFXzY5PbdCYc5qJs83jYTHVBSkcb3dHc4kJrDb9Bd/NuWmRPRrmJ3G41KSl0JT1y2ZjNEzqeSlcqPdbeRqiB2VDk43DFLoTKKtd5I4Yw4HghqpidH0j0Zk0sjitrIszt4YwmVkMjrKyuyi13hnXM9cVVEal9tW5+Pm0kwuNOuZ7BnW5/Dyip+FZR/OUCZL9J7uqMjiVMOQ3vPWUTJSYukfmwsvUZ2Z1zPZ1jtFXWkmF5r1+znVMEhlUdptmbRZzXimlyhy6jnaHMqk0WMl//ZMxhqZLM1L4UaHh23l+juxOyodnLo+RHGunu+EyEwmRDE4Pk95YRoN6jjbylafJ8/cGCY/OxG1f4qYWzLZOzJLZSiTRr+2GM+Tzsx4uob0TC4u65nMTo+nc2Ca2pJ0LrcaYxqGqL1DJv0BPZOuLP158k6OXujFYv1yPi7ofpbgOoCrEf/vNr43a3x1R/xsHCi+142lpMRitVo+ZZl3l5GR8IXd1nqSutffg1q71L3+HtTapW7xWX2efbPVYjbOYwJNC517pJ8/FVq8Ff5qMoXPedLQz18LasY5dMZ5gJELvjRNP4NJ08BinDNnjrgNNDCbWHs/xve0iNs1G8vIzGZ9yTC31KaFakMf4/MTPq8rdK6eibX3oxnn+YXOFQtvl3G/xt3cYYxRt1m/59VtX91uU8Q/wueTarfXdNu2R2xP+HciehA692xtTfq231rT6v1xhzFa+PbC2xNxG3fqV1ALPf5axPmLes8td+kXRq64pQfB8HnDt/QLbqtptQdrxxDxuEdm0GJZrelO/cI4L3K1pohMhu/39scjPOYOj8s9Mxk63y+on1sZuT23Z3JtjrVbenDHHhvfu60m4+utt0/k72LURMQcu8O8v3XMmh4Y/bxzfrmtT6Gvtz8uxnYAFjOrPYi4v9syGT5X8pY+RTxn3Km2yH4FIzJ/a75CNOM89bU1cduYNc+TrObKYomcW/fY9jU1QWguo3F7VsK1rW7rrawWE0mJMeEX6b5In+VDiO61GPgTFwpPTS1+hru8s4yMBNzuuS/s9taL1L3+HtTape7196DW/ttctxzAfn6fZ9+s5Kfwk3db+Idfq+GXH6g8tbeQ800j1G/Npb1/muridGYXvKQnx2A2m5ieXyE3M4F3z/bwh89W8fJH7Ty+s4BLLaMc2OykZ3iG8oJUFpf9JMVHYTPe1SnISeTDy338wZMVvHGyi/otuVy5OcbemhwGxuYocSWz7A0QE6WfUzrsWeDZA8X8zZvNvHi4jPfO9VK/xUWDOs6uKgcjngUKshPx+vQP7kiMszMwOsuTewr54VvN/O5jCh9e6qd+ay5NXR62VzgYn1rClZWAPxAkqEFKQjRdQzM8uiOPn77Xxtcf2sSphiEe3uqitUd/l29ydpns9DiCQY1lb4CstFjeONnBP/xaDS+9f5PnDhQb/XLR3jdFTUk6M/MrZKXGYkJfBurMiOfdM9384bNV/PpYO4d3F4TPAesamqGiMJX5RR+piVFYLWYmppfIz07k/Yt9/P2nK3n1eAcPb8/jSpt+bl7f6ByleSksLvtJiLURZbcwMrHAcweL+fiNJv7OUxW8fbqb+i0urqnj7K7JZsg9T7EziRVfALvNQnyMjcHxOZ7eV8QP3mrm9x8v4+j5Xuq35nKj08OOymzGJhfJd+j9MgHJ8VH0Ds9weHcBP36nhW8+UsrHVwao35JLc5eHrWVZTMws48yIJxDU8PoDpCfH0DEwzUNbXfz8aBtfO7hJP1dym4ubvfo7g9NzKzjSYgFYXPaHlyf+g+eq+NWH7Xomm0c4uCWXzoFpqorTmFv0kp5kZHJuBVdWAkfO9fD3n6nilY87eHRnHpdaR9lf56RneJayghQWlnwkxkVht1kYm1ykMCeJY5f7+YMnK3jz1Gom99TkMDA+z6ZcI5N2K3HRNobc8zyzv2hNJh/a6uJ6u5tdVQ5GJ/RM+vxBLGYTiXF2+kZmeGJPAT98u4XffbSUY5f6qd/ioqlrgm1GJnMz4wkENAIBfYVB5+AMh7avzeRDW3Np7Zlgc+lqJjUNllb8ONLiePNkZziTz+4vWs1k/xQ1m9KZWfCSmRKD2WRiZsFLbmY8757VM/kbI5MXmkc4sCWX7lAml3ykJERhs+jvNBZkJ/LBxT7+3tOVvH6ik4e2ubjcpp//GMrk0oqfuBibvqzVo2fy+JvNfOeJct4+0039llwa1HF2V2cz7F6gyJmE1xfAZjWTEGtnYGyWp/bqc/j3Hivj/Yt91G910djpYUelg/GpRfIcCfj8+gcapSRG0TM0zeO78sOZPH51gIe2umjuvkMmfQEyU2PpOLE2k/o55bmovZPUlWaE5zDA/KLvjpm80DzKwS1OuganqSrSM5lmZHJqdoU8RwJHzxuZPN7Boe15xvnITnpHZlHy9TmcGGcnyshkkdPI5FMVvHWqi4Nbcrl6c4y9tTkMjs9TnJvEsjdAtN1CXLS+nP2Z/UW8f6Hvtuf2x3cVMDn52Zfh3mvfbAp9AtfdKIryb4ARVVW/Z/x/N1CrquqcoigFwC+N80NRFOVfAxOqqv7l3W7P7Z679x1+Cr/Nf3BthAe1bnhwa5e619+DWvtvc90ZGQlfzqck/Bb5XPtmE3QMz3GxdRRHaizLKwGWvfofte39U/pSy6ZhDmzO5fjVAQ7U5XKxRf8gnp7hGdKSovUP71n0kZeVQGvPBNvKHZxtHOJAXS4nrg2wr87J1bYxygvSGBibIzHejtmkL+ksykmisdPNzqpsTl8f4uDmXE41DLK7Jodr6hhKXiqjngVioq1E2fU/0kpdKfqBaHU2pxqGqN+ij9lZlU1jl4einCQmppewWvUPStGXz6VytXWMPbVOTl4b4OAWF2euD7G9IouWngnyshKZmV8BjD9qh2epKU7nYuso+2udHL82wMHNuZxrHGZrWRZq/xTZaXEsLvuMZbMxdA7MUKfoHxZyYHMuJ64OcGBzLheahqkxPuwoIyUWf2iZcUYcN/umwsuXQ2P21Tm53DpKVZH+wTLJCVGgaUzPeynITqCpe4Id5fqS1INb9DF7a/UP4inLT2XYPU98rB2rxYx7eokSVxLX2z3sqtKXGdZvzuVkwwC7q3O43uFmU24y45NLRNktxEZbGfHMo+Sncu3mOHtqcjh5bZCDW3I5c13/kJimLg8F2YlMzy5jMptIjI9iYHSWyqJ0/aCv1smJa4Mc2OzkbKO+tPNm3yTOjHjmFn0EgkHSk2PoHpyhpiSdC82jHKhzcvzqAAe35HK+aYS60gw6B6fJisxkehztfaFMjnBgs3NNJquL0+kdmSU1MZpgUGNu0YsrK4GW7gm2G0t4D27WM6n3a5SKgvTwhx1ZLSYmZm7JZIPe41MNg+yqzuZ6u5vSvBRGjExG2y2MGks6r7ePs6tqNZMnGwbZVaV/OFSRM/kTMmn0+MYg28sdtPRMkpeVwMzCCpoGqffI5PmmYTYrWbSHMmmcy+pIjaWjf3pNJo9f6efAZpc+h0sy6B6aJj15NZO5mXG09Uyxtfz2TF5pHaOiKI3+0VmS46MBjen5FQqyE2nqnmCnscz0oJGvPTX6B/EoEZm0Wc2MTxmZVN3GHB6kfovrtky6p5aw28zERtsY8cxTlp/K1Ztj7KlxcuraIAeMTG6vcNDSPUG+kUlMJpITougbnaWqSF/Ouq82h5MNg+yvuz2T80s+/AF92WyXkcmLzfqLFyeuGXO4eYTakgw6BqfJSonF6wvoB//pcajhOTzCAWPM/rpcLrWMUFWcTt+ofn64pmnhD5Rq6Z5g+x3m8LWbY5QVpDI0Ph/OpMf4kLPGDj2Tq3N4kN1GJktcyfzmow4WlnxE2y1858lydiiZWD7H3vVe++b7OQDdA/xbVVUfVRRlC/Dnqqrui/h5C/AUMAicB76tqmr73W5PDkCl7o3woNYuda+/B7X23+a65QD08/u8+2az2cSiN8CKb/XSB5qxfDF0mYxg0Lhcgj+IxTiPMHwpCuMRDC8VNS4JEDAufeAPXYogfJkEjKWhGsFg6LIPay9fEAxomI1LRkReJsFsMhHQ9MujBDQtfLkEu81iXFojtPQyoiaTfjtWswm/tnp5CVvoEh4RyzUxLq0Q2narWb/8gsW4xIXFsrqENIhGaDFdaPlc5OUXrOF+WQgGg7f0S/+3zaKfY2iOuEyKP+LSDWaTvvwVkwkzGoGIZayhS5CELmdhNi7hYDGWJYYfQ2MJYagHvrtt+x17HMRiMuMPRowJX8pDvxxHaAlyMMjabQ/VFupXuMe39Ct02Y+Iy+9E5mt1OetdMhm+RIgWXuYaymT4siIRl8fQs+I3LtkSxGyKzCTh2/9UmQyN0YzLZQRYvUTMrZkEzBiPh8W0tv5Qb023Z9JqNePzBVczGTEmGNljTPp23KHH4cuxWC0E7pLJ1TkcuryMWb9UUMTjEjQe9FAmLabI7Qn1azWTVmNsaNlquLfB1Tkc7vUdMhnO8Sdk0myKnMNEPL/cJZOhOaytLvsN1eAPBomyWVcv73S3fkU8/pGZDN2fxWwsYWf1Mi+Rl4hZvZxQcE0mQ89focfSEtG30HbcmkmvL0CM3YLLkfi53v2Ee++bP3EJrqqq5xRFuaooyjkgCHxXUZS/C8yoqvo68D8BvzR+/df3OvgUQgghxN8+waBGtNVMtNV8jxcVjHNM7Z/lXFPLLV+/ePf/Ysjnqf8zjAn3687nYa2t+/P06cvq7d1v9xOz8pnu59OM/Wz9unPPN9L91fD56761X5/m3MDPch7hao1f7Ius6zeH19Z9Pz34Iubw58hklD72yzjvM9J9nQOqquqf3PKtGxE/OwXs/iKLEkIIIYQQQgjxt8+Xe3grhBBCCCGEEEIY5ABUCCGEEEIIIcS6kANQIYQQQgghhBDrQg5AhRBCCCGEEEKsCzkAFUIIIYQQQgixLuQAVAghhBBCCCHEupADUCGEEEIIIYQQ60IOQIUQQgghhBBCrAs5ABVCCCGEEEIIsS5MmqZtdA1CCCGEEEIIIX4LyDugQgghhBBCCCHWhRyACiGEEEIIIYRYF3IAKoQQQgghhBBiXcgBqBBCCCGEEEKIdSEHoEIIIYQQQggh1oUcgAohhBBCCCGEWBdyACqEEEIIIYQQYl1YN7qAz0JRlP8G7AI04J+qqnp5g0u6J0VR/jOwH73f/xF4FtgKTBi/8l9UVX13g8q7I0VR6oGXgRbjW03AfwZ+BliAEeA7qqqubEiB96Aoyh8C34n41jbgChAHLBjf+19UVb263rXdiaIoVcCbwH9TVfUvFUVxcYc+K4rybeCfAUHg+6qq/mCjag65S+0/AmyAD3hRVdVRRVF8wNmIoY+oqhpY/4p1d6j7x9xhTn7Ven6Hul8GMowfpwIXgP+APl9D+XarqvrNdS/2Fnd4HrzMA5JzcX9k3/zlk33z+pF98/qTffP626h98wN3AKooykGgRFXV3YqilAM/BHZvcFl3pSjKQ0CVUW8a0AB8DPzvqqq+s7HVfaKTqqp+I/Q/iqL8CPjvqqq+rCjKfwD+PvA/Nqy6uzAmxQ8gnJdvAZXA31NVtXkja7uVoihxwF8AH0V8+99xS58VRfkp8K+AHYAXuKwoyuuqqk6ue9GGu9T+Z+hPTL9RFOW7wD8H/ldgRlXV+vWv8nZ3qRtumZPG731len6nuiN3Xoqi/BD4m9UffTX6DXd9HvyIByDn4v7Ivnldyb75Syb75vUn++b1t5H75gdxCe4jwBsAqqq2ASmKoiRuaEX3dgoIBXEa/ZU+y4ZV8/nUA28Z/34bOLRxpdy3fwX86UYXcQ8rwJPAcMT36rm9zzuBy6qqzqiquoT+iuXedazzTu5U+z8GXjX+7QbS1ruo+3Cnuu/kq9bzu9atKIoCJKuqemndq7o/d3oerOfByLm4P7Jv3jj1yL75iyb75vUn++b1t2H75gfuHVDAwerb16BPJAcwuzHl3JuxlCG0tOQPgfeAAPBPFEX558A48E9UVfVsUIn3UqEoylvoywf+LRAXsaxnHMjesMrug6Io24EBY5kJwL9TFCUdaAP+mTGJNpSqqn7Ab9QXcqc+O9Czzi3f3zB3ql1V1QUARVEswHfRXzEGiFYU5RdAPvCqqqr/dZ3LDbtLz+GWOclXrOf3qBvgn6K/AhviUBTlFSAH/ZXMl9ahxLu6y/Pg4w9CzsV9k33z+pF985dM9s3rT/bN628j980P4jugtzJtdAH3Q1GU59Af3H+Cvrb6T1RVfRi4DvybjavsrjrQd2zPAX+Avmwm8gWLB6Hv/wD4sfHv/w/4F6qqHkBfv/7djSrqU7pbn7+y/Td2cD8DPlZVNbQk5Y+BPwIeA76tKMq2jarvLu5nTn4le64oih3Yp6rqceNbE8D/Cfwe+jltf6ooylfiD9JbngcjPXA5F5/ogXjsZN+8IWTfvAFk37y+ZN98bw/iO6DD6EfiITnoJ8l+ZSmK8jjwL4HDqqrOsHZ9+1t8Nc/VGAJ+bfxvl6Ioo8B2RVFijFcnnXzyMomNVg/8zwCqqr4e8f23gd/ZiILu0/wd+nxr7p3oJ7V/Ff0I6FBV9d+GvqGq6l+F/q0oykdANfqHT3wlROyMYXVOvsKD0fODQHh5j6qqc+iPAYBHUZQrQBkb/Dx56/OgoigPes7FWrJvXgeyb95QD/pzluyb15fsm+/hQXwH9APgGwCKomwBho0H9StJUZQk4L8AT4dO1lUU5VVFUYqMX6kHvlIn3wMoivJtRVH+2Pi3A8hCnzhfN37l68DRDSrvEymKkgPMq6rqVRTFpCjKMUVRko0f1/MV7HmEY9ze54vof2QkK4oSj772/vQG1XdXxqekeVVV/dcR31MURfmF8ThY0WtvueuNbIC7zMkHoufAduBG6H8URXlIUZT/avw7DqgD2jemtHBNtz0P8gDnXNyR7JvXgeybN9QD+5wl++YNIfvmezBpmvZ5xm8IRVH+ExBerqGq6o1PGLJhFEX5I/QlA5Eh+xH629yLwDz6J8CNr391d6coSgLwCyAZsKMv+WkAfgpEA33odfs2qsZ7URRlK/Bnqqo+Yfz/t4D/DX2t+xDwh6qqLm5giUC4zv8HKED/aPQh4Nvoy5PW9FlRlG8A/wL9Egd/sdHnDtyl9kxgmdXzvlpVVf3HiqL8X8DD6HP2LVVV//36V6y7S91/AfwJt8zJr1LP71L3C+hz84yqqr82fs+K/ol7CvqHqvwPVVV/dKfbXC93eR78A/Q6v9I5F/dP9s1fPtk3rw/ZN68/2Tevv43cNz+QB6BCCCGEEEIIIR48D+ISXCGEEEIIIYQQDyA5ABVCCCGEEEIIsS7kAFQIIYQQQgghxLqQA1AhhBBCCCGEEOtCDkCFEEIIIYQQQqwLOQAVYp0oiqIZH8N9v7//Z4qi/JsvsSQhhBDit5rsm4VYf3IAKoQQQgghhBBiXdz3Kz5CiC+Goij16BdWHgQq0S9cfFhV1UVFUf498DQwgH5h7jZjzEPAvwZMxu//Q/QLR38EbFdVdUpRlI+B/6qq6jvru0VCCCHEg032zUKsH3kHVIiNsRv4P1RV3Q0EgMcVRSkFvg3sAL4GlAAoihIL/BXwgqqqB4G/AP5vVVX7gP8M/CdFUf4u0CM7OCGEEOIzk32zEOtA3gEVYmO0qao6bvy7D0gFqoGrqqquACiKcsr4eRWQDbymKAqABdAAVFX9vqIoR4A9wN71K18IIYT4W0f2zUKsAzkAFWJj+G/5f5PxXzDiexbj6wrQr6pq/a03YnxwQrIxNgmY/aILFUIIIX5LyL5ZiHUgS3CF+OpoA7YoimJXFMUGHDS+3w6kK4pSBaAoygFFUf7I+Nm/BI4Cfwz8UFEU03oXLYQQQvwtJvtmIb5gcgAqxFeEqqotwBvAReBl4Lrx/SXgReAHiqKcBP4UOKkoSi3wAvAfVVU9CowD313/yoUQQoi/nWTfLMQXz6Rp2kbXIIQQQgghhBDit4C8AyqEEEIIIYQQYl3IAagQQgghhBBCiHUhB6BCCCGEEEIIIdaFHIAKIYQQQgghhFgXcgAqhBBCCCGEEGJdyAGoEEIIIYQQQoh1IQegQgghhBBCCCHWxf8P50qKkI3sae8AAAAASUVORK5CYII=\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(16, 6), sharey=True)\n", + "training_stacking_weights = trace[\"w\"].mean(axis=0)\n", + "sns.scatterplot(data=pd.DataFrame(training_stacking_weights), ax=ax[0])\n", + "fixed_weights = pd.DataFrame(\n", + " np.repeat(\n", + " scipy.special.softmax(lpd_point.sum(axis=0))[:, np.newaxis].T,\n", + " len(X_stacking_train),\n", + " axis=0,\n", + " )\n", + ")\n", + "sns.scatterplot(\n", + " data=fixed_weights,\n", + " ax=ax[1],\n", + ")\n", + "ax[0].set_title(\"Training weights from Bayesian Hierarchical stacking\")\n", + "ax[1].set_title(\"Fixed weights derived from lpd_point\")\n", + "ax[0].set_xlabel(\"Index\")\n", + "ax[1].set_xlabel(\"Index\")\n", + "fig.suptitle(\n", + " \"Bayesian Hierarchical Stacking weights can vary according to the input\",\n", + " fontsize=18,\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "c60e0c01", + "metadata": { + "papermill": { + "duration": 0.065143, + "end_time": "2021-09-18T11:10:58.110931", + "exception": false, + "start_time": "2021-09-18T11:10:58.045788", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## 4. Evaluate on test set \n", + "\n", + "### 4.1 Stack predictions \n", + "\n", + "Now, for each model, let's evaluate the log predictive density for each point in the test set. Once we have predictions for each model, we need to think about how to combine them, such that for each test point, we get a single prediction.\n", + "\n", + "We decided we'd do this in three ways:\n", + "- Bayesian Hierarchical Stacking (`bhs_pred`);\n", + "- choosing the model with the best training set LOO score (`model_selection_preds`);\n", + "- fixed-weights stacking based on LOO scores (`fixed_weights_preds`)." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "ce86bd9e-b2c6-4947-9675-92c925b6088d", + "metadata": {}, + "outputs": [], + "source": [ + "# for each candidate model, extract the posterior predictive logits\n", + "train_preds = []\n", + "for k in range(K):\n", + " predictive = numpyro.infer.Predictive(logistic, fit_list[k].get_samples())\n", + " rng_key = jax.random.fold_in(jax.random.PRNGKey(19), k)\n", + " train_pred = predictive(rng_key, x=train_x_list[k])[\"logits\"]\n", + " train_preds.append(train_pred.mean(axis=0))\n", + "# reshape, so we have (N, K)\n", + "train_preds = np.vstack(train_preds).T" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "5b686b7c", + "metadata": { + "papermill": { + "duration": 0.54285, + "end_time": "2021-09-18T11:10:59.694998", + "exception": false, + "start_time": "2021-09-18T11:10:59.152148", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# same as previous cell, but for test set\n", + "test_preds = []\n", + "for k in range(K):\n", + " predictive = numpyro.infer.Predictive(logistic, fit_list[k].get_samples())\n", + " rng_key = jax.random.fold_in(jax.random.PRNGKey(20), k)\n", + " test_pred = predictive(rng_key, x=test_x_list[k])[\"logits\"]\n", + " test_preds.append(test_pred.mean(axis=0))\n", + "test_preds = np.vstack(test_preds).T" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "436f8789", + "metadata": { + "papermill": { + "duration": 0.145066, + "end_time": "2021-09-18T11:11:00.042707", + "exception": false, + "start_time": "2021-09-18T11:10:59.897641", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [ + "# get the stacking weights for the test set\n", + "test_stacking_weights = trace[\"w_test\"].mean(axis=0)\n", + "# get predictions using the stacking weights\n", + "bhs_predictions = (test_stacking_weights * test_preds).sum(axis=1)\n", + "# get predictions using only the model with the best LOO score\n", + "model_selection_preds = test_preds[:, lpd_point.sum(axis=0).argmax()]\n", + "# get predictions using fixed stacking weights, dependent on the LOO score\n", + "fixed_weights_preds = (scipy.special.softmax(lpd_point.sum(axis=0)) * test_preds).sum(\n", + " axis=1\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "76233762", + "metadata": { + "papermill": { + "duration": 0.064289, + "end_time": "2021-09-18T11:11:00.170538", + "exception": false, + "start_time": "2021-09-18T11:11:00.106249", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "### 4.2 Compare methods " + ] + }, + { + "cell_type": "markdown", + "id": "c2d889c2", + "metadata": { + "papermill": { + "duration": 0.06178, + "end_time": "2021-09-18T11:11:00.293209", + "exception": false, + "start_time": "2021-09-18T11:11:00.231429", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "Let's compare the negative log predictive density scores on the test set (note - lower is better):" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "33e15689", + "metadata": { + "papermill": { + "duration": 0.463508, + "end_time": "2021-09-18T11:11:00.819086", + "exception": false, + "start_time": "2021-09-18T11:11:00.355578", + "status": "completed" + }, + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
    " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(12, 6))\n", + "neg_log_pred_densities = np.vstack(\n", + " [\n", + " -dist.Bernoulli(logits=bhs_predictions).log_prob(y_test),\n", + " -dist.Bernoulli(logits=model_selection_preds).log_prob(y_test),\n", + " -dist.Bernoulli(logits=fixed_weights_preds).log_prob(y_test),\n", + " ]\n", + ").T\n", + "neg_log_pred_density = pd.DataFrame(\n", + " neg_log_pred_densities,\n", + " columns=[\n", + " \"Bayesian Hierarchical Stacking\",\n", + " \"Model selection\",\n", + " \"Fixed stacking weights\",\n", + " ],\n", + ")\n", + "sns.barplot(\n", + " data=neg_log_pred_density.reindex(\n", + " columns=neg_log_pred_density.mean(axis=0).sort_values(ascending=False).index\n", + " ),\n", + " orient=\"h\",\n", + " ax=ax,\n", + ")\n", + "ax.set_title(\n", + " \"Bayesian Hierarchical Stacking performs best here\", fontdict={\"fontsize\": 18}\n", + ")\n", + "ax.set_xlabel(\"Negative mean log predictive density (lower is better)\");" + ] + }, + { + "cell_type": "markdown", + "id": "dc7517ce", + "metadata": { + "papermill": { + "duration": 0.066707, + "end_time": "2021-09-18T11:11:01.178051", + "exception": false, + "start_time": "2021-09-18T11:11:01.111344", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "So, in this dataset, with this particular train-test split, Bayesian Hierarchical Stacking does indeed bring a small gain compared with model selection and compared with fixed-weight stacking.\n", + "\n", + "### 4.3 Does this prove that Bayesian Hierarchical Stacking works? \n", + "\n", + "No, a single train-test split doesn't prove anything. Check the original paper for results with varying training set sizes, repeated with different train-test splits, in which they show that Bayesian Hierarchical Stacking consistently outperforms model selection and fixed-weight stacking.\n", + "\n", + "The goal of this notebook was just to show how to implement this technique in NumPyro." + ] + }, + { + "cell_type": "markdown", + "id": "29cf8140", + "metadata": { + "papermill": { + "duration": 0.066367, + "end_time": "2021-09-18T11:11:01.310721", + "exception": false, + "start_time": "2021-09-18T11:11:01.244354", + "status": "completed" + }, + "tags": [] + }, + "source": [ + "## Conclusion \n", + "\n", + "We've seen how Bayesian Hierarchical Stacking can help us average models with input-dependent weights, in a manner which doesn't overfit. We only implemented the first case study from the paper, but readers are encouraged to check out the other two as well. Also check the paper for theoretical results and results from more experiments.\n", + "\n", + "## References\n", + "\n", + "1. Yuling Yao, Gregor Pirš, Aki Vehtari, Andrew Gelman (2021). [Bayesian hierarchical stacking: Some models are (somewhere) useful](https://arxiv.org/abs/2101.08954)\n", + "2. Måns Magnusson, Michael Riis Andersen, Johan Jonasson, Aki Vehtari (2020). [Leave-One-Out Cross-Validation for Bayesian Model Comparison in Large Data](https://arxiv.org/abs/2001.00980)\n", + "3. https://github.com/yao-yl/hierarchical-stacking-code.\n", + "4. Thomas Wiecki (2017). [Why hierarchical models are awesome, tricky, and Bayesian](https://twiecki.io/blog/2017/02/08/bayesian-hierchical-non-centered/)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "32694722", + "metadata": { + "papermill": { + "duration": 0.068268, + "end_time": "2021-09-18T11:11:03.218672", + "exception": false, + "start_time": "2021-09-18T11:11:03.150404", + "status": "completed" + }, + "tags": [] + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "good-bayesian", + "language": "python", + "name": "good-bayesian" + }, + "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.8.5" + }, + "papermill": { + "default_parameters": {}, + "duration": 1224.415684, + "end_time": "2021-09-18T11:11:05.150406", + "environment_variables": {}, + "exception": null, + "input_path": "__notebook__.ipynb", + "output_path": "__notebook__.ipynb", + "parameters": {}, + "start_time": "2021-09-18T10:50:40.734722", + "version": "2.3.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From a9418d4ff1e971be82577e7917c1b3b6be0fdbda Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Omar=20Sosa=20Rodr=C3=ADguez?= <32113591+omarfsosa@users.noreply.github.com> Date: Tue, 12 Oct 2021 14:18:59 +0100 Subject: [PATCH 184/222] Solves #1184 (#1185) * Avoid infinities when doing inverse-transform sampling in truncated distributions * Remove use of jax.config. Do not use maxval in random.uniform as it is already exclusive. * lint and format --- numpyro/distributions/truncated.py | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/numpyro/distributions/truncated.py b/numpyro/distributions/truncated.py index 1717b155a..26333adc9 100644 --- a/numpyro/distributions/truncated.py +++ b/numpyro/distributions/truncated.py @@ -61,7 +61,10 @@ def _tail_prob_at_high(self): def sample(self, key, sample_shape=()): assert is_prng_key(key) - u = random.uniform(key, sample_shape + self.batch_shape) + dtype = jnp.result_type(float) + finfo = jnp.finfo(dtype) + minval = finfo.tiny + u = random.uniform(key, shape=sample_shape + self.batch_shape, minval=minval) loc = self.base_dist.loc sign = jnp.where(loc >= self.low, 1.0, -1.0) return (1 - sign) * loc + sign * self.base_dist.icdf( @@ -126,7 +129,10 @@ def _cdf_at_high(self): def sample(self, key, sample_shape=()): assert is_prng_key(key) - u = random.uniform(key, sample_shape + self.batch_shape) + dtype = jnp.result_type(float) + finfo = jnp.finfo(dtype) + minval = finfo.tiny + u = random.uniform(key, shape=sample_shape + self.batch_shape, minval=minval) return self.base_dist.icdf(u * self._cdf_at_high) @validate_sample @@ -197,7 +203,10 @@ def _tail_prob_at_high(self): def sample(self, key, sample_shape=()): assert is_prng_key(key) - u = random.uniform(key, sample_shape + self.batch_shape) + dtype = jnp.result_type(float) + finfo = jnp.finfo(dtype) + minval = finfo.tiny + u = random.uniform(key, shape=sample_shape + self.batch_shape, minval=minval) # NB: we use a more numerically stable formula for a symmetric base distribution # A = icdf(cdf(low) + (cdf(high) - cdf(low)) * u) = icdf[(1 - u) * cdf(low) + u * cdf(high)] From 145ed8373fe268798b352b98350ffc596a51e682 Mon Sep 17 00:00:00 2001 From: Mark Worrall Date: Wed, 13 Oct 2021 00:17:53 +0100 Subject: [PATCH 185/222] WIP: Initial port of `check_model_guide_match` to `numpyro/util.py` (#1171) * Initial port of check_model_guide_match to numpyro/util.py * Move shape check inside infer/util.py to log_density function * Add tests for check_model_guide_match * Set default value for site['is_observed'] to False * Use pytest.warns * Modify test_collapse_beta_binomial test to make data a jax array to allow checking of shape i.e. value.shape in log_density function * Promote params to jnp.array in test_scan_constrain_reparam_compatible to allow shape comparisons * Cast model_shape to tuple so can check broadcasting for tfp TensorShape objects * Remove check for site['is_observed'] when site type is plate * Use jnp.shape in log_density * Amend vae example to ensure shapes match * Correct vae example - consider image_dim as event dimension * Amend logic to obtain guide_vars --- examples/vae.py | 11 ++--- numpyro/infer/elbo.py | 2 + numpyro/infer/util.py | 13 ++++++ numpyro/util.py | 100 ++++++++++++++++++++++++++++++++++++++++++ test/test_util.py | 90 ++++++++++++++++++++++++++++++++++++- 5 files changed, 210 insertions(+), 6 deletions(-) diff --git a/examples/vae.py b/examples/vae.py index 6d2569343..a7881518a 100644 --- a/examples/vae.py +++ b/examples/vae.py @@ -55,9 +55,10 @@ def model(batch, hidden_dim=400, z_dim=100): batch = jnp.reshape(batch, (batch.shape[0], -1)) batch_dim, out_dim = jnp.shape(batch) decode = numpyro.module("decoder", decoder(hidden_dim, out_dim), (batch_dim, z_dim)) - z = numpyro.sample("z", dist.Normal(jnp.zeros((z_dim,)), jnp.ones((z_dim,)))) - img_loc = decode(z) - return numpyro.sample("obs", dist.Bernoulli(img_loc), obs=batch) + with numpyro.plate("batch", batch_dim): + z = numpyro.sample("z", dist.Normal(0, 1).expand([z_dim]).to_event(1)) + img_loc = decode(z) + return numpyro.sample("obs", dist.Bernoulli(img_loc).to_event(1), obs=batch) def guide(batch, hidden_dim=400, z_dim=100): @@ -65,8 +66,8 @@ def guide(batch, hidden_dim=400, z_dim=100): batch_dim, out_dim = jnp.shape(batch) encode = numpyro.module("encoder", encoder(hidden_dim, z_dim), (batch_dim, out_dim)) z_loc, z_std = encode(batch) - z = numpyro.sample("z", dist.Normal(z_loc, z_std)) - return z + with numpyro.plate("batch", batch_dim): + return numpyro.sample("z", dist.Normal(z_loc, z_std).to_event(1)) @jit diff --git a/numpyro/infer/elbo.py b/numpyro/infer/elbo.py index 34ae516e9..6e1e1d0e4 100644 --- a/numpyro/infer/elbo.py +++ b/numpyro/infer/elbo.py @@ -13,6 +13,7 @@ from numpyro.distributions.util import scale_and_mask from numpyro.handlers import replay, seed, substitute, trace from numpyro.infer.util import get_importance_trace, log_density +from numpyro.util import check_model_guide_match class ELBO: @@ -124,6 +125,7 @@ def single_particle_elbo(rng_key): model_log_density, model_trace = log_density( seeded_model, args, kwargs, params ) + check_model_guide_match(model_trace, guide_trace) mutable_params.update( { name: site["value"] diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 03000ad4d..ba28a4c2b 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -10,6 +10,7 @@ from jax import device_get, jacfwd, lax, random, value_and_grad from jax.flatten_util import ravel_pytree +from jax.lax import broadcast_shapes import jax.numpy as jnp from jax.tree_util import tree_map @@ -60,6 +61,18 @@ def log_density(model, model_args, model_kwargs, params): if intermediates: log_prob = site["fn"].log_prob(value, intermediates) else: + guide_shape = jnp.shape(value) + model_shape = tuple( + site["fn"].shape() + ) # TensorShape from tfp needs casting to tuple + try: + broadcast_shapes(guide_shape, model_shape) + except ValueError: + raise ValueError( + "Model and guide shapes disagree at site: '{}': {} vs {}".format( + site["name"], model_shape, guide_shape + ) + ) log_prob = site["fn"].log_prob(value) if (scale is not None) and (not is_identically_one(scale)): diff --git a/numpyro/util.py b/numpyro/util.py index 84c5f6e55..0a689c79c 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -3,6 +3,7 @@ from collections import OrderedDict from contextlib import contextmanager +from itertools import zip_longest import os import random import re @@ -507,6 +508,105 @@ def model(*args, **kwargs): return _format_table(rows) +def check_model_guide_match(model_trace, guide_trace): + """ + :param dict model_trace: The model trace to check. + :param dict guide_trace: The guide trace to check. + :raises: RuntimeWarning, ValueError + Checks the following assumptions: + 1. Each sample site in the model also appears in the guide and is not + marked auxiliary. + 2. Each sample site in the guide either appears in the model or is marked, + auxiliary via ``infer={'is_auxiliary': True}``. + 3. Each :class:`~numpyro.primitives.plate` statement in the guide also + appears in the model. + 4. At each sample site that appears in both the model and guide, the model + and guide agree on sample shape. + """ + # Check ordinary sample sites. + guide_vars = set( + name + for name, site in guide_trace.items() + if site["type"] == "sample" and not site.get("is_observed", False) + ) + aux_vars = set( + name + for name, site in guide_trace.items() + if site["type"] == "sample" + if site["infer"].get("is_auxiliary") + ) + model_vars = set( + name + for name, site in model_trace.items() + if site["type"] == "sample" and not site.get("is_observed", False) + ) + # TODO: Collect enum variables when TraceEnum_ELBO is supported. + enum_vars = set() + + if aux_vars & model_vars: + warnings.warn( + "Found auxiliary vars in the model: {}".format(aux_vars & model_vars) + ) + if not (guide_vars <= model_vars | aux_vars): + warnings.warn( + "Found non-auxiliary vars in guide but not model, " + "consider marking these infer={{'is_auxiliary': True}}:\n{}".format( + guide_vars - aux_vars - model_vars + ) + ) + if not (model_vars <= guide_vars | enum_vars): + warnings.warn( + "Found vars in model but not guide: {}".format( + model_vars - guide_vars - enum_vars + ) + ) + + # Check shapes agree. + for name in model_vars & guide_vars: + model_site = model_trace[name] + guide_site = guide_trace[name] + + if hasattr(model_site["fn"], "event_dim") and hasattr( + guide_site["fn"], "event_dim" + ): + if model_site["fn"].event_dim != guide_site["fn"].event_dim: + raise ValueError( + "Model and guide event_dims disagree at site '{}': {} vs {}".format( + name, model_site["fn"].event_dim, guide_site["fn"].event_dim + ) + ) + + if hasattr(model_site["fn"], "shape") and hasattr(guide_site["fn"], "shape"): + model_shape = model_site["fn"].shape(model_site["kwargs"]["sample_shape"]) + guide_shape = guide_site["fn"].shape(guide_site["kwargs"]["sample_shape"]) + if model_shape == guide_shape: + continue + + for model_size, guide_size in zip_longest( + reversed(model_shape), reversed(guide_shape), fillvalue=1 + ): + if model_size != guide_size: + raise ValueError( + "Model and guide shapes disagree at site '{}': {} vs {}".format( + name, model_shape, guide_shape + ) + ) + + # Check subsample sites introduced by plate. + model_vars = set( + name for name, site in model_trace.items() if site["type"] == "plate" + ) + guide_vars = set( + name for name, site in guide_trace.items() if site["type"] == "plate" + ) + if not (guide_vars <= model_vars): + warnings.warn( + "Found plate statements in guide but not model: {}".format( + guide_vars - model_vars + ) + ) + + def _format_table(rows): """ Formats a right justified table using None as column separator. diff --git a/test/test_util.py b/test/test_util.py index 9152aa145..99963810d 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -1,9 +1,11 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 + from numpy.testing import assert_allclose import pytest +from jax import random from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.test_util import check_eq @@ -11,7 +13,7 @@ import numpyro import numpyro.distributions as dist -from numpyro.util import fori_collect, format_shapes, soft_vmap +from numpyro.util import check_model_guide_match, fori_collect, format_shapes, soft_vmap def test_fori_collect_thinning(): @@ -166,3 +168,89 @@ def model_test(): " value | 3\n" " data plate 10 | " ) + + +def test_check_model_guide_match(): + def _run_svi(model, guide): + adam = numpyro.optim.Adam(1e-3) + svi = numpyro.infer.SVI(model, guide, adam, numpyro.infer.Trace_ELBO()) + svi.run(random.PRNGKey(42), num_steps=50) + + def _run_svi_check_warnings(model, guide, expected_string): + with pytest.warns(UserWarning, match=expected_string) as ws: + _run_svi(model, guide) + assert len(ws) == 1 + assert expected_string in str(ws[0].message) + + def _create_traces_check_error_string(model, guide, expected_string): + model_trace = numpyro.handlers.trace( + numpyro.handlers.seed(model, rng_seed=42) + ).get_trace() + guide_trace = numpyro.handlers.trace( + numpyro.handlers.seed(guide, rng_seed=42) + ).get_trace() + with pytest.raises(ValueError, match=expected_string): + check_model_guide_match(model_trace, guide_trace) + + # 1. Auxiliary vars in the model + def model(): + numpyro.sample("x", dist.Normal()) + + def guide(): + numpyro.sample("x", dist.Normal(), infer={"is_auxiliary": True}) + + _run_svi_check_warnings(model, guide, "Found auxiliary vars in the model") + + # 2. Non-auxiliary vars in guide but not model + def model(): + numpyro.sample("x1", dist.Normal()) + + def guide(): + numpyro.sample("x1", dist.Normal()) + numpyro.sample("x2", dist.Normal()) + + _run_svi_check_warnings( + model, guide, "Found non-auxiliary vars in guide but not model" + ) + + # 3. Vars in model but not guide + def model(): + numpyro.sample("x1", dist.Normal()) + numpyro.sample("x2", dist.Normal()) + + def guide(): + numpyro.sample("x1", dist.Normal()) + + _run_svi_check_warnings(model, guide, "Found vars in model but not guide") + + # 4. Check event_dims agree + def model(): + numpyro.sample("x", dist.MultivariateNormal(jnp.zeros(4), jnp.identity(4))) + + def guide(): + numpyro.sample("x", dist.Normal().expand((3, 5))) + + _create_traces_check_error_string( + model, guide, "Model and guide event_dims disagree" + ) + + # 5. Check shapes agree + def model(): + numpyro.sample("x", dist.Normal().expand((3, 2))) + + def guide(): + numpyro.sample("x", dist.Normal().expand((3, 5))) + + _create_traces_check_error_string(model, guide, "Model and guide shapes disagree") + + # 6. Check subsample sites introduced by plate + def model(): + numpyro.sample("x", dist.Normal().expand((10,))) + + def guide(): + with numpyro.handlers.plate("data", 100, subsample_size=10): + numpyro.sample("x", dist.Normal()) + + _run_svi_check_warnings( + model, guide, "Found plate statements in guide but not model" + ) From 63f54587b521bec5cc77cc6eabc9d0ec583443e4 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Wed, 13 Oct 2021 00:12:59 -0400 Subject: [PATCH 186/222] Fix typo in conftest.py (#1188) --- test/conftest.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/conftest.py b/test/conftest.py index 98b91aec9..9a7e63d5a 100644 --- a/test/conftest.py +++ b/test/conftest.py @@ -11,6 +11,6 @@ def pytest_runtest_setup(item): - if "JAX_ENABLE_x64" in os.environ: + if "JAX_ENABLE_X64" in os.environ: config.update("jax_enable_x64", True) set_rng_seed(0) From e45b9199bd828507485ce4c78b5490f8d08e4292 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Omar=20Sosa=20Rodr=C3=ADguez?= <32113591+omarfsosa@users.noreply.github.com> Date: Wed, 13 Oct 2021 14:38:47 +0100 Subject: [PATCH 187/222] Avoid sampling -inf from soft Laplace distribution (solves #1186) (#1189) * Avoid infinities when doing inverse-transform sampling in truncated distributions * Remove use of jax.config. Do not use maxval in random.uniform as it is already exclusive. * lint and format * Avoid sampling -inf from soft Laplace distribution --- numpyro/distributions/continuous.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 75b727872..203b69b26 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -1349,9 +1349,10 @@ def log_prob(self, value): def sample(self, key, sample_shape=()): assert is_prng_key(key) - u = random.uniform( - key, shape=sample_shape + self.batch_shape + self.event_shape - ) + dtype = jnp.result_type(float) + finfo = jnp.finfo(dtype) + minval = finfo.tiny + u = random.uniform(key, shape=sample_shape + self.batch_shape, minval=minval) return self.icdf(u) # TODO: refactor validate_sample to only does validation check and use it here From 2ce25748c39cfa6083eca6af704ee2877ce5e7fa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Omar=20Sosa=20Rodr=C3=ADguez?= <32113591+omarfsosa@users.noreply.github.com> Date: Mon, 18 Oct 2021 17:58:27 +0100 Subject: [PATCH 188/222] Update hsgp (#1183) * simplified the hsgp example significantly. * New figure for hsgp example * remove old figure for hsgp example * Lint and format * Fixed typo in the name of figure * Clean up old comments * Explain how the scope handler is being used. Fix minor typos. --- docs/source/_static/img/examples/hsgp.png | Bin 67283 -> 318936 bytes examples/hsgp.py | 1001 +++++++++------------ test/test_examples.py | 5 +- 3 files changed, 430 insertions(+), 576 deletions(-) diff --git a/docs/source/_static/img/examples/hsgp.png b/docs/source/_static/img/examples/hsgp.png index 1c0ef2d2281444afdbbf56fa6799cb06b40ae43b..66b4bf990c7cd78794267758ad0fa83e40a53484 100644 GIT binary patch literal 318936 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

    LSn*9qG8_ z2?O)NDYFH?vy-Q$_YiuoVznZKNKgcQt<4F{68tNC?6JG4fd`NGZyztM>;#?$N zDq)iT8(oB=Xwvxf)s6j^B%55d1}g_aki10IMyd&#Ph_#(@Mx6qu)LZxNjhK%JFU=X=lZY zg0ZnF;nzQzXiQAJljEDd(h<_{O+Yj^?6PQQ@+dVpx8d7=a#DH4dZH?aENf1-WkPzX z#m;S{re#`p&FzVTr{fkwkUnN~>}7K!B5><1{CsvfNYbffsWk=^=a`jZ;->PdgOx`% z9_~_x?(1EunJpG^c3q0$o}$O;8! zW!P{~{Bwwry5VM+Yyn>QA|MIv!K00Q=<%aMrElLjf}G$YtLcSr*2>lA(-X<(!4j2F#N$?x5&O!%Y)!N z%&X68o9UDuMU8=JtpO`3>Ht~VU zMp-S*S#CXb`|#NQf6Hv(26@69Ph(kydzUU7nl`pN<>#CoGGW2h6RHVB8w>;Y`+7zl z87h+7X>a7>8EMok1DLbN^}}wC2s_siUPtjy!SxK*CNHLCx=zm{R6^)eiTJD8;O!Ap z6cH^3?xP=a*CHO8)421QOArh;mT*#I2n0R$UCHZ}bY*6RU_Q9ne#lN0>GswHZb+s# z-6bHak*TbY9SxT%LM?3#SX35oE7z*5POH0jls~5J+LP@JW}?_XNshVHRmNJr_68_` zRszNK2myEgmHNv=*!$@Z+7_*QdhC?7xfDA7Xn?;j92KD4j5*k=gE{p(o0~s?0yRSh zRHt`Ph0efOl~n1(ZSM&YNUT$dq0nhfcd+067Vdeep(9bR!rmh8-VX03;~j|yl~>|i z-v6`5rYh)StduPx->yB(qt&}Fd<5}w+op4^T&_VRR<<7HxO=kUIn+M)45kgMpp$9& zN*d7oUWAR6{=(NW-V=U05cL~yr9?m61ORix^U2qWg~f&U;!bDLr{a|!9trqwKB|`uKiHNepzWHGXyX`ziF(D|Wx7hl z9?LjgvnV$?3j`yHOu)A?#A9)9M{=DK`Xjr0uG{0tJsYUL?cFlQ^Y!;4ubDBZV4^-$ z#l=jd5(ttNDc*lgXWBW>9LO0t_IB&z)SsMQy@glh{tolRo9*QRDK>Kb|Ik#hGiHNH zd>7ioM-#27k*P<|-?^)z(nMS^sLyk>^|Wd+5v?A-Af6Es54bhj38-S+cZ?hiYy3`g zyIJOIYh*K(euO5ynx)`RR7~hEQnb$pYWYg70~8cNjS(-Dy-O zU{$#wm72<@C#w!)OpkoCbSi}mVxrcFKHL~}gmGF8u)EJcXU@z9X{ZklW790vHwntAgG>h2{9-+AnR56OP7gL=RMwF-7J1Bhgd3O56 zCOOS;CB$A_m5Vkd6hQebKRG9xefKS+8kEa;N`%aMVeOks8-Jwt&+hG-JV@q5!7(rX z!HOiNE#j4oGPC+PR#YH9e<8l$&kE4Yqdp$K6~0_{1Mi z(uzovb9eB@Jb?(Kl0o16XEY904`e77W)AuQznQi~^78U>^4(A1&tK5x8Mwh0OJaez zfJlR1+_}^@oDeOi=FfZbxsmyHJ(EJma;xxxfV1TI+NzMsd*%EFWuL%s`p~gt&rxJf zqdixQHQMK7-?ZVI{ax+2J1sVoApi2_H&@TIuN@HSUm4v3a&Q1xEMtI44?ksr0`!{u z&*K|QLYS^q%C(TWMt9?%Pq+1@>_(Q-Ua-oJdy5}zw|ZDxr>1@AO_ZT3yrTi;m5e{0 z650hwn+MiQ$*vde(p_0a)nV4QAKSWwrTh zqg!yZOUWeFOTt9+cuR5c+B0wWV?28iUzRzb87-8%t8s zd8Pd64Qam^>tTBi%SDP?XFJ7y?C(G-d-a4Z81zpGZRxtqW)va=FVZJOL@PL21v&sD z8X&sbNgBRR80=FH6VDASm&1Z4GVU@muZ_8qun$X7 zyXNOWimxm$_mLQl?>i98q-47C<15SK#HzTF5-cd@y{g3 zONY5sCyvJSgTgT%y$bGWn@N;s=(P)5$iT2^8(dS1){V-<&SxZM`jHtpt>%H62Sr0xC7jqMjYyaD{pZ7|$nI+dmy>q>&;yBczu`A6PD) z_$Q0c^AgXT&ft@djW-H=LA=RvjRe7`X#qr{0T6?<$i&b~+cGxSsuJh!5Tti@a>GCq z_aZW8y`$`=U?Ndq+|_{ok)oWEL)=Absm#AK6+dK>Bdq*MDa-}CyXoMS3sY*f#BM8J zuMX`a!t=c9bT7G%Ya0ykPT{4y7q`PuYqxp%`u&hUhsZTmvQp84~W^y$RquEQhLVZ&V-3%236=WPZ~WV4L}9nXd+f zsWW}HW(53x#1xOX2Q7UX8M|CE{=A7{a}n`Q`(~~l9K5gk7%iH(UlIVuqVkA%P*hoN zX1EJmWkCLC>Ag-wz@}uT&y$G4R9G1`T6S{35sKUqF*>8@c3}bdjwd?L<2wF~bHWf$ zz1ex1Yp0I%ips_q9HBXf;vU_bZNl=Y%1otuD~);!L&6i4C=PaN)3uk| zSqcl2Ns8d=Q%3uQqwQuak6OIYwrgo)EA6ResYU|dYu-30D^yU zI2S0?JEbbV_K3=LT?#E>94J{i4}Habn2HL~qG%ymue;)WQdlFky6cWjTS&M_KRb24 zd3?LAic83!)P(#Re!b;&=S2#KfAF=C65ukRm`ah`zwG;5+zm9ghB0Hwde6D9G#GS* zd!dR`tkZzEw)SGVu?jPQw^Z5lAaS&rN??8{f4he(iFw?$eo_JB^VBV7?wO8+Te3E0?&l7QzrCgHHLV-v2bTr z5V=c%XV9#15|m;8+0*uqVe!?W%teJsy)(YcKwxC&oj@&9;bds*BJ z@??>i?)$F51|m0GNgjXi`Ih}VTmTdKqz)@f(6X0EEJe^mnrGY=_jKU?_I)%VGPcq- zCm~Fvh<>1C)^JOiD?W!><&=sHMSyytLV_4JQ6!Ol&GrBYzxC2{6{riz#L^j@DK6V^ zi-6|Qn0Kj&P|u&}nTF>`nDaCuGsCbkmFdCcG1h@Rqw#JnWwaE=q${Ll5&AY}od_)) zxy@g`9vsx@gsgfKu^hLrGdni2S>*Hn z6b#7EZ`W6G%4YiyrV^)>9P`LLKiTaV6LU5jJOX-9{h8O6G!+;emkStoq>0m$0Eq--_ z>()zl{CuJKcdwKzJFE~KT8w2Qw4SN3 z8Az0ip%qlYFy+_Au~VrStRq*OSy5}$N_0w`LkoB(I3)<-m02~)hguhTY;*QM59(0=O zkUa+Bqfr`DooD}{GFmS?GL^B-Efqh_`}Mwij*G*QGT}Y;I4HAX(%A}ihAolPryG~k zyz^1KRHnyhY+rFeiyg&OwGDS>l};*p-fzXIbd&_EOIU%-%aW^9EqZXTFT8p(IAkO* zqbfb;ESYU2JNh{@Rhq6|(O?Q*euHV3;q6tX2U9w?vruiR?nC!dZ@30V>PsX#pRD~t zxHsZ}HuWfQ>CvG`eM=0RZT59e?2 zrmoXK18#r-xV$GualE-RN=EWSxjEMmw~>;(vRA2PN4dpNNtd9;R%j(%nS+NDAHj;Z zjHrlkHpQHroyMu^#Qd{9eWCkomBFbCyrqeT9lLCZB=o*SwUQvFd2zNcH)%jwtqVG+ zVY5b#K>!aEC5XjJiA3qAk&lepd;f{kK_@KUj$Jtab#MQ`+QG((27A;iW`{~Z5HoV> z`2L3IlIH*G_GH0K=$$*+@ORn=uDgwG4{ex2rnm;jef5adYZhUK@*^^9g}FTs1BFZ+ zilS`j)2U5UFpW9~STkr$kuhE>%y_;A8Fzch)F_J<#$Fc^9%tjDe;NpKYmprV)>DnA zv@Pbl@WJ-WQj3iBBHL+2WWWvSbgaEv5My1D)wrhpPZ<54kmZHDFNfTWBE7>Pc-=6f*-X8u^dB;lOs<7;>(vq~`D+je=D*XkpNFwr`|55GE*s%$KfQ)f<=Xe% z4xPIRB3a*sDqaigzXskErb`%ZBNhfpk<*I(!Z~u$iwsU zA~MzS&?9^qO2m6LUiZ>LT%};c z9EynmvXU?{MbiXCp>wkD?HI_`{tsJk9Tw%G_$}E zzUu-&9`}98>l=Wv;c6!|kY^5w2R9f(D*-2lZ?tb6=aHOgH>8!6Ezt1!euGV|j-_X5 z|NKj)k(Rzz8>vq{sj(NGfyj)6nw{YCu4Os%`vIGjL1a}&p3qfYdhd0X|*D9Ipo2edsOKOUymIhIzI4tXqX$@)P3h#7`B206Bfrvpxf%G~m1!&6WJbWwhu- z7?%6C!~0wF)&E^-RTEzVWv>HJ(r|U^0+SNj10VsGfSTH)s|e^bGOUu7Hx=b-R{)CA z)K}W|UuI0tl#(#iU=_vU!=yOxi%EdRf4>X9D7Rd3odg`wcKFbrF!}*}$C_;ELitqf z@464!kj*Zjn0M0;TulxDKv1Mf>XIAM*7O_E_v)mi8Lp{MP>ZiPzbveLW&q9iRnHQC zDX4r)^P*rxw_nrp88y(N6gD6p&piXScm37rcFQ06Hc~)p?_p=fY-pk}JLx`6@&RDC z)ksqQjUvTLT#TrrS8p5Lz*${eA3J2*WY0c`;aM~etbFSH|WbI6aeEWjLDf1;Z zp4H!=%wtYui$LS8KYT0!nLnyOK%Q_9L_Yl=Rs$Y9D5*1Vbc}RVx^n+~e*Lb5^8Itp zQoHA(TrD^KhtH6PRup-zmBlYo%>etlbxrd3xD)~(On@|VfT?-g0_81Y(Rt=OO<79A zOue##mQ?|2D{!zeKNff&%cn#v783xz)J8EVZ)>vX|G4wD?49bk)K}bpPh4`@8oISaq4Mc875#I{~JO zKZf=J2B!_c-Q=1|pynzn;j7qnOl8;gu(P~AeJ)UdGxDL{Ig70{(5ia>`72@H3wx~< zgD%MN=lK4Sd_;tuu#7yyfUOXTt>XQhvAdhcGOEr3>Q$mM0Ol1E*k;Oy_ z)O>{mfm8-8+lY>ARv&o*DvABOHOIdyg#XV! zK9(_nog@l4O)NEs0A20jYI~clLwale2!6`Dk0rvHO#9;l&Nu=R0wjM1_dSGqG%WRP z!%S$^jy}>~17)YtkQNdvvyy1duboEbyo$5c-w$l<@yj+$3M40=U(Ojwho; z3~VmEnExe0(2}CAh6XDGOm_uEZ9slum@Ht)~ETwgGoSA)MV7d+c3M`x`;(Gx@3D|jdXhm#~~*& zn&btei~SYP!?bBzCLRH@u6=1xNFDI0^=KxI33845suf-pX`|Fz-p8~~w z)#J8*4iZV@hsfTI*4Vg{QW{596fw(nOY8q=%MzcWaDFNWI@=O)(&t|P_phwT8F;|f9YmJm4~v}#DfK~zHWe+RSx_3=}VNKqv9 zq)}Yte^zZ@Oki*vw#c;ulCz|2i4hJclO&4*@SFT`t%U%sQMtu^&L`kU*ov~=VGG1l z2yzAF2A2MHKO6eAS*v1B1I;hzy}j|WDMkRr;>wE(c>h%uD$_epw~ko=d;(&7qLIt5CrD>wB*$;_DcosTJkUM(QOps04=DzyxgG#!HwT=*89X~)NLx-S&qWO(xke;pYsx}``RNT(`k-z2~rb2rQ zcLh|z?|!HNsof*df5t#^0JV$eC%W2afWrgW3@v;XbfW%a^*^35L2t1*fTC)v70^lj z`cvel&~McRM8$~}$DD=+`#B|P+T?xQ zLC%WPfH~QqW!cTF3E&-#^j3gw{>yNreHa9!NEtIViZg&-b2z}9spl)rzrjcWb(Nz> z*-B{UyGD=4oaLvTyIt#;Ra&z%Q!asSH$Xu0@EuB)bZ6Cru_ojtssBc*jI>MMQ~^wA z$fA`HE4f?ZzlLf^;*f_qkjIn(FzdJrfK}E4RCw;@(Z6~cf8T47zs3fYT%%JtR;$=-XNP>AS%4|s&VHYfi} z*O%xW5O|jfGe4z!fB}TpYZ&0Q>LYdHZu>6VKy(ChzGw;=g;nA{_fD6ek%Sijo8&jr zY#TLx@|#Kxz|Z3@WN8IpCM=#$@@FF3t}p<@XxAxfExAiOsTmG zscwNIhPwjS0Xr0n6zl-HTP@p8w zr1}yz2H>5~!9#zSiB37`WH4nt6j6~EZ<%fg6F}vw8#L8zd371S ze1m5vHtG%h%~|KRb@&?i;`+|Y(WzsSpoU5Q^}I}FT!?PR_4Lv>&_GMIcF+HNm;wk` z@ga9zZS4mC4)A_lr^)@MiATBRh5HY;>_dauW}Vz!fPME(bR$uw8GvY85y-Yu`^`ef z-NIom;xwRr`OBNbe@7oVMjj7QTCJ5zTMM3BnjiPWWalD1xeUPQPro_8K{@mu_4Ob% z`k>MAX*9`Y!a>Jw?@2#>*yS^sZgY;hrGZ}3|e*S zcnbBt)L;M3$8R_E-ZZULf*VWd**C!h@vDBdi`{pXH!J}#mZj_?zilx!YyZlBM;5qF z({sY#`1p{06U4P);Na^~PWzJ=$&TZ??BOO2=J(EgB*di83CXhyLk7our0K_7KI6z&h5 zweCoJvs7T9?#=n{3YBBvQC!_ItSj5gBdoam-=X{c7X3nI)#hQs(N)foFy=M%ZVBp+ z*blg?2thRXCOwHi5Ui)LZfg+42Aq%@=KQ*kb2){8|3KENC4faw z1BG?m|998@{fQd-#3%7k#2r*(zjOi5v#!*r9GO4Vw{~E1L&}^v@FAQ8+~>JrY?S5s zgX~uGImAHr;$@vNo%i>AZA#LzQx5jH2oDr$YW!!-RR&=GRy#t@#XZxP_SUDEDG}=i zB<7ZR|2t)c3M)Y8eWx9kT4AraZTx3-Cq%zW9~;8?tI{O^SX8Y&REJ|~0}}A2(YWAC ze8e&Sl7htb_~8Yxpls58{*E7&4VW8D+Q82{om5mj`AveBy$uTXubi9N#K?cvHvZbzF+&A}hP14H;tRB2=;`q;U(<4W3KP%*Rukc;kzdpOa zgChLlmk^2en+C)Mbmn&hA5-I7tn6>jx64O&%ZJ|t+ic+`z+cP@yncW_q&YLmC|SD>r(dNhoVEBhGuP*Hxn2EK(PxO)Uw>X8J#zQm;CM=Uo0|@yG@K`78~Vuv6OML+UMb_k9+y zA@B~w-4eU;N%Z)lF|g&c872*vVQFB7ao}1k_5$cCeKFqxRn`*CZ5Pc4AnXN91Z?Eq z)db8?VBC)3->GkZe%Jpq#ii3){50dx&g8~`Cg*rv3g1Uv0Y$&I9W$1*_&J1`{j2jC zRQ4N5d?M@fzap40;UzLAo}+F%`K?pj4bWGOHg8IKYduks?|jdZVSL$5n%2!5qKPP? zH^xrr1tnk}p$6p4H<`{fq;P~djLOG8K{wxJYhIdY>a!u(gQ!pvU z3WU;4+4ED&Vj(>EH&NqXi+_Nw^GjGyL~7}L6*FIV->*Gw&(?J+(Gfbi{ip|FLjgBV zi1M1e;5LYNBb#sdI%vcZxVEF>PYXVIt%xT2N&jt8=-k7EzNQ%7q$?`#@@*Z)n?42c zi3(@u%!S2of-eSIyBxPH1VNNatBsjV^(`(=hO3t}_dNkS)aTz79N68{95|5o-zL@B z*~37NCcR_x(e{{EvW{f17-oNaDuFmX1U7~4(aB}?r?xUtfIs0AUWjWlyB{K1s-9A+ zr#by{^PQcT+^XIiV3U*vJ@_?A3giSML`m~p;n|f7uKg01Aril-yf>0Ux{s#&j0*V} zj%NezX4}T*$d(V62v;$4$)DZ*RJ)axkczu;Uyklf>>fu)0Oj^UywF-?dCY8l*g)Pp6(=993j5<&=}c0FhcaX-23B!`p)RY*xwjVZqJZln ze=m%}%Rpo>))PY~BLYVD==U1A+E_sL{@bFPBE(tl1vU$aF0A0m4@$w7x#8>0)xmX_ z^8sIuUt8WON&&Z!fJF+jE$6*J?=RCB=WvO0EeY*AFovz%J;f1XJ>WLsZbomT5jo8* zqKm6|A=E=SiN-)6gDagvH<$%?H@yJ^Gb!#z%Ljje#H)eOxcsu=J>}Lb(V#H%ihe#i zW;2c}@w;6$PZ53J(#4x)cuqRWa(Y=Z??PD%n|97cZIL^W!JMu5rUi%r4A2%Jfv=$X z&SriXfVlDOxUlP}mm`z7bZstnyBvnz4jb>v>{zoA@7|r8AkM*2$t115!*<4#0fu_M zX24z;{eygb3}qQKAfawxof_UK{-YHAJ4IM03c8m7k(b`+4IRGsE6=-qlYr-37|hE3 z6wAlq#=ASpyLvYws$q^yXcqXuv1iY(jSYDkH{4WT(nXwe910%3g+g$C_W&u{% zFZ>1ZNii7l2DX4fXs-+Ik|IHzynD6U=eEMc?X5UEiZJin?D*(-N|1I~x81+|X|@a- zVz{{WR4l>4IHt8|cqW?2*Tkw6CbxbI^p6(?(OAj;@Y~&|Ma`ml2Z!8-d<=d7#7wX| z{5V3QHI|jn^t^*W&lTN^M+3lnqt{kF8d{93McJ!!ltG!t;W{}CqUU(t>T#Up#nU$l z3SPjNKz(1l7Q@%6Hp8a569-EhjYAE)V(sT%W49UsS(m71EJ2J88p;i?A=^X=d2AH* z?aCvylwCf)>H%D%UQQ?P!9#2CmbH(X4RwXi)NhpmYzQ)Jh~8&;D=W#cht-bm`*;)l zuJ3k{s6O@#fP4D0eC`;Qb|T6KU+*qCAugQYN=@&|UbX|P_FjuS>+7!ItA?LM1Tw0{ z#X-x!Z0?jt*@6fuumq9ZO!}9jLkuPnCONN2_Ek$ zfYu0?km=}Q)2P3rQ-*Wy&0^8bj)KH|QDGdkc_{ti@;AA#P6E`jIgb2j@@(xnvJ(PL zpY2WV0B?zmy0;MIQRxNp5um-jKSF@H`|7RjE($39tEm47qlP|74-7c3xYs`FD*1Dk z;DAVDVay?Qc#1lMux9Kbc(inP=y}9avAJ85b>2zc7AxEBb_KWz?#GMledp8}o#!qH-#WH2_PEp zDIaY$0>=<=CX1nN9e%an7=CraV{4)l%`(8mr_!1y+`VrMZ$3;)@U!5o>VW@hsN~k9 zbZyQ%(i<6Q9~^O?*PTlOEP!4Dz)yEk`nYletH&siCT`H3nU8eJb zm70n3M4-#Q&+q^;Nv|~<^k7r+&!c?2YMbm&Q=CJXYq;jQ5Jih7UhLZlu|H;a1y|79 z%z(*;7R95fnl=SVXui{`*jS zHQ|7K^g|5g`P#x-EMD)rB_K;WiU&GWVEx%foDWPfcej{!< zHNWrapi+5M9t91Zy#le%B zd4Be>nh_DZm~MXvjh-p`<*c4@M4eB|yWWD)N-qhZuD&TeJF~ow&}Q1T{>gF#`fzf1 z@N=rQtGdgJ*kN6c+egDmR*0>`99!YYD}Y>4;;yCRrlrjcD-3lx#&ow|4eSbM?|`vW znJcpA?@W?YcSeo{1?8XA+jtW6f#8f^zwp@=U%1$h>vh;kn-6BKjtAE&Ii&D-#}2uX zaWnMFwq|WH`G-33%dfob;weW$NNE%(ZXe{Ob<)i^Ku6WV8<`eTy>xCjdRUfCZbrp} zm^?%p9$v=1&o}&QK32oyVcVVE>vc9wgtP%nJ;;t2{*Q}S)>3Joo_KG;)O;qAeKKq^ z*orpVN!0)gNQn$U(9cqD0BvojT42@7ZxdoTN-$4(Pwwy z6)+LUs7p4hsoO{8=yT96cbe zHyAnpjb;og2hap4g>No_mf^NsmoHCBElHhklLh%#y51yRv_blT&>hH`9i84ARg&?& zD4rBcsdU`|dE+G(3VFuDmURhH%yW)+`m&-0&A63PuoiPUegqrwQ~M}C%^8Q7UrDvptfrESNNJv9A6ca z)|I0cVCIBB#P*Z_q?&WgkSY;}{cv#--F?6ASmFJAKc*ICa24-hX)=6twpV@-uKx?I zW585lX^xGJ6hpGNUBAq^;YQ4|hjnXi6ztJK;`P(KLSO#LKum<5F`cZ?Iu5mUEHn9& zwUT1}=Yeq=yC5WWBuQa5>Z=^DC*3 zE@C8cX^cl)H<;W_n;byk-jj)OiN^}&Df=Wj(p0k*?AwM*dpd0qumZ3wmAb-|V1bD` z=}-h`ei^m!8T^_Lv_kkObauk>>OjADs_Km04Vs%G4mEyZ@?+HHOVw$?i?~f|!6OQ% z+DSTY9Wq{H8XkJom7S=A1yQ+uWN7O@p(ucWFl16E__yoCH{+cDH$$PY{l`uDuN zS3uN!a-)P!=frBymo^W!C@c-HS2q=Vv?O1H!hikt_j?JlI+%0=UDNruzF^N6x*%H5 z`sRJlPJE7OB7O0Nb8T{+=ctHMS0a1;7+UjIXF1`1K>zL>*8yUN7YP{)5FToC6H8~g z8zj@o)~!ecFE+;2PNzq}1-CB8Nk86^Z6A+a2U^k}NY3p!*(1JiiXMyYJ%}LoPXGxW z-(Oe14e$_E>m9oz)2&5m{oJe?Uz2@uhQxH7A|oKCjW(_1^bYFYD^gZswVt=dGFP#6 zim-=n?CYaw)W?C#Jprt^r;EwP{%F*%+QuNtdkNEQrzqwnK61v~!-Mi$O?_T8e3*FX z^Oem`BWm*U)L%JHd^v5od+i;5rrT0?kM%_hw#aQ%RpNfsfi80u2XOX#j=!gMu0z9h zvs?=D5`j@}BwYe|@AdOY;z~PHGEFK)=0Qu1=1PL-Or9 z;QX4h(jztc9N|ze5}H;FKE)OxOuJuE9Qh>-NyZ^$K`j`ir(%t~_x{X?jSi%kcND*;2vTDes5 zn^3knkz}M}Wq6(6-jDS~V|J&ZCXr;tTQVgKqEO<>o&o}k&XjR9r3P9{D(dM^)aj7~ z@2;6G`G5U5BBCuZoZxK#%GbF;h*}#F_4PLLu@#J5+IDoxGy3T3CB1)lSeW%<4F5Mn zf7`)%*{3pv_zn+Y?NV4=0nW6wy|Hz&mC~3o<2{ijYI|&Qs6#A-U0_#)ts<}3#uP=?8%YpTm#7< z{G{V+%=6d&Gx6Cf>a1_smJRskBCPjO3YXcOHj9m}a%4nm0~~&RrM4Lycp5Lv?a;oK zxmQ*jM>X))`25L$oIy&llh7192AT}^tJjlm_QRo%(^5iO=b`#n!YN_*zw`|!@%I!`<)$7V*{U78 zbQ;~8`=trqG0J6~$lNK+hw_eI7J+Kb96I&IY2hFNDObBdE5m;ni+Gz`?q z$@OZ1{PuMbJF{%prbRzQYALL3Ypt2>H%ggCr?tbMrv$ppe8UQ+Oqrd}_j0BAI;65v z?nSRMpATSH#{wPah8=a5i>D5oXM-KLgLl6<@6rI;eujx&7gIpKO2xIQy`ZCTipi8H z6#xFA$rr!Gdu_29(r{_^z1GX0gyscy-m?k4U%7tO@xz8M9p6Iq7bm_BiaqHJ>Ebf_LbbmB zF-Je?{N6&E+KM>)Lu9U=FDT)k8NuEwr@?I*ovur(WIj)cZ4z6O+-884eWq;P7wB*Y zq{Z`b=Izc^ny1Jks=D+F5}tIp20~s`AEmX=34H;79}JBikP~KqWLavY5b%BUocb!f zcD)pf_MBzyy<#S#3}J(IMjq8Ka>sTm%Z2v+XI%3Yt{N8;8;jIAT}FtVv54=6(bc)oAC&*I^q&2u*RGb9)g$wN*8A>s)SwL^2iic_*|E zD_t+sL?UTiFDv}|K9cRL(x?BV7#$xk%HC|@VHnT>ZGo~7pUng4+NE>N}yId}V81dXS{GDI9 zwLi5Y(lGeUtsq7sZo-~$kvOs=niY3?98&6*l3Tx%$mLI7HqCy{yjSSza?pO?t*^(( z8B3Yu8LS(9l;O6Q-M=S}qKj9d_v1rZV&C7dQer<|g4b8umB zeV4$Gv!M$bfe~D}#P>B`^ARBfbcR|)%lvAtMReeV@dvJF#4?oKXy@~4|&@nzi@v^r*4~Qgd$v7o%$@`(0 zAVRx@Gd$Jcg~4)_@+~_Nrb{!d9SqSf>OW*_GpL@xez?cT_mn4*pZb+KWv_vo^j(#} z?~mg82&__@hCSgN!OJND5YBK^ibIysK85L4riM=PkJN1NGblP5bZYctzJb|5t0edg ztJf@|_Bon&U`I_)7C{;h-*Q3{kA@&atcL;^LXMWfz#}lFi&GcmESAS!OkW!-MlLK5-(Q)GPy6z;?@MBOJimMC3#7|j?w4hoN;(eQFIn)ScjkzY^ z8HbKUgce%Ym8u0CLj~)z$EtvOuKo0Ev7nO?C4XSPX9J2Jw4!UQmwzfbrnoQEAY&e_ zNrhsS@Z^YqJmo_p=BYF$pZtNQZ;CzHI31A*j~eq<@&$Ql6bjmI85?Ifri`jf3=j7< zHNp4zapTSY2lhM}l92cd%w*Ih- z(B3^`WveY)wef(F&n&^5yD_fsCwJ#JCedYS949J9$Dpj9=3j0fVNu*XvKvgJn8G`w z8>hiqsAmbr8H_Gnzvhempj7!;P;Gg1bE>xq=O7AB$|M=9#>^sPK3dS+K)I)+8QG(;V+fr= zch5-s3T5~?{w@E{{0pKiGQlZgzpKJWq46Y1DY4@UWE8P6y;VEVqUpBFUNGFZMR;q# zd?Dv{HmCNw~{SI?UB4urpGNVK2h%ZVnb1 zQtr^LGwK&|dc7D<8vH^LH5-bJ`rZs?Zo*BZwa>ltrh*vAL&d!`b878^t-C?h@%7vZ zeh}fk9EABM$sM95=e#VWdtQZ;rPmzP3cVWf#0YH*)E8xbD?fQH=9i)^!+cJd@hPh? z%MV~#bf0EEB8Wd#)lEqBaLQQTF}%(k9<2q*jcMDeO|)c#G89(vdn5B0F5iJlg|);AIqg_Koy<^;oXJ zH*zU;o7p7u)vg_XbQlKo@z?sg`Fb<8*m?(I?koR@K&*Q)INsfpITVRS+0C5n+N$}^ ze;-l@4Ma&r*8Z5k41FZXlCK==AyLl#$-1CpjH@;Y*#vVtkw11#Ja`z!p>86R8&t5l z_;7HLyp8W?lz7QzuD_cxRp6ORBla>Tvp%!1?a=vf+D|Q?xFdSLm>*Uw*buwg&QUj& zs9pmu4A!T^WG2xfxbMkXIVeATlOciQno7A)jjn;S*1@4MH!|D$9W<*yyWXdsqb4XM z<4GG!OLe0w8Ts^LKa`0|B8(q<%TTWn)8$6AtL~)}Psq%aX4hwi`7#*u8>Cw<}pwBBy4nor)(-o0L^&y%4h1`{!!aA`gYr5H?xhjhJc zq$8$DDbIP=xlcoVNmpj`@Tm)QPL?T@cmkBBYR2Z;orw|Bv*!_6?dqhNmBeylTHV_{ zlF4$S$WW+hNV?>txWrI94$Y{2Z)y&RryBAz_kgJS#- zD=e^rqv6^b4XaMM3{GBvR}kylZw20(P$^A;Gw)H6GtajFN+-@Mc=sz zm%Y=PS>8HI$hcrd0I`Q;Xds;TV=Mmo=0JA!T)QJPN_VWkiAdcYL0N1a%kE-1C`#03 z`GVwV)6GzIeqZlC?h}o;>7OuYH-B6hF#@zX_03wtJ6c>}u_;TLL#FGyQ>2|)1dL>T z9=u)5S(L?Miyz%w)JmpNdnXqf<(A3PxN$GuEliA!&c0W-QCbiaMt>KzS_ z7+}k(+Om@Ua-apmIZq0;d1c7#W%}WT4t#@fS?VUKs6LB1uBoXE0%PQkdCqeCZYooM z``G|D%z~Q7;XZU0yRfqsbYej)J};F*0T%P}fFGBKMx!UgLcz&T7$O=b6(#iOuY~9toY90MU>lK>F4sKhTZn@NGW^2wimvd(n zYB%e5E<$Hx+D)3L$;~BihWipuIlPG+Q|Bi=PGvJB(4euKnq4X^v@-djee zJT`afZ6VC@v*svsVNQu#rg*%q-xu}vNFirK*hVvF-nm0cUiA&3aCQSVlsr!gX5JhZ0{MVJ!L@n#W2%!a%duap(Bm_6=ex(KQF~V~!^1 z`4a7U4kd}=kzP*P*DU(sn6>v%*y@nvqK!K2uMezwPpl#Iuu_h$DCHwas0Srj9cO7 zfGJT`>+~3>cDEL7GS(OWPCff$i!9k^pIe(sGVW^rW~~J1kI$nZ0?M^4gV?+5iN3Ir&ol5d71&W*eHMMYklH{pIIc4c zC0sms1+j>hrm_dd9MrRt(^t%eG5S#rX!-GvjOVO%G+WcVbv-2gS$=O1ef7Hj*xq(O z$0^sPm)t*-P|rwX`GPI%yukHYi7zvujMA+JGy2Sc$M-+y=CCg+wv!X%1~rO?XJ{N~ zbzPl`OA&?D6HYA^hrNQ+Y&qwlrW2fw1=;#}Ox;~Cu9@85m2saQ0()bm0o50=sc2j< zSMw^y8kTdq0Z#N>;~6K>fj$}qMV-g{+iuRjMr-YU=a)A{8;h-pe};Q{v3YXuant4n z)u)_~cCFLwYIU!O8?0+Ti$wF!Xp>~9Fu%(=zSeL3A`%D+n0TqroMK&bfCF-1{D!UUgj{hX@*LLOq}rI=uZAwA)aZ@wCF$`~5obwS+pEIyzfu^LZyx zU$E3vyb1!=#*5|R(Hi$oz$#Q^Q!AaHIufzJ( zmYlt4NB2AgHf%nv*FUCiV!udE;dXFhOZkKumI5J)W+&^WmgwvJrP;pqWUu0$iG(s~ zMt{(jLyb_)ciDEyZasS6b`#yukLVT?a2Q^60R-*Si#|*r{Qh>p*OzCw^8+?TE*W& zWM7Jj)81HGg!9qRarPQIpr>6rn1A+}st>u}+$!QMI*3c zTWw>)s}`02AoGG#?PR2&{cStB+-K{La^z~UT`fg(4k~0LOg%-r6vwY`{6hp+N@B34Y68i1Jvg;DYpw2{N zxyee~pkhzhUSOR_8Aof8YS(iM2SQcvHPSkX_5Q@3uornAe)PVAh-dV>>iE+4zb^=d zTPx?o&q^xj1P4}c1;eBEBhgx$+Mk+~A6k5#I@+vs$f?!WiyP99fY+blrhu93Pq|UuBFM9H!^%zhdDXZ1}}A8gx|KXdUO)0JF%Gt|XC_ zvWikg`;3-6XUzU6wz!9u2-W0BYf*nbg`lUPjVZXmVjJ#I_vwB@tE6w|`X%EAXH14CJeWpjwxW0EOAA~k=j33pdOGbvMRsM|VP`u_<7Ox){eTnoYyb5^=K+)4-s9K_TyTc<`0@&Cd*7#4TkeAZ_>@+-s0^|F0a^Wkwoynv z!;fr#nSd|tn5ER+kzE-wB4!EPm2W;?sDAw#o0o-&%Q_g#DN_KgL}XTJz8xTNQd%*U z?jle#P6;^^Qp$9l*%q#qF*}3c38|;34+w8SeS5JQ_m!pvi31{BwGNjb;}i;pMqhu` z$FqExOY7~jlZ!cCfa}Oy+)lh<*d3=)YDzyeRqrJunph37V`sT*JW{`xrJ2e}glq7T#rT+{ zZhU#_rpu#DQ`OfATqkX&mj8IuN7yRGPZx5tBdb&#V$L#C!?|2zs9QqVKkBorYyN>#b4xWgyh(5UfqZFcf z{)vv#8@$;8xen9EC=UAmv&$<29^XTjwPt$RcTG+rs1Z(MTX3pI97^_f_qI)=M) zaZUeN8OqB3pF0rOrdaf|kiAk7PH~rYnSu=7(i;-cHQC7^X&4h4`6dVSnzJ_oZ`VdK zThnAi_a?&J(PTcSU1`n=Cbn60_wy@F!oH2}MER)mchdQAr+BL6WD}^zcZsb>GTr93 zW6*uk6%?(;I#9aD_vPXamrHJ=*itf0jA9@M4_8`<_r@oWDOB?h6wR+ln}@H1ebqiM z2syOLyaK&RFnjWQRf6gsQYR4IFgyBul-67+5!8VQlzc`*^pni^^OXPZ-APJVSW2nL zAr8B3jBDJ!P$@->2-F={50@_v}}k;DB?QV(v@nJFNC^o1dmwU=Qy;WGayH zk^P#zim%@=yw(B*3*%FVXq2?pGE&8r85SuavStp2V?9p2Pbo2~TvZD}Ig_I!gW_X{Z3Bv48-Hv~k{u7;|d%zIU;Td+jdDh$q#{-%AN+=5DErM>$ox+i{DWqIvV$aw~p8>skCK ze+y1ER9O>N2*jimq6thcXIy~Ra$c%+?*~|Y)rXOs;G}AS2Dk5qv{VPn5DoQ}`cM&q zc*%)^m=>;wk*`BJic6AI=yAi2y&4qdW>LuXlyh(@Im1@8Ap|7LK_VG+&wQ*|vwW+# zj%yp&GR;p+d6Y3s?SjK_@JKM8vraS-QJ%hLH=ssWzATSfB*O2~bFFQY_~3ACdiN~a z$_xjPYhgHKlTTn}I-{F$VBX<;NGCjSkL77eezg?cMHaGP;IHcAG*RO%vZ{EZ>|^x> z|JRV7(9okGDkm%A67R_KOC^)*3GhdWi<~YV^h$Fxk5e#f^EvN0%~ei6HuJFY!;IcN zG!B(FD+LnTq`jCI=|T}FW*P-VQsO9Oz7?(`VH{=wGVUCZRH#fDG(=gR{5xRa z@wGCtpBhD;_5Hgt+n#MZf0@DG+uJR7Ce5o!ycydq^WPaTC&}fX91_kvr-5qf8d&Co zl@0l%bVkGb7#$n>88e*68vzD+8YZLnTJ;AUIt38Ri=xO#7sf+kozIEsjl+{r_D6RR zJsP5uql>u$XPcoOeqpjG8?^x~n!=9HVWFAUnjhC0f7^snTwQ?>SY=7=bP%=#jx)9| z0HIcplEc&6a`?6I!~8U5O_|m7eRT@Q9J>Q)nx}WaK}THl_OViH1IgyC(~JYsnTtm; z317!m6%Bdi9j&u|b`TWoWFAL3h%vumkY!}0$O9ZV>Y+U?PnZd@SGgg}gb7#K{TF4# zjz=pJ--g{n4Rt0=2!M^}haVXi7wWv4TFyN;(C5ci*NOdo{LDJrT}Q%^ zKfP0dc9iue8>Qj9tZ2wr^%=w}p*Kh_Q+Je#x8aP-65dJ@9m60W8nHKSobaUA+fPI1 zdNi}44Lf0bEBkX);Kb$mJ=y?+JKa%JVf-#WWlf@Y-u;O0!s>RbpilKG>=F1_y zXHzoKQV>R>AKF6or?y8)40RT&F0riyXvYe z#|!?D_Xw3envy!<{xG+#hjxnT*+gNeK*v$wVJzrvz_f} z%so1-1L-wvH9U4bSsoKUBQn388xvhh9e@V_%fNfCn z8D>3>bEpgRix-EHg~50h6G>q?Xye>}o|>U!7-5&cW^;Y4> zsYNj;4wD`Wgz0R^%)R`WNwYpWX4}PTH+p=-;pxxUtb#9M({AJjLmo&;vTwW;&eEP^ zCB?v3Vy?BTYH_Nx*{}8ZjrTJh1BWC$ZAA!!^k_sWg{Re%AlxGxllUIlwG|UjV<*e} z)9eZLpoRHhh{QDdle^C*L32 z%@~?&vp6+(bi3x1g zwJYW<6|M!>Zy&6(BMsCD5m@8rk8f0xj5pJ;a!vbbZ&j6D&mM7HpV(z29D{$>a0GwP zDw4Zpx#e-mo!aJJ6K#2-a5ib~U)4Id7Z?H8%7LYTg@w-3VZ!Vbg}iIzKJ|v)zX!eC zjPR7^s$OhtU)@!~FJNHI$0y!R)axkFlXy>@XFLB7Rc{>?<@f#ZDxxBwfYRMHG)lm46yEUbCTSmjB-VsFLMQ&8Hyy-Stgm-amWQ7m4#}hji-dpRDl-7UKm5 zRj{WonYwuP{%%sFe&mbizkDS0(3-610oDp$IMJb+ca>fz!;&ElF=_G$m$lRM`x1-W z%q3H*smXn9KdGBCOuUe1%hUnLE9jZQ(tVop;0ZFJ%(P~nhw&&8vF8Fv*1K&*@UAJy#Gg?AXG)IhUF_GlSe!e8( zhSe;_E8#OWN#hz@chrA}&hOe;=9aYP@dw!UHiX{9t%cT_c*&&QdcZ-|NYzCw>-t$} zXZE{}uE7T(mC(9- z9&R`E)f&I&+@bbyqpayPu3`f590QlN-gpH{hBzkCH6dDF@AfdR#@0Ley`c{d(i$9+s-M0OCy-o?==mtfwf=6=}>hc>@m|fqF`XKbAts%{{{NW*;8^Nt% z4jR3eRS_R72d(gjWQ~JIO6dBAS?{GY*>}_zo@6HS;Cm+;?Q|O~eiU$e*XBgQ(N)E; zsc}abzS{ePHIX!qSEh$hO0HqgK4GXRtk5q^iU&f?=6$lmVr+&ZMJTS&;I>E23OTK^ z?-*$!+mmb9uBbD9fc;wo`iY+-5h2U5oY5hWIo>|8G9yBVoQ07K60dX4MFwz>WRgU< zNDiHN2S~PUuZwo^uL{fQhS^HY#nI+MY9=9MG<8YF86j)2RAo`K}(bHWEOQs`1 zeC3+u-a5mt_L5Iv!4sV1?@PA*TA=I);Y~Ar*5_GYoCk)<7@*p`Q{GP{GVO7yrYnx= zRCa24KG5A<4ZFg<)%b~A#xb@#_)}@c3|x=+Kq#|UjG-+MSIBKz{&!Ak>ka zdYRg$*Py=R;zFX})=v|D=m$A3WZ`eScB->>hSmrn-{+zZzld!Z4x(SLp_eb8W)^9F zaS|qV@tSzhN^liZ81%5KZ~C1b(({nJj56k5S2mw(%IXF6E8(tz^Y^FCVmS5&i{!lw zu_GK|k&?IX7JN|ZR!cO;OzRQw#O#5&wrce|X3AWtt?~6NeR5}srj@Eq-c>KW%7p}e z=nF~`RF0L7?Um!0ahUHuaM8=e6|~}LQ$-f}%m!aHmTQJ-7g{>zBn6F!<^f$;&5}}j z9LMqEA(w|_aDUjN)GC%ME z>#c3Iv12Ne@At}_A%^*vRxtBNP)i2=GqomGza2 z_2@SrSIgPn>(bA`N&Mw4-1|f_N7}2NjCA!bq3^tPRFL^Yellk>?xe+BZ(?vPpViZZ zJ1uH^KY0-6WA6Q3l}NE8HEaB8Ri0kQYH5{NLFOO_S(>WBWgLT_r>!vjX!vPJ=O($< zTk>DsxK*bMR{>?jYWQ%3ihMzsln6)ciGydR zf-~J&n1WwHSO-co{Uj?kcT%t>*HT+V8D42*Gpw8=>(FDOX z5Nf8s4VN!NbP{NWNxi%1sZ42}K1*P^&$fd=IGzoTH>^FO85Wp(hnnG2dVEs7uCX~w zzFUe@#!$~f%6-)*7MIM>nRSyxn0A-w{F%zm`9kY-LLL)DF7qRC!qfXM&o!Gg?ah6{ z3a#%Eu|qoLYY+Q$o62=#^%+a7uZY0VrNqziR3Vn>JxBZb;kUOK;CyLKgu#g|Vac*

    U(ccpmQ)fi# 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

    d+FIn_)PFB48p)Dn_oTS*N^#||84gLZ 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 literal 67283 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 G|9=79*V4BD diff --git a/examples/hsgp.py b/examples/hsgp.py index b24d25dc4..6c7684b05 100644 --- a/examples/hsgp.py +++ b/examples/hsgp.py @@ -5,7 +5,7 @@ Example: Hilbert space approximation for Gaussian processes. ============================================================ -This example replicates a few of the models in the excellent case +This example replicates the model in the excellent case study by Aki Vehtari [1] (originally written using R and Stan). The case study uses approximate Gaussian processes [2] to model the relative number of births per day in the US from 1969 to 1988. @@ -13,12 +13,27 @@ processes because it circumvents the need for inverting the covariance matrix. -The original case study presented by Aki also emphasizes the iterative +The original case study also emphasizes the iterative process of building a Bayesian model, which is excellent as a pedagogical -resource. Here, however, we replicate only 4 out of all the models available in [1]. +resource. Here, however, we replicate only the model that includes all +components (long term trend, smooth year seasonality, slowly varying day of week effect, +day of the year effect and special floating days effects). + +The different components of the model are isolated into separate functions +so that they can easily be reused in different contexts. To combine the +multiple components into a single birthdays model, here we make use of Numpyro's +`scope` handler which modifies the site names of the components by adding +a prefix to them. By doing this, we avoid duplication of site names +within the model. Following this pattern, it is straightforward to construct the +other models in [1] with the code provided here. + There are a few minor differences in the mathematical details of our models, -which we had to make in order for the chains to mix properly. We have clearly -commented on the places where our models are different. +which we had to make for the chains to mix properly or for ease of +implementation. We have commented on the places where our models are different. + +The periodic kernel approximation requires tensorflow-probability on a jax backend. +See +for installation instructions. **References:** 1. Gelman, Vehtari, Simpson, et al (2020), `"Bayesian workflow book - Birthdays" @@ -32,12 +47,9 @@ """ import argparse -import functools -import operator import os import matplotlib.pyplot as plt -import numpy as np import pandas as pd import jax @@ -47,64 +59,106 @@ import numpyro from numpyro import deterministic, plate, sample import numpyro.distributions as dist -from numpyro.infer import MCMC, NUTS +from numpyro.handlers import scope +from numpyro.infer import MCMC, NUTS, init_to_median -# --- utility functions -def load_data(): - URL = "https://raw.githubusercontent.com/avehtari/casestudies/master/Birthdays/data/births_usa_1969.csv" - data = pd.read_csv(URL, sep=",") - day0 = pd.to_datetime("31-Dec-1968") - dates = [day0 + pd.Timedelta(f"{i}d") for i in data["id"]] - data["date"] = dates - data["births_relative"] = data["births"] / data["births"].mean() - return data +# --- Data processing functions +def get_labour_days(dates): + """ + First monday of September + """ + is_september = dates.dt.month.eq(9) + is_monday = dates.dt.weekday.eq(0) + is_first_week = dates.dt.day.le(7) + + is_labour_day = is_september & is_monday & is_first_week + is_day_after = is_labour_day.shift(fill_value=False) + + return is_labour_day | is_day_after -def save_samples(out_path, samples): +def get_memorial_days(dates): """ - Save dictionary of arrays using numpys compressed binary format - Fast reading and writing and efficient storage + Last monday of May """ - np.savez_compressed(out_path, **samples) + is_may = dates.dt.month.eq(5) + is_monday = dates.dt.weekday.eq(0) + is_last_week = dates.dt.day.ge(25) + is_memorial_day = is_may & is_monday & is_last_week + is_day_after = is_memorial_day.shift(fill_value=False) -class UnivariateScaler: + return is_memorial_day | is_day_after + + +def get_thanksgiving_days(dates): """ - Standardizes the data to have mean 0 and unit standard deviation. + Third thursday of November """ + is_november = dates.dt.month.eq(11) + is_thursday = dates.dt.weekday.eq(3) + is_third_week = dates.dt.day.between(22, 28) - def __init__(self): - self._mean = None - self._std = None + is_thanksgiving = is_november & is_thursday & is_third_week + is_day_after = is_thanksgiving.shift(fill_value=False) - def fit(self, x): - self._mean = np.mean(x) - self._std = np.std(x) - return self + return is_thanksgiving | is_day_after - def transform(self, x): - return (x - self._mean) / self._std - def inverse_transform(self, x): - return x * self._std + self._mean +def get_floating_days_indicators(dates): + def encode(x): + return jnp.array(x.values, dtype=jnp.int64) + return { + "labour_days_indicator": encode(get_labour_days(dates)), + "memorial_days_indicator": encode(get_memorial_days(dates)), + "thanksgiving_days_indicator": encode(get_thanksgiving_days(dates)), + } -def _agg(*args, scaler=None): - """ - Custom function for aggregating the samples - and transforming back to the desired scale. - """ - total = functools.reduce(operator.add, args) - return (100 * scaler.inverse_transform(total)).mean(axis=0) - -# --- modelling functions -def modified_bessel_first_kind(v, z): - v = jnp.asarray(v, dtype=float) - return jnp.exp(jnp.abs(z)) * tfp.math.bessel_ive(v, z) +def load_data(): + URL = "https://raw.githubusercontent.com/avehtari/casestudies/master/Birthdays/data/births_usa_1969.csv" + data = pd.read_csv(URL, sep=",") + day0 = pd.to_datetime("31-Dec-1968") + dates = [day0 + pd.Timedelta(f"{i}d") for i in data["id"]] + data["date"] = dates + data["births_relative"] = data["births"] / data["births"].mean() + return data +def make_birthdays_data_dict(data): + x = data["id"].values + y = data["births_relative"].values + dates = data["date"] + + xsd = jnp.array((x - x.mean()) / x.std()) + ysd = jnp.array((y - y.mean()) / y.std()) + day_of_week = jnp.array((data["day_of_week"] - 1).values) + day_of_year = jnp.array((data["day_of_year"] - 1).values) + floating_days = get_floating_days_indicators(dates) + period = 365.25 + w0 = x.std() * (jnp.pi * 2 / period) + L = 1.5 * max(xsd) + M1 = 10 + M2 = 10 # 20 in original case study + M3 = 5 + + return { + "x": xsd, + "day_of_week": day_of_week, + "day_of_year": day_of_year, + "w0": w0, + "L": L, + "M1": M1, + "M2": M2, + "M3": M3, + **floating_days, + "y": ysd, + } + + +# --- Modelling utility functions --- # def spectral_density(w, alpha, length): c = alpha * jnp.sqrt(2 * jnp.pi) * length e = jnp.exp(-0.5 * (length ** 2) * (w ** 2)) @@ -112,12 +166,11 @@ def spectral_density(w, alpha, length): def diag_spectral_density(alpha, length, L, M): - """spd for squared exponential kernel""" sqrt_eigenvalues = jnp.arange(1, 1 + M) * jnp.pi / 2 / L return spectral_density(sqrt_eigenvalues, alpha, length) -def phi(x, L, M): +def eigenfunctions(x, L, M): """ The first `M` eigenfunctions of the laplacian operator in `[-L, L]` evaluated at `x`. These are used for the approximation of the @@ -130,538 +183,354 @@ def phi(x, L, M): return num / den +def modified_bessel_first_kind(v, z): + v = jnp.asarray(v, dtype=float) + return jnp.exp(jnp.abs(z)) * tfp.math.bessel_ive(v, z) + + def diag_spectral_density_periodic(alpha, length, M): """ Not actually a spectral density but these are used in the same - way. These are simply the first `M` coefficients of the Taylor - expansion approximation for the periodic kernel. + way. These are simply the first `M` coefficients of the low rank + approximation for the periodic kernel. """ a = length ** (-2) - J = jnp.arange(1, M + 1) - q2 = (2 * alpha ** 2 / jnp.exp(a)) * modified_bessel_first_kind(J, a) + J = jnp.arange(0, M) + c = jnp.where(J > 0, 2, 1) + q2 = (c * alpha ** 2 / jnp.exp(a)) * modified_bessel_first_kind(J, a) return q2 -def phi_periodic(x, w0, M): +def eigenfunctions_periodic(x, w0, M): """ Basis functions for the approximation of the periodic kernel. """ m1 = jnp.tile(w0 * x[:, None], M) - m2 = jnp.diag(jnp.linspace(1, M, num=M)) + m2 = jnp.diag(jnp.arange(M, dtype=jnp.float32)) mw0x = m1 @ m2 - return jnp.cos(mw0x), jnp.sin(mw0x) + cosines = jnp.cos(mw0x) + sines = jnp.sin(mw0x) + return cosines, sines -# --- models -class GP1: +# --- Approximate Gaussian processes --- # +def approx_se_ncp(x, alpha, length, L, M): """ - Long term trend Gaussian process + Hilbert space approximation for the squared + exponential kernel in the non-centered parametrisation. """ + phi = eigenfunctions(x, L, M) + spd = jnp.sqrt(diag_spectral_density(alpha, length, L, M)) + with plate("basis", M): + beta = sample("beta", dist.Normal(0, 1)) - def __init__(self): - self.x_scaler = UnivariateScaler() - self.y_scaler = UnivariateScaler() - - def model(self, x, L, M, y=None): - # intercept - intercept = sample("intercept", dist.Normal(0, 1)) - - # long term trend - ρ = sample("ρ", dist.LogNormal(-1.0, 1.0)) - α = sample("α", dist.HalfNormal(1.0)) - eigenfunctions = phi(x, L, M) - spd = jnp.sqrt(diag_spectral_density(α, ρ, L, M)) - - with plate("basis1", M): - β1 = sample("β1", dist.Normal(0, 1)) - - f1 = deterministic("f1", eigenfunctions @ (spd * β1)) - μ = deterministic("μ", intercept + f1) - σ = sample("σ", dist.HalfNormal(0.5)) - with plate("n_obs", x.shape[0]): - sample("y", dist.Normal(μ, σ), obs=y) - - def get_data(self): - data = load_data() - x = data["id"].values - y = data["births_relative"].values - self.x_scaler.fit(x) - self.y_scaler.fit(y) - xsd = jnp.array(self.x_scaler.transform(x)) - ysd = jnp.array(self.y_scaler.transform(y)) - return dict( - x=xsd, - y=ysd, - L=1.5 * max(xsd), - M=10, - ) - - def make_figure(self, samples): - data = load_data() - dates = data["date"] - y = 100 * data["births_relative"] - μ = 100 * self.y_scaler.inverse_transform(samples["μ"]).mean(axis=0) - - f = plt.figure(figsize=(15, 5)) - plt.axhline(100, color="k", lw=1, alpha=0.8) - plt.plot(dates, y, marker=".", lw=0, alpha=0.3) - plt.plot(dates, μ, color="r", lw=2) - plt.ylabel("Relative number of births") - plt.xlabel("") - return f - - -class GP2: - """ - Long term trend with year seasonality component. - """ + f = deterministic("f", phi @ (spd * beta)) + return f - def __init__(self): - self.x_scaler = UnivariateScaler() - self.y_scaler = UnivariateScaler() - - def model(self, x, w0, J, L, M, y=None): - intercept = sample("intercept", dist.Normal(0, 1)) - - # long term trend - ρ1 = sample("ρ1", dist.LogNormal(-1.0, 1.0)) - α1 = sample("α1", dist.HalfNormal(1.0)) - eigenfunctions = phi(x, L, M) - spd = jnp.sqrt(diag_spectral_density(α1, ρ1, L, M)) - with plate("basis", M): - β1 = sample("β1", dist.Normal(0, 1)) - - # year-periodic component - ρ2 = sample("ρ2", dist.HalfNormal(0.1)) - α2 = sample("α2", dist.HalfNormal(1.0)) - cosines, sines = phi_periodic(x, w0, J) - spd_periodic = jnp.sqrt(diag_spectral_density_periodic(α2, ρ2, J)) - with plate("periodic_basis", J): - β2_cos = sample("β2_cos", dist.Normal(0, 1)) - β2_sin = sample("β2_sin", dist.Normal(0, 1)) - - f1 = deterministic("f1", eigenfunctions @ (spd * β1)) - f2 = deterministic( - "f2", cosines @ (spd_periodic * β2_cos) + sines @ (spd_periodic * β2_sin) - ) - μ = deterministic("μ", intercept + f1 + f2) - σ = sample("σ", dist.HalfNormal(0.5)) - with plate("n_obs", x.shape[0]): - sample("y", dist.Normal(μ, σ), obs=y) - - def get_data(self): - data = load_data() - x = data["id"].values - y = data["births_relative"].values - self.x_scaler.fit(x) - self.y_scaler.fit(y) - xsd = jnp.array(self.x_scaler.transform(x)) - ysd = jnp.array(self.y_scaler.transform(y)) - w0 = 2 * jnp.pi / (365.25 / self.x_scaler._std) - return dict( - x=xsd, - y=ysd, - w0=w0, - J=20, - L=1.5 * max(xsd), - M=10, - ) - - def make_figure(self, samples): - data = load_data() - dates = data["date"] - y = 100 * data["births_relative"] - y_by_day_of_year = 100 * data.groupby("day_of_year2")["births_relative"].mean() - μ = 100 * self.y_scaler.inverse_transform(samples["μ"]).mean(axis=0) - f1 = 100 * self.y_scaler.inverse_transform(samples["f1"]).mean(axis=0) - f2 = 100 * self.y_scaler.inverse_transform(samples["f2"]).mean(axis=0) - - fig, axes = plt.subplots(1, 2, figsize=(15, 5)) - axes[0].plot(dates, y, marker=".", lw=0, alpha=0.3) - axes[0].plot(dates, μ, color="r", lw=2, alpha=1, label="Total") - axes[0].plot(dates, f1, color="C2", lw=3, alpha=1, label="Trend") - - axes[0].set_ylabel("Relative number of births") - axes[0].set_title("All time") - - axes[1].plot( - y_by_day_of_year.index, y_by_day_of_year, marker=".", lw=0, alpha=0.5 - ) - axes[1].plot( - y_by_day_of_year.index, f2[:366], color="r", lw=2, label="Year seaonality" - ) - axes[1].set_ylabel("Relative number of births") - axes[1].set_xlabel("Day of year") - for ax in axes: - ax.axhline(100, color="k", lw=1, alpha=0.8) - ax.legend() - - return fig - - -class GP3: - """ - Long term trend with yearly seasonaly and slowly varying day-of-week effect. - """ - def __init__(self): - self.x_scaler = UnivariateScaler() - self.y_scaler = UnivariateScaler() - - def model(self, x, day_of_week, w0, J, L, M, L3, M3, y=None): - intercept = sample("intercept", dist.Normal(0, 1)) - - # long term trend - ρ1 = sample("ρ1", dist.LogNormal(-1.0, 1.0)) - α1 = sample("α1", dist.HalfNormal(1.0)) - eigenfunctions = phi(x, L, M) - spd = jnp.sqrt(diag_spectral_density(α1, ρ1, L, M)) - with plate("basis", M): - β1 = sample("β1", dist.Normal(0, 1)) - - # year-periodic component - ρ2 = sample("ρ2", dist.HalfNormal(0.1)) - α2 = sample("α2", dist.HalfNormal(1.0)) - cosines, sines = phi_periodic(x, w0, J) - spd_periodic = jnp.sqrt(diag_spectral_density_periodic(α2, ρ2, J)) - with plate("periodic_basis", J): - β2_cos = sample("β2_cos", dist.Normal(0, 1)) - β2_sin = sample("β2_sin", dist.Normal(0, 1)) - - # day of week effect - with plate("plate_day_of_week", 6): - β_week = sample("β_week", dist.Normal(0, 1)) - # next enforce sum-to-zero -- this is slightly different from Aki's model, - # which instead imposes Monday's effect to be zero. - β_week = jnp.concatenate([jnp.array([-jnp.sum(β_week)]), β_week]) - - # long term variation of week effect - α3 = sample("α3", dist.HalfNormal(0.1)) - ρ3 = sample("ρ3", dist.LogNormal(1.0, 1.0)) # prior: very long-term effect - eigenfunctions_3 = phi(x, L3, M3) - spd_3 = jnp.sqrt(diag_spectral_density(α3, ρ3, L3, M3)) - with plate("week_trend", M3): - β3 = sample("β3", dist.Normal(0, 1)) - - # combine - f1 = deterministic("f1", eigenfunctions @ (spd * β1)) - f2 = deterministic( - "f2", cosines @ (spd_periodic * β2_cos) + sines @ (spd_periodic * β2_sin) - ) - g3 = deterministic("g3", eigenfunctions_3 @ (spd_3 * β3)) - μ = deterministic("μ", intercept + f1 + f2 + jnp.exp(g3) * β_week[day_of_week]) - σ = sample("σ", dist.HalfNormal(0.5)) - with plate("n_obs", x.shape[0]): - sample("y", dist.Normal(μ, σ), obs=y) - - def get_data(self): - data = load_data() - x = data["id"].values - y = data["births_relative"].values - self.x_scaler.fit(x) - self.y_scaler.fit(y) - xsd = jnp.array(self.x_scaler.transform(x)) - ysd = jnp.array(self.y_scaler.transform(y)) - w0 = 2 * jnp.pi / (365.25 / self.x_scaler._std) - dow = jnp.array(data["day_of_week"].values) - 1 - return dict( - x=xsd, - day_of_week=dow, - w0=w0, - J=20, - L=1.5 * max(xsd), - M=10, - L3=1.5 * max(xsd), - M3=5, - y=ysd, - ) - - def make_figure(self, samples): - data = load_data() - dates = data["date"] - y = 100 * data["births_relative"] - y_by_day_of_year = 100 * ( - data.groupby("day_of_year2")["births_relative"].mean() - ) - year_days = y_by_day_of_year.index.values - - μ = samples["μ"] - intercept = samples["intercept"][:, None] - f1 = samples["f1"] - f2 = samples["f2"] - g3 = samples["g3"] - β_week = samples["β_week"] - β_week = np.concatenate([-β_week.sum(axis=1)[:, None], β_week], axis=1) - - fig, axes = plt.subplots(2, 2, figsize=(15, 8), sharey=False, sharex=False) - axes[0, 0].plot(dates, y, marker=".", lw=0, alpha=0.3) - axes[0, 0].plot( - dates, - _agg(μ, scaler=self.y_scaler), - color="r", - lw=0, - label="Total", - marker=".", - alpha=0.5, - ) - axes[0, 1].plot(dates, y, marker=".", lw=0, alpha=0.3) - axes[0, 1].plot( - dates, _agg(f1, scaler=self.y_scaler), color="r", lw=2, label="Trend" - ) - axes[1, 0].plot(year_days, y_by_day_of_year, marker=".", lw=0, alpha=0.3) - axes[1, 0].plot( - year_days, - _agg(f2[:, :366], scaler=self.y_scaler), - color="r", - lw=2, - label="Year seasonality", - ) - axes[1, 1].plot(dates, y, marker=".", lw=0, alpha=0.3) - for day in range(7): - dow_trend = (jnp.exp(g3).T * β_week[:, day]).T - fit = _agg(intercept, f1, dow_trend, scaler=self.y_scaler) - axes[1, 1].plot(dates, fit, lw=2, color="r") - - axes[0, 0].set_title("Total") - axes[0, 1].set_title("Long term trend") - axes[1, 0].set_title("Year seasonality") - axes[1, 1].set_title("Weekly effects with long term trend") - for ax in axes.flatten(): - ax.axhline(100, color="k", lw=1, alpha=0.8) - ax.legend() - - return fig - - -class GP4: +def approx_periodic_gp_ncp(x, alpha, length, w0, M): """ - Long term trend with yearly seasonaly, slowly varying day-of-week effect, - and special day effect including floating special days. + Low rank approximation for the periodic squared + exponential kernel in the non-centered parametrisation. """ + q2 = diag_spectral_density_periodic(alpha, length, M) + cosines, sines = eigenfunctions_periodic(x, w0, M) + + with plate("cos_basis", M): + beta_cos = sample("beta_cos", dist.Normal(0, 1)) + + with plate("sin_basis", M - 1): + beta_sin = sample("beta_sin", dist.Normal(0, 1)) + + # The first eigenfunction for the sine component + # is zero, so the first parameter wouldn't contribute to the approximation. + # We set it to zero to identify the model and avoid divergences. + zero = jnp.array([0.0]) + beta_sin = jnp.concatenate((zero, beta_sin)) + + f = deterministic("f", cosines @ (q2 * beta_cos) + sines @ (q2 * beta_sin)) + return f + + +# --- Components of the Birthdays model --- # +def trend_gp(x, L, M): + alpha = sample("alpha", dist.HalfNormal(1.0)) + length = sample("length", dist.InverseGamma(10.0, 2.0)) + f = approx_se_ncp(x, alpha, length, L, M) + return f + + +def year_gp(x, w0, M): + alpha = sample("alpha", dist.HalfNormal(1.0)) + length = sample("length", dist.HalfNormal(0.2)) # scale=0.1 in original + f = approx_periodic_gp_ncp(x, alpha, length, w0, M) + return f + + +def weekday_effect(day_of_week): + with plate("plate_day_of_week", 6): + weekday = sample("_beta", dist.Normal(0, 1)) + + monday = jnp.array([-jnp.sum(weekday)]) # Monday = 0 in original + beta = deterministic("beta", jnp.concatenate((monday, weekday))) + return beta[day_of_week] + + +def yearday_effect(day_of_year): + slab_df = 50 # 100 in original case study + slab_scale = 2 + scale_global = 0.1 + tau = sample( + "tau", dist.HalfNormal(2 * scale_global) + ) # Orignial uses half-t with 100df + c_aux = sample("c_aux", dist.InverseGamma(0.5 * slab_df, 0.5 * slab_df)) + c = slab_scale * jnp.sqrt(c_aux) + + # Jan 1st: Day 0 + # Feb 29th: Day 59 + # Dec 31st: Day 365 + with plate("plate_day_of_year", 366): + lam = sample("lam", dist.HalfCauchy(scale=1)) + lam_tilde = jnp.sqrt(c) * lam / jnp.sqrt(c + (tau * lam) ** 2) + beta = sample("beta", dist.Normal(loc=0, scale=tau * lam_tilde)) + + return beta[day_of_year] + + +def special_effect(indicator): + beta = sample("beta", dist.Normal(0, 1)) + return beta * indicator + + +# --- Model --- # +def birthdays_model( + x, + day_of_week, + day_of_year, + memorial_days_indicator, + labour_days_indicator, + thanksgiving_days_indicator, + w0, + L, + M1, + M2, + M3, + y=None, +): + intercept = sample("intercept", dist.Normal(0, 1)) + f1 = scope(trend_gp, "trend")(x, L, M1) + f2 = scope(year_gp, "year")(x, w0, M2) + g3 = scope(trend_gp, "week-trend")( + x, L, M3 + ) # length ~ lognormal(-1, 1) in original + weekday = scope(weekday_effect, "week")(day_of_week) + yearday = scope(yearday_effect, "day")(day_of_year) + + # # --- special days + memorial = scope(special_effect, "memorial")(memorial_days_indicator) + labour = scope(special_effect, "labour")(labour_days_indicator) + thanksgiving = scope(special_effect, "thanksgiving")(thanksgiving_days_indicator) + + day = yearday + memorial + labour + thanksgiving + # --- Combine components + f = deterministic("f", intercept + f1 + f2 + jnp.exp(g3) * weekday + day) + sigma = sample("sigma", dist.HalfNormal(0.5)) + with plate("obs", x.shape[0]): + sample("y", dist.Normal(f, sigma), obs=y) + + +# --- plotting function --- # +DATA_STYLE = dict(marker=".", alpha=0.8, lw=0, label="data", c="lightgray") +MODEL_STYLE = dict(lw=2, color="k") + + +def plot_trend(data, samples, ax=None): + y = data["births_relative"] + x = data["date"] + fsd = samples["intercept"][:, None] + samples["trend/f"] + f = jnp.quantile(fsd * y.std() + y.mean(), 0.50, axis=0) + + if ax is None: + ax = plt.gca() + + ax.plot(x, y, **DATA_STYLE) + ax.plot(x, f, **MODEL_STYLE) + return ax + + +def plot_seasonality(data, samples, ax=None): + y = data["births_relative"] + sdev = y.std() + mean = y.mean() + baseline = (samples["intercept"][:, None] + samples["trend/f"]) * sdev + y_detrended = y - baseline.mean(0) + y_year_mean = y_detrended.groupby(data["day_of_year"]).mean() + x = y_year_mean.index + + f_median = ( + pd.DataFrame(samples["year/f"] * sdev + mean, columns=data["day_of_year"]) + .melt(var_name="day_of_year") + .groupby("day_of_year")["value"] + .median() + ) - def __init__(self): - self.x_scaler = UnivariateScaler() - self.y_scaler = UnivariateScaler() - - def model( - self, - x, - day_of_week, - day_of_year, - memorial_days_indicator, - labour_days_indicator, - thanksgiving_days_indicator, - w0, - J, - L, - M, - L3, - M3, - y=None, - ): - intercept = sample("intercept", dist.Normal(0, 1)) - - # long term trend - ρ1 = sample("ρ1", dist.LogNormal(-1.0, 1.0)) - α1 = sample("α1", dist.HalfNormal(1.0)) - eigenfunctions = phi(x, L, M) - spd = jnp.sqrt(diag_spectral_density(α1, ρ1, L, M)) - with plate("basis", M): - β1 = sample("β1", dist.Normal(0, 1)) - - # year-periodic component - ρ2 = sample("ρ2", dist.HalfNormal(0.1)) - α2 = sample("α2", dist.HalfNormal(1.0)) - cosines, sines = phi_periodic(x, w0, J) - spd_periodic = jnp.sqrt(diag_spectral_density_periodic(α2, ρ2, J)) - with plate("periodic_basis", J): - β2_cos = sample("β2_cos", dist.Normal(0, 1)) - β2_sin = sample("β2_sin", dist.Normal(0, 1)) - - # day of week effect - with plate("plate_day_of_week", 6): - β_week = sample("β_week", dist.Normal(0, 1)) - # next enforce sum-to-zero -- this is slightly different from Aki's model, - # which instead imposes Monday's effect to be zero. - β_week = jnp.concatenate([jnp.array([-jnp.sum(β_week)]), β_week]) - - # long term separation of week effects - ρ3 = sample("ρ3", dist.LogNormal(1.0, 1.0)) - α3 = sample("α3", dist.HalfNormal(0.1)) - eigenfunctions_3 = phi(x, L3, M3) - spd_3 = jnp.sqrt(diag_spectral_density(α3, ρ3, L3, M3)) - with plate("week_trend", M3): - β3 = sample("β3", dist.Normal(0, 1)) - - # Finnish horseshoe prior on day of year effect - # Aki uses slab_df=100 instead, but chains didn't mix - # in our case for some reason, so we lowered it to 50. - slab_scale = 2 - slab_df = 50 - scale_global = 0.1 - τ = sample("τ", dist.HalfCauchy(scale=scale_global * 2)) - c_aux = sample("c_aux", dist.InverseGamma(0.5 * slab_df, 0.5 * slab_df)) - c = slab_scale * jnp.sqrt(c_aux) - with plate("plate_day_of_year", 366): - λ = sample("λ", dist.HalfCauchy(scale=1)) - λ_tilde = jnp.sqrt(c) * λ / jnp.sqrt(c + (τ * λ) ** 2) - β4 = sample("β4", dist.Normal(loc=0, scale=τ * λ_tilde)) - - # floating special days - β5_labour = sample("β5_labour", dist.Normal(0, 1)) - β5_memorial = sample("β5_memorial", dist.Normal(0, 1)) - β5_thanksgiving = sample("β5_thanksgiving", dist.Normal(0, 1)) - - # combine - f1 = deterministic("f1", eigenfunctions @ (spd * β1)) - f2 = deterministic( - "f2", cosines @ (spd_periodic * β2_cos) + sines @ (spd_periodic * β2_sin) - ) - g3 = deterministic("g3", eigenfunctions_3 @ (spd_3 * β3)) - μ = deterministic( - "μ", - intercept - + f1 - + f2 - + jnp.exp(g3) * β_week[day_of_week] - + β4[day_of_year] - + β5_labour * labour_days_indicator - + β5_memorial * memorial_days_indicator - + β5_thanksgiving * thanksgiving_days_indicator, - ) - σ = sample("σ", dist.HalfNormal(0.5)) - with plate("n_obs", x.shape[0]): - sample("y", dist.Normal(μ, σ), obs=y) - - def _get_floating_days(self, data): - x = data["id"].values - memorial_days = data.loc[ - data["date"].dt.month.eq(5) - & data["date"].dt.weekday.eq(0) - & data["date"].dt.day.ge(25), - "id", - ].values - - labour_days = data.loc[ - data["date"].dt.month.eq(9) - & data["date"].dt.weekday.eq(0) - & data["date"].dt.day.le(7), - "id", - ].values - labour_days = np.concatenate((labour_days, labour_days + 1)) - - thanksgiving_days = data.loc[ - data["date"].dt.month.eq(11) - & data["date"].dt.weekday.eq(3) - & data["date"].dt.day.ge(22) - & data["date"].dt.day.le(28), - "id", - ].values - thanksgiving_days = np.concatenate((thanksgiving_days, thanksgiving_days + 1)) - - md_indicators = np.zeros_like(x) - md_indicators[memorial_days - 1] = 1 - ld_indicators = np.zeros_like(x) - ld_indicators[labour_days - 1] = 1 - td_indicators = np.zeros_like(x) - td_indicators[thanksgiving_days - 1] = 1 - return { - "memorial_days_indicator": md_indicators, - "labour_days_indicator": ld_indicators, - "thanksgiving_days_indicator": td_indicators, - } - - def get_data(self): - data = load_data() - x = data["id"].values - y = data["births_relative"].values - self.x_scaler.fit(x) - self.y_scaler.fit(y) - xsd = jnp.array(self.x_scaler.transform(x)) - ysd = jnp.array(self.y_scaler.transform(y)) - w0 = 2 * jnp.pi / (365.25 / self.x_scaler._std) - dow = jnp.array(data["day_of_week"].values) - 1 - doy = jnp.array((data["day_of_year2"] - 1).values) - return dict( - x=xsd, - day_of_week=dow, - day_of_year=doy, - w0=w0, - J=20, - L=1.5 * max(xsd), - M=10, - L3=1.5 * max(xsd), - M3=5, - y=ysd, - **self._get_floating_days(data), - ) - - def make_figure(self, samples): - special_days = { - "Valentine's": pd.to_datetime("1988-02-14"), - "Leap day": pd.to_datetime("1988-02-29"), - "Halloween": pd.to_datetime("1988-10-31"), - "Christmas eve": pd.to_datetime("1988-12-24"), - "Christmas day": pd.to_datetime("1988-12-25"), - "New year": pd.to_datetime("1988-01-01"), - "New year's eve": pd.to_datetime("1988-12-31"), - "April 1st": pd.to_datetime("1988-04-01"), - "Independence day": pd.to_datetime("1988-07-04"), - "Labour day": pd.to_datetime("1988-09-05"), - "Memorial day": pd.to_datetime("1988-05-30"), - "Thanksgiving": pd.to_datetime("1988-11-24"), - } - β4 = samples["β4"] - β5_labour = samples["β5_labour"] - β5_memorial = samples["β5_memorial"] - β5_thanksgiving = samples["β5_thanksgiving"] - - day_effect = np.array(β4) - md_idx = special_days["Memorial day"].day_of_year - 1 - day_effect[:, md_idx] = day_effect[:, md_idx] + β5_memorial - ld_idx = special_days["Labour day"].day_of_year - 1 - day_effect[:, ld_idx] = day_effect[:, ld_idx] + β5_labour - td_idx = special_days["Thanksgiving"].day_of_year - 1 - day_effect[:, td_idx] = day_effect[:, td_idx] + β5_thanksgiving - day_effect = 100 * day_effect.mean(axis=0) - - fig = plt.figure(figsize=(12, 5)) - plt.plot(np.arange(1, 367), day_effect) - for name, day in special_days.items(): - xs = day.day_of_year - ys = day_effect[day.day_of_year - 1] - plt.plot(xs, ys, marker="o", mec="k", c="none", ms=10) - plt.text(xs - 3, ys, name, horizontalalignment="right") - plt.title("Special day effect") - plt.ylabel("Relative number of births") - plt.xlabel("Day of year") - plt.xlim([-40, None]) - return fig + if ax is None: + ax = plt.gca() + + ax.plot(x, y_year_mean, **DATA_STYLE) + ax.plot(x, f_median, **MODEL_STYLE) + return ax + + +def plot_week(data, samples, ax=None): + if ax is None: + ax = plt.gca() + + weekdays = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] + y = data["births_relative"] + x = data["day_of_week"] - 1 + f = jnp.median(samples["week/beta"] * y.std() + y.mean(), 0) + + ax.plot(x, y, **DATA_STYLE) + ax.plot(range(7), f, **MODEL_STYLE) + ax.set_xticks(range(7)) + ax.set_xticklabels(weekdays) + return ax + + +def plot_weektrend(data, samples, ax=None): + dates = data["date"] + weekdays = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"] + y = data["births_relative"] + mean, sdev = y.mean(), y.std() + intercept = samples["intercept"][:, None] + f1 = samples["trend/f"] + f2 = samples["year/f"] + g3 = samples["week-trend/f"] + baseline = ((intercept + f1 + f2) * y.std()).mean(0) + + if ax is None: + ax = plt.gca() + + ax.plot(dates, y - baseline, **DATA_STYLE) + for n, day in enumerate(weekdays): + week_beta = samples["week/beta"][:, n][:, None] + fsd = jnp.exp(g3) * week_beta + f = jnp.quantile(fsd * sdev + mean, 0.50, axis=0) + ax.plot(dates, f, **MODEL_STYLE) + ax.text(dates.iloc[-1], f[-1], day) + + return ax + + +def plot_1988(data, samples, ax=None): + indicators = get_floating_days_indicators(data["date"]) + memorial_beta = samples["memorial/beta"][:, None] + labour_beta = samples["labour/beta"][:, None] + thanks_beta = samples["thanksgiving/beta"][:, None] + + memorials = indicators["memorial_days_indicator"] * memorial_beta + labour = indicators["labour_days_indicator"] * labour_beta + thanksgiving = indicators["thanksgiving_days_indicator"] * thanks_beta + floating_days = memorials + labour + thanksgiving + + is_1988 = data["date"].dt.year == 1988 + days_in_1988 = data["day_of_year"][is_1988] - 1 + days_effect = samples["day/beta"][:, days_in_1988.values] + floating_effect = floating_days[:, jnp.argwhere(is_1988.values).ravel()] + + y = data["births_relative"] + f = (days_effect + floating_effect) * y.std() + y.mean() + f_median = jnp.median(f, axis=0) + + special_days = { + "Valentine's": "1988-02-14", + "Leap day": "1988-02-29", + "Halloween": "1988-10-31", + "Christmas eve": "1988-12-24", + "Christmas day": "1988-12-25", + "New year": "1988-01-01", + "New year's eve": "1988-12-31", + "April 1st": "1988-04-01", + "Independence day": "1988-07-04", + "Labour day": "1988-09-05", + "Memorial day": "1988-05-30", + "Thanksgiving": "1988-11-24", + } + + if ax is None: + ax = plt.gca() + + ax.plot(days_in_1988, f_median, color="k", lw=2) + + for name, date in special_days.items(): + xs = pd.to_datetime(date).day_of_year - 1 + ys = f_median[xs] + text = ax.text(xs - 3, ys, name, horizontalalignment="right") + text.set_bbox(dict(facecolor="white", alpha=0.5, edgecolor="none")) + + is_day_13 = data["date"].dt.day == 13 + bad_luck_days = data.loc[is_1988 & is_day_13, "day_of_year"] - 1 + ax.plot( + bad_luck_days, + f_median[bad_luck_days.values], + marker="o", + mec="gray", + c="none", + ms=10, + lw=0, + ) + return ax + +def make_figure(data, samples): + import matplotlib.ticker as mtick + + fig = plt.figure(figsize=(15, 9)) + grid = plt.GridSpec(2, 3, wspace=0.1, hspace=0.25) + axes = ( + plt.subplot(grid[0, :]), + plt.subplot(grid[1, 0]), + plt.subplot(grid[1, 1]), + plt.subplot(grid[1, 2]), + ) + plot_1988(data, samples, ax=axes[0]) + plot_trend(data, samples, ax=axes[1]) + plot_seasonality(data, samples, ax=axes[2]) + plot_week(data, samples, ax=axes[3]) + + for ax in axes: + ax.axhline(y=1, linestyle="--", color="gray", lw=1) + if not ax.get_subplotspec().is_first_row(): + ax.set_ylim(0.65, 1.35) + + if not ax.get_subplotspec().is_first_col(): + ax.set_yticks([]) + ax.set_ylabel("") + else: + ax.yaxis.set_major_formatter(mtick.PercentFormatter(xmax=1)) + ax.set_ylabel("Relative number of births") + + axes[0].set_title("Special day effect") + axes[0].set_xlabel("Day of year") + axes[1].set_title("Long term trend") + axes[1].set_xlabel("Year") + axes[2].set_title("Year seasonality") + axes[2].set_xlabel("Day of year") + axes[3].set_title("Day of week effect") + axes[3].set_xlabel("Day of week") + return fig + + +# --- functions for running the model --- # def parse_arguments(): parser = argparse.ArgumentParser(description="Hilbert space approx for GPs") parser.add_argument("--num-samples", nargs="?", default=1000, type=int) parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) parser.add_argument("--num-chains", nargs="?", default=1, type=int) - parser.add_argument( - "--model", - nargs="?", - default="tywd", - help="one of" - '"t" (Long term trend),' - '"ty" (t + year seasonality),' - '"tyw" (t + y + slowly varying weekday effect),' - '"tywd" (t + y + w + special days effect)', - ) parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') - parser.add_argument("--x64", action="store_true", help="Enable float64 precision") - parser.add_argument( - "--save-samples", - default="", - type=str, - help="Path where to store the samples. Must be '.npz' file.", - ) + parser.add_argument("--x64", action="store_true", help="Enable double precision") parser.add_argument( "--save-figure", default="", @@ -672,46 +541,34 @@ def parse_arguments(): return args -NAME_TO_MODEL = { - "t": GP1, - "ty": GP2, - "tyw": GP3, - "tywd": GP4, -} - - def main(args): is_sphinxbuild = "NUMPYRO_SPHINXBUILD" in os.environ - model = NAME_TO_MODEL[args.model]() - data = model.get_data() + data = load_data() + data_dict = make_birthdays_data_dict(data) mcmc = MCMC( - NUTS(model.model), + NUTS(birthdays_model, init_strategy=init_to_median), num_warmup=args.num_warmup, num_samples=args.num_samples, num_chains=args.num_chains, - progress_bar=False if is_sphinxbuild else True, + progress_bar=(not is_sphinxbuild), ) - mcmc.run(jax.random.PRNGKey(0), **data) + mcmc.run(jax.random.PRNGKey(0), **data_dict) if not is_sphinxbuild: mcmc.print_summary() - posterior_samples = mcmc.get_samples() - if args.save_samples: - print(f"Saving samples at {args.save_samples}") - save_samples(args.save_samples, posterior_samples) + if args.save_figure: + samples = mcmc.get_samples() print(f"Saving figure at {args.save_figure}") - fig = model.make_figure(posterior_samples) + fig = make_figure(data, samples) fig.savefig(args.save_figure) plt.close() - return model, data, mcmc, posterior_samples + return mcmc if __name__ == "__main__": args = parse_arguments() - if args.x64: - numpyro.enable_x64() - + numpyro.enable_x64(args.x64) numpyro.set_platform(args.device) numpyro.set_host_device_count(args.num_chains) main(args) diff --git a/test/test_examples.py b/test/test_examples.py index ba8bda327..58c26d248 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -36,10 +36,7 @@ "hmm_enum.py -m 4 -t 3 -d 4 --num-warmup 1 -n 4", "hmm_enum.py -m 6 -t 4 -d 3 --num-warmup 1 -n 4", "horseshoe_regression.py --num-samples 10 --num-warmup 10 --num-data 5", - "hsgp.py --model t --num-samples 10 --num-warmup 10 --num-chains 2", - "hsgp.py --model ty --num-samples 10 --num-warmup 10 --num-chains 2", - "hsgp.py --model tyw --num-samples 10 --num-warmup 10 --num-chains 2", - "hsgp.py --model tywd --num-samples 10 --num-warmup 10 --num-chains 2", + "hsgp.py --num-samples 10 --num-warmup 10 --num-chains 2", "minipyro.py", "neutra.py --num-samples 100 --num-warmup 100", "ode.py --num-samples 100 --num-warmup 100 --num-chains 1", From a27ceb1c36778c05c8db332c0632f1630b44a41c Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 18 Oct 2021 12:59:08 -0400 Subject: [PATCH 189/222] Remove the deprecated ops.index_update (#1181) * use new apt for index_update * revise the logic to make sure that nonzero is a concerete array * make sure rate is ndarray --- examples/sparse_regression.py | 39 +- notebooks/source/bayesian_imputation.ipynb | 436 ++++++++++----------- numpyro/distributions/continuous.py | 9 +- numpyro/distributions/discrete.py | 17 +- numpyro/distributions/transforms.py | 10 +- numpyro/infer/hmc_gibbs.py | 18 +- numpyro/infer/hmc_util.py | 6 +- numpyro/infer/mixed_hmc.py | 6 +- numpyro/nn/auto_reg_nn.py | 3 +- numpyro/nn/block_neural_arn.py | 8 +- numpyro/primitives.py | 14 +- numpyro/util.py | 4 +- 12 files changed, 262 insertions(+), 308 deletions(-) diff --git a/examples/sparse_regression.py b/examples/sparse_regression.py index 9dae25b82..3317365a1 100644 --- a/examples/sparse_regression.py +++ b/examples/sparse_regression.py @@ -28,7 +28,6 @@ import numpy as np -import jax from jax import vmap import jax.numpy as jnp import jax.random as random @@ -92,9 +91,7 @@ def compute_singleton_mean_variance(X, Y, dimension, msq, lam, eta1, xisq, c, si P, N = X.shape[1], X.shape[0] probe = jnp.zeros((2, P)) - probe = jax.ops.index_update( - probe, jax.ops.index[:, dimension], jnp.array([1.0, -1.0]) - ) + probe = probe.at[:, dimension].set(jnp.array([1.0, -1.0])) eta2 = jnp.square(eta1) * jnp.sqrt(xisq) / msq kappa = jnp.sqrt(msq) * lam / jnp.sqrt(msq + jnp.square(eta1 * lam)) @@ -124,12 +121,8 @@ def compute_pairwise_mean_variance(X, Y, dim1, dim2, msq, lam, eta1, xisq, c, si P, N = X.shape[1], X.shape[0] probe = jnp.zeros((4, P)) - probe = jax.ops.index_update( - probe, jax.ops.index[:, dim1], jnp.array([1.0, 1.0, -1.0, -1.0]) - ) - probe = jax.ops.index_update( - probe, jax.ops.index[:, dim2], jnp.array([1.0, -1.0, 1.0, -1.0]) - ) + probe = probe.at[:, dim1].set(jnp.array([1.0, 1.0, -1.0, -1.0])) + probe = probe.at[:, dim2].set(jnp.array([1.0, -1.0, 1.0, -1.0])) eta2 = jnp.square(eta1) * jnp.sqrt(xisq) / msq kappa = jnp.sqrt(msq) * lam / jnp.sqrt(msq + jnp.square(eta1 * lam)) @@ -168,12 +161,8 @@ def sample_theta_space(X, Y, active_dims, msq, lam, eta1, xisq, c, sigma): start2 = 0 for dim in range(P): - probe = jax.ops.index_update( - probe, jax.ops.index[start1 : start1 + 2, dim], jnp.array([1.0, -1.0]) - ) - vec = jax.ops.index_update( - vec, jax.ops.index[start2, start1 : start1 + 2], jnp.array([0.5, -0.5]) - ) + probe = probe.at[start1 : start1 + 2, dim].set(jnp.array([1.0, -1.0])) + vec = vec.at[start2, start1 : start1 + 2].set(jnp.array([0.5, -0.5])) start1 += 2 start2 += 1 @@ -181,20 +170,14 @@ def sample_theta_space(X, Y, active_dims, msq, lam, eta1, xisq, c, sigma): for dim2 in active_dims: if dim1 >= dim2: continue - probe = jax.ops.index_update( - probe, - jax.ops.index[start1 : start1 + 4, dim1], - jnp.array([1.0, 1.0, -1.0, -1.0]), + probe = probe.at[start1 : start1 + 4, dim1].set( + jnp.array([1.0, 1.0, -1.0, -1.0]) ) - probe = jax.ops.index_update( - probe, - jax.ops.index[start1 : start1 + 4, dim2], - jnp.array([1.0, -1.0, 1.0, -1.0]), + probe = probe.at[start1 : start1 + 4, dim2].set( + jnp.array([1.0, -1.0, 1.0, -1.0]) ) - vec = jax.ops.index_update( - vec, - jax.ops.index[start2, start1 : start1 + 4], - jnp.array([0.25, -0.25, -0.25, 0.25]), + vec = vec.at[start2, start1 : start1 + 4].set( + jnp.array([0.25, -0.25, -0.25, 0.25]) ) start1 += 4 start2 += 1 diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index ab399f1f4..72d0e0b6d 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -43,7 +43,7 @@ "import pandas as pd\n", "\n", "from jax import numpy as jnp\n", - "from jax import ops, random\n", + "from jax import random\n", "from jax.scipy.special import expit\n", "\n", "import numpyro\n", @@ -294,8 +294,8 @@ "0 678\n", "1 118\n", "2 80\n", - "5 5\n", "3 5\n", + "5 5\n", "4 4\n", "6 1\n", "Name: Parch, dtype: int64\n", @@ -360,16 +360,16 @@ "Dr. 7\n", "Rev. 6\n", "Mlle. 2\n", - "Major. 2\n", "Col. 2\n", - "Ms. 1\n", - "Don. 1\n", - "the 1\n", - "Sir. 1\n", + "Major. 2\n", "Lady. 1\n", + "Sir. 1\n", + "the 1\n", + "Ms. 1\n", "Capt. 1\n", - "Jonkheer. 1\n", "Mme. 1\n", + "Jonkheer. 1\n", + "Don. 1\n", "Name: Name, dtype: int64" ] }, @@ -516,12 +516,12 @@ " \"age_impute\",\n", " dist.Normal(age_mu[age_nanidx], age_sigma[age_nanidx]).mask(False),\n", " )\n", - " age = ops.index_update(age, age_nanidx, age_impute)\n", + " age = jnp.asarray(age).at[age_nanidx].set(age_impute)\n", " numpyro.sample(\"age\", dist.Normal(age_mu, age_sigma), obs=age)\n", " else:\n", " # fill missing data by the mean of ages for each title\n", " age_impute = age_mean_by_title[title][age_nanidx]\n", - " age = ops.index_update(age, age_nanidx, age_impute)\n", + " age = jnp.asarray(age).at[age_nanidx].set(age_impute)\n", "\n", " a = numpyro.sample(\"a\", dist.Normal(0, 1))\n", " b_age = numpyro.sample(\"b_Age\", dist.Normal(0, 1))\n", @@ -561,7 +561,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "sample: 100%|██████████| 2000/2000 [00:18<00:00, 110.91it/s, 63 steps of size 6.48e-02. acc. prob=0.94] \n" + "sample: 100%|██████████| 2000/2000 [00:15<00:00, 132.15it/s, 63 steps of size 5.68e-02. acc. prob=0.95]\n" ] }, { @@ -570,213 +570,213 @@ "text": [ "\n", " mean std median 5.0% 95.0% n_eff r_hat\n", - " a 0.18 0.80 0.20 -1.14 1.50 1078.98 1.00\n", - " age_impute[0] 0.23 0.82 0.27 -1.09 1.54 2412.70 1.00\n", - " age_impute[1] -0.09 0.83 -0.10 -1.34 1.39 1956.25 1.00\n", - " age_impute[2] 0.36 0.80 0.33 -1.01 1.60 1558.35 1.00\n", - " age_impute[3] 0.23 0.90 0.24 -1.23 1.70 2134.81 1.00\n", - " age_impute[4] -0.65 0.89 -0.61 -2.06 0.82 2027.61 1.00\n", - " age_impute[5] 0.23 0.87 0.23 -1.26 1.50 1777.25 1.00\n", - " age_impute[6] 0.45 0.78 0.45 -0.78 1.66 1428.74 1.00\n", - " age_impute[7] -0.66 0.91 -0.64 -2.01 0.91 2021.78 1.00\n", - " age_impute[8] -0.09 0.87 -0.08 -1.41 1.42 1630.14 1.00\n", - " age_impute[9] 0.22 0.89 0.24 -1.42 1.56 1404.25 1.00\n", - " age_impute[10] 0.20 0.87 0.20 -1.16 1.66 2489.31 1.00\n", - " age_impute[11] 0.17 0.85 0.17 -1.28 1.51 2063.14 1.00\n", - " age_impute[12] -0.66 0.89 -0.62 -2.18 0.72 1632.65 1.00\n", - " age_impute[13] 0.19 0.91 0.17 -1.34 1.64 2394.35 1.00\n", - " age_impute[14] -0.02 0.85 -0.01 -1.38 1.33 1809.29 1.00\n", - " age_impute[15] 0.37 0.84 0.40 -1.04 1.66 1443.69 1.00\n", - " age_impute[16] -1.73 0.25 -1.73 -2.11 -1.30 2062.38 1.00\n", - " age_impute[17] 0.22 0.86 0.22 -1.23 1.55 1565.91 1.00\n", - " age_impute[18] 0.23 0.90 0.23 -1.28 1.72 1483.35 1.00\n", - " age_impute[19] -0.68 0.86 -0.66 -2.13 0.67 2069.45 1.00\n", - " age_impute[20] 0.21 0.89 0.27 -1.39 1.59 1675.83 1.00\n", - " age_impute[21] 0.19 0.89 0.22 -1.28 1.56 1984.23 1.00\n", - " age_impute[22] 0.19 0.92 0.20 -1.37 1.57 1608.50 1.00\n", - " age_impute[23] -0.14 0.86 -0.13 -1.59 1.26 1890.99 1.00\n", - " age_impute[24] -0.67 0.88 -0.66 -2.14 0.74 1530.94 1.00\n", - " age_impute[25] 0.17 0.89 0.19 -1.34 1.55 1767.90 1.00\n", - " age_impute[26] 0.19 0.84 0.22 -1.11 1.56 1617.58 1.00\n", - " age_impute[27] -0.70 0.89 -0.68 -2.02 0.89 1761.35 1.00\n", - " age_impute[28] 0.60 0.76 0.62 -0.72 1.75 1645.46 1.00\n", - " age_impute[29] 0.24 0.85 0.24 -1.13 1.56 2126.36 1.00\n", - " age_impute[30] 0.22 0.84 0.23 -1.03 1.69 2796.85 1.00\n", - " age_impute[31] -1.72 0.27 -1.72 -2.15 -1.28 2433.69 1.00\n", - " age_impute[32] 0.43 0.86 0.43 -0.93 1.81 1458.56 1.00\n", - " age_impute[33] 0.32 0.87 0.33 -1.08 1.70 1583.13 1.00\n", - " age_impute[34] -1.72 0.28 -1.72 -2.19 -1.28 2429.56 1.00\n", - " age_impute[35] -0.43 0.86 -0.42 -1.88 0.90 1451.65 1.00\n", - " age_impute[36] 0.30 0.87 0.29 -1.09 1.72 2084.66 1.00\n", - " age_impute[37] 0.30 0.83 0.33 -0.98 1.74 1924.58 1.00\n", - " age_impute[38] 0.35 0.79 0.33 -0.82 1.73 1980.63 1.00\n", - " age_impute[39] 0.19 0.93 0.19 -1.33 1.75 1463.15 1.00\n", - " age_impute[40] -0.65 0.90 -0.67 -2.04 0.85 1548.78 1.00\n", - " age_impute[41] 0.20 0.86 0.21 -1.19 1.56 1889.65 1.00\n", - " age_impute[42] 0.22 0.88 0.22 -1.39 1.54 1785.76 1.00\n", - " age_impute[43] 0.21 0.82 0.23 -1.35 1.36 1663.29 1.00\n", - " age_impute[44] -0.40 0.92 -0.40 -1.96 1.15 1745.40 1.00\n", - " age_impute[45] -0.34 0.86 -0.33 -1.75 1.05 1380.72 1.00\n", - " age_impute[46] -0.30 0.90 -0.30 -1.87 1.10 1237.61 1.00\n", - " age_impute[47] -0.73 0.91 -0.73 -2.13 0.78 1467.82 1.00\n", - " age_impute[48] 0.22 0.89 0.22 -1.15 1.84 2169.66 1.00\n", - " age_impute[49] 0.43 0.77 0.43 -0.79 1.65 1839.23 1.00\n", - " age_impute[50] 0.23 0.86 0.24 -1.30 1.49 1579.39 1.00\n", - " age_impute[51] -0.29 0.88 -0.35 -1.58 1.23 2247.95 1.00\n", - " age_impute[52] 0.36 0.82 0.38 -1.13 1.57 1606.92 1.00\n", - " age_impute[53] -0.67 0.94 -0.65 -2.08 0.94 1587.69 1.00\n", - " age_impute[54] 0.25 0.90 0.25 -1.07 1.77 2455.98 1.00\n", - " age_impute[55] 0.33 0.88 0.33 -0.94 1.88 1593.76 1.00\n", - " age_impute[56] 0.39 0.78 0.39 -0.81 1.65 1101.71 1.00\n", - " age_impute[57] -0.01 0.82 -0.03 -1.40 1.25 1532.71 1.00\n", - " age_impute[58] -0.69 0.90 -0.68 -2.09 0.77 1614.68 1.00\n", - " age_impute[59] -0.12 0.88 -0.13 -1.52 1.33 1384.61 1.00\n", - " age_impute[60] -0.62 0.89 -0.61 -2.08 0.77 2116.31 1.00\n", - " age_impute[61] 0.22 0.83 0.24 -1.11 1.58 1581.98 1.00\n", - " age_impute[62] -0.59 0.93 -0.60 -2.17 0.88 1528.18 1.00\n", - " age_impute[63] 0.20 0.87 0.20 -1.35 1.48 1677.96 1.00\n", - " age_impute[64] -0.69 0.89 -0.67 -2.22 0.70 1877.18 1.00\n", - " age_impute[65] 0.41 0.75 0.42 -0.80 1.67 1501.98 1.00\n", - " age_impute[66] 0.24 0.96 0.25 -1.25 1.86 2558.45 1.00\n", - " age_impute[67] 0.32 0.73 0.34 -0.82 1.55 1678.01 1.00\n", - " age_impute[68] 0.34 0.88 0.34 -1.05 1.83 1712.65 1.00\n", - " age_impute[69] 0.24 0.92 0.24 -1.15 1.88 1170.47 1.00\n", - " age_impute[70] -0.65 0.89 -0.64 -2.13 0.76 2018.98 1.00\n", - " age_impute[71] -0.67 0.86 -0.69 -2.12 0.64 1625.09 1.00\n", - " age_impute[72] 0.18 0.84 0.17 -1.14 1.53 1929.52 1.00\n", - " age_impute[73] 0.38 0.77 0.37 -0.92 1.63 1696.03 1.00\n", - " age_impute[74] -0.67 0.90 -0.66 -2.14 0.81 1683.08 1.00\n", - " age_impute[75] 0.44 0.84 0.40 -0.84 1.88 1215.51 1.00\n", - " age_impute[76] 0.20 0.86 0.22 -1.24 1.61 1899.12 1.00\n", - " age_impute[77] 0.18 0.86 0.16 -1.38 1.44 1809.40 1.00\n", - " age_impute[78] -0.42 0.87 -0.44 -1.79 1.05 2265.80 1.00\n", - " age_impute[79] 0.20 0.84 0.20 -1.27 1.50 2009.37 1.00\n", - " age_impute[80] 0.25 0.84 0.23 -1.15 1.64 1561.96 1.00\n", - " age_impute[81] 0.26 0.88 0.29 -1.20 1.68 2251.52 1.00\n", - " age_impute[82] 0.62 0.83 0.62 -0.70 1.98 1502.80 1.00\n", - " age_impute[83] 0.21 0.86 0.20 -1.07 1.63 2044.48 1.00\n", - " age_impute[84] 0.20 0.86 0.18 -1.30 1.54 1497.56 1.00\n", - " age_impute[85] 0.25 0.88 0.24 -1.23 1.72 2379.66 1.00\n", - " age_impute[86] 0.31 0.75 0.32 -1.07 1.43 1543.45 1.00\n", - " age_impute[87] -0.13 0.90 -0.10 -1.61 1.41 2132.30 1.00\n", - " age_impute[88] 0.21 0.90 0.25 -1.40 1.53 1824.99 1.00\n", - " age_impute[89] 0.23 0.93 0.23 -1.29 1.70 2859.52 1.00\n", - " age_impute[90] 0.40 0.82 0.39 -1.00 1.73 1416.46 1.00\n", - " age_impute[91] 0.24 0.92 0.24 -1.17 1.84 1843.64 1.00\n", - " age_impute[92] 0.20 0.83 0.19 -1.18 1.47 1970.14 1.00\n", - " age_impute[93] 0.24 0.89 0.26 -1.24 1.66 1831.49 1.00\n", - " age_impute[94] 0.21 0.90 0.17 -1.24 1.69 1975.06 1.00\n", - " age_impute[95] 0.21 0.88 0.22 -1.22 1.67 1904.83 1.00\n", - " age_impute[96] 0.34 0.90 0.33 -1.05 1.81 2090.87 1.00\n", - " age_impute[97] 0.27 0.88 0.24 -1.26 1.61 1768.14 1.00\n", - " age_impute[98] -0.40 0.92 -0.40 -1.83 1.12 1787.86 1.00\n", - " age_impute[99] 0.16 0.91 0.14 -1.22 1.70 1518.86 1.00\n", - "age_impute[100] 0.24 0.86 0.22 -1.21 1.61 1856.56 1.00\n", - "age_impute[101] 0.20 0.88 0.21 -1.14 1.76 1967.24 1.00\n", - "age_impute[102] -0.30 0.89 -0.28 -1.76 1.12 1795.47 1.00\n", - "age_impute[103] 0.01 0.86 0.01 -1.37 1.38 1416.70 1.00\n", - "age_impute[104] 0.25 0.92 0.26 -1.13 1.87 1643.05 1.00\n", - "age_impute[105] 0.25 0.85 0.29 -1.24 1.55 1831.86 1.00\n", - "age_impute[106] 0.25 0.87 0.24 -1.17 1.72 2185.41 1.00\n", - "age_impute[107] 0.21 0.87 0.21 -1.07 1.70 1945.87 1.00\n", - "age_impute[108] 0.34 0.86 0.35 -1.03 1.78 1666.87 1.00\n", - "age_impute[109] 0.27 0.88 0.22 -0.95 1.93 1470.86 1.00\n", - "age_impute[110] 0.32 0.76 0.35 -0.96 1.41 1737.45 1.00\n", - "age_impute[111] 0.22 0.86 0.22 -1.25 1.59 2439.65 1.00\n", - "age_impute[112] -0.03 0.86 -0.03 -1.41 1.44 1737.27 1.00\n", - "age_impute[113] 0.22 0.87 0.23 -1.32 1.56 1211.30 1.00\n", - "age_impute[114] 0.38 0.79 0.36 -0.90 1.65 1416.21 1.00\n", - "age_impute[115] 0.20 0.88 0.19 -1.12 1.78 1437.63 1.00\n", - "age_impute[116] 0.25 0.86 0.20 -1.26 1.53 1336.80 1.00\n", - "age_impute[117] -0.35 0.91 -0.36 -1.91 1.10 1737.09 1.00\n", - "age_impute[118] 0.23 0.94 0.23 -1.18 1.95 2347.76 1.00\n", - "age_impute[119] -0.63 0.93 -0.66 -2.09 0.94 1681.58 1.00\n", - "age_impute[120] 0.60 0.80 0.59 -0.54 2.06 1437.89 1.00\n", - "age_impute[121] 0.21 0.85 0.23 -1.06 1.69 2152.47 1.00\n", - "age_impute[122] 0.22 0.82 0.20 -1.07 1.65 2296.29 1.00\n", - "age_impute[123] -0.38 0.94 -0.39 -2.01 1.03 1557.61 1.00\n", - "age_impute[124] -0.61 0.92 -0.63 -2.13 0.86 1450.41 1.00\n", - "age_impute[125] 0.24 0.93 0.23 -1.16 1.74 2397.23 1.00\n", - "age_impute[126] 0.21 0.84 0.21 -1.06 1.72 2248.42 1.00\n", - "age_impute[127] 0.36 0.87 0.36 -0.96 1.81 1663.20 1.00\n", - "age_impute[128] 0.24 0.90 0.25 -1.34 1.62 1790.40 1.00\n", - "age_impute[129] -0.71 0.88 -0.67 -2.07 0.84 2155.52 1.00\n", - "age_impute[130] 0.19 0.85 0.17 -1.29 1.50 1766.80 1.00\n", - "age_impute[131] 0.25 0.88 0.25 -1.12 1.76 1891.41 1.00\n", - "age_impute[132] 0.32 0.88 0.32 -1.21 1.70 2209.15 1.00\n", - "age_impute[133] 0.22 0.89 0.20 -1.21 1.66 1656.09 1.00\n", - "age_impute[134] -0.10 0.91 -0.14 -1.51 1.46 2255.33 1.00\n", - "age_impute[135] 0.22 0.85 0.23 -1.04 1.66 1534.46 1.00\n", - "age_impute[136] 0.18 0.84 0.17 -1.21 1.55 2292.26 1.00\n", - "age_impute[137] -0.69 0.88 -0.68 -2.29 0.63 2473.01 1.00\n", - "age_impute[138] 0.19 0.93 0.18 -1.36 1.65 2256.20 1.00\n", - "age_impute[139] 0.20 0.85 0.19 -1.16 1.59 1589.73 1.00\n", - "age_impute[140] 0.40 0.79 0.41 -0.90 1.66 2200.96 1.00\n", - "age_impute[141] 0.24 0.90 0.22 -1.14 1.73 1805.79 1.00\n", - "age_impute[142] -0.32 0.92 -0.32 -1.82 1.19 1755.92 1.00\n", - "age_impute[143] -0.15 0.86 -0.14 -1.58 1.22 1850.64 1.00\n", - "age_impute[144] -0.67 0.94 -0.66 -2.21 0.80 1812.97 1.00\n", - "age_impute[145] -1.75 0.25 -1.75 -2.17 -1.36 1786.83 1.00\n", - "age_impute[146] 0.35 0.84 0.34 -1.02 1.66 2006.44 1.00\n", - "age_impute[147] 0.26 0.89 0.27 -1.27 1.61 1800.77 1.00\n", - "age_impute[148] -0.67 0.88 -0.65 -2.13 0.68 1832.48 1.00\n", - "age_impute[149] 0.29 0.83 0.29 -1.07 1.59 2181.78 1.00\n", - "age_impute[150] 0.22 0.87 0.23 -1.20 1.63 1788.63 1.00\n", - "age_impute[151] 0.20 0.87 0.17 -1.19 1.62 1561.13 1.00\n", - "age_impute[152] 0.01 0.83 -0.01 -1.35 1.38 2966.42 1.00\n", - "age_impute[153] 0.19 0.91 0.22 -1.44 1.55 2302.81 1.00\n", - "age_impute[154] 1.06 0.96 1.07 -0.53 2.59 1612.33 1.00\n", - "age_impute[155] 0.22 0.81 0.22 -1.08 1.51 1460.31 1.00\n", - "age_impute[156] 0.27 0.94 0.25 -1.40 1.75 1409.05 1.00\n", - "age_impute[157] 0.22 0.92 0.21 -1.26 1.70 1705.55 1.00\n", - "age_impute[158] 0.22 0.87 0.22 -1.08 1.72 1561.10 1.00\n", - "age_impute[159] 0.21 0.90 0.22 -1.30 1.56 1366.89 1.00\n", - "age_impute[160] 0.18 0.84 0.14 -1.15 1.46 1437.73 1.00\n", - "age_impute[161] -0.49 0.92 -0.52 -1.91 1.09 1357.29 1.00\n", - "age_impute[162] 0.37 0.84 0.37 -0.98 1.72 1971.90 1.00\n", - "age_impute[163] 0.31 0.84 0.28 -1.05 1.71 1541.32 1.00\n", - "age_impute[164] 0.22 0.85 0.21 -1.23 1.60 2056.93 1.00\n", - "age_impute[165] 0.23 0.88 0.22 -1.12 1.65 2037.07 1.00\n", - "age_impute[166] -0.11 0.87 -0.11 -1.49 1.33 1851.82 1.00\n", - "age_impute[167] 0.21 0.89 0.21 -1.10 1.73 1777.15 1.00\n", - "age_impute[168] 0.20 0.83 0.21 -1.12 1.56 1793.28 1.00\n", - "age_impute[169] 0.02 0.88 0.01 -1.40 1.43 2410.48 1.00\n", - "age_impute[170] 0.16 0.88 0.16 -1.29 1.60 2230.68 1.00\n", - "age_impute[171] 0.41 0.83 0.40 -0.96 1.75 1846.52 1.00\n", - "age_impute[172] 0.24 0.89 0.22 -1.32 1.54 1852.66 1.00\n", - "age_impute[173] -0.44 0.87 -0.45 -1.92 0.92 2089.83 1.00\n", - "age_impute[174] 0.22 0.82 0.23 -1.12 1.55 2427.19 1.00\n", - "age_impute[175] 0.22 0.96 0.26 -1.45 1.79 2380.77 1.00\n", - "age_impute[176] -0.43 0.89 -0.41 -1.84 1.06 1803.21 1.00\n", - " age_mu[0] 0.19 0.04 0.19 0.12 0.27 1509.52 1.00\n", - " age_mu[1] -0.55 0.08 -0.55 -0.67 -0.43 1224.77 1.00\n", - " age_mu[2] 0.42 0.08 0.42 0.30 0.56 1212.38 1.00\n", - " age_mu[3] -1.73 0.04 -1.73 -1.79 -1.64 1274.40 1.00\n", - " age_mu[4] 0.85 0.19 0.85 0.55 1.16 1387.85 1.00\n", - " age_sigma[0] 0.88 0.03 0.88 0.83 0.93 646.28 1.00\n", - " age_sigma[1] 0.90 0.05 0.90 0.82 0.98 1120.20 1.00\n", - " age_sigma[2] 0.79 0.05 0.79 0.71 0.88 1113.02 1.00\n", - " age_sigma[3] 0.26 0.03 0.25 0.20 0.31 1443.42 1.00\n", - " age_sigma[4] 0.94 0.13 0.92 0.74 1.16 1106.42 1.00\n", - " b_Age -0.44 0.13 -0.44 -0.66 -0.24 832.14 1.00\n", - " b_Embarked[0] -0.30 0.53 -0.30 -1.14 0.59 525.77 1.00\n", - " b_Embarked[1] 0.27 0.54 0.28 -0.65 1.08 572.29 1.00\n", - " b_Embarked[2] 0.02 0.55 0.02 -1.00 0.78 524.41 1.00\n", - " b_Parch[0] 0.44 0.57 0.46 -0.52 1.35 484.44 1.00\n", - " b_Parch[1] 0.10 0.57 0.10 -0.76 1.11 494.90 1.00\n", - " b_Parch[2] -0.49 0.56 -0.48 -1.42 0.38 498.59 1.00\n", - " b_Pclass[0] 1.16 0.56 1.17 0.32 2.15 475.02 1.00\n", - " b_Pclass[1] 0.02 0.55 0.04 -0.87 0.94 496.89 1.00\n", - " b_Pclass[2] -1.23 0.56 -1.20 -2.20 -0.37 477.51 1.00\n", - " b_Sex[0] 1.18 0.70 1.16 -0.05 2.24 691.88 1.00\n", - " b_Sex[1] -1.00 0.69 -1.01 -2.12 0.11 802.26 1.00\n", - " b_SibSp[0] 0.26 0.63 0.28 -0.78 1.25 779.73 1.00\n", - " b_SibSp[1] -0.19 0.64 -0.18 -1.15 0.91 775.18 1.00\n", - " b_Title[0] -0.96 0.57 -0.96 -1.85 0.02 521.30 1.00\n", - " b_Title[1] -0.34 0.62 -0.33 -1.40 0.62 695.62 1.00\n", - " b_Title[2] 0.54 0.63 0.54 -0.42 1.58 672.71 1.00\n", - " b_Title[3] 1.46 0.64 1.46 0.32 2.39 708.52 1.00\n", - " b_Title[4] -0.66 0.62 -0.68 -1.61 0.49 635.26 1.00\n", + " a 0.12 0.82 0.11 -1.21 1.49 887.50 1.00\n", + " age_impute[0] 0.20 0.84 0.18 -1.22 1.53 1346.09 1.00\n", + " age_impute[1] -0.06 0.86 -0.08 -1.41 1.26 1057.70 1.00\n", + " age_impute[2] 0.38 0.73 0.39 -0.80 1.58 1570.36 1.00\n", + " age_impute[3] 0.25 0.84 0.23 -0.99 1.86 1027.43 1.00\n", + " age_impute[4] -0.63 0.91 -0.59 -1.99 0.87 1183.66 1.00\n", + " age_impute[5] 0.21 0.89 0.19 -1.02 1.97 1456.79 1.00\n", + " age_impute[6] 0.45 0.82 0.46 -0.90 1.73 1239.22 1.00\n", + " age_impute[7] -0.62 0.86 -0.62 -2.13 0.72 1406.09 1.00\n", + " age_impute[8] -0.13 0.90 -0.14 -1.64 1.38 1905.07 1.00\n", + " age_impute[9] 0.24 0.84 0.26 -1.06 1.77 1471.12 1.00\n", + " age_impute[10] 0.20 0.89 0.21 -1.26 1.65 1588.79 1.00\n", + " age_impute[11] 0.17 0.91 0.19 -1.59 1.48 1446.52 1.00\n", + " age_impute[12] -0.65 0.89 -0.68 -2.12 0.77 1457.47 1.00\n", + " age_impute[13] 0.21 0.85 0.18 -1.24 1.53 1057.77 1.00\n", + " age_impute[14] 0.05 0.92 0.05 -1.40 1.65 1207.08 1.00\n", + " age_impute[15] 0.37 0.94 0.37 -1.02 1.98 1326.55 1.00\n", + " age_impute[16] -1.74 0.26 -1.74 -2.13 -1.32 1320.08 1.00\n", + " age_impute[17] 0.21 0.89 0.22 -1.30 1.60 1545.73 1.00\n", + " age_impute[18] 0.18 0.90 0.18 -1.26 1.58 2013.12 1.00\n", + " age_impute[19] -0.67 0.86 -0.66 -1.97 0.85 1499.50 1.00\n", + " age_impute[20] 0.23 0.89 0.27 -1.19 1.71 1712.24 1.00\n", + " age_impute[21] 0.21 0.87 0.20 -1.11 1.68 1400.55 1.00\n", + " age_impute[22] 0.19 0.90 0.18 -1.26 1.63 1400.37 1.00\n", + " age_impute[23] -0.15 0.85 -0.15 -1.57 1.24 1205.10 1.00\n", + " age_impute[24] -0.71 0.89 -0.73 -2.05 0.82 1085.52 1.00\n", + " age_impute[25] 0.20 0.85 0.19 -1.20 1.62 1708.01 1.00\n", + " age_impute[26] 0.21 0.88 0.21 -1.20 1.68 1363.75 1.00\n", + " age_impute[27] -0.69 0.91 -0.73 -2.20 0.77 1224.06 1.00\n", + " age_impute[28] 0.60 0.77 0.60 -0.61 1.95 1312.44 1.00\n", + " age_impute[29] 0.20 0.89 0.17 -1.23 1.71 938.19 1.00\n", + " age_impute[30] 0.24 0.87 0.23 -1.14 1.60 1324.50 1.00\n", + " age_impute[31] -1.72 0.26 -1.72 -2.11 -1.28 1425.46 1.00\n", + " age_impute[32] 0.44 0.77 0.43 -0.83 1.58 1587.41 1.00\n", + " age_impute[33] 0.34 0.89 0.32 -1.14 1.73 1375.14 1.00\n", + " age_impute[34] -1.72 0.26 -1.71 -2.11 -1.26 1007.71 1.00\n", + " age_impute[35] -0.45 0.90 -0.47 -2.06 0.92 1329.44 1.00\n", + " age_impute[36] 0.30 0.84 0.30 -1.03 1.73 1080.80 1.00\n", + " age_impute[37] 0.33 0.88 0.32 -1.10 1.81 1033.30 1.00\n", + " age_impute[38] 0.33 0.76 0.35 -0.94 1.56 1550.68 1.00\n", + " age_impute[39] 0.19 0.93 0.21 -1.32 1.82 1203.79 1.00\n", + " age_impute[40] -0.67 0.88 -0.69 -1.94 0.88 1382.98 1.00\n", + " age_impute[41] 0.17 0.89 0.14 -1.30 1.43 1438.18 1.00\n", + " age_impute[42] 0.23 0.82 0.25 -1.12 1.48 1499.59 1.00\n", + " age_impute[43] 0.22 0.82 0.21 -1.19 1.45 1236.67 1.00\n", + " age_impute[44] -0.41 0.85 -0.42 -1.96 0.78 812.53 1.00\n", + " age_impute[45] -0.36 0.89 -0.35 -2.01 0.94 1488.83 1.00\n", + " age_impute[46] -0.33 0.91 -0.32 -1.76 1.27 1628.61 1.00\n", + " age_impute[47] -0.71 0.85 -0.69 -2.12 0.64 1363.89 1.00\n", + " age_impute[48] 0.21 0.85 0.24 -1.21 1.64 1552.65 1.00\n", + " age_impute[49] 0.42 0.82 0.41 -0.83 1.77 754.08 1.00\n", + " age_impute[50] 0.26 0.86 0.24 -1.18 1.63 1155.49 1.00\n", + " age_impute[51] -0.29 0.91 -0.30 -1.83 1.15 1212.08 1.00\n", + " age_impute[52] 0.36 0.85 0.34 -1.12 1.68 1190.99 1.00\n", + " age_impute[53] -0.68 0.89 -0.65 -2.09 0.75 1104.75 1.00\n", + " age_impute[54] 0.27 0.90 0.25 -1.24 1.68 1331.19 1.00\n", + " age_impute[55] 0.36 0.89 0.36 -0.96 1.86 1917.52 1.00\n", + " age_impute[56] 0.38 0.86 0.40 -1.00 1.75 1862.00 1.00\n", + " age_impute[57] 0.01 0.91 0.03 -1.33 1.56 1285.43 1.00\n", + " age_impute[58] -0.69 0.91 -0.66 -2.13 0.78 1438.41 1.00\n", + " age_impute[59] -0.14 0.85 -0.16 -1.44 1.37 1135.79 1.00\n", + " age_impute[60] -0.59 0.94 -0.61 -2.19 0.93 1222.88 1.00\n", + " age_impute[61] 0.24 0.92 0.25 -1.35 1.65 1341.95 1.00\n", + " age_impute[62] -0.55 0.91 -0.57 -2.01 0.96 753.85 1.00\n", + " age_impute[63] 0.21 0.90 0.19 -1.42 1.60 1238.50 1.00\n", + " age_impute[64] -0.66 0.88 -0.68 -2.04 0.73 1214.85 1.00\n", + " age_impute[65] 0.44 0.78 0.48 -0.93 1.57 1174.41 1.00\n", + " age_impute[66] 0.22 0.94 0.20 -1.35 1.69 1910.00 1.00\n", + " age_impute[67] 0.33 0.76 0.34 -0.85 1.63 1210.24 1.00\n", + " age_impute[68] 0.31 0.84 0.33 -1.08 1.60 1756.60 1.00\n", + " age_impute[69] 0.26 0.91 0.25 -1.29 1.75 1155.87 1.00\n", + " age_impute[70] -0.67 0.86 -0.70 -2.02 0.70 1186.22 1.00\n", + " age_impute[71] -0.70 0.90 -0.69 -2.21 0.75 1469.35 1.00\n", + " age_impute[72] 0.24 0.86 0.24 -1.07 1.66 1604.16 1.00\n", + " age_impute[73] 0.34 0.72 0.35 -0.77 1.55 1144.55 1.00\n", + " age_impute[74] -0.64 0.85 -0.64 -2.10 0.77 1513.79 1.00\n", + " age_impute[75] 0.41 0.78 0.42 -0.96 1.60 796.47 1.00\n", + " age_impute[76] 0.18 0.89 0.21 -1.19 1.74 755.44 1.00\n", + " age_impute[77] 0.21 0.84 0.22 -1.22 1.63 1371.73 1.00\n", + " age_impute[78] -0.36 0.87 -0.33 -1.81 1.01 1017.23 1.00\n", + " age_impute[79] 0.20 0.84 0.19 -1.35 1.37 1677.57 1.00\n", + " age_impute[80] 0.23 0.84 0.24 -1.09 1.61 1545.61 1.00\n", + " age_impute[81] 0.28 0.90 0.32 -1.08 1.83 1735.91 1.00\n", + " age_impute[82] 0.61 0.80 0.60 -0.61 2.03 1353.67 1.00\n", + " age_impute[83] 0.24 0.89 0.26 -1.22 1.66 1165.03 1.00\n", + " age_impute[84] 0.21 0.91 0.21 -1.35 1.65 1584.00 1.00\n", + " age_impute[85] 0.24 0.92 0.21 -1.33 1.63 1271.37 1.00\n", + " age_impute[86] 0.31 0.81 0.30 -0.86 1.76 1198.70 1.00\n", + " age_impute[87] -0.11 0.84 -0.10 -1.42 1.23 1248.38 1.00\n", + " age_impute[88] 0.21 0.94 0.22 -1.31 1.77 1082.82 1.00\n", + " age_impute[89] 0.24 0.86 0.23 -1.08 1.67 2141.98 1.00\n", + " age_impute[90] 0.41 0.84 0.45 -0.88 1.90 1518.73 1.00\n", + " age_impute[91] 0.21 0.86 0.20 -1.21 1.58 1723.50 1.00\n", + " age_impute[92] 0.21 0.84 0.20 -1.21 1.57 1742.44 1.00\n", + " age_impute[93] 0.22 0.87 0.23 -1.29 1.50 1359.74 1.00\n", + " age_impute[94] 0.22 0.87 0.18 -1.09 1.70 906.55 1.00\n", + " age_impute[95] 0.22 0.87 0.23 -1.16 1.65 1112.58 1.00\n", + " age_impute[96] 0.30 0.84 0.26 -1.18 1.57 1680.70 1.00\n", + " age_impute[97] 0.23 0.87 0.25 -1.22 1.63 1408.40 1.00\n", + " age_impute[98] -0.36 0.91 -0.37 -1.96 1.03 1083.67 1.00\n", + " age_impute[99] 0.15 0.87 0.14 -1.22 1.61 1644.46 1.00\n", + "age_impute[100] 0.27 0.85 0.30 -1.27 1.45 1266.96 1.00\n", + "age_impute[101] 0.25 0.87 0.25 -1.19 1.57 1220.96 1.00\n", + "age_impute[102] -0.29 0.85 -0.28 -1.70 1.10 1392.91 1.00\n", + "age_impute[103] 0.01 0.89 0.01 -1.46 1.39 1137.34 1.00\n", + "age_impute[104] 0.21 0.86 0.24 -1.16 1.64 1018.70 1.00\n", + "age_impute[105] 0.24 0.93 0.21 -1.14 1.90 1479.67 1.00\n", + "age_impute[106] 0.21 0.83 0.21 -1.09 1.55 1471.11 1.00\n", + "age_impute[107] 0.22 0.85 0.22 -1.09 1.64 1941.83 1.00\n", + "age_impute[108] 0.31 0.88 0.30 -1.10 1.76 1342.10 1.00\n", + "age_impute[109] 0.22 0.86 0.23 -1.25 1.56 1198.01 1.00\n", + "age_impute[110] 0.33 0.78 0.35 -0.95 1.62 1267.01 1.00\n", + "age_impute[111] 0.22 0.88 0.21 -1.11 1.71 1404.51 1.00\n", + "age_impute[112] -0.03 0.90 -0.02 -1.38 1.55 1625.35 1.00\n", + "age_impute[113] 0.24 0.85 0.23 -1.17 1.62 1361.84 1.00\n", + "age_impute[114] 0.36 0.86 0.37 -0.99 1.76 1155.67 1.00\n", + "age_impute[115] 0.26 0.96 0.28 -1.37 1.81 1245.97 1.00\n", + "age_impute[116] 0.21 0.86 0.24 -1.18 1.69 1565.59 1.00\n", + "age_impute[117] -0.31 0.94 -0.33 -1.91 1.19 1593.65 1.00\n", + "age_impute[118] 0.21 0.87 0.22 -1.20 1.64 1315.42 1.00\n", + "age_impute[119] -0.69 0.88 -0.74 -2.00 0.90 1536.44 1.00\n", + "age_impute[120] 0.63 0.81 0.66 -0.65 1.89 899.61 1.00\n", + "age_impute[121] 0.27 0.90 0.26 -1.16 1.74 1744.32 1.00\n", + "age_impute[122] 0.18 0.87 0.18 -1.23 1.60 1625.58 1.00\n", + "age_impute[123] -0.39 0.88 -0.38 -1.71 1.12 1266.58 1.00\n", + "age_impute[124] -0.62 0.95 -0.63 -2.03 1.01 1600.28 1.00\n", + "age_impute[125] 0.23 0.88 0.23 -1.15 1.71 1604.27 1.00\n", + "age_impute[126] 0.18 0.91 0.18 -1.24 1.63 1527.38 1.00\n", + "age_impute[127] 0.32 0.85 0.36 -1.08 1.73 1074.98 1.00\n", + "age_impute[128] 0.25 0.88 0.25 -1.10 1.69 1486.79 1.00\n", + "age_impute[129] -0.70 0.87 -0.68 -2.20 0.56 1506.55 1.00\n", + "age_impute[130] 0.21 0.88 0.20 -1.16 1.68 1451.63 1.00\n", + "age_impute[131] 0.22 0.87 0.23 -1.22 1.61 905.86 1.00\n", + "age_impute[132] 0.33 0.83 0.33 -1.01 1.66 1517.67 1.00\n", + "age_impute[133] 0.18 0.86 0.18 -1.19 1.59 1050.00 1.00\n", + "age_impute[134] -0.14 0.92 -0.15 -1.77 1.24 1386.20 1.00\n", + "age_impute[135] 0.19 0.85 0.18 -1.22 1.53 1290.94 1.00\n", + "age_impute[136] 0.16 0.92 0.16 -1.35 1.74 1767.36 1.00\n", + "age_impute[137] -0.71 0.90 -0.68 -2.24 0.82 1154.14 1.00\n", + "age_impute[138] 0.18 0.91 0.16 -1.30 1.67 1160.90 1.00\n", + "age_impute[139] 0.24 0.90 0.24 -1.15 1.76 1289.37 1.00\n", + "age_impute[140] 0.41 0.80 0.39 -1.05 1.53 1532.92 1.00\n", + "age_impute[141] 0.27 0.83 0.29 -1.04 1.60 1310.29 1.00\n", + "age_impute[142] -0.28 0.89 -0.29 -1.68 1.22 1088.65 1.00\n", + "age_impute[143] -0.12 0.91 -0.11 -1.56 1.40 1324.74 1.00\n", + "age_impute[144] -0.65 0.87 -0.63 -1.91 0.93 1672.31 1.00\n", + "age_impute[145] -1.73 0.26 -1.74 -2.11 -1.26 1502.96 1.00\n", + "age_impute[146] 0.40 0.85 0.40 -0.85 1.84 1443.81 1.00\n", + "age_impute[147] 0.23 0.87 0.20 -1.37 1.49 1220.62 1.00\n", + "age_impute[148] -0.70 0.88 -0.70 -2.08 0.87 1846.67 1.00\n", + "age_impute[149] 0.27 0.87 0.29 -1.11 1.76 1451.79 1.00\n", + "age_impute[150] 0.21 0.90 0.20 -1.10 1.78 1409.94 1.00\n", + "age_impute[151] 0.25 0.87 0.26 -1.21 1.63 1224.08 1.00\n", + "age_impute[152] 0.05 0.85 0.05 -1.42 1.39 1164.23 1.00\n", + "age_impute[153] 0.18 0.90 0.15 -1.19 1.72 1697.92 1.00\n", + "age_impute[154] 1.05 0.93 1.04 -0.24 2.84 1212.82 1.00\n", + "age_impute[155] 0.20 0.84 0.18 -1.18 1.54 1398.45 1.00\n", + "age_impute[156] 0.23 0.95 0.19 -1.19 1.87 1773.79 1.00\n", + "age_impute[157] 0.19 0.85 0.22 -1.13 1.64 1123.21 1.00\n", + "age_impute[158] 0.22 0.86 0.22 -1.18 1.60 1307.64 1.00\n", + "age_impute[159] 0.18 0.84 0.18 -1.09 1.59 1499.97 1.00\n", + "age_impute[160] 0.24 0.89 0.28 -1.23 1.65 1100.08 1.00\n", + "age_impute[161] -0.45 0.88 -0.45 -1.86 1.05 1414.97 1.00\n", + "age_impute[162] 0.39 0.89 0.40 -1.00 1.87 1525.80 1.00\n", + "age_impute[163] 0.34 0.89 0.35 -1.14 1.75 1600.03 1.00\n", + "age_impute[164] 0.21 0.94 0.19 -1.13 1.91 1090.05 1.00\n", + "age_impute[165] 0.22 0.85 0.20 -1.11 1.60 1330.87 1.00\n", + "age_impute[166] -0.13 0.91 -0.15 -1.69 1.28 1284.90 1.00\n", + "age_impute[167] 0.22 0.89 0.24 -1.15 1.76 1261.93 1.00\n", + "age_impute[168] 0.20 0.90 0.18 -1.18 1.83 1217.16 1.00\n", + "age_impute[169] 0.07 0.89 0.05 -1.29 1.60 2007.16 1.00\n", + "age_impute[170] 0.23 0.90 0.24 -1.25 1.67 937.57 1.00\n", + "age_impute[171] 0.41 0.80 0.42 -0.82 1.82 1404.02 1.00\n", + "age_impute[172] 0.23 0.87 0.20 -1.33 1.51 2032.72 1.00\n", + "age_impute[173] -0.44 0.88 -0.44 -1.81 1.08 1006.62 1.00\n", + "age_impute[174] 0.19 0.84 0.19 -1.11 1.63 1495.21 1.00\n", + "age_impute[175] 0.20 0.85 0.20 -1.17 1.63 1551.22 1.00\n", + "age_impute[176] -0.43 0.92 -0.44 -1.83 1.21 1477.58 1.00\n", + " age_mu[0] 0.19 0.04 0.19 0.12 0.26 749.16 1.00\n", + " age_mu[1] -0.54 0.07 -0.54 -0.66 -0.42 786.30 1.00\n", + " age_mu[2] 0.43 0.08 0.42 0.31 0.55 1134.72 1.00\n", + " age_mu[3] -1.73 0.04 -1.73 -1.79 -1.65 1194.53 1.00\n", + " age_mu[4] 0.85 0.17 0.85 0.58 1.13 1111.96 1.00\n", + " age_sigma[0] 0.88 0.03 0.88 0.82 0.93 766.67 1.00\n", + " age_sigma[1] 0.90 0.06 0.90 0.81 0.99 992.72 1.00\n", + " age_sigma[2] 0.79 0.05 0.78 0.71 0.87 708.34 1.00\n", + " age_sigma[3] 0.26 0.03 0.25 0.20 0.31 959.62 1.00\n", + " age_sigma[4] 0.93 0.13 0.93 0.74 1.15 1092.88 1.00\n", + " b_Age -0.45 0.14 -0.44 -0.66 -0.22 744.95 1.00\n", + " b_Embarked[0] -0.28 0.58 -0.30 -1.28 0.64 496.51 1.00\n", + " b_Embarked[1] 0.30 0.60 0.29 -0.74 1.20 495.25 1.00\n", + " b_Embarked[2] 0.04 0.61 0.03 -0.93 1.02 482.67 1.00\n", + " b_Parch[0] 0.45 0.57 0.47 -0.45 1.42 336.02 1.02\n", + " b_Parch[1] 0.12 0.58 0.14 -0.91 1.00 377.61 1.02\n", + " b_Parch[2] -0.49 0.58 -0.45 -1.48 0.41 358.61 1.01\n", + " b_Pclass[0] 1.22 0.57 1.24 0.33 2.17 371.15 1.00\n", + " b_Pclass[1] 0.06 0.57 0.07 -0.84 1.03 369.58 1.00\n", + " b_Pclass[2] -1.18 0.57 -1.16 -2.18 -0.31 373.55 1.00\n", + " b_Sex[0] 1.15 0.74 1.18 -0.03 2.31 568.65 1.00\n", + " b_Sex[1] -1.05 0.74 -1.02 -2.18 0.21 709.29 1.00\n", + " b_SibSp[0] 0.28 0.66 0.26 -0.86 1.25 585.03 1.00\n", + " b_SibSp[1] -0.17 0.67 -0.18 -1.28 0.87 596.44 1.00\n", + " b_Title[0] -0.94 0.54 -0.96 -1.86 -0.11 437.32 1.00\n", + " b_Title[1] -0.33 0.61 -0.33 -1.32 0.60 570.32 1.00\n", + " b_Title[2] 0.53 0.62 0.53 -0.52 1.46 452.87 1.00\n", + " b_Title[3] 1.48 0.59 1.48 0.60 2.48 562.71 1.00\n", + " b_Title[4] -0.68 0.58 -0.66 -1.71 0.15 472.57 1.00\n", "\n", "Number of divergences: 0\n" ] diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 203b69b26..c14f0c07d 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -26,7 +26,7 @@ # POSSIBILITY OF SUCH DAMAGE. -from jax import lax, ops +from jax import lax import jax.nn as nn import jax.numpy as jnp import jax.random as random @@ -751,11 +751,8 @@ def _onion(self, key, size): w = jnp.expand_dims(jnp.sqrt(beta_sample), axis=-1) * u_hypershere # put w into the off-diagonal triangular part - cholesky = ops.index_add( - jnp.zeros(size + self.batch_shape + self.event_shape), - ops.index[..., 1:, :-1], - w, - ) + cholesky = jnp.zeros(size + self.batch_shape + self.event_shape) + cholesky = cholesky.at[..., 1:, :-1].set(w) # correct the diagonal # NB: we clip due to numerical precision diag = jnp.sqrt(jnp.clip(1 - jnp.sum(cholesky ** 2, axis=-1), a_min=0.0)) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 305ea83c1..7658b155f 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -33,7 +33,6 @@ from jax import lax from jax.nn import softmax, softplus import jax.numpy as jnp -from jax.ops import index_add import jax.random as random from jax.scipy.special import expit, gammaincc, gammaln, logsumexp, xlog1py, xlogy @@ -621,7 +620,6 @@ def sample(self, key, sample_shape=()): def log_prob(self, value): if self._validate_args: self._validate_sample(value) - value = jax.device_get(value) if ( self.is_sparse and not isinstance(value, jax.core.Tracer) @@ -629,15 +627,18 @@ def log_prob(self, value): ): shape = lax.broadcast_shapes(self.batch_shape, jnp.shape(value)) rate = jnp.broadcast_to(self.rate, shape).reshape(-1) + nonzero = np.broadcast_to(jax.device_get(value) > 0, shape).reshape(-1) value = jnp.broadcast_to(value, shape).reshape(-1) - nonzero = value > 0 sparse_value = value[nonzero] sparse_rate = rate[nonzero] - return index_add( - -rate, - nonzero, - jnp.log(sparse_rate) * sparse_value - gammaln(sparse_value + 1), - ).reshape(shape) + return ( + jnp.asarray(-rate) + .at[nonzero] + .add( + jnp.log(sparse_rate) * sparse_value - gammaln(sparse_value + 1), + ) + .reshape(shape) + ) return (jnp.log(self.rate) * value) - gammaln(value + 1) - self.rate @property diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 1fffe42ac..9cc4b5fd4 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -7,7 +7,7 @@ import numpy as np -from jax import lax, ops, vmap +from jax import lax, vmap from jax.flatten_util import ravel_pytree from jax.nn import log_sigmoid, softplus import jax.numpy as jnp @@ -795,10 +795,10 @@ def __call__(self, x): def _inverse(self, y): size = self.permutation.size - permutation_inv = ops.index_update( - jnp.zeros(size, dtype=jnp.result_type(int)), - self.permutation, - jnp.arange(size), + permutation_inv = ( + jnp.zeros(size, dtype=jnp.result_type(int)) + .at[self.permutation] + .set(jnp.arange(size)) ) return y[..., permutation_inv] diff --git a/numpyro/infer/hmc_gibbs.py b/numpyro/infer/hmc_gibbs.py index f458bfe5c..abfac81b5 100644 --- a/numpyro/infer/hmc_gibbs.py +++ b/numpyro/infer/hmc_gibbs.py @@ -8,17 +8,7 @@ import numpy as np -from jax import ( - device_put, - grad, - hessian, - jacfwd, - jacobian, - lax, - ops, - random, - value_and_grad, -) +from jax import device_put, grad, hessian, jacfwd, jacobian, lax, random, value_and_grad from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.scipy.special import expit @@ -195,7 +185,7 @@ def _discrete_gibbs_proposal_body_fn( rng_key, z, pe, log_weight_sum = val rng_key, rng_transition = random.split(rng_key) proposal = jnp.where(i >= z_init_flat[idx], i + 1, i) - z_new_flat = ops.index_update(z_init_flat, idx, proposal) + z_new_flat = z_init_flat.at[idx].set(proposal) z_new = unravel_fn(z_new_flat) pe_new = potential_fn(z_new) log_weight_new = pe_init - pe_new @@ -279,7 +269,7 @@ def _discrete_rw_proposal(rng_key, z_discrete, pe, potential_fn, idx, support_si z_discrete_flat, unravel_fn = ravel_pytree(z_discrete) proposal = random.randint(rng_proposal, (), minval=0, maxval=support_size) - z_new_flat = ops.index_update(z_discrete_flat, idx, proposal) + z_new_flat = z_discrete_flat.at[idx].set(proposal) z_new = unravel_fn(z_new_flat) pe_new = potential_fn(z_new) log_accept_ratio = pe - pe_new @@ -296,7 +286,7 @@ def _discrete_modified_rw_proposal( i = random.randint(rng_proposal, (), minval=0, maxval=support_size - 1) proposal = jnp.where(i >= z_discrete_flat[idx], i + 1, i) proposal = jnp.where(random.bernoulli(rng_stay, stay_prob), idx, proposal) - z_new_flat = ops.index_update(z_discrete_flat, idx, proposal) + z_new_flat = z_discrete_flat.at[idx].set(proposal) z_new = unravel_fn(z_new_flat) pe_new = potential_fn(z_new) log_accept_ratio = pe - pe_new diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index 53495715a..ba8bd96c1 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -6,7 +6,6 @@ from jax import grad, jacfwd, random, value_and_grad, vmap from jax.flatten_util import ravel_pytree import jax.numpy as jnp -from jax.ops import index_update from jax.scipy.linalg import solve_triangular from jax.scipy.special import expit from jax.tree_util import tree_flatten, tree_map, tree_multimap @@ -1040,10 +1039,7 @@ def _body_fn(state): r_ckpts, r_sum_ckpts = cond( leaf_idx % 2 == 0, (r_ckpts, r_sum_ckpts), - lambda x: ( - index_update(x[0], ckpt_idx_max, r), - index_update(x[1], ckpt_idx_max, r_sum), - ), + lambda x: (x[0].at[ckpt_idx_max].set(r), x[1].at[ckpt_idx_max].set(r_sum)), (r_ckpts, r_sum_ckpts), identity, ) diff --git a/numpyro/infer/mixed_hmc.py b/numpyro/infer/mixed_hmc.py index ee4b7defd..863418602 100644 --- a/numpyro/infer/mixed_hmc.py +++ b/numpyro/infer/mixed_hmc.py @@ -4,7 +4,7 @@ from collections import namedtuple from functools import partial -from jax import grad, jacfwd, lax, ops, random +from jax import grad, jacfwd, lax, random from jax.flatten_util import ravel_pytree import jax.numpy as jnp @@ -159,7 +159,7 @@ def update_discrete( ) delta_pe_sum = delta_pe_sum + pe - hmc_state.potential_energy - ke_discrete = ops.index_update(ke_discrete, idx, ke_discrete_i) + ke_discrete = ke_discrete.at[idx].set(ke_discrete_i) hmc_state = hmc_state._replace(potential_energy=pe, z_grad=z_grad) return rng_key, hmc_state, z_discrete, ke_discrete, delta_pe_sum @@ -194,7 +194,7 @@ def body_fn(i, vals): # (see the note at total_time below) trajectory_length = arrival_times[idx] * time_unit arrival_times = arrival_times - arrival_times[idx] - arrival_times = ops.index_update(arrival_times, idx, 1.0) + arrival_times = arrival_times.at[idx].set(1.0) # this is a trick, so that in a sub-trajectory of HMC, we always accept the new proposal pe = jnp.inf diff --git a/numpyro/nn/auto_reg_nn.py b/numpyro/nn/auto_reg_nn.py index a14ee707b..d39a70d0e 100644 --- a/numpyro/nn/auto_reg_nn.py +++ b/numpyro/nn/auto_reg_nn.py @@ -5,7 +5,6 @@ import numpy as np -from jax import ops from jax.experimental import stax import jax.numpy as jnp @@ -41,7 +40,7 @@ def create_mask(input_dim, hidden_dims, permutation, output_dim_multiplier): """ # Create mask indices for input, hidden layers, and final layer var_index = jnp.zeros(permutation.shape[0]) - var_index = ops.index_update(var_index, permutation, jnp.arange(input_dim)) + var_index = var_index.at[permutation].set(jnp.arange(input_dim)) # Create the indices that are assigned to the neurons input_indices = 1 + var_index diff --git a/numpyro/nn/block_neural_arn.py b/numpyro/nn/block_neural_arn.py index 8eb8598be..b1dc22176 100644 --- a/numpyro/nn/block_neural_arn.py +++ b/numpyro/nn/block_neural_arn.py @@ -3,7 +3,7 @@ import numpy as np -from jax import ops, random +from jax import random from jax.experimental import stax from jax.nn import sigmoid, softplus from jax.nn.initializers import glorot_uniform, normal, uniform @@ -43,10 +43,8 @@ def init_fun(rng, input_shape): # Initialize each column block using W_init W = jnp.zeros((input_dim, out_dim)) for i in range(num_blocks): - W = ops.index_add( - W, - ops.index[: (i + 1) * in_factor, i * out_factor : (i + 1) * out_factor], - W_init(k1[i], ((i + 1) * in_factor, out_factor)), + W = W.at[: (i + 1) * in_factor, i * out_factor : (i + 1) * out_factor].set( + W_init(k1[i], ((i + 1) * in_factor, out_factor)) ) # initialize weight scale diff --git a/numpyro/primitives.py b/numpyro/primitives.py index 14b179daf..adf014878 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -7,7 +7,7 @@ import warnings import jax -from jax import lax, ops, random +from jax import lax, random import jax.numpy as jnp import numpyro @@ -391,17 +391,7 @@ def body_fn(val, idx): i_p1 = size - idx i = i_p1 - 1 j = random.randint(rng_keys[idx], (), 0, i_p1) - val = ops.index_update( - val, - ops.index[ - [i, j], - ], - val[ - ops.index[ - [j, i], - ] - ], - ) + val = val.at[jnp.array([i, j])].set(val[jnp.array([j, i])]) return val, None val, _ = lax.scan(body_fn, jnp.arange(size), jnp.arange(subsample_size)) diff --git a/numpyro/util.py b/numpyro/util.py index 0a689c79c..fbc0b6154 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -14,7 +14,7 @@ from tqdm.auto import tqdm as tqdm_auto import jax -from jax import device_put, jit, lax, ops, vmap +from jax import device_put, jit, lax, vmap from jax.core import Tracer from jax.experimental import host_callback from jax.flatten_util import ravel_pytree @@ -323,7 +323,7 @@ def _body_fn(i, vals): collection = cond( idx >= 0, collection, - lambda x: ops.index_update(x, idx, ravel_pytree(transform(val))[0]), + lambda x: x.at[idx].set(ravel_pytree(transform(val))[0]), collection, identity, ) From b7e16b5c0153f35c36f42e1e58d0a0c1bfb02bcd Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 18 Oct 2021 13:00:22 -0400 Subject: [PATCH 190/222] support enumerate support for zero inflated distribution (#1179) --- numpyro/distributions/discrete.py | 9 ++++++++- numpyro/infer/autoguide.py | 2 +- numpyro/infer/initialization.py | 4 ++-- numpyro/infer/util.py | 8 +++++--- test/test_distributions.py | 7 +++++++ 5 files changed, 23 insertions(+), 7 deletions(-) diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 7658b155f..2c597abc5 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -660,7 +660,7 @@ class ZeroInflatedProbs(Distribution): def __init__(self, base_dist, gate, *, validate_args=None): batch_shape = lax.broadcast_shapes(jnp.shape(gate), base_dist.batch_shape) (self.gate,) = promote_shapes(gate, shape=batch_shape) - assert base_dist.is_discrete + assert base_dist.support.is_discrete if base_dist.event_shape: raise ValueError( "ZeroInflatedProbs expected empty base_dist.event_shape but got {}".format( @@ -701,6 +701,13 @@ def variance(self): self.base_dist.mean ** 2 + self.base_dist.variance ) - self.mean ** 2 + @property + def has_enumerate_support(self): + return self.base_dist.has_enumerate_support + + def enumerate_support(self, expand=True): + return self.base_dist.enumerate_support(expand=expand) + class ZeroInflatedLogits(ZeroInflatedProbs): arg_constraints = {"gate_logits": constraints.real} diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 01be6640e..8239f8a2b 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -161,7 +161,7 @@ def _setup_prototype(self, *args, **kwargs): self._prototype_plate_sizes = {} for name, site in self.prototype_trace.items(): if site["type"] == "sample": - if not site["is_observed"] and site["fn"].is_discrete: + if not site["is_observed"] and site["fn"].support.is_discrete: # raise support errors early for discrete sites with helpful_support_errors(site): biject_to(site["fn"].support) diff --git a/numpyro/infer/initialization.py b/numpyro/infer/initialization.py index 78afe5435..b6e00e9ca 100644 --- a/numpyro/infer/initialization.py +++ b/numpyro/infer/initialization.py @@ -23,7 +23,7 @@ def init_to_median(site=None, num_samples=15): if ( site["type"] == "sample" and not site["is_observed"] - and not site["fn"].is_discrete + and not site["fn"].support.is_discrete ): if site["value"] is not None: warnings.warn( @@ -63,7 +63,7 @@ def init_to_uniform(site=None, radius=2): if ( site["type"] == "sample" and not site["is_observed"] - and not site["fn"].is_discrete + and not site["fn"].support.is_discrete ): if site["value"] is not None: warnings.warn( diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index ba28a4c2b..427d765d8 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -326,7 +326,7 @@ def body_fn(state): if ( v["type"] == "sample" and not v["is_observed"] - and not v["fn"].is_discrete + and not v["fn"].support.is_discrete ): constrained_values[k] = v["value"] with helpful_support_errors(v): @@ -401,7 +401,7 @@ def _get_model_transforms(model, model_args=(), model_kwargs=None): has_enumerate_support = False for k, v in model_trace.items(): if v["type"] == "sample" and not v["is_observed"]: - if v["fn"].is_discrete: + if v["fn"].support.is_discrete: has_enumerate_support = True if not v["fn"].has_enumerate_support: raise RuntimeError( @@ -599,7 +599,9 @@ def initialize_model( constrained_values = { k: v["value"] for k, v in model_trace.items() - if v["type"] == "sample" and not v["is_observed"] and not v["fn"].is_discrete + if v["type"] == "sample" + and not v["is_observed"] + and not v["fn"].support.is_discrete } if has_enumerate_support: diff --git a/test/test_distributions.py b/test/test_distributions.py index 706d8420f..519c1e695 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -2009,6 +2009,13 @@ def test_enumerate_support_smoke(jax_dist, params, support, batch_shape, expand) assert_allclose(actual, expected) +def test_zero_inflated_enumerate_support(): + base_dist = dist.Bernoulli(0.5) + d = dist.ZeroInflatedDistribution(base_dist, gate=0.5) + assert d.has_enumerate_support + assert_allclose(d.enumerate_support(), base_dist.enumerate_support()) + + @pytest.mark.parametrize("jax_dist, sp_dist, params", CONTINUOUS + DISCRETE) @pytest.mark.parametrize("prepend_shape", [(), (2, 3)]) @pytest.mark.parametrize("sample_shape", [(), (4,)]) From 965daa369810d61273415fa10a76f406ec3d4442 Mon Sep 17 00:00:00 2001 From: Ben Jeffrey <36240394+bjeffrey92@users.noreply.github.com> Date: Mon, 25 Oct 2021 14:45:13 +0100 Subject: [PATCH 191/222] Option to use state of previous SVI run as starting state (#1194) * argument to SVI.run() which takes the state of previous SVI run as starting point * change argument name and type hint * usage in documentation * remove trailing whitespace --- numpyro/infer/svi.py | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index faeefae95..646d11fc6 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -285,6 +285,7 @@ def run( *args, progress_bar=True, stable_update=False, + init_state=None, **kwargs, ): """ @@ -304,6 +305,15 @@ def run( ``True``. :param bool stable_update: whether to use :meth:`stable_update` to update the state. Defaults to False. + :param SVIState init_state: if not None, begin SVI from the + final state of previous SVI run. Usage:: + + svi = SVI(model, guide, optimizer, loss=Trace_ELBO()) + svi_result = svi.run(random.PRNGKey(0), 2000, data) + # upon inspection of svi_result the user decides that the model has not converged + # continue from the end of the previous svi run rather than beginning again from iteration 0 + svi_result = svi.run(random.PRNGKey(1), 2000, data, init_state=svi_result.state) + :param kwargs: keyword arguments to the model / guide :return: a namedtuple with fields `params` and `losses` where `params` holds the optimized values at :class:`numpyro.param` sites, @@ -321,7 +331,10 @@ def body_fn(svi_state, _): svi_state, loss = self.update(svi_state, *args, **kwargs) return svi_state, loss - svi_state = self.init(rng_key, *args, **kwargs) + if init_state is None: + svi_state = self.init(rng_key, *args, **kwargs) + else: + svi_state = init_state if progress_bar: losses = [] with tqdm.trange(1, num_steps + 1) as t: From bc47ff025b947fba530bec7e428eea66c102a459 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 25 Oct 2021 21:30:04 -0400 Subject: [PATCH 192/222] Clarify that obs_mask should not be used in MCMC (#1197) * Clarify that obs_mask should not be used in MCMC * remove deprecated xla_bridge * Add threshold * fix lint --- numpyro/primitives.py | 3 ++- test/infer/test_compute_downstream_costs.py | 4 ++-- test/infer/test_mcmc.py | 6 +++--- test/test_compile.py | 6 ++---- 4 files changed, 9 insertions(+), 10 deletions(-) diff --git a/numpyro/primitives.py b/numpyro/primitives.py index adf014878..bb2e67d2c 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -128,7 +128,8 @@ def sample( broadcastable with ``fn.batch_shape``. If provided, events with mask=True will be conditioned on ``obs`` and remaining events will be imputed by sampling. This introduces a latent sample site named ``name - + "_unobserved"`` which should be used by guides. + + "_unobserved"`` which should be used by guides in SVI. Note that this + argument is not intended to be used with MCMC. :return: sample from the stochastic `fn`. """ assert isinstance( diff --git a/test/infer/test_compute_downstream_costs.py b/test/infer/test_compute_downstream_costs.py index 91b55cdf7..4ac4adb95 100644 --- a/test/infer/test_compute_downstream_costs.py +++ b/test/infer/test_compute_downstream_costs.py @@ -360,10 +360,10 @@ def test_compute_downstream_costs_plate_reuse(dim1, dim2): for k in dc: assert guide_trace[k]["log_prob"].shape == dc[k].shape - assert_allclose(dc[k], dc_brute[k]) + assert_allclose(dc[k], dc_brute[k], rtol=1e-6) expected_c1 = model_trace["c1"]["log_prob"] - guide_trace["c1"]["log_prob"] expected_c1 += (model_trace["b1"]["log_prob"] - guide_trace["b1"]["log_prob"]).sum() expected_c1 += model_trace["c2"]["log_prob"] - guide_trace["c2"]["log_prob"] expected_c1 += model_trace["obs"]["log_prob"] - assert_allclose(expected_c1, dc["c1"]) + assert_allclose(expected_c1, dc["c1"], rtol=1e-6) diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index dc9e3fa15..d41efe72d 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -7,8 +7,8 @@ from numpy.testing import assert_allclose import pytest +import jax from jax import device_get, jit, lax, pmap, random, vmap -from jax.lib import xla_bridge import jax.numpy as jnp from jax.scipy.special import logit from jax.test_util import check_close @@ -586,7 +586,7 @@ def model(labels): def test_chain_inside_jit(kernel_cls, chain_method): # NB: this feature is useful for consensus MC. # Caution: compiling time will be slow (~ 90s) - if chain_method == "parallel" and xla_bridge.device_count() == 1: + if chain_method == "parallel" and jax.device_count() == 1: pytest.skip("parallel method requires device_count greater than 1.") num_warmup, num_samples = 100, 2000 # Here are settings which is currently supported. @@ -716,7 +716,7 @@ def model(data): reason="without this mark, we have duplicated tests in Travis", ) def test_functional_map(algo, map_fn): - if map_fn is pmap and xla_bridge.device_count() == 1: + if map_fn is pmap and jax.device_count() == 1: pytest.skip("pmap test requires device_count greater than 1.") true_mean, true_std = 1.0, 2.0 diff --git a/test/test_compile.py b/test/test_compile.py index 99dec7058..545ecc5db 100644 --- a/test/test_compile.py +++ b/test/test_compile.py @@ -3,8 +3,8 @@ import pytest +import jax from jax import lax, random -from jax.lib import xla_bridge import numpyro import numpyro.distributions as dist @@ -42,9 +42,7 @@ def test_mcmc_one_chain(deterministic, find_heuristic_step_size): @pytest.mark.parametrize("deterministic", [True, False]) -@pytest.mark.skipif( - xla_bridge.device_count() < 2, reason="only one device is available" -) +@pytest.mark.skipif(jax.device_count() < 2, reason="only one device is available") def test_mcmc_parallel_chain(deterministic): GLOBAL["count"] = 0 mcmc = MCMC(NUTS(model), num_warmup=100, num_samples=100, num_chains=2) From 99ae4ed783d65320410172e69761bbb798742a12 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 29 Oct 2021 11:03:22 -0400 Subject: [PATCH 193/222] Allow to pass a custom precision fn to laplace approximation (#1196) * Allow to pass a custom precision fn to laplace approximation * address comment: replace get_precision by hessian_fn --- numpyro/infer/autoguide.py | 27 ++++++++++++++++++++++++++- test/infer/test_autoguide.py | 19 ++++++++++++++++++- 2 files changed, 44 insertions(+), 2 deletions(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 8239f8a2b..2549d1093 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -1086,8 +1086,33 @@ class AutoLaplaceApproximation(AutoContinuous): guide = AutoLaplaceApproximation(model, ...) svi = SVI(model, guide, ...) + + :param callable hessian_fn: EXPERIMENTAL a function that takes a function `f` + and a vector `x`and returns the hessian of `f` at `x`. By default, we use + ``lambda f, x: jax.hessian(f)(x)``. Other alternatives can be + ``lambda f, x: jax.jacobian(jax.jacobian(f))(x)`` or + ``lambda f, x: jax.hessian(f)(x) + 1e-3 * jnp.eye(x.shape[0])``. The later + example is helpful when the hessian of `f` at `x` is not positive definite. + Note that the output hessian is the precision matrix of the laplace + approximation. """ + def __init__( + self, + model, + *, + prefix="auto", + init_loc_fn=init_to_uniform, + create_plates=None, + hessian_fn=None, + ): + super().__init__( + model, prefix=prefix, init_loc_fn=init_loc_fn, create_plates=create_plates + ) + self._hessian_fn = ( + hessian_fn if hessian_fn is not None else (lambda f, x: hessian(f)(x)) + ) + def _setup_prototype(self, *args, **kwargs): super(AutoLaplaceApproximation, self)._setup_prototype(*args, **kwargs) @@ -1114,7 +1139,7 @@ def loss_fn(z): return self._loss_fn(params1) loc = params["{}_loc".format(self.prefix)] - precision = hessian(loss_fn)(loc) + precision = self._hessian_fn(loss_fn, loc) scale_tril = cholesky_of_inverse(precision) if not_jax_tracer(scale_tril): if np.any(np.isnan(scale_tril)): diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 3b779197e..d0e334141 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -6,7 +6,7 @@ from numpy.testing import assert_allclose import pytest -from jax import jit, lax, random +from jax import jacobian, jit, lax, random from jax.experimental.stax import Dense import jax.numpy as jnp from jax.test_util import check_eq @@ -361,6 +361,23 @@ def model(x, y): guide.sample_posterior(random.PRNGKey(1), params) +def test_laplace_approximation_custom_hessian(): + def model(x, y): + a = numpyro.sample("a", dist.Normal(0, 10)) + b = numpyro.sample("b", dist.Normal(0, 10)) + mu = a + b * x + numpyro.sample("y", dist.Normal(mu, 1), obs=y) + + x = random.normal(random.PRNGKey(0), (100,)) + y = 1 + 2 * x + guide = AutoLaplaceApproximation( + model, hessian_fn=lambda f, x: jacobian(jacobian(f))(x) + ) + svi = SVI(model, guide, optim.Adam(0.1), Trace_ELBO(), x=x, y=y) + svi_result = svi.run(random.PRNGKey(0), 10000, progress_bar=False) + guide.get_transform(svi_result.params) + + def test_improper(): y = random.normal(random.PRNGKey(0), (100,)) From cb7d4805d627dbb422246aab1f5a28e119941f84 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 29 Oct 2021 11:09:27 -0400 Subject: [PATCH 194/222] update installation instruction for cuda (#1205) --- README.md | 4 ++-- setup.py | 13 ++----------- 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/README.md b/README.md index 475afde89..cd3a2270c 100644 --- a/README.md +++ b/README.md @@ -199,8 +199,7 @@ pip install numpyro[cpu] To use **NumPyro on the GPU**, you need to install CUDA first and then use the following pip command: ``` -# change `cuda111` to your CUDA version number, e.g. for CUDA 10.2 use `cuda102` -pip install numpyro[cuda111] -f https://storage.googleapis.com/jax-releases/jax_releases.html +pip install numpyro[cuda] -f https://storage.googleapis.com/jax-releases/jax_releases.html ``` If you need further guidance, please have a look at the [JAX GPU installation instructions](https://github.com/google/jax#pip-installation-gpu-cuda). @@ -216,6 +215,7 @@ You can also install NumPyro from source: ``` git clone https://github.com/pyro-ppl/numpyro.git +cd numpyro # install jax/jaxlib first for CUDA support pip install -e .[dev] # contains additional dependencies for NumPyro development ``` diff --git a/setup.py b/setup.py index 9b74345a3..48735ef33 100644 --- a/setup.py +++ b/setup.py @@ -9,12 +9,6 @@ from setuptools import find_packages, setup PROJECT_PATH = os.path.dirname(os.path.abspath(__file__)) -_available_cuda_versions = [ - "101", - "102", - "110", - "111", -] # TODO: align these with what's available in JAX before release _jax_version_constraints = ">=0.2.13" _jaxlib_version_constraints = ">=0.1.65" @@ -80,12 +74,9 @@ ], "cpu": f"jax[cpu]{_jax_version_constraints}", # TPU and CUDA installations, currently require to add package repository URL, i.e., - # pip install numpyro[cuda101] -f https://storage.googleapis.com/jax-releases/jax_releases.html + # pip install numpyro[cuda] -f https://storage.googleapis.com/jax-releases/jax_releases.html "tpu": f"jax[tpu]{_jax_version_constraints}", - **{ - f"cuda{version}": f"jax[cuda{version}]{_jax_version_constraints}" - for version in _available_cuda_versions - }, + "cuda": f"jax[cuda]{_jax_version_constraints}", }, long_description=long_description, long_description_content_type="text/markdown", From ab9a6f6910e489d7bbbbe24dc165bfdd816c87d2 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Fri, 29 Oct 2021 12:54:36 -0400 Subject: [PATCH 195/222] Raise errors for using AutoContinuous with local latent variables (#1199) * Raise errors for using auto continuous with local latent variables * also improve lkj sampler * fix failing test * fix auto dais subsampling test --- numpyro/distributions/continuous.py | 6 +++--- numpyro/infer/autoguide.py | 8 ++++++++ test/infer/test_autoguide.py | 15 ++++++++++++--- 3 files changed, 23 insertions(+), 6 deletions(-) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index c14f0c07d..7dfae508d 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -754,8 +754,8 @@ def _onion(self, key, size): cholesky = jnp.zeros(size + self.batch_shape + self.event_shape) cholesky = cholesky.at[..., 1:, :-1].set(w) # correct the diagonal - # NB: we clip due to numerical precision - diag = jnp.sqrt(jnp.clip(1 - jnp.sum(cholesky ** 2, axis=-1), a_min=0.0)) + # NB: beta_sample = sum(w ** 2) because norm 2 of u is 1. + diag = jnp.ones(cholesky.shape[:-1]).at[..., 1:].set(jnp.sqrt(1 - beta_sample)) cholesky = cholesky + jnp.expand_dims(diag, axis=-1) * jnp.identity( self.dimension ) @@ -798,7 +798,7 @@ def log_prob(self, value): order = 2 * jnp.expand_dims(self.concentration, axis=-1) - order_offset # Compute unnormalized log_prob: - value_diag = value[..., one_to_D, one_to_D] + value_diag = jnp.asarray(value)[..., one_to_D, one_to_D] unnormalized = jnp.sum(order * jnp.log(value_diag), axis=-1) # Compute normalization constant (on the first proof of page 1999 of [1]) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 2549d1093..186d12053 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -519,6 +519,14 @@ def _setup_prototype(self, *args, **kwargs): type(self).__name__ ) ) + for site in self.prototype_trace.values(): + if site["type"] == "sample" and not site["is_observed"]: + for frame in site["cond_indep_stack"]: + if frame.size != self._prototype_frame_full_sizes[frame.name]: + raise ValueError( + "AutoContinuous guide does not support" + " local latent variables." + ) @abstractmethod def _get_posterior(self): diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index d0e334141..bbbd6a179 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -601,10 +601,8 @@ def test_autodais_subsampling_error(): data = jnp.array([1.0] * 8 + [0.0] * 2) def model(data): + f = numpyro.sample("beta", dist.Beta(1, 1)) with numpyro.plate("plate", 20, 10, dim=-1): - f = numpyro.sample( - "beta", dist.Beta(jnp.ones(data.shape), jnp.ones(data.shape)) - ) numpyro.sample("obs", dist.Bernoulli(f), obs=data) adam = optim.Adam(0.01) @@ -627,3 +625,14 @@ def model(): svi_result = svi.run(random.PRNGKey(0), 10) samples = guide.sample_posterior(random.PRNGKey(1), svi_result.params) assert "x2" in samples + + +def test_autocontinuous_local_error(): + def model(): + with numpyro.plate("N", 10, subsample_size=4): + numpyro.sample("x", dist.Normal(0, 1)) + + guide = AutoDiagonalNormal(model) + svi = SVI(model, guide, optim.Adam(1.0), Trace_ELBO()) + with pytest.raises(ValueError, match="local latent variables"): + svi.init(random.PRNGKey(0)) From 5d1d15a2578cd32550e1b44468ec5d5ee80f6099 Mon Sep 17 00:00:00 2001 From: Hessam Mehr Date: Sun, 31 Oct 2021 12:05:29 +0000 Subject: [PATCH 196/222] Add note on mixed parallel/vectorized sampling. (#1207) --- numpyro/infer/mcmc.py | 26 ++++++++++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/numpyro/infer/mcmc.py b/numpyro/infer/mcmc.py index 367afbfdf..7ceb43ab1 100644 --- a/numpyro/infer/mcmc.py +++ b/numpyro/infer/mcmc.py @@ -239,6 +239,32 @@ class MCMC(object): on a same sized but different dataset will not result in additional compilation cost. Note that currently, this does not take effect for the case ``num_chains > 1`` and ``chain_method == 'parallel'``. + + .. note:: It is possible to mix parallel and vectorized sampling, i.e., run vectorized chains + on multiple devices using explicit `pmap`. Currently, doing so requires disabling the + progress bar. For example, + + .. code-block:: python + + def do_mcmc(rng_key, n_vectorized=8): + nuts_kernel = NUTS(model) + mcmc = MCMC( + nuts_kernel, + progress_bar=False, + num_chains=n_vectorized, + chain_method='vectorized' + ) + mcmc.run( + rng_key, + extra_fields=("potential_energy",), + ) + return {**mcmc.get_samples(), **mcmc.get_extra_fields()} + # Number of devices to pmap over + n_parallel = jax.local_device_count() + rng_keys = jax.random.split(PRNGKey(rng_seed), n_parallel) + traces = pmap(do_mcmc)(rng_keys) + # concatenate traces along pmap'ed axis + trace = {k: np.concatenate(v) for k, v in traces.items()} """ def __init__( From c5cd51d997f4e68a4e30646ce440839d77b23d55 Mon Sep 17 00:00:00 2001 From: Mark Worrall Date: Tue, 2 Nov 2021 22:09:43 +0000 Subject: [PATCH 197/222] Add multivariate student-t distribution (#1200) * Add MultivariateStudentT distribution and tests * Remove unneeded reshape in log_prob * Update comment for test_distribution_constraints test * Remove redundant logic * Update for black ;) * bump scipy version to >= 1.6 to support multivariate t distribution * Update Python version to 3.7 * Change to tfp-nightly * Ensure value in LKJCholesky log_prob is a jax array * avoid appending new axis when initializing mvt dist * Use jax.scipy.linalg.solve_triangular * Ensure variance is broadcast * Change np.argsort kind to stable due to warnings raised * Use jnp.diagonal * Resolve conflict * Fix hmm_enum.py example * fix ode.py example as jnp.percentile no longer takes a tuple * Update test python version to 3.7 and fix failing tests * Suppress warnings * Fix scipy version to >=1.6 and < 1.7 due to broadcasting bugs * Add MVT to Sphinx * fix sphinx underline * fix scipy version * suppress CI warning * Use _batch_mahalanobis function in log_prob calc and add test case for batched df * Tidy up shapes * test precision and covariance matrix * skip multivariate-t tests if scipy version <1.6 Co-authored-by: Du Phan --- .github/workflows/ci.yml | 8 +-- docs/requirements.txt | 3 +- docs/source/distributions.rst | 8 +++ examples/gaussian_shells.py | 5 +- examples/hmm_enum.py | 2 +- examples/ode.py | 3 +- numpyro/distributions/__init__.py | 2 + numpyro/distributions/continuous.py | 96 +++++++++++++++++++++++++++++ numpyro/distributions/gof.py | 4 +- numpyro/examples/datasets.py | 2 +- numpyro/infer/hmc_util.py | 4 +- setup.py | 7 ++- test/test_distributions.py | 95 +++++++++++++++++++++++++++- test/test_handlers.py | 2 +- 14 files changed, 221 insertions(+), 20 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 4aac638a8..e65ad17c8 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -14,7 +14,7 @@ jobs: runs-on: ubuntu-latest strategy: matrix: - python-version: [3.6] + python-version: [3.7] steps: - uses: actions/checkout@v2 @@ -50,7 +50,7 @@ jobs: needs: lint strategy: matrix: - python-version: [3.6] + python-version: [3.7] steps: - uses: actions/checkout@v2 @@ -80,7 +80,7 @@ jobs: needs: lint strategy: matrix: - python-version: [3.6] + python-version: [3.7] steps: - uses: actions/checkout@v2 @@ -118,7 +118,7 @@ jobs: needs: lint strategy: matrix: - python-version: [3.6] + python-version: [3.7] steps: - uses: actions/checkout@v2 diff --git a/docs/requirements.txt b/docs/requirements.txt index e4a250672..9369a0260 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -11,5 +11,6 @@ readthedocs-sphinx-search==0.1.0 sphinx==4.0.3 sphinx-gallery sphinx_rtd_theme==0.5.2 -tensorflow_probability>=0.13 +# TODO: change to tensorflow_probability when it is stable +tfp-nightly tqdm diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index 901197c12..f65e4d3c7 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -225,6 +225,14 @@ MultivariateNormal :show-inheritance: :member-order: bysource +MultivariateStudentT +^^^^^^^^^^^^^^^^^^^^ +.. autoclass:: numpyro.distributions.continuous.MultivariateStudentT + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + LowRankMultivariateNormal ^^^^^^^^^^^^^^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.continuous.LowRankMultivariateNormal diff --git a/examples/gaussian_shells.py b/examples/gaussian_shells.py index 5685ae97b..973412a53 100644 --- a/examples/gaussian_shells.py +++ b/examples/gaussian_shells.py @@ -22,6 +22,7 @@ import matplotlib.pyplot as plt +import jax from jax import random import jax.numpy as jnp @@ -62,7 +63,9 @@ def run_inference(args, data): print("=== Performing Nested Sampling ===") ns = NestedSampler(model) ns.run(random.PRNGKey(0), **data, enum=args.enum) - ns.print_summary() + # TODO: Remove this condition when jaxns is compatible with the latest jax version. + if jax.__version__ < "0.2.21": + ns.print_summary() # samples obtained from nested sampler are weighted, so # we need to provide random key to resample from those weighted samples ns_samples = ns.get_samples(random.PRNGKey(1), num_samples=args.num_samples) diff --git a/examples/hmm_enum.py b/examples/hmm_enum.py index cf924d2fa..ae577492d 100644 --- a/examples/hmm_enum.py +++ b/examples/hmm_enum.py @@ -313,7 +313,7 @@ def main(args): # find all the notes that are present at least once in the training set present_notes = (sequences == 1).sum(0).sum(0) > 0 # remove notes that are never played (we remove 37/88 notes with default args) - sequences = sequences[..., present_notes] + sequences = sequences[:, :, present_notes] if args.truncate: lengths = lengths.clip(0, args.truncate) diff --git a/examples/ode.py b/examples/ode.py index aa437ab49..46b40d2d9 100644 --- a/examples/ode.py +++ b/examples/ode.py @@ -100,7 +100,8 @@ def main(args): # predict populations pop_pred = Predictive(model, mcmc.get_samples())(PRNGKey(2), data.shape[0])["y"] - mu, pi = jnp.mean(pop_pred, 0), jnp.percentile(pop_pred, (10, 90), 0) + mu = jnp.mean(pop_pred, 0) + pi = jnp.percentile(pop_pred, jnp.array([10, 90]), 0) plt.figure(figsize=(8, 6), constrained_layout=True) plt.plot(year, data[:, 0], "ko", mfc="none", ms=4, label="true hare", alpha=0.67) plt.plot(year, data[:, 1], "bx", label="true lynx") diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index a413224a9..4ab02fba6 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -30,6 +30,7 @@ LogNormal, LowRankMultivariateNormal, MultivariateNormal, + MultivariateStudentT, Normal, Pareto, SoftLaplace, @@ -141,6 +142,7 @@ "MultinomialLogits", "MultinomialProbs", "MultivariateNormal", + "MultivariateStudentT", "LowRankMultivariateNormal", "Normal", "NegativeBinomialProbs", diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 7dfae508d..4060f7f0e 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -1044,6 +1044,102 @@ def infer_shapes( return batch_shape, event_shape +class MultivariateStudentT(Distribution): + arg_constraints = { + "df": constraints.positive, + "loc": constraints.real_vector, + "scale_tril": constraints.lower_cholesky, + } + support = constraints.real_vector + reparametrized_params = ["df", "loc", "scale_tril"] + + def __init__( + self, + df, + loc=0.0, + scale_tril=None, + validate_args=None, + ): + if jnp.ndim(loc) == 0: + (loc,) = promote_shapes(loc, shape=(1,)) + batch_shape = lax.broadcast_shapes( + jnp.shape(df), jnp.shape(loc)[:-1], jnp.shape(scale_tril)[:-2] + ) + (self.df,) = promote_shapes(df, shape=batch_shape) + (self.loc,) = promote_shapes(loc, shape=batch_shape + loc.shape[-1:]) + (self.scale_tril,) = promote_shapes( + scale_tril, shape=batch_shape + scale_tril.shape[-2:] + ) + event_shape = jnp.shape(self.scale_tril)[-1:] + self._chi2 = Chi2(self.df) + super(MultivariateStudentT, self).__init__( + batch_shape=batch_shape, + event_shape=event_shape, + validate_args=validate_args, + ) + + def sample(self, key, sample_shape=()): + assert is_prng_key(key) + key_normal, key_chi2 = random.split(key) + std_normal = random.normal( + key_normal, + shape=sample_shape + self.batch_shape + self.event_shape, + ) + z = self._chi2.sample(key_chi2, sample_shape) + y = std_normal * jnp.expand_dims(jnp.sqrt(self.df / z), -1) + return self.loc + jnp.squeeze( + jnp.matmul(self.scale_tril, y[..., jnp.newaxis]), axis=-1 + ) + + @validate_sample + def log_prob(self, value): + n = self.scale_tril.shape[-1] + Z = ( + jnp.log(jnp.diagonal(self.scale_tril, axis1=-2, axis2=-1)).sum(-1) + + 0.5 * n * jnp.log(self.df) + + 0.5 * n * jnp.log(jnp.pi) + + gammaln(0.5 * self.df) + - gammaln(0.5 * (self.df + n)) + ) + M = _batch_mahalanobis(self.scale_tril, value - self.loc) + return -0.5 * (self.df + n) * jnp.log1p(M / self.df) - Z + + @lazy_property + def covariance_matrix(self): + # NB: this is not covariance of this distribution; + # the actual covariance is df / (df - 2) * covariance_matrix + return jnp.matmul(self.scale_tril, jnp.swapaxes(self.scale_tril, -1, -2)) + + @lazy_property + def precision_matrix(self): + identity = jnp.broadcast_to( + jnp.eye(self.scale_tril.shape[-1]), self.scale_tril.shape + ) + return cho_solve((self.scale_tril, True), identity) + + @property + def mean(self): + # for df <= 1. should be jnp.nan (keeping jnp.inf for consistency with scipy) + return jnp.broadcast_to( + jnp.where(jnp.expand_dims(self.df, -1) <= 1, jnp.inf, self.loc), + self.shape(), + ) + + @property + def variance(self): + df = jnp.expand_dims(self.df, -1) + var = jnp.power(self.scale_tril, 2).sum(-1) * (df / (df - 2)) + var = jnp.where(df > 2, var, jnp.inf) + var = jnp.where(df <= 1, jnp.nan, var) + return jnp.broadcast_to(var, self.batch_shape + self.event_shape) + + @staticmethod + def infer_shapes(df, loc, scale_tril): + event_shape = (scale_tril[-1],) + batch_shape = lax.broadcast_shapes(df, loc[:-1], scale_tril[:-2]) + return batch_shape, event_shape + + def _batch_mv(bmat, bvec): r""" Performs a batched matrix-vector product, with compatible but different batch shapes. diff --git a/numpyro/distributions/gof.py b/numpyro/distributions/gof.py index b6d93bb73..d101c56ac 100644 --- a/numpyro/distributions/gof.py +++ b/numpyro/distributions/gof.py @@ -145,7 +145,7 @@ def unif01_goodness_of_fit(samples, *, plot=False): if bin_count < 7: raise InvalidTest("imprecise test, use more samples") probs = np.ones(bin_count) / bin_count - binned = (samples * bin_count).astype(np.int) + binned = (samples * bin_count).astype(int) binned = np.clip(binned, 0, bin_count - 1) counts = np.bincount(binned, minlength=bin_count) return multinomial_goodness_of_fit(probs, counts, plot=plot) @@ -186,7 +186,7 @@ def density_goodness_of_fit(samples, probs, plot=False): if len(samples) <= 100: raise InvalidTest("imprecision; use more samples") - index = np.argsort(samples, 0, kind="quicksort") + index = np.argsort(samples, 0, kind="stable") samples = samples[index] probs = probs[index] gaps = samples[1:] - samples[:-1] diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index cf444c5db..116b2360a 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -232,7 +232,7 @@ def _load_jsb_chorales(): for split, data_split in data.items(): processed_dataset[split] = {} n_seqs = len(data_split) - processed_dataset[split]["sequence_lengths"] = np.zeros(n_seqs, dtype=np.long) + processed_dataset[split]["sequence_lengths"] = np.zeros(n_seqs, dtype=int) processed_dataset[split]["sequences"] = [] for seq in range(n_seqs): seq_length = len(data_split[seq]) diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index ba8bd96c1..d860a557a 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -540,7 +540,7 @@ def warmup_adapter( find_reasonable_step_size = identity ss_init, ss_update = dual_averaging() mm_init, mm_update, mm_final = welford_covariance(diagonal=not dense_mass) - adaptation_schedule = jnp.array(build_adaptation_schedule(num_adapt_steps)) + adaptation_schedule = build_adaptation_schedule(num_adapt_steps) num_windows = len(adaptation_schedule) def init_fn( @@ -677,7 +677,7 @@ def update_fn(t, accept_prob, z_info, state): identity, ) - t_at_window_end = t == adaptation_schedule[window_idx, 1] + t_at_window_end = t == jnp.asarray(adaptation_schedule)[window_idx, 1] window_idx = jnp.where(t_at_window_end, window_idx + 1, window_idx) state = HMCAdaptState( step_size, diff --git a/setup.py b/setup.py index 48735ef33..4b944278b 100644 --- a/setup.py +++ b/setup.py @@ -52,7 +52,7 @@ "isort>=5.0", "pytest>=4.1", "pyro-api>=0.1.1", - "scipy>=1.1", + "scipy>=1.6,<1.7", ], "dev": [ "dm-haiku", @@ -61,7 +61,8 @@ "graphviz", "jaxns==0.0.7", "optax>=0.0.6", - "tensorflow_probability>=0.13", + # TODO: change to tensorflow_probability when it is stable + "tfp-nightly", ], "examples": [ "arviz", @@ -89,9 +90,9 @@ "License :: OSI Approved :: Apache Software License", "Operating System :: POSIX :: Linux", "Operating System :: MacOS :: MacOS X", - "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", ], ) diff --git a/test/test_distributions.py b/test/test_distributions.py index 519c1e695..0facbd2c4 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -10,6 +10,7 @@ import numpy as np from numpy.testing import assert_allclose, assert_array_equal import pytest +import scipy import scipy.stats as osp import jax @@ -67,6 +68,17 @@ def _mvn_to_scipy(loc, cov, prec, tril): return osp.multivariate_normal(mean=mean, cov=cov) +def _multivariate_t_to_scipy(df, loc, tril): + if scipy.__version__ < "1.6.0": + pytest.skip( + "Multivariate Student-T distribution is not available in scipy < 1.6" + ) + jax_dist = dist.MultivariateStudentT(df, loc, tril) + mean = jax_dist.mean + cov = jax_dist.covariance_matrix + return osp.multivariate_t(loc=mean, shape=cov, df=df) + + def _lowrank_mvn_to_scipy(loc, cov_fac, cov_diag): jax_dist = dist.LowRankMultivariateNormal(loc, cov_fac, cov_diag) mean = jax_dist.mean @@ -211,6 +223,7 @@ def tree_unflatten(cls, aux_data, params): n=total_count, p=_to_probs_multinom(logits) ), dist.MultivariateNormal: _mvn_to_scipy, + dist.MultivariateStudentT: _multivariate_t_to_scipy, dist.LowRankMultivariateNormal: _lowrank_mvn_to_scipy, dist.Normal: lambda loc, scale: osp.norm(loc=loc, scale=scale), dist.Pareto: lambda scale, alpha: osp.pareto(alpha, scale=scale), @@ -328,6 +341,60 @@ def get_sp_dist(jax_dist): jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), None, ), + T( + dist.MultivariateStudentT, + 15.0, + 0.0, + jnp.array([[1.0, 0.0], [0.5, 1.0]]), + ), + T( + dist.MultivariateStudentT, + 15.0, + jnp.array([1.0, 3.0]), + jnp.array([[1.0, 0.0], [0.5, 1.0]]), + ), + T( + dist.MultivariateStudentT, + 15.0, + jnp.array([1.0, 3.0]), + jnp.array([[[1.0, 0.0], [0.5, 1.0]]]), + ), + T( + dist.MultivariateStudentT, + 15.0, + jnp.array([3.0]), + jnp.array([[1.0, 0.0], [0.5, 1.0]]), + ), + T( + dist.MultivariateStudentT, + 15.0, + jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), + jnp.array([[1.0, 0.0], [0.5, 1.0]]), + ), + T( + dist.MultivariateStudentT, + 15.0, + jnp.ones(3), + jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), + ), + T( + dist.MultivariateStudentT, + jnp.array(7.0), + jnp.array([1.0, 3.0]), + jnp.array([[1.0, 0.0], [0.5, 1.0]]), + ), + T( + dist.MultivariateStudentT, + jnp.arange(20, 22, dtype=jnp.float32), + jnp.ones(3), + jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), + ), + T( + dist.MultivariateStudentT, + jnp.arange(20, 26, dtype=jnp.float32).reshape((3, 2)), + jnp.ones(2), + jnp.array([[1.0, 0.0], [0.5, 1.0]]), + ), T( dist.LowRankMultivariateNormal, jnp.zeros(2), @@ -672,11 +739,28 @@ def test_dist_shape(jax_dist, sp_dist, params, prepend_shape): samples = jax_dist.sample(key=rng_key, sample_shape=prepend_shape) assert isinstance(samples, jax.interpreters.xla.DeviceArray) assert jnp.shape(samples) == expected_shape - if sp_dist and not _is_batched_multivariate(jax_dist): + if ( + sp_dist + and not _is_batched_multivariate(jax_dist) + and not isinstance(jax_dist, dist.MultivariateStudentT) + ): sp_dist = sp_dist(*params) sp_samples = sp_dist.rvs(size=prepend_shape + jax_dist.batch_shape) assert jnp.shape(sp_samples) == expected_shape - if isinstance(jax_dist, dist.MultivariateNormal): + elif ( + sp_dist + and not _is_batched_multivariate(jax_dist) + and isinstance(jax_dist, dist.MultivariateStudentT) + ): + sp_dist = sp_dist(*params) + size_ = prepend_shape + jax_dist.batch_shape + size = (1) if size_ == () else size_ + try: + sp_samples = sp_dist.rvs(size=size) + except ValueError: + pytest.skip("scipy multivariate t doesn't support size with > 1 element") + assert jnp.shape(sp_samples) == expected_shape + if isinstance(jax_dist, (dist.MultivariateNormal, dist.MultivariateStudentT)): assert jax_dist.covariance_matrix.ndim == len(jax_dist.batch_shape) + 2 assert_allclose( jax_dist.precision_matrix, @@ -1254,7 +1338,7 @@ def test_mean_var(jax_dist, sp_dist, params): if ( sp_dist and not _is_batched_multivariate(d_jax) - and jax_dist not in [dist.VonMises] + and jax_dist not in [dist.VonMises, dist.MultivariateStudentT] ): d_sp = sp_dist(*params) try: @@ -1380,6 +1464,11 @@ def test_distribution_constraints(jax_dist, sp_dist, params, prepend_shape): valid_params[i] = gen_values_within_bounds( constraint, jnp.shape(params[i]), key_gen ) + if jax_dist is dist.MultivariateStudentT: + # As mean is only defined for df > 1 & we instantiate + # scipy.stats.multivariate_t with same mean as jax_dist + # we need to ensure this is defined, so force df >= 1 + valid_params[0] += 1 assert jax_dist(*oob_params) diff --git a/test/test_handlers.py b/test/test_handlers.py index e43804773..557a09686 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -22,7 +22,7 @@ @pytest.mark.parametrize("use_jit", [False, True]) def test_mask(mask_last, use_jit): N = 10 - mask = np.ones(N, dtype=np.bool) + mask = np.ones(N, dtype=bool) mask[-mask_last] = 0 def model(data, mask): From 4d9a4e6c82db29bc8afc74d1dbe00729909ae63f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Wed, 3 Nov 2021 16:55:42 +0100 Subject: [PATCH 198/222] Example/ssbvm mixture (#1087) * added sine_skewed distribution * Cleaned and added ssbvm mixture model. * Fixed missing math import. * Fixed failing tests. * Fixed linter and test cases. * Ran isort on entire project. * Fixed compact.pyro * Removed rogue .isort.cfg file. * Ran black. * Fixed docstring for `SineSkewed` distribution. * Added 9mers data. * Added `base_dist.event_shape` check to instantiation, fixed docstring and added todo. * Fixed assert in `SineSkewed` * Fixed logp1 * Fixed lint. * Added L1BallTransform. * Fixed docstring. * Rewriting mixture with L1BallTransform * added l1ball * Added circular reparam to phi_loc and psi_loc. * Fixed concentration. * Added license. * Added BvM. * Added BvM tests. * Added comment with tests that need to be fixed. * Added tests. * Added docs to ssbvm_mixture.py * Fixed spacing in `ssbvm_mixture` * Fixed `split` and image format. * Added test to `ssbvm_mixture` example * Changed `load_dataset` to use split to pick aa in `load_dataset`. Updated name for torus projection. Added explanation for `CircularReparam`. Co-authored-by: Ola --- .../_static/img/examples/ssbvm_mixture.png | Bin 0 -> 78955 bytes .../img/examples/ssbvm_mixture_torus_top.png | Bin 0 -> 171000 bytes docs/source/index.rst | 1 + examples/ssbvm_mixture.py | 302 ++++++++++++++++++ numpyro/examples/datasets.py | 23 +- test/test_distributions.py | 33 ++ test/test_examples.py | 1 + 7 files changed, 358 insertions(+), 2 deletions(-) create mode 100644 docs/source/_static/img/examples/ssbvm_mixture.png create mode 100644 docs/source/_static/img/examples/ssbvm_mixture_torus_top.png create mode 100644 examples/ssbvm_mixture.py diff --git a/docs/source/_static/img/examples/ssbvm_mixture.png b/docs/source/_static/img/examples/ssbvm_mixture.png new file mode 100644 index 0000000000000000000000000000000000000000..9abaf96fee978e76a9edb11f0c84c62b2824888d GIT binary patch literal 78955 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�oTb2lbC2` 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 literal 0 HcmV?d00001 diff --git a/docs/source/_static/img/examples/ssbvm_mixture_torus_top.png b/docs/source/_static/img/examples/ssbvm_mixture_torus_top.png new file mode 100644 index 0000000000000000000000000000000000000000..d00a8c7492f32695bb7387637a12f05fbe143ed3 GIT binary patch literal 171000 zcmYgYWl&r}w_IFDO)%WWA zK|yWR&Yd}Prn^s{xx{E|D!oD{LkEFCuT+%fbwMC_81VCgiVS>0CDKm;{6ce4Hgp4l zIO+fWz*7jx+@sC>p9!Hds%+A0eN|OaenyZ=w@ZA3rOF&msaz1~V(P)q2|PB^X4s=d`OaF)!h$v-}x zm5_K_Rv_v@H6(IC6OL2Fw%-2t&5|770`x_FRT`Bx9CM_^0~C%U`!wV;MI5|ExiW~y z#L#Vrxs@C8IZzgLMoJZeM!SdECX72e|1yw!dGTo_#%NKc@gZmHtI6eW$&uLb7!f_! z<#Iid~UZxL_#=8hzOk^%$7QlIhd`?X8$u;HXKWNI(1Q+T_o7pauE;@$&sCFSEJnmG^u z<08lkgz|+PS9ZjL1dT}|8Fgr%zxLMqiqC#GjYSU=SV5GcfW$i zpL>ow{TJOIW4jH^mi~7oa4lc#IHdENq)o9{0&_nXgukt;xTkcZiYQSA9%-?9)S_d- z(Kp`brftubxLZj^h6PeR-B(P%z?Y4W*Adf_jn;9Q^iy@mY_k(vbH#c53cu&YcxT>x zI()`YOO#pAR6K0bEqAmYz-kvo&a(~+@#is8xy`&?+dpg zJuDo@s%W49NH(6cRBx>-Xa2zDC}PJ2%jY96mv_A)4=W{pAVl*EzcN89Pq5DjuN|{^ zqOCLi52O2{g#cL%$nb&sKzyhh9&GJ*4@pnB!4%na2C{6lW9H)^V&0{-*hp70Rk;NxW+F#;VsT3O}S-++~-YU>od!L)^@-_Q$JESwCRg_kJz zQb8M<%SbGX|eR}Wlt9!<&Wp~d4I$%Z-GI-PcrnB~k2lglheTw76 zEO-3~zYlp``;pZxdqfYS`bb`=PL@?8mWFL^w6tvcjouiUAE$_ z&w+D34%=VE4J5A|Kt1Ulq-07&zhsShCb$*{ zVAo03m@^`o4>(^CaAkL56ao0*DZ~>0d4lP_CDeW)7k1B&h$wb%!slQ!$^->j;Ie0$ zaT}Zd-Fo=ZiH-?Bbn+k?Q9@P{hU0-w7d}AF2xKFn$CiquO3LN*`LpXE4@_D8_DSQR zfLCftCKayM;9?h~x7B{rdmqDl5Hl4p6zvk{McLPjHD$t+z405df^mwZdgEN_AC+vx zSChIUJgZ=a$%271Bg*{262)2j$=G7S-%g52Kg(>hs0QPoS!CIUaSqrnUER-9A zNPVmTEhUBrD9VNGLml;fk`6sO@9bzx(Fm=e)yT*baQ)6q?Pw{o!uPpaO5Y{!{zgAqW{hs z;(Ad#z4H;i$C7CL0d`Z+%Wi;YWQ*_o^DFv(=CuW(lf*?~3tB?HuW80>QU!*6>2RFg ze|SZId_vHT$Gc2KxwMG0IV1D4Pc*i>?j_m8y&|Z_IgecIewX-S2(I<5Wg-gW??m-miKDlpo z{3AgEAlYXAQ&_nb4_Sl7P-|{JAC=j1*lhkvxD?kHv|Az-G;Pri>~IpwTQD<2ggf&c z0&M1c??|4Rr?GKTcYHyYU;nq0S5x`Hev^*~e=*IGLCL?=*PUc@UEUV=no^%$a7B~k z2;h?bRj=+pPAh!gA>R`4d>NU(K%hnbM+YUDl4IVJr{i*|Mau!Ni*7YNDf+NC zyC}T6e}Zxn#b2r1F$>qv>7J7y<^0B?d06%wdvj8Yc8n??y*(2xMJqaYQD9?V8-SoP zzdpSw*-kwb2)39@8f)BpKXXXV-MI&^&Lv4*nnj2f&DkW3koQk0jEtjOXE!urF<0n* zxXI-SMnlNMRnA+KRTllX)0D?8CBwlgQps&GFE5W40)mu2qJPf_gd;8G@4T(Eu9Iyh zl$r&oYot+D#9vv&Z@0TqDTG)VP|z(1P5KxyC9>XTKeM6~;nB$IhN+x@P-z2BIFER) z6xu3kdMTIHJHtMBF5dbSx`cERba(GfG%7!ZT$cP?-$c$hmCp)jjl@kcoBP@$A;vTW z!V;V=g$u{Y185|fABm&`O}{sCLz!w?I^@+gO8iY%k3J zPNn<&7d)j4is)|Fx{iq6<;b6wKfFg5g5#1V8aL2->ND881bVu#qD1NN5=1f}gJh78 z$BP#(4^O3)ZNyU?KMw~LRm31QTwV^6r&w`BKR4^eOjs+`2vDDOS@do0ILkLP62lk& zd`;8btyevnE3b+tLCQ8N$Jnpx@Z2x$4y@H!BeRS6>aT>XfXg$mMc1>|bf5N?X~Hy~?w{$W$m zwCNwYw2!4i5o7kZ{POoSSnO;NqAs61XFUA$5Hxk^W=1X3^YoRYczw}BD_!nv)cE8j z?H#QV(mva{SC3^jDq00#oC$uP<8ShADXb{Gm9KT6Kd{Yeg1ZiGq>hc>I2R%9xMAaM|1}~#eh>Er* zOugaidV-)HPTL+j1OCKl`v@RFq@r!D8Of5`8C1Np&u>tjOjzxM(yzO9ZVj5XGIY5%R7pGF;74|Y+)MxQtPVX#o zI}Z@{+T?JsA7$8(PE1UoCCrQn3$LYO0IZTd9amnC7@gev54%juJEG(rzTv*8t8oUl zTO)iYnmD^Yc)mO9$9K#Rra|>S?2V#9<%i)_i+XWbGlGT?TN#P#$CrVOxC#EZU;;{4 zWg`{aVJZpt9-0`}6_1Xo=j+o!Z|kE~C=;})%mLhk(A@*J8rIe`P4L?AVNS6m``Vvg zxN)aEx6VAz;1;xG4y@u2AtQ_dsy$4FSL}Q6)9jv5IC48F!>P9w0y}va8yo#;(F^bK z`0Jn`Y)m1>u@RVoLuc~<<$u}D=Wt#gBzw`qx-!CBvxpnqwsWj;#83wp2Y z%W_0J)L01%tHV%@<5S$4*}o`ccXX0Znwppxe5-F>&FQ?>irZ91=ZLN93*h+Ns@XDv zCh-A@D&1Wr|06LiaAN6!ElC9hRX*kUip^$6b(^#y3?^>teB6y4tCe9K9SCm2hgiEG6-pJ}%ER^$biQCdA_%tC+(`imb<;HiYxQP{ zm<*!?LuaRl1AXgG6rE9uo>g#2<^4!fwZ zi;Ao35?)kPbf{c#SgJ%?4vtH)8J@aV2^b*YdIy>Z^bF( zIL`{vnnx@|;XewucvHzUy*C(gQJ<`gAM+$OYsE1%?8Oq`%)pqEdNDC+&fz@$o{v$C zph{DE^U`xHQ>*Tr#uDx*i55A9{P*b`8z6((9-d$8bk`ZL4#{Q|<4kDq{Dc3cpL zqcKo}Y=vRJAI}_F2}|8tCP6|+L>;NO?q^y-3Bpmq;9303hxn}EVG1G7_=s0T3os3< zN?tfyq)wo0B;DpalEo5g&{s~=*py;LIMl$J0)vLgu6V^>+hdiR4@Bm8`armONK_#) zpBR1dI7L0w=x%+kIh`u~#4J@xSz=qE&8zdPRvsOZY(k40C7YIIU+!}Dhm>kL-L zr!l?IDaw>e%D42X`t}9kWTX&39i}Mu0 zlXwzII@(pCdch#Js!&3r8T1q#wKsUbqSd@)M+5t)srNlmXK(~otxw&o~FR&JK?|96`Cg_|bAeFa;bBW{618b&mP&&tWPBD>;OPYCpm4DLaC|WfZ$__yEx> z=hmdq{Kgdpj-Rg*FhE{iqC~j86HwI8tzJiRsE@kkdu==(pJ7WrfS&L58TWnk@|5m+ znEeV}kW%rcMJZA_%dfFj{+(Tofl4cEjSdC8-(1h!BF>_pIUYg5zXmZvsHNq1Y3*8bs1fn1-j!tE9;vBt<X*EihN&+K~`n@NCD@~%!=huaWcaYNqss5ujQBY3=F{iwZ zjSU2WBsl+t;+DcV$i8loq=*CVxb~Debr=s1n}0_OFNtZ7jx{pON`F`B_^K-O7nvf$ z-u^x<7nhc4;QI;uWE;c&=o^i{ydCw#RKH(!pU#R>$o7S6J`jpyeDjcJ$O8liUgD^q z@{fum@pxNvgkTG$f~<%G2MS!5gX4Le@GZ{gy%_wZ4xff0+@p*t<;zhjASx4EYB$W* z+?csxVZM;Gy~2Tl0R=i>CQrSOTQ5bXQY%5=SPr~|e8u?jDiA1sB0t*6?bG;b{D5?= zve>uVv7GnJzn?lu!S^}nblE*8@%P=& z2ksOMG4cX1hQO!M3z3AIv^h7;nMZH8$1?ltrf)OGwI0Gha-7X#u%(`GKDChNy5$PH z!t0eWc?E{Nq2c8@?K49{mybpe55;-qK`BPsmim%BDFv7p0Jpf#n2r`FUJch#7D=T* zjAXIj+&HS|E(&!euB0*ld_OobGC8>*O0oV=dBy^!XITAi$Q}t#OF|oec`n5wQMoHEQ-?LygD;=wwU6 zk491HsVo=jxgn{(Lm;L)zVl*pX|fu;QU)f9p>k`R_Gy& zaOK-+&~k3*|8!Jl6jda~)QgDE*Gp$)SroIV9J?L7@)(uuT|^dyho87K=7&0y)>+-l zu)^xmLwYzZoDB;A4-$Ld{FEweY9j29eARz*G;1lS7rHtzpw69jgrlUJZgfA@Du6_BBgzafu6gTfWnRZ%;L>N5gVI*gJ$=vHpq?|S5Z^bTOcu` z!sK@F;A5$I%h0Bj9g6Cy@w9+2mV0E}Pisb#BSVh^3b&v zL@`C%#2MkD5F1oj!w5M4c4S3he&gvdO#jQZyc7L4U+_NVg!uf3A?OfOZgo?6RK0lc1&R4d^m^jhtYk`v6q6BVt(~GisX$%) zP}GtpFQ-F*3ZK_=7RR=QXoU&b^0-y}LSczIlPlyJ4+=X8cfs=W7Zv@eqkbbjhv`Bp zCDSF{#l;9y;@A8gX0^a7l0*R77dpD{CV;&&ENaKxsyYdjtL?wy2{@ucaNfQqk8L{H2UX$z!bqU ze!HgqJaqljaDvcUwBN;J%>wNQ&YL1L`io&@=c798G9Z6n9q$%I(q$!AEGc@iCvAe`-e+B6+C`^!Ek7&@F|wHjZH-Lu4ntq(P_NB-=ohXcg}?6 zeN$s24Gq$qP26&5M@I)-%k11-IQ0463I=(^m8hLTB#^S^)Z5W|qc{=ptakh%mFo}3 z?bCb;Et=W}N@ns{H0D!%^knP$r?r54uRd5JiB+rj@4<(s#qPq5`#y}9K1Xu1IQyI= z$tMz3wb1p5L@J5UVd@|XfnkTf1;bVs+OF%f_Gf>88l0Y|Tdv(N`sN|*Veo{MP zOD5_VT5)sQ@e;iL znDDj)<9%wx-PE&pW`U24ReqoH+BzKO9ZWorY&sWK>$U~NALr7JuciW@+}^xCSSiZ?JYD;R-~9~jKfVf(dgL0<72(@id{01;+XYINES1Bf z5Utm;kvd9fdm=GlSoe$fE$!B67fK!|_bAYI&ajD(_wlo8Q@m+6WdAC;C}y-is}ju< z85?zn&aOJC7ZH2f&^hH-xvPGX|j^4AAHDlttmA&^KI?Qa*H#M!^s39?h(>Yxi zg4vIVg0yFV(CF#$9X2Ch|FaA3yS%s{fl{8QOCeE#&or9(;vsrv4k$r&GSjD>;Wr7R zfqyU(9>}%5e6aH-m>77aBu^GySKqn0@vW?^%Luz0o{^D0RezSBw63Yg!>q@5X@M+Y zA@tW5wARW1Cp@%TiY2;J$metm{5=C2ER;TtZ>r8|9^|%)o^c zH64iDoxx0r_A0hx_HBRZ*)n5&AX<|_2&%^+bz({tf3&-dLGWA~dcdg^(iZ%sKlSO>3c#^(1k7P~1t zO+#^c>MZ_Dh2OM(53zqu$c$86UvL8u(d%L$2j4I3Ichr}tj50IFe_`&>s*)k5%~R> zuNL93INa_z@eCCa{`gAdAeY<~^X2{`C=B3W9QCV<&V%;Ogw{M%19tdFI*PD{>*wN8tX%&zq-T zxWB~>%m#aCxXJG6tflA9hLi25GGui-JD3Tz0`PVnuUpDnuAPt&sz|f?iezt_SI>ri zr!oKUV-mgQHxL4n?z*3j*@SVgTG?t_>o*%v>_k0&5c%Dm>SWY*pFagIQcASZu^-h| zR4hOP8Hi%(Q(GOoN z$4>H%i3Q~@fIR3|^`7jg^BOZYzFfPWihx35*=ph+9=$F$s;SbIl4^P$!1%}k>S}5j zu)CJ-ohYd%+KtVpz=5eR4&}`S$%n2kqhgrhssXx~U+!`6%!6`Xw7eOFL`$)jkd($( zjT;Z?I-XW4?LVO9t1JPgQy@65V0VLZEd9>?7mjn8q*5 z9#h{63u#ZQKvtL-MC?6hE$bntr>Eul-9HO;Iwc(T%A={=u4BI}{c>aOFyk^ZHU?jf zac%$2(O10fs0ily%KNODYDV{H;E?U)=Kf^_DedKa^yQPgAcu$cP62uw%7f3;k)UjJ zphhM)?#uPCQk~71t^dPzl&~j+MEC&Ec*j}6pUSjQR%3XFxZgjZ0{n*$7!lnez&)-3)lN23SSE^1vju?>o=rd=js0g>=qSg}3 z&}stp=+h_o_1!`tp9iO|@MIbA)}>S%*K?`A)GfEBVMz^m+FA-J4Mu>GQBr8*JRUi2 zvuAh(p3d$5M(60iR?xryxv&eyPez_|`78y|go;t|_#?in=|Dn4dSqc`jp)Y>T#&gF z41Fe}eI_exJ^A)PmdpcN4aT8p`0%p#N%`#g+r!E?WlonMwsXI}7`qKLGdTdGA*fPa zO(c{Bf!+G*-*Z`6y8NA8WKvv?MaYFwB*j7gSA^Uj3F^F&wd<@gsu<(i@-NK19Tq|i zuV^xPX$;)p+&G>3iRi8R)_XM`jkYRRF?)G1i<(f!jSzXTKI-nu{N)usz{!+04NxAP z(MX*L-G#-&S@gb?;l9iPPK;=J?7oC3Rzfmdze04O5uh zy}z`)O5&{jnt5so?zCB4Nc30kiiGJ`NFaTY4s9&^R(8(}pYDeH0; z@M0z3s2?gVm{=Qv$^s{FY#1hepkKGA8DYVt%3ngaV?nM`*(f>RoHcm>Eg#y_G}34$Yd>&p=Y+Y~wSx#p+u4 z{+&tu`G%~cVS{3AksHeeZ5fNEAH6Qwk-By7oR6t@j_)yJ=i^~#C|!serNbX=5M_H1 z=CWQHC*KS@j~iyaog}L9qYVhO900$?I}oq)Ej|w?ps>DRPClkvQ|F#a7H^8)r|)ZZ zQD=bw{jTT(3xuOU#$gquVwa|sAXh@jYjSgo#EbbyWl|^_Q!onG9_8D$YlGzg-A;}r z)wxymMwvPyIrsEX!#KEw+3jJTBeNyNP0Zd@4BN>Fi^&0zM{{_sO*D|O%NFRAu%*w; zbqG}))V-NRZ1zCB&|Oa@S%Ceu-lBejq`$-G+GVx6guK0rmpO+OJZKU2 z5^~)`Z}A;7^D|R#Iv>*C+~0KslVPR8S7;M``DKo8A`}_XVsJg4RaDX+P7ncn~hM(Lgz@gJ$GJNvg~`$=L6IPV~Q!EKn%%cq9`{3>(ec&YWoc;!{}ZrIK*q zjxeGlZB;38@B67i`gUL2GiXcDv#2b&S9YX#imR&*k75E@g4M7C2;}@}C0y*>0EtGJ z?;=~kQM;-8^(l{!k5B7%B>B&WqCuSShlOQ~zg1@DW{7H>S6u!orhik(bq{byCh0BB z*+WYe)=Lp3)I}uB)gcMgeLh>b9$7K(fXwL8^_Hx+lfZn9OUD2%KV=5MzLx$CP`G{G zH;%iU{*@#L*p0f(@UK?49hYLIXEj}x<3b0W;X#?zh#?DHzKl@mOWC#aflWz>YUZg8 z_r7{0s~x&#Q%BNlpXWCOX(g9A>QGX3Zh9J4;m`cu)K-`g5#SSlx8>4|?I7wGK9B{_ zc5yjtTHKBxhDB&Ne?rgUk|t1K@3dz9)b>H4Hc|HXfI3#@^=r#Xi~^S`i{C^pzmb4L zR?-}R+IXS#4G3?a+q?%nM|(e2zYR4+gIX?SZRA|@i4cv0x+*v`NKjqj+JZwEg?sSb zf&waTd=grZg3~D%o!nb`scmKPBOQC?Og<=FyX0)Xce^^!+{wINt zW}u*5Ebd-Rz4JFfwEA*`h^qQIkG$Nw0N)K3EL9||8moqE&MKSJ;xx3Mfim_HC`~xK zA+dGg)F9i5?1;CO@9tkCs0wW0pKMpJQ}B1WViADQ zK{Ac~?_4;m7>Vhu{&eE7i$JB|XjxS&2XZ2sAFQ|U@y~R2YH6E_OI2WE89p zU6C{dbaaykbi|u3bC*DyM=e{mLBz4$uRt`mi3)#9E_TwNg%=9^UvauIQNS_R2-pDG zNX0&QZNVu{{5AQLz}KSdMqg4L5kM8zAEklMN zA#0Ae7v2rF%zaQm>DgUsPgVc@1+y#i?2{ zGZdf{CmXf)l^8r(I$0a3HlVyxQQVgZXTZrQd@!0vs}Y}{`sOkGLsFmP*D;P~TcXwA zYKAnZUs*|{+03VWGm+c(z+DtP%69T|`}S2b0~!Fzl$2*I9F&o9M5f_{Y@ZZ8J@2;2 zd4+2baqM9Pu%VAQl>L^}0eqkyKL>oHjn0m#VFHd#BsZAhZ_Kpha1~oTO&h7Fv}~o; zH%jY%s4?VJE`9nfX!&Wiyf4W#K zXjW7BUIGzFyUXO}Tv!{&RxGu8opc>xpV?2mqEgUTOEn9QeCn^|to}*9#>&0TN&lMo z*#cTyOJFO@du(z+Ou*-hxt>%@xMGl~`^p*F58 zp!q4d{jbQw@kV&53l{oUL?x5zL1NiDB5AOITpdx5AmsBuo@%<;iB>Z6QQqM~f6{_< znsJ%=oxSbofY~6zOYm(2`Z@^azvg*zHZn0W&n*i*A#;oOhE8K?-o+Zzti%F919Cn? zX6YgV1&h3}M`u~h+1W2~Q-06=?eb;~)A7;9B5WL0Ls|4&J$1mh0Vx&PF+adQvbNA2 zmT^D#!|B35DMS>Ve-3y>E$vwld`JR^%CwgY6+=y|w-}qCjjyxKa^vaTa^mKWr`l2f z^?TZM_+^|=tGK$F`y^CeXf+V{1J zV^LTnB_Qx*j>Qo#e(Td@HdvCo3IIx{$EaSJgPe}xOnW(rQ(M0PamM(b>WM>%7Pl<_ z!-XIVmCFzMTU|dwGC}o=rbK%-g>xjWUZc-C_5HKsDfCf4Z70Ym#ND}1VGxLam5C1q z(YU#E*(m)$FD)w`BGZlWF@9yDRuJeQMCz`s0L_-b+z*i6!sk<2+B4_adSDCukB|?S z_g@b)l-C0r<>+BC^1wMH#laTd7Jk9+jdeDHDNo;E&C_qw1GOj^c2tAF+c2n zz?UV&qKpyP5{ExiHrPfj8=%z@atmr7N>c*$KUiO&_JC23A0Cx>d42iZ6r+?@rlG;V zQ{WP^AmI{ptMBcQkHNOj+F{Mcu5f@Lec5NK5ZVOM^++xCP9s2@tU18$NuqO9k!VFg*VWHZJB zUCxO|Eu6K$p?<|)X8ROkwI*aaS*dO>E+cdM!6)83Y$5+bR3nbuJ!2=zf-UYTFsdsAu%Rni; zAo&aV_V(8DKBQBjUG6h@A-oNucpE?;h7m@)EPwV1UJI z-s!-c(ZKi!)c{mlG{*MC-T>=Yyk$`0Op8c+YGlX9(#t%5fNKn{EC9%*usRR^W${ke z3V&Kpkl`Mzz+mX$@Z(>;yg9>u*-6REOK`01#2U-sh@zQRC{#=dSa9BwY$M9gJ}7)J zo_`)3N52)s7A}0qp|Oo$pplhLjT#M1jRV>k%CZmSlEK$o1zQqe^d6f`x9@#|$H*Y* zp$F$sKk_Y-7mX#Q^>2pl{nJGG^>mETM=>!m@IMd!yO5BKPI`W;Jgyp-VQkJPBelgp1K1}0biLSVpyO{@0(Kv@ z;_|2FmVG{xt`D4uOf;KD(Ni@NS?LE~Y)Er9*205e*VHcU>y}bE0**xQs*MuV4IZ~J;CnM>_8`-a4bM;y;*WbR z1~PDxPSZqxf{<+*4mVMiYB9^WzO0y8hfIkCl2uoF59kZM-a) z(7X>IZxa;QoChs83V!tn$%}`FggNvbP%_Cje%MTiP4))J;3J;I>)RL|-Z8&FJ3?QG zxOjV0xpnD)`>2MuVy#J%NSuC_qgnAgV|V4hJKbKWE!d2a^(NE9hwHcJZ;#Zo+w*9ap2iPTm0s3>62W@HzypGevQA|JTq?e7;WIAgGc4TmRQIpopSS0Jt+Aiy4$E2-COI(96W|chDZo3oOenAfgZVkCg?@KV4x-28y&)D_(USiyRw$|(- z{+b%cAFpnHceWZO;F#a@b9cD!oLbO{6-_<8n<<;qD`aa{Sz$(av8*)nz5TUyftn@&<4&&ip0r%Z^4)(OMV&--xDhw zU4`24vP*|-aZD#(7~Tu*x2t?w-nlpxT)8!w*ZD^7fndjfd8-dUA{N8}&>}pjWKs^5 zKLGQ&oG>`~iTRaXCqMi|mm;cq574(tYCxZi@g+B_C9dtfdu?X+!V4b~>?>u3d3`W7 z{IO*tacynQJ5nQ3`W*wyR-_8#Z7ibKglOyC3+^NF$8Z2E0fp~RKv@9AN&M+W=eQDp zb816|qPn9v{M&g=)~eSv==F09mntMGIEv{Rjq`$M&Usjyi%CKLSJ)eW4wrXOteUW- z&@rmpKpsbNRnC__oETUZ(Z_Omj{|+2%wPfHu2769Qwp$^$ic&5anj}7tX5G)1?zu{ zg>dgE^+@GyiL?^NAAV_Om%;e2YBj@8t5HDQX$b#j<+h?lV-zQlm^h#g%*sUWg#NK? zKuT~(ES6c>d|x6)^+}ION;6A()*!vRIB{Jn_<1DF@;=6JH(3H|*XA@#if#BcKT&j2 zT4^9j?DHP?LX}}ySQJ*|dO<-!(ib-8-q1&kLr^K7qSl?9%A`Y2IvP#pgWK;{i@n2u zt%dySKmrZ06;_ay-_LG#nW8-Bwnh$xaY(j1!e-t+ZZ>F~nLGag)F>Ih2r&;?jWjqn zbc+NFG?M#d<^5wZgbfb$j@SC_2KMmMyhW(%$)5%Qf`X#D1A+y@{#!2u1Os9n=p?wV zdo1?bHZU^0lclqntd#$UIsp$ah1X-7z|inG9jHsGQgXY8s4-Y5D8dMB-H6&R>h#8$MW?kes>fAO7N`LoWKn;6zRy*q!w0x^%Z<|ZY?z;4jrNH+< zcYZe^!5dskybbp53lwx*U|;h&FlFH^!b6uh;k=!>-ZKRcAoB4tLC7fxTY5bXr(Dio zD0!LuF+w{jr0dl5$L@@iMZi=BYD5m??6e5mAiLhZf;Q+tqyvP0KmT65ZjHFBM}C<4foM6u{rv*WJgh~F#ro|>JUt~6l)MPJy{ z(^K8^@SFJFA8#wUed@cIU(?ILEn{;dhoIpYl1-$pHEq6we6$!ZX?{9gyT=i|U&98~ zVRgfc@KJ}dI(FDvrV7t4!^F?m0}&Ta0(pg1A@p;34{ROn8_XN4NiTx-l2Ry8=6_o28P>cakKzZb}EFcmZl=ZR#>Vkwztb zjl3Md%YM{CU>cm;KppujN$1>sVR<>`pTQ^C`3o)f&n%ka{~IAl6j)J_xT%F(xq6?c z6}atagSN>Jm!Jp_(m#yQpYKn(*g{c_h=_&Cn&xF5cSlpezMBmb<@cOA!o~~M9h0t0L6s-6w0{92# zet&{;U`c#8JR0*@*DBBP-0jHHS%T z=409B(8miiWMt$VG5pz$4(`)~|8g=EaZ|muTj7Csc6K&5U#F5!Lb2uCIuBhwo>qb%S@)AJVHA6Z;a;wr41i*152E zAL{V^UG&I*_(SSPX(HmczwsBp`Cwc!rgewKQn`kUA-eNu-yLx4ZdVsyuo`xd+J z*M(&hYcP-_E`Wx*8;{~oOit$Pu;VmWEPe?ql5`J1Ehtwzu}3{BI2A_^+C@43d}r7l zV$T-Q^dL*X@xpJAp{DW@tR9NSn8+K=gv*qMCT>g$kzv?(amn`PQB`lGt-K;;F@jaB z&`7&rD*bJIp7&_Qn|>`W3vz#J%VPS9m8av*t~ZklgN~zjO$j z3za`+o?j5U?W6+Ora-Q4Po{3K@G|uy4xiE>RVkJx3iH@V{0vSO+I}J~H_r+OSxO0F z+lmi5HyYFK_*zal^cSlg9{SggSNAi_v<7jsnGGONY%LPdaETg^@d7$MULdB!qCF zJP17Gc$VLb46P-u{d(bY)lwDHOx=ORVs8Ppd!iB0?k@Xl2uVmoMg1U|UGj$h)WDf{@W!MbD>T+L zmSG}|aYbc>A08|WaEEh2 z{xLwu$g~UPZbqo`-t~9Fo#}ng?Yy}_{J6oBSRw;NxKalXKdG#g=oFz?m)bo*nE;D1 z5#Rl2$Fww+YCW3qWY$>cKX(Bpw8finPWOR-D&RNWdSv3_jPd!eIM(VV+b;f=1!g`= zr)fLx=0+D@DxKwLGe$vnsP;*+GKH%P@M;huD)7$yzjt1AA%|NQyAqG+D_()*^|f%{ zb5&SO?!a64h^gfYyhjGIcXO-;cg32gjMHnBc15^B(jPZfNZDra8K*-QC|e3Gcb!Hy zW78ru?i*(_+$QmdDhq0c2Li*)xL z%=0DY;C#hlW-mE3cY6w26`?ov>)nl%;0pnr4Bp0f&TW48csR)$X77K*F`Qir1;qoU zxUAukRt8D323gil zVu=SR_0L?v<}c?zg=dN&`&{Qo{Ic*&rB`!4l6=~fSfPG0c-kpAr-wOkWZ_m$tEldv z1BbTQXG~V$U$gBn9Pe6Gi1O`_7s#VDEvS5H~+i_AJA^X zFa>n<;cL2t9E7MONDeza;!R(v^-_QUuPUZ*(3uvHups<2()UJWSt5#^rU%vY+<17- zlFJyt-N5nEISr8e%xg|`b$Q!;C`;@A&~(*NQGL;R=s~2rySqVR=#=gjK`9Xsq+#fg zMx-R9OFyz#}wRjhd%E-Y)}H&M~(zJDl};Ac4xuPM3jiEe&ASC-(Ha)dCVz=#EsWuA$x z#1S1&K}>!OibGjlY7<`}3g35K>FgPwTCxTJ^`$`P8ZmWATFKCD{?i1w3D98lvsmg0LJN>(HUr&Sy)Y^P#Ds5bk*R5Ve5ms$L z91R7rvAUizj%5XrM6#YOO2Q&#BJpAi|L68)|zi9vaJZ3IL=ecJZ-8qXiky@KB+l4b* zW>e8)Qn|)*isemO=ZxTmdaxP-mzoDa(&>is zLZo2xUpxUk4#&v{{(lq?coFRCt4lL<7=1YJ&tB?X3P_a^(4ESbzSm$QkOC6b^c+kc zCr$D9cdOgLYI_w9bJ+~}Q z%RU6(XrXzFuo=DT@_SIRs&H4WJSs7BXf`pdGJQ50!7S$dMClpcC^K?!^Kr|3Bny+HUj zqUH$J!{{+b@60!(E;rTV)C@U%R&N%V2q#TfvA!sA*l*gZJw4QCHor{s>$wzqr8g%e zB9bkrBtCrX70?lZ$$=3;jsDXa_(9l<@yHh=(Lm`#b42pw zS>&7-(ege@Fk7KZnMA$40@NP#Qm{ny0n^qRrZ0tK79$i`Fy_aht5=?2_qsR|jO7jCj-@LH9e9sVZ?h>y^4BvIU8E0YC>;?CC zp+K2=suOSaJF!Y26&^s@3Ffc_o;V{`)|(`rLmVIfKN2SLHBnKi0mHjCi2G+c*e`w; zg!O7S_8I;V^2Z_FqVhI7%4l|G?-@GImYB8E^v+8btbZet&v7HN8`l-c?BRzrCF`0p zrrRT2bzE!8u1s=eQyfAmTnYeT2rH1ZJPJV#o(NIq;ZZoW#GTHNN2bJx1s>Pm_17$| zBB;q!2m8Dq%in7_f~BOMA?b;-K|l+}XS%AahvTjDukSH|XSK8A(U&1gPW`d7Vxtbz zk~#ZQEOCr!`-+pesp~5yogK>x8wMtzEbgShE0zK#x%4?1)7d(WJic5QSPk2bmia;%r8UM#Pwf6lg~QHq~cv zP=k%r{8n}4Llod#!rY*kC-S(|&vT#ueO1{Hu?cli2@20#KUnkbYUNuRP3_vXG1sDW zqau&b0y>7On{FFJ%k9~sQuP7#4frKJ_{QGm*7Lt884v`Y&o*luX=n8~?69GjD_mGC z<#P7q0@dhASSbIYvM-%joNib_t!;X5qNP0$VT5`vE~f8<K^~(OG-@OnV?XFv zGjK<&W6W+8w$qCUx8l?1lzWJh75}VJbG7@^K3^sclwfTkrQ88+n?%$s7fGRs_j?8L z;~w0QP9w0-&K=egf^g#{YZZ>9z(x~}pfHEtCeTOv#vgme8xBHFK(@LUKdE#G0)1)n@nCE9wL0^ zjV3?N80vrd!eMO0AdeC#ur_;4l%O^G7^2^c4;qycD#h`A@nTeODtMa^G;mk1!*Cf8 z+G%x`|O)X4+8$q@ry4Abs+*8FDKfvb$L$^Rs3=6E;4n%>(lZT>g2*(OQHCtU$mz zq=oLV$EGsppJD?ak~Mokxo|cjze1NY`Tg#~wnAAb6g(Us>X7p;01R$VftK+NGPNse z;}_jW6CM{cf><1M6)QtqV@-+Qrs|WLuU|hoUGb;w>^P#S8)uf%baSc9t@en`2#fj0 z7Dc`0i8mA31_IT0K-F*Y82^pk7J{W-(eZJdv!Ze>EsF(!zSj>$W!TfmHPtxAV8zWW zKQdrI&S-jakB!t>+HIIH7BfZfETehCO>Vv6QEk-hp~)nP-jGlR4W`2r7QP6CMxCC9a|m9hhp1hR+zU>}_?YjSO z_K~vSYV~Bwv`1cl4VS_bydoZBd~AxfejA3qr-Clco_#NiTpJ2*IOitdQJsR**ToD+ zv%0191xVkcjQ4zcg}iSfF+Q!d(pe|oI6Mbi3B-3q@IT=8YGy}d4sa-2td7jdeTfATWCoj-pU9JQUW(~c0_LVsd)Z$T%*?iVUJEo zK;M1SIUX>I#oh9$Ff}BUXf}^(@|qdC@F-_ju%54M z;@Q_$Y(YBz-)`P#leSvk5PTZ`p^@f$ZXgK%v zcJUbR6^TcA*gvtFD?3BaHQ~mgL}lasK&J)!)`8ZRhsvtLj3*>yAmc=eJ_w^ zvP zA*9+Jj0?JLWLhV?V==i(XWESFKZ3qFCa8Rh;H$8ab{!z5d`U}BwOEv1EMm!!OCL$_ zGKz8Y3AEc^X{00edu%z!)Mc;wbz%~LA?_6rso*}&I2OJ_ANj$B#G%;NA?T6--X-zf zM-|O6#mrzxrAtM1s?;t1AwpBG`W&$!%BW)3j+TpEITGpvc@)$yp|}042G0)*EEXEC zNa12tzfZ_FcG-+5VR7Lc3l}{bg_P@Q_{b*|Pzprno~o}N5`GEXzT2SM?vBgaaR^hS zf5k^!Q&+>BZ9w-sXW~GB#K%c}3MvvY&ZEUmKhox%rjo$Ni+ z>-o+YH~Gp4?kAQMk2K<<@`vH7WiQ_AZPzQJkk6adXgT7VOadKDV?_qLGyZm=9q@+G zPZ$;2dLeFi{`^dNVZ^q(XCRJx-jIJ!moDd~FMbg`+j9M=_sJ7|8tCYn)+0pU06bXg z!pw{3;k{I@EaK%|F_73_JY{ZwIC_9~CES3RNF-j}5xt9e3MoO`_y2UYKBR<)|qeBkgoh|LPC#@3Tu5b!TVGk1A2df3ekDJXh4OZ|i*IWBcj_G&6}=goGMQQWSM6DL#~c(W+vw;n)iIT@mWLpyanrbgM-@ zQ7THUdUL%rOXQlJwmfBg)rqiRBkVXT{-yE-tPhwME|f`%Gv%Doa$Bg??t!Yo=P9VW zdg#kZVl42@{|&W)0N3*#obphW%~0oCB!i_gsD#pnv|r<^%HzCU=j)6E9FY+9W9rAL zdjfuX<=X_tNSgJt+;J7pDKP~jap&qsoNpnV4+*OOyk2Gw5@S}>l(vw2&AV1$Sqyzx z=rb!Y`Bj8E5Jcz0q^MR~J-lU|^EVzbH5Gfc%gKCSV=c8)@?u#E)rPY%P#b>oj)$Z9 zAenKn2f!mEnK{lqXdZ21<}(`1mjd5?1sF1TR!u4gpSNe}#OuUi?7a9QnqsN;w4JlvR=we+H!h>b*(7hcg{FHt!_?$ZA(}xPd>4ejM zW-fgq!`^ItnH=7PAJD*OxT)v+5zx{uf47l>CSn)q9?v+-B0><`10Dkn2zGX7;+DL- zqk(Z}XF7l{SgR!Qhc(}ey9!gC{BlIsw@&qpH*4pdw1TaDCQ0|dWTImM8?iQ3h>nBc*4!O4Z5Y`8OfroJosY4ajB96A{%Wd{4L**%eS@M12w&yWX=OKXmtnOYgz!Hb zABJSHEO$_>3)*0dFSsmP7q6WM0B0KfXbskj*iti^zW?o%%CMBS{F=Ez04bMIP2q9E z!h?-ZbGmvVbJgEAO)eM5DZ_BHQu^aHmvm)UouMm{DZoyY;l!M(5D?e=x2ZX-xM*^u7zWJQ+z($>ic+s)zac zoywVovvHRi{37}sM~Dv*;-3zN6f@5^X>L~Myc0g!w>vJ9Qz?75Y*09l9P_(zA9Bmb zdI-f`HRhhDvXWsCFS4xDVGfR(WksqT{jmK+7#0c zIGgRAEpF7s1RofqKBp+o7Tfg}ElFS+q*mdJdaXqLygIpWd|Xg=`~5K^xA(=nZZ}bI z;dc4K?*zVsGz9i|Y*c9DP+n55UdcA<({_= zcA0Jz$%POtS}tLx^adyM72qAatew5j)+0eR;%P$W>T^rQ_Ug~i?7Zc+=^qs?XCO>7 zfwKDsY!BKsaZz31$0Z~sU!lLeYHr$dEp6C3>RVW*=F+^a90C9Qx8x@6-c95Ol~wVS zE2m^%?W<#|#Dy6HHUin`qY=v1*+whCVm*9I&z*7}g|UT%!qUz;VP`LO40HeK!-sAm z;ivlo=wjr2#*sk4sWK1Wn-Jpw;X)sY6h6kY_^92MNKWHpJx$XmFBc#C?em2|`G2qW zA;tG>dW{m9^IG)gs#bkcJBxX~3)kIA{`ayZ7A6VmVce3;DKVUT87g;LDVy_Ig!3f5 z;b{4A3L?uvWxK5|_5DdfMc{OKUS%wX_(J@K*(3dwF-W1(o`dBi;SCKxPOJk3k?OgX zaVE-L?M1-W><0YGKi+_i;lz3-*ko9HU{%mrcGb#M|Hf$D0_Wj>`^)JqBm&-z zAt(5X4*G$M(%eMGQn!tAd^9wrT-7hYoj{Sy(RWt%Kgu3*U+@j0&PRSdRlJp^Ps%|# zm8<`4A8#9cc7CbRMIH0U=n=v-?_eN$QUWMJstUM4?qrJDOfWrorvFf%{zoLj_oP9) z$T;PCiX~!e=cjj_())!?Gy5k5Dl)Q-TvETtNKoRKTP9xE=o)~!= z&srmye-pypS2l1Xqud(om5P)HRJtJd*5b=4sHV>3*5$`!ja6=4iGidGQy$kyzmPl( zm-De0&14bsgf zPlO$IrXKu;hB>}8x4Zn*?~AZPctm5aaJI4JfZNaKspnZ<3Kz-)>ImfGJ_lh}Oo5qv z^i{VmfTpVVcXc^G#y+0=RlM2+Lkrn1-!0C^0#uOhX>FGQCGy38K`r~8CP{cXXDH@> zq`2S^Ua?pX&+Uk8`@%xoX@u(#e4>)V&(hB1d@7e&sRrhuf4mXhL>Im6f&luKq?kL zjj;Ek*FZRL)NJric5%l@B-DDFNEYKQ_>i31W-p_#IrJq5zz)lx(5 zwa_8T{n*-zb`tcU|`JpH{3Kk4K6+FYV5Aq}fYcXx{o?cAc9py6I;}3~G>`n*Vc4tjXWf z2=b*!Y#}>StdI%CyoLoDM_1dpn_+jFAMlQVt$r;%O*LpeAk?*6yZ>GB#W+Q=FXAj* zl_t-9?ROlVz=qi!#c!GoyjAOVEQ{l~Z#rPpC`L22ha}<<@Jq7X4?Rhcuw1&EGja+f zCd>gC3xilX)@PjXfs-DW8!GXDrss$nZ`}tGr%ltJ4+KI%2EG}`8jl*el$%L|AJ07X zu1HaXeJ>=FQ{c2++1QD;&w<*1!;8L>PnCJ`Zy(76%|g($#{B`#LhD)q9m|iQugy?< zIN1^Pesj5vs;F=Alam*}^^W5r9$LZeje}Zh@8q+(5oxOz31Q7^i6^_uOlRQ*emfs9 zHw{yNI7vXgxEXM5$3uG9Bphi{7QbF$KcxkFpxNn}y!)YWISiv8kF9gC7LEt;z8}sO zFE@?*-$j-L)^EQR+j0~yNIOe6b;y^xI=?_TLjkCoYQG|!ko-H*Q?{to%NTYxmZoc| z?J(J`JLa4xcl7hi7&v1k`pxlrT&+1JS*GTkc!i6+WwjN%)joqF6zpjQmpR(l+1^xY zsOk@|n7aJEH?cD&HERQ1>kcq0 zv~FO9tdZevPCqXEYCSMx(Q%fIXDJ~1)Kj#i80>UycAh_PH*gvb=n^|T^vZ2sLMv4s zdS46aoTv5T47g9_?!e*`*mG22W8G$txgP#+hz(q%cpv!Jg23n?5}X1RpT!V_Zy&Ct za#56=3RbG2QM3KE+4nL(xtE7rq31V#I>LWP^8p}6byihVe>^S^aK?vmeBwi(F&RVX z@rOdKHj_``^d$L{{?5R^Zl;(p5?VyF%a6&r9D2gQ%-t0wNaC*Xa@UVqi0$Y@qD5kB z392tYCQ^aOJyWHHLqmiFSJiXi!OaJH1Nh-n>)VjhhSHkO0+He6(R=i;fbk*wcSvL7 zSXZGo7h8^yknXCe;{^hmFh`!~Rkb+OfOe*5>n$ccMv8^hczsQfb?t@$*@u#>oxWTo zlW9B{EqDK+_fza+3xVg&=y}do*wUw`0~egKCD#pIUtmkeJuLXn&-N;)og^bFiFE0_ zdF178@enr)ok?(5>t|p$7%cbbfWr+4#9?E7y;p-Jo=W#YbT+%s;jzK2$b>Auo~$mP z_o|6kp8<#{d`FoYa=zHWHdiFaK&xu}WJ2K7L>$m~bmsrcJ;bT~^Kv{PU>}j9+#{SuuA!t^~PT*O|+t?!rAtG|X(=EK*H_HSVcb?nYj-$(LrcGVD@-^FJ0QKt<87y%#>p zUWp{jw$K53-t|xj-h1y(Fc&O+JPjKcy1515MNiPBt_wHYjMrTBvFNJn6TPz_GAF%I z=$Gvkpf!f(cO1%x>~#U z!nX3vzRh26inW;R!wc5mMnQ}{y!n%8 zpbhzU8i={KGLv$MX{@V0EyK-T;d-!Gx#XD0Cs-0XnOH=q+$wwFf!z;B+*;JkJQ%O# zw%L2JVZK9KNOVn#(()PUDkQ+4{AC-;_?=De7Bo~D?!kO0;&-nsdc zCl){bK=;bo!K(PIAb;KA^N7^`oR5=3z4fD4C-g`wuS=^%*n0R0gXMsp)~E{mlX@au znxEitlkx1ucXR-Cy;>6K#s8`TNxHHkrT$4aKPzACaa-5HVCg!noDlaeCJF+3GJVpe z^o+JPG1_&?^C5}BN`(l;HrCsGv{VQCJ94&od(D=-)%mUKda8OG2sJijuXt?b&%ZLH zixsPU_gr(yHq^syt6jj!@TRgd$bu{so&L8Ufd~>y9^(`?z6NQ8BRHJ;PmY(WW58M zvYnJ>=FH5K#1?TAbETE1AA6SG`w9O|o;ARWpqd}T;Q;Ss60Og)G1yE;noHPAhdtj9 zzRheCs=G7iV}Q0+Sa^JNMW=1u98BJDe~}2F4waEmxi23@vQ3N-9%Y?M7?T>>6Rqb^ zdr^FxxDTPnjcoaR((BEhNMD1GatEQV(no(naes+IzH!27-Y%dKJ2yk)76eZ=b`pjm z5!0b`apxEz?nJYX<8(Z?40^qVw_p+!dm6(E-XIy*ua9GlOU=oe@X^}Mp!pLF(x?kp zOhi?(`bBr!trEbhBqnBCWZ4_)-YmBmhaR#Fe}m%E)Rm)k-5qDY5mLKc|EJ%|ML z?&9M)PFR7zB*WT!#*JqWG}(h+n09Qv2TLzKr>|0;&AbK@EHd{^FM>8r`{$_ya(!`W zSdu_tA<99*sek+amIvqur)B{_=aLkkTb_Vw+L$Ah_<%AzVuKaB^GJuG#2=#%+HOI) zA8x$uRGY6=NKiKkINEU0a;NK0@v^Ww*AlfmO?Z}h$(Wx~!x z)}9gkaWB|1$hdSo3+uPY-KDwr_{#XnOyZlgwaKgU?geZ!`&%R~7NyTb6|@X&Fx(4IsgO+=JFTl&nrj2HZ4mwH(WLH}!unInY#bB69`!1a6$J4L0x(npgK{UX9ZxxAS z8eo5aV<)s-w0p4N;N^2%kGT26dQ7aNF1juI85lpj9NW{0mM3?Ie4+IRPAOA3xY1*S zutduwzal;6ba;dG2X*fbx-7{xkUmv#)1iGWIo|iRT)Gl}KCsF8(|Mu+E0W7$`b^m5 z<3=nH{%QDjV1lRu_k$`eQKdts#Cw4Dq$HpFA(xv`E%1fR+yR=H0K9V%&`P%KhbL6X zsBv>Q1L@@D&a?pToJb#HY!ZU(u(TIDP7KBJxzO=yQf(@ zm|Ww~!kXNF2Rgrep2mly6bBx~s)hV9p%Su+edZZP|EQ=rK=0Rn`*ZO*k#%6$Uuinx z)toFqu6h=Gixa;)x{()B8!X?8Gd`=x8=dM(se8AjW%~6KSv)#?^+HFQLjh-{FIrTBp#i4 zy;NO(^&T|AH-E`7#_2GHyiZbfys}_>*du3#5r!>FCq;EBd}4c`?|TpPfYtWB=Nd&G zBXP%ZQR%0~?L`Ib3cYq;ng>vZs?efmW%LGUy>>}{idC+H?P|$UT_L2w91l7d55lsm zygMj8-Ue{hm8>6--hX%kECi|#z-5j%c5I)zLlWVm z2eU>Yw89OcSTBQ6g#1qO$<_5|pI+ps_`fEIx)-@qzAt9IZbW!7TuLL*%ZKq#T-^HY zpftoIbJ`jF(@DJ7w`n)*y~Tx0=sItWt?UEr#Af6Y6BRFcUr)c&Y}2?hdscPYL=EdUuh>kOLQ9wyy%rt}Fd+EH zR)@O9O-=&YBFD`o+?adM8{p4$hvaUBm%@;U`dyRXgP8HSw z&)qyCay_-w(aA6=Yv>JhY%O!XCLJaX8NAfY(7@Hp>m*0gg=Bg*y)MzqSg5#c_`Gf= ze)CjikZ-|{(7m-|s_ExF`GA-C&zy-$`>Ex1!OSkS(bv+oCN?Ttuk5laZmnvQbz3Hnp3^J{EFh`FhM~1vPLuwG7o=?%R zRHmMDzUk||c7E*U5X=83YOE6osphoX{iTTsqcRnci*g*s8Wtys$28pt#9R1gRdL2T zeFl6Yga|g+0t)lov96rf1(c%*jYETwH~puSNvRGt9eM1?;+r^@zt!84lN5|T4Zbh$ z|IMHEqrLp~yLyJuAmo8*BG0p`Xjpb*+ed||t{CZ04ddiQEdGlNm9`P^eqY|<(&3Oa%PS#8&POnq*rLdEh^%&To7O*9T39XMWm zXjoKN-iK0Uz=OfFeDg)8A3egNx7DJ(u zfPx_r1v2VP#BQZgW ztTU@d}?|vS`c%x78v03;_xGu_4vOz z2Of|1eX29n;k>%Bq1+-3m&_+AaHAOk7ImLvz3W?XQ30G9*UKrI2rl9eGe#8pWK8nT zrCoF{!1KB@O)-rRM2f-RS)`_g=z5KRb#-d4&8v?hZayB=Ig{WNs#ZI>`z93mPEgAJ zie=J@whsJ_`3{Ze!>5Bsk$6VRp6g68Z&dh=h;VRoCHzdl$hua3deXC^V8;$11Xk|gUhKp zdAWy(gD8UH05!1)VF3zjmA3o0L=&+UW*x{w@(!&y4fU?f_cZJJ_9BFkRjy$XNDelA zzc*(kn-D!*JbxaOKe+2qVFByZH%dDQWH8y8_%6S4m};|4KElm#NeY%26(IlF^9~&npQaxuF@&d+zD;^O0P3A{gT&C!6&J95;u*fL`GXP>l^(+!e}-G?^7Ms?QYV8phJ?Y&T~OqD`hxc5vJ`a z%aGqja$T{1*`DUg)7VwqhSyyO1fx}{5a-6Fw2!_E zO#S#UDk#N+aL+I7-8eGTNxk;V*n7JxG{Ralb^j2(%pWt?EfGcg+KTbTp5CA75W{pj zDuaE`Z`Og`&X~NdR_!dnEk6HaqC^LUS|3E+_xqs)-$9X{m*@cCUMw(03@Z``foU_e zcMIE#q1;JVSu$xis$g-(to4~6A>sy^&foLLv^C&vB^yNKk(p|578$R{b1e!lrl=x> z9DtYGuvte5vDSWOY6V#&plUR)%s}Fzk2+AspxfKsW4pm6oj)eV@MArS|C zxtQs~zp4;sj-s+uMgu14wD78;d z*kLSxnQ|XS509%ea2EY#ZOyODdS|~UAln%4qgQ|&EP#;HAsTf4GhfI3eRA>n_o?a7 zM+r4M9qmMY(*wMc;DitxCUZ(m=A_}~*=e7nI)E@etLCu5EDQX)$U*!`S3&)C{1#Ev z0MOG-*R;`^u7=>HGo4Sa#yy*DBE4t0nWE|C*D}~u-GT2v#Lc~F-)S%VmR@RZ`rBae zh_rsa*D3m#TfcciL|F&z$!4o(-8;~d<_5EM-ZosuWG@b}9Os^>HLO~4AH|nwQ)1F9 zSm%J)Cq<5C^7mzRns-+K_Cmqe@293!H>_(X$m`o>cYoC%&Plu)BIxQAN|RQ9_RFbq z^0cgW5J8!ACLse0%D`PW~u#a3@26!7EOa>W{pID#bg@&aS;cfudFnAf~3Ae_YiYDK4z! zno$nwkO)5q(g*PoKt6>j;5?xJ=7A9aaPS<8A8;hbLZKvfD$%fyvAQHk6~zXzVk_u} zf{KjDceK+g(*AW{BZ_O_2}ICaz2T4&{n=pU zuP*{LWD4c21_VFUET*K?f5?4F-Vw``H(28gVU4`N)VuOto8Kj?cgo#-+v$t&p-}SK z_ehid@gyt;etHl8EZ+H)m_A?n@!c;iO^$PC48{Y!<#Sx9Ta#MxSp3P|PgLh?#4Dii z(wI-4+J!xi&UQ=|3()dy4IIEt^s7itLVo54jSDFhU=yE|s_*$r?LymThybLx?W6&zGt?71)>>-M`(?zZ4dbFh>W?yT!Y2XuZ@ zeUMKTsO6qDwPbO-8B4}XEp&>BBxt!MQVbtDQRe^-CGTY%N@3_QYj0!cJZUK{sFRN} z3wQ)4svq*Jdz``agJAWj%f6=weW*)up`e?4-~?yKbuv?b1=eLqu>O2!~< zjxh+MdXQheea9oNLGXHot~h-Ns|s$s z*a*9xfb?-11K!}nz{@xkl~XuF%`6!d2|IPw%b2!D!$r3bu`Zdkrfn@x$XCa&iC%F^ zXPv3}zPc7dGdB6ReMp<|IUNLM;9aRra6?{?@{_y0yz(dlQf2D z^JNwM8co*lW63d_iiWW7vqZ$1q}LfTp#Mv{68y!Akbd)>wV?&!0}GU@u7}$W-b<&P z`~QT=6Vo*>>v{b;PCIW}vr-ZfRJCt~3r6kHtBig?u5n=-SolEdspRwu z;}8BYDrwVQ0J}``oQJFT8bjv-|y^HWo55Fs<6&Unl%+iz;yvbQHdp_TqmR?5Q($dqryGoi7o*94lYQn=mZCw_UBG0}84ArXf z4RzcVY$=J!eM%bi7FhpPo)c}}OU}`YD#7m+Ko-6~ zWsjNZ2L1Vk`JrtTZ9RPAVNKiJfndeUfolbSh2TwA#QhQX<8~3d%ChpQoJ!71pL^~b zA*<(Cq$*X$It-_M{|mn)y@IjDTm;Q}3Lpd_eCJCEfsn=ERR5ho@f+$3eK&R# zV05~Ma)&@ACGZLTl6%>Pm~#yFO_S$UV7`AO;0j(Lx-ZO+qX-NKaRH8_A6kRVyqdA} zvzT_ER9X1fPV(x)X#Jfv5*ptdSx;+p_Bn3OdNXeR(K~G21!pxvdedriC+vE?k(M|S z;P@^MA6uzht)kXVNZRQO^mKl{`V;p=DQO7E5Gg+j)jt+aR0u zL+pD)B%U&EJD7BS_L1D(oztltv+vsWvvLM4A1Oo9T2P!;1llnBozlX7A<);^6!+Yp zac1=l9nWMo4w42*hUm=*%yLrbu`Lkt3=n>o&D=Ru7qgH3hQkx9ez8uM?P(I(LS1Oq zoLb*(zGZ76jC>VBsh(cC1fR_bF31UhC}yzUr3VkZ^!nQTN_C{zPWC|U0^{#>3mp!4 zvCpV1PuIp0!pmzH!B4AprUelFxo%%$9Vr~X-99uqO7EGaBbVpQNUUGs&LV=NzL#dX z+FNCw{TH{k@KvJw+9$zAsxQR@q-waLGHKB97RmWY`(rT*N~soxv`A3a(U>0tu%5$d z*BQ8^DGlPCrKh{LUw^e~(mkWg6tqj8gre})x^N+2s0>C>@b#`>|6aslG4}aas9(MP zba~X-UtfgL=ri{#FFMAh8Em>@l`H13S0DW@z|dShHXrQ85YqLOv4QT-W}hkGBvCeM zA3`H4Rkkmr-dfb7A1`!#T<+;tg(xm5Y7;WAcP#_;R)owjy#qFxLZv`Y$(O6pWaG)z z|DFWtAXW#aL3sa;*H?4kFE=c*kn}=)cA*sUp}pjWavmkOcX*z=XQb1&zlS;`V$V~z z6M`@b8W$%~_X{Ul)#_gaH3?7ETA>M@^wdz_jd#gE0H98>30z zx5l4N=mEz)nj~e&>vG)Uwt&wm{}c5gVWME=s>UHMJ2UFVkccrBo~5J_}2AfA;^i02v4igzvvCQJ|VnLw)os^Y3qy z{9Pwf_eq|P=b$)02i;#WmZ z9=-=cno;T?KHJd2c}GwA^0{5b-9hHyC2tSIAdrlg4Yp?&zbg_m$ z$Pw35CZw<`_2-Q_@{c<%G=VTX>|8STaxVC`TT3cA=5&aH30N>dQB}ti^&(X*+a*4L zxyr}d8=TWBnY74}&k_&qJ;alqIrIhqE&ukkr-AeB4FiujEvEH0w4-id!k}DK z(XYkGx1cC~^TCc-gKVYZh`6Dh=EL&OT9imChBAl5X=PCu6AktzLL`s@LcC5msnF{2 zaS@wXz(_Vc>+_Q5nb%6nB;iu-zn=%e={AA~XMN+GVXC=Uf74z@NXg=_x{Mvsh_bD0 z9cF*~nvqf02h}eYC`KQNM**)kRo~Dx{%{X+vT>yMyZGeu)e~9p za6x4lYp2`_6$LQ`9H>U+{z(z|lY++!kzEX9Ob^Dry}l#ds#e=-)2DlU!ucM~jtp`9 z>jIbz5hgL8V_ay2=jZb!*l_56V{e%h++b>NTmW%rk3NF z2r^{m3tHT7rmmWl7vM=^9BnQb{Y^P*!j6Sss?&;Y5(CgV*aS2a$h~jQo1L|ll?wjx z*ME(wqJVlaub5RWBlIhV(E4I5({EaJRmf;7h6pssN-Bv}lk`=-KEWib1v7s>(^{hj zw2t89x4=L8v*5nsB17p=?a)(+Z$1$QBH1=6PtWMDaBs3wATXY<)#N&7AyieYb;|Th z1ZBR(K(K@s1(aHSisEHOlEGpw0 z8owK<&aAY|{zBh6_nk6N<;CAU3hp(9Z+uTszH~t2Nhj$Og@&~-Ex15+q0Lje4s(;3 zR7fCs$4XSYkneVANT3sD5#~Vya6mf8{EM96vb>v1I4WRWUX~1@RUwo7HAM-nMlJ6k z&X_o@7^yBs!u@Xjj~>=*(pEOu4*2fi_h}fPe-NV&elQ*du>RjaqHO_Zge3t}P{+?d z49WVh)P{wSd~-p*srqq3wV-iDw$YD>R?82RTWHlR66KDe(y@YgBa^4=S95>epZ0Eq z_95V}rHtV(O|#8BnS$`)2~AN)Gt%QW`hsp&zlr_;hiGGLg9|@km4F4?jM>fuN0LDv zeJCnm4rA-TLk?^U@w9I9y+PVk9KJ&?XwwF;-IQ@|1n*TWG>W1j;AvK z?!ljcC-&Y}_U*(OE)FxoJQosH9;+RDK;g_XrVCF8a;;8<%*u|IpU+>xI zxA^Z7Nz3y2%J;t^Hct}SQ+-VSmYakGN6vZA{cZQIN-6yy#_=YOKf#YHu<~I7&)44Z z$)EE|-TxZlSP#DWK?YR6 zxO8>-`}lCRVXot8S*TJv+Cu*U$Rn89A2SM)H*S$=J2}|+sO+;KP~DU*X59ay63R`W zzFhTDqI?sms&>J5S!DIcc?XErT~#Lh;F5$rht7IW(W4*VO9t8ehlRV@3m2xWXBtkAk#6Gm<)z{#Uhq&b^@!P= z7?Y+kd^k=Q%%z>=`HOAAa--B3JGIi6#{XT}i`LX$>{UqSgJ*FN^hF#rERk^$gNI?n zxr$US)~i`Kk{PeVCYb#ezk~C8PyVOe%AZ!iIm5*)Ylp*|YXh2Hl*X;!PYC-Bk{nA% z2k`KbmWID@R39D(NG`$0B(3la@cdi?xsi;mXY`k;4Fd@hReDe+*V^r^b-jwm+3*Ad ze7O2dT00)1yQ<>$lvKe+TO{y7F;cy|8w?AZyc0gOOSH|Y(s z1+yTcStJY(FJ@B^t=AL6p<}i|{;>VSOLGp0$jo>;eN#oj+PL+3$bVrV&`$`?`{5Ok zC-HLvIhCf!zz@%F0V2PVBw*3V?Ejhl3XudZ$Hbk?3gy0wJq0e(vYZh@8Ijp}e#+Bq zX(wt_LFszy;@~SekpkTC^>e|WT#}{^2>p%ixI{ZH{Yf6>Nv!CH!4lF4GXHMV$4L4A z9s!ie*+p($)!?wVF4Yms5hv zQ={ov5azFcjkVnR>5F#%@1q;?d9W9FQ4qE7^OhPp#D_fE-|(pN`EIK&m5*i-U0jec z2~3i00|8W;{GYHexD6H#o5-zBFZEa2%BNNlZa)%*=)PC>;mt501yjlBG@-^f;+e& zqAN9@JN3uy=A2rljn3M8xAt#+Fn{bdH5m#Bp09I1C_;&CzkzLpD-{2R=#bO=d87kL zIH_c&O_6@gGadA?7Be?|4oKWcu`Dyc0#Gq=P;K)^^>aMT-1%Y{8ZC#RI(dh#}rUEN2f z#K~)1$rUpi7Zj`>tJa#6m+8I(N3!44EWxN`-kFfN(^zxo^9OPgd>?fOXEU6V%u=e7 zhFbAkCw&$Gw!t;^lLsso5~`B$JPPs$1#wcGSK|+qvW-x39D@K_)k~}wmlN9FYgzy# zIAL@435C^?BMbo45ZY<)5E#~67wjH59&o>F*>0?`l#s{p23a9byPq>T;@QIv{~&C` z{c=8@NS*9)?b?JtTYQSkn0p8Be@`WU^5Dw6le(_(jOq0c_gxR#idEkpnaFjJ?lb!6 zGkqHzvlgt~?E1himPx*wmmO9kT&@-Ze``!}NY{nkk_QJO6+iIl2J`pi;`%f`kk!R< zD@FUg#1e*RLo46K|Hqra9627@{oy}AUj=#i62KG%2~JR0!>gTzfC6bH4GZ|m-n|Gi z2(!2+dnpVYvIOH%Jp=rzQJSS?WeR{EDmEBSsejC^-vO+=FjdV-8_f0iG;x77xAj-X znncD*m?y1CqFPgwS_d}ifS_mh%$nDZ0Ln~^^$97^$u)K?)lu(mNzGg;NI&MMu<$3y z{R!{D7X@(D3tsxzgx(=e=+k`BzzH@~ou{4A-<0%YY<-;sWHeSQ0%n< z-uwFmR5m5ij3R*4NdB91$tv2;NazoMD1-9sw33uHiSP9nT`#dzM>Yd=vVu#{OZ#)EQF5QpNZ9Rdi#guf8wK8hr{k zQTZeG%_cJYNqeYy-8XN;>2x?oww2}PUZ+Sm^mo(aT1BpmhOY6p{r-%KPkAErf-xHGb?&M2`Na zCGYp}2D8l9ZxrNhO)Xuuvjvno;G~-$S7MH@#c85}l#7fJDq>jB{XdMPgect6Vo&;e zvz6IErNHQSQ2lq~n_5Ag7VwW>ycYonBB+!*R&0JShE?yiT;_;HDGi_ABwMXLBI)vu;4*iR|CMFqtl|5B=<8k{|2sH1|BU z%zY5cx&{UjBmq0}w^zvqW>FOtya4G2r>^_mVZG#dMLvJNca;(^_{XU4quLA7wM@6M zdZ#!vS=y7+QC2yshW$(df^8!*`(hay7`ahb^caK{;Awb_5P_WR#&>@Z`)DtAa9Zmy zVd7vQ(tv#%L$%{2p9k)ILA`1X6AdSQJ9dG#skp4VANN3xz6x5JjJXMC9SRxH4|G|w#agAC#t1-ZG~YdT{R+{TsPaBG zI{-w4mzI`j=;=dCNNQ`VYwXhs*5*7QyBxr@)q_Z=Cd~3m3F0XB=u*aa@jV<@YnFW zV{qw~-{Ucq%FJ6ACC68Gx95NJahy{`8@VxgUKWFDKfZ&G$W4I=eeGi>C!N0H(zx5$IJ5M`zS3clu(M>x2+(M%u<;7Dz@#wOYU zmiIzz^SiD)ApC8$-0VAkz=mhuCI=ii+wc0=F61!arFv*50dWM2M*i34Gy8vx7G2~4 z;__=S@|35XgU!t%;lC&rNgs;e5g?cS_!xawF#@{Wdt#o70iv?*g95!d<>f@Nv9Wkz za@RK_&^SN=0CrmqNR;yF=<0?5rch?uL`4En(GoLAgwB{l8UCYtj{x6W`md40n7wK9 znzbE+%1&m+*%Xkd!5AYRDl%jnr@nxzp>my|GU}_ zte%PgkryoKGg0A$!=nHBkl}AzK;?m+c>U|kincjBSXO(*e(dBFpk6)FQ zy)jRP+?Rc~5yO(lT>z1Ejsxux91Q`r*`%7XcbkFRXATEcK6Zy?{SrJY>oYFRLVfS_ z3mdReo9r&tzB!ro%3&eu0XC{io6X=4JVBpbly2L`v&O*8RzfaI z)1&}m>*Gr3!^=9C1@rZe{JnuEIHO|YY(*x_}x*H&sr46#bI|ewbfjWP0A(-uu{3Xmi0KLkurenTHy(- zClLySEoNC6R3Mm9pZ?jWRhGx)jr1T=M_&@!VV~9=fnli}3fS;(*BLnq!-l4`_d`rK zy(Y09dlMy)I0u=erns@l`$Q}seWbxgBWB(~Uli(cezmTZB7O8e0e7O^D~a2UTK=Zs+Z-H@}kvhBX62Lk((Sb zRB~VjEu`}L*l1*0K0Mye`;q)}f8`F{7`6xC=Rd7W2?+_(_}*&YbK7DUhYVZK)8f+7 z&ik8lLPo2P=NN&z6Gg@;F3!#hPWx3fUjZ-Wb7B!S{UkXOwiJ->Bop7hy&V1D>)i}_ zH^~X%d?d9%#z6xBKJo4MPW)g171inS^Y_@mGhZq-BI#xPY1VsUI{`0ua(_Oue!E}U z>kYqK(#b#i>ABj5adCCExA5C`h)W{hf&vv&o%gRvspsr?KVLyPS*bW61*Qna2~lE3 zt_rewopMehQo*$0(B{FS4kqSP^QyxGHKBVuozNm$Ak6`^KK+qRE5bJyurGVXV!H)N z>YLLQrqO_i2^IXhn-3VY%b&T439ETm2Z!nx;xVVW`7JFBfW`{;07sI_#AiJ{N_Y@( zGmr_6DauyCRZcKAq|^J0>{W6ooX7u*X;^?Q2?DFI=yS#f3toqBczF0p%W=TScdVE7 z2?lz4W$*tG0Nx-0rJYm41q49>=h-TZ88bhgLiO~wZ=2Z2KTb_k4V!*bXRmf!kqKx@ z$c)#c(*W-JQ8mWe-bOGJAYeKsuKyXe$e^i6#sluMEJX7bFBxkRBSjTv94N zvzY&!Bj9bM3pKM!QWskML|ajpmFoZrIcM=QJ98s)T`>*7D4Eei^TinG>^PdHXL=?QWpl2Iu-kG{qm8a|L7 zK6^S=7V~nv&}S)MhNopsDwN$M@>WO_1gdh+cgF(xZXkbeM(?rFlJ&8sM_Oz!0SEJg ztRLdVziFWg7&8u0FtdCDnXQ}X2;7Ca5 zm4-YwRi}pNQm9+NzOmTVtX0^&C~q^ipc4UsrTQW^McfW1C{x5m(1p*i3Y4pTg8T08 zt+!;Nzd}CJ(3PToX#CX#-Po_!QZ|bD`*@V8O1Uxyv7d+Y{lvCMutVcL=n zkI-lFK{upzeLHctjK8CoMs7Ptx#?Ld+!%1M$mXaK|oB8iz zU;ny!7Mh_I{1&{h)Wgu@&BkXow_blP`|ep@9$5JWMMtm9m4N?w=E|hvVlRu+aS+E0J#$m_R;z#YO51cG;7$KM^TD5oJe{ zl><~EEcXHIj=?~05yncE?h`bSX_f4VdY=8`SYKE{)$yVt0E6pfLXnn~P>Fle^w6a6 znwGdJ=j$||bP%R&#IGt$ir@kcy= zv=)(?CE*{Ydqr^b+Eq**0^;esL>84Lv+rXg64SnPd zmp3plSguh*fE~u44Jep2c^~%xR$APoT31`Un&DKDnC(C4`&cy09~tooNjk6)g5{419tR7Hwptu!Smwy+DCvK((FFQ% z`DHGOoMSDV&K1y2UJrw3X5t}_pW)HVi_!7fJtfmHHvH@K=F_6+UfSfcpTohgLA(j` z-}eIDo7ml(&++7lHGydZbfv}3AU8J8l2qs=KH~AUTzuQL%%SOJf=cOEm_)%)7e)Vh z=`UZtxbK(O=K-pU=UYSaPEIdBRHyBxh2WB`W&0hy7ED)wLczrJVu66D)~*h8Z-3w8 zzi>XT#;5q{)1UI=ZK_36|L67?Dl0mMU6RbVHc2w~tdqIk%7c3uD>9u%#YIYEADK1~TO3Q!Pi05h} zNAwaTxx8R}+P0VE+0sBZyjB3v-sE2mr1H%y`TsXIpt~Ccs1gM~91P5SpS#`g7}xErZ~&MyHy1<5b`Ve>^>V)$Q?>#G(u2tEl@!7X^a^AuSEH7# z=1mnGsJ$3C=V_q2`Fp3G@`0T5>eD$J*l>_tJ$0m z!SlFB-G7rZ)nMYx$-4Amnlks-?PZAURR|FlqIPGb+IddU^t#gMH_kun@p0T0f*u+` z3Q!CXS@I}+2nh+fzO01C+Q9`gG)R790>-)K;=z`iF&w_rrbHGgUhYuq|6U1WbZ55Qs9OYil#1i;(Yf(J)SO$P6m zfPe#t*akZI^?&EIx3^~=Gw&Id-L`*wha%>gv%6`Shm$$3yr<@2{qgKE?HQlAPHNUO z6HhJQ#D2#j7QqLhz$Za(B{e=gs_e+R@6#_+CH(T&a2m0n2#tPbuK!OgW>dq(1|Ach z$SWUyMvpI}eiuEbNosT!g*qRWBmt)XC)>mw;41!u`hbEE1_%%xZy!t-`Z<}US)@Vo z1kk`td0TnRc_iEklt7rO-IHs}CO!anh=)nO>N=*133A0H`oqH$4=MKVYW*px9di`k zGC;ZBvo~y;y<_+tIDl2^)H!cj_fgcM^o}@npHKM%pTl-~Z}-e(g%`eP=i@pEpG|!2 z*v6B%P0Hc!Jw4iZ`O9D?!g?6>+o&r6De*K$*1q_N69Ly~6upa!OXJD$@o~N0%!C#= z76_+A3=9lA2M3eXhmW43QCg6*q%=VrfSSJj*zR$8j(7qM@>V=UpWhw#@lH?S)4gQF6L@n^ zj?wXQj6_yz3)|uy1*6Wlf6ssz9?Yp*NWl#RdP@H>Eiom5F}M4e*A`WLFHuVeWHk}Nu(uxPwE#G&kX+=3TNhaxia88Xa^6?@HU z1~g(XaCIW&IwxTL?gm@k*6}|_ToHWw`fR8*(b#@j4SJ=EDU!VfBBmXIh-+^7(11I9 zfWBe|;4b~*=XZ$&Y`vmZ<(;(wC#7gl&%qYCw%?5GzWGRif62M!yXSuGtV6#0R4vap zgkX&>+nkxdWS-rYTjokk)TP9Iv5snbcb)MGvLi+2dlIsPtDR2hE*%LDJD`)VuW_%>Bl&?yz*7tzvOw@Y)(2qux9M6o3K(@~uMSp96uQ22uaCI3T+;IXU?Vbak{8vb;Ptqvz)**%J>mtkBTVR7n{CRe{>p7Tj?cxlv`tiWH`!qZ6=E-7@K37XYds0q^`q0~@@ycenSJyuDdz z8E7vld*fk&b#;Rcdq=xHK@a(rrF(m{gBhPF0tXxBn|;@R34-{&woV%Mc4nhnTM_$T z1;QJ1sRcxq(~+}szm(0wL~6;)G&K!PI|2mRP|r{Uj8qOmDU_)9HKNBansxlnO`c>R zFql{RBJ?hDgF`UFL(2C~C7+?9n7tNU>Mf^A^cpQ_!4RqGO7nOiQUVL`6c8Sk1X*Jt zh(s3?>f;vN;HL5Q(Bl^5+U1NnlipSbAzzmr_|6E_))Pxt?YY^nWApiN{%7=MlBNXy zOZ~F8)z#Hso+|*7sj?qq1-0eJ%Y2Ps{9^wu9mqG=0M$**1hQuRy8j_Gd3jr<3&8q1 zfbyDh^39-~Oh`0uBOd6a|7GQ>DEwyVm*7N^)_)2|_&FyHjfZs${J^4s(!DO{ohoCw z&QVA>6Z(`1jRBf%_7wuquRw{qiwh6xBm%s%@Y0~7OBM?K+~s?X^DtFu7Okr_^rN&F zcFn=)yMfU8)Uv&y3+P;%BQ%V?W;|t%t_3@Pd?3Lu^(oTcNur+>BcMBD4G!bdTuSZD~G8ty`qvMcDO_F*;Y_ zM$oUHJVsa^1mgc546Ht}2L-+U_PU1|L(YOFmq?|h#2o2Yxq@6uI`0+NOHNNVDjGIz z-E2u(T4~yz{MX-K;-|G$S#vfSMHw)+$EW%X%|~y7p`S{|+lnX6P$*#wvyE?;64!W{ zL06D@iV}%EKWO|>l;^!+g}!l_qrT<~gY}&`K*mxt)LFH`sHf|{N0;QKTDB9F8QTZU zQD@{6o4FB;s)ukOi3JNtAH8@Io)eVSx54L}*hvvEVI4AbtG-}~P$SB+>N2ZwUmrSf z{Dxg*xj@_mwN6cy(7zS+2>8mICD~=y><*~~kB{M^eScG-#J;B~qvAGT$I;slIhp>_ zsk6*7q4(a7QM;d&5BI!iqZY{{RuFSnO7QEV6@pO7Eu$j^f0K`U_mdhsr?r#PFBR<5 zX5y8qj`4Hp>bRS9Z{efgO2JmjL-SOx5qa+Wc%cpVPtGeJz-P4m!5}+7DhrI%9#ZVKq=@1f`7Z>Lr zj~ksi%uj-;(+*FU!g$SFo%`3UDCO*FOL3X}M>nF2#oI;=q9fqPAW(&AQ#b&#?M59> zmb{Mxe6A61r;~BdDtK^lae-eV2pJ!db{R^C(uwxh{!&Xl+j^49Yu?dG0yeo;l-8fA zNIt~yEUPeS2zClL^Z0{9!+Mv(jq<|?bRseBlupH!ZXjvx>e*ZNI~KMvZ8(#akTEPb zS-Lsi+Y2!mq6}9{<%_mb(^toSv}g6nJpr-wfL!9cHbdvF^fpXgEI%-g4I%TPXD&Mx z5D4!=hnvVvahOO^n+zr?F-iO{^CYYv2VIyI#?lGv{m#GkA6aRQel)ENUZ8R-DUP40 z3NQ~u7yN5V&wPvp^_jA)?uj^`UclGOu34O0f%8J7oP9=T8kh~6?U>oG<&*6|w-~ZJ zj~aQIKU(_AI^~89^IuBmnj;O7SQmo;PtYRL+xYrR?_51r*J7gvMy;>RQWAL6{G;)^ z&9avsKUz^Y^$^P2qWc0OSxUb6nIa7g3)CZ*MqUq<98f!m z|7TO&B>QZ#6K~73G8pfw+aKe|ocm)6!wUYPf7T}{oTX~9LUfY)t1By5jcQHFbECam zbYCWL{pr{V+8aXV+u{F&KmGklOms%~_?x7TMN$aHwfBxb;fc9@?r){Vh%4#XRr8-m ziHGviFkw+`JB%xKsHuM44c#L*UDg3Sp{F%^&sz$l#)b=QV~4Z2>=L(T9lspKyYHu( z&r}4;BUWWh?)%XRRiPw{5y9`B7IB6DxLjB2LrP88`=7;c_XaQxkx1v7K%%wWa8WFe zRhU>l7Wp%wUD{6KNWIi1(cGg5KQxOgs-x6nJ(gtc>i7_uOaB3ywS8oACIpS>K!R?)4ie^c(@(ALdj5`L(xF8znNM}>Q$ zPLD+IwUDz%Dfk$6FFYEH{6mbE)QeJXWE8k=HZ&ubSb%-)vr)ZVH=z z9xq_HIHF6_YaW#&%p#+$hMVYY!ft(1iI^}C2dL8p9oF1b3%|io859{S%M|6{<|cbE zCfg*2H8Acx@ zhyqO7&~k)4uQJ8nSi`uk;ddg)H+RG`hc>L$eu)b@P{Ie;Jy?>u3AGx>K~6Z7SGZzC z1A@j}^W9w^C#cIB@l;{_;%q8@=<8)bH_Stf^t@d6ir9=L~xS%mb+*<$p&rub+?7~c0|7}IDLbeuC=YVh#`(r6_sSOi4j7q|5 z5-EKvY`KKYkxAXJM;3Z|um=2ydemoaAn3h`EDES7lVmteO|X_&6Cs-w^KctDoF>M++&&Ce_O$nNKp{nWQ$G8`$~Q4ZPXlzzEEv5LB$5t zH?EfZ4+bD*-K{_8Yi%EIHI%*$nE#A_k|Ie2S^v8+^@#_ zELDCw80G0i^#NO={KYcG(fCHpb47+5YQd}vI=;i+vVKUZiFXU_+VNHA-4RW07}fh7 z=O^O5w;w06d}{|&m{S%~G;FO~UzFbM?^#H56(VMY{r!nsBD{(cdintoZ&k+@6@VMJ^CBRxhHjJ+vO zDifKy4YuzLY}_WH2eF1=RCJCpQ`_GBjOFFH8;qw@(Bw-@*}E(w7aE&|MWMA;oBswb zQQ4y0NXO27moO52`5SW+l|4XV0fap%7kmHGsn45O-k|1|K8UXiNp@4stxohUwaf*L ztRgy>X@Fz9;=|=Px9+{4P;A6mzDnh#AB4I3Bel5{Jv~6yA{5k_ZS z&OXUK-ZayLQ4SRH>%Tv5W7@nI$o_K9II^ydIU;v%kAbqseBeQDIn3f0D(x372VXLw ztw6G3=su-3roM2ey}8f{pCp2%zDWMnGWplQ(#xDUcrZs!No z7xgAw>^Ngrt~v7u4U3m67}9r5c&RdEOE2L}xO}%t+J6mq6zgTuw0K(!SOs#LZWRG& zK}PHf4!^vEVksX#+!;a-w%y&YA9pm|aa_86;whqkn`J~Bh-L@3Ne>z#6K7Uv|AC!0 zc+2%~Dc86eJ2hH|)S5Fqd8_e1U)&|TJIJ>tF1V_12Vu405JuWxz0DbM+sVUyb3ZsY zZYlqj49#0K4v9Q{OdRR!|0pmp8!vanh5H6Y$n#M`1+12;)q7{!q-BdsVALJN>vURv ze&0VSg@&icrO69_9$|`b_A@T7YTe+#bkJRbZg5n8nSw@7y=^mL96btTxt?{%w9RD4HZGH*r+dl_ zFATqWU8;3o+7_mj=4^ZU^_YPjmrncd^^+fdOJK~U+fk*|el>WZ}XhDkK-Ol2Z=TCjB4#+lkkw& z^uLAogBvb9BC1>5)MgM0&dO3K(^{r99Vr)}?;%BUe^^C@hK841X5eC!gxMy^T7WYw&Jy`?Gre6%v3 zDYE{zi~Zm$x({_aEF1rDolWONijwcl%DZ1TS2%5elDWjL%mt=Js_b_Se$KI@OcR7t zT;bC*LHlq*69{%knDUj&3&ENq+-UD8qqs z+j1t}dKWXN_5~no4E>42Q-~fez`kaqQ`Otcz8%{iU(LP(wTnpJSwFQgss;iwls|`-jMk0xNRrfPxpq#;z`-Tc`KK#leXURN|=jC_Fdv10p zuu|a79mwD*HK&Aih<$Kp{z39S3$4HM!jaeW_*+p-ttBPG z6NB%As_R3hLbOF>7ZV7foc&|al0ToESo}$c8<+2o7nk&szh{^u$-*Ngituh3Y3pKA zQz{Q9>DhjlW(Au-IQ(@pSGfW3Tm-9ad43$MCnYov*DApodW`$-T&0j3oL%oNF+9X< zI}r=+?@cwY)*YJ{E%JPYwOG|~XXc--MR;QON&$oRs3ZJMyTjj9o;;4_n9h}35s>WP z?Iia&4Cp>a;e2$X=69v&)jg>c?4G71Ta|vTM#IAot*3KOuOlWlsZL0)a*hE6^3nDU z*1i_r#fawaSfKU{Nlg_e`^;#iMq^VkpH#BUce17HkdO37zEek=eh?zUYcRe9T^rn? zP+imapH)!z^qnU!T2n=xTV!%ITdQBt6-6dnALNcQ%p)sTOZqGkXC*xNxgdr#)iy>& zU4)kkhqF%31oARz16(8)=gM!8~Cn)vh=VJo_$p`{(RnQ;bKiQ@k7_0d<^X0 zKkl^!X?(XYB7tb)e~%t`n(bmumiWK~q34*Z$MK`!JH}8y@aF8NQjCR`pZhe4&ny@6 z6Y({@2>7*%+1Z&Tze+i?^$JxnYWZtd9S8A_UJF)YU+~qA7U$7sOge9=SdlBWwBW>W zCoJ@dKKH62xCvOMK4k5#(<{uW>S(8i6N>pixmau>U8%M$TkHC+8emnJ7qKV>7 z6@DLtbhUP79)RyLv|tMC&MS=#Ob=v%Vu|UonAfzadDUxk_94c@-s9T7#evyB{ZihP zh@cVN#tBN2&s6>jmIKGASL=1_g%6NUty&n_bRZ~t z@z_eZy)`-uio>C+`||ck@|(#@K4Ge2rC}YCqm)&PUa*p8CWM`4o2;<|_Bh^Ee{c|G*w%&TQ0htDXY3%Q__I-_ zrtC%W*}D)A9vL^*jFH}=T^$)2SM21TnQul40P)lD;UkVu8Qak}(d;|{k)VtEamj#i zN^ehHQ`MV^MisEl9SOlzDj$EFVd|Ydi+lrz)6bl#5TmCxs=`nt3vWcxgP8HbQ1YAt z`KRNONOW<|`&SLtJZKu91&TOtWHXM~-{6xrnB0HZM$j=Z3(df>dsTMo^i8*kA4LXs zOEC9V+B_9eI8srwsUa3k{U6H7w)e3#fFF%jssvX&y3nHUP<0ZS1f>;}L{`1z6{`YhiN{@^qQzCu&^OS(Yo*WzHq{9W6(ONLY!xO~<-?9}?j| zpVc#NzG?u(hU$7g9@VUBbNs!xnSabzlxH#tu<5WRAG5XIYSYgye2RM^K98*`6oOFb zQ*S(-WVoRl(A%u3Nfx1qx$MjJ^7gUM( zO>p8es}~@H*ipT)X_&EHg1z;~4XEM&*?Hnn*!t=xrV;AbRFT9kuMkMlDX`BEVU>6J zX?4p_Xe0nO{4xC(p}Czmb(UBiWjasSl1>suG1fuS)7u{&-aepro*6ui#!I|Y9*v@@C2S8OzT5}-^$q|6vzUA=jFPUBk#&$M3&?J?#3 z)4lxr@ZwHpFDH-BOJ8Sk3ai&0Kj3kSkn1s!j|?+!CcH8K+Dkcl{52~d=bu((xqo($ zd6L@(Ic*XgyWkEukkMS-ILsC&i%f^GWktUhBTMKSvy7cN4IjksS0aT*~1O*6!j6LTj^HbJE4>g%|#B({I_Gin^n~G zm!}6D`m;%YX3kG&a48wSiAd~Oy_KwMU3!?z(%$6!`baIwW4`#`;0Rr4VRD(pZuf-S z2gyL64H?q6lQ5s_6^ED0A1LhKlt+zVRz*cjrv9X?zMwN@%$Lz!H;=wQXP{go=o@|8 zsvIeo;eRQeR}fOr-Cq2C;Qw855-s(OvKPO$MBg(pjU-yfJjTkx-! z!Wmob_w8a17{yl5JGmt?Ve#*$RJ%Q(vG%mEGUt=k;jB=hJobg8lAIFh7wjx9g zob6sE=Lt#TdUR@r`I%vs@nY;}f|hWk&ox*3_eIIKc2edAb#-W`mwg0$=KC+)0+mai zU)Mve1cmz=s0-f)e(+6@ddsrw+)b$OlR@6ZbkpBGIneBgGc=EA*SO357GW=zTUM|H zq@p~vxL;*qE-O*~aN?rD*3%4LPb#LG!IS!Fqr?s&OPJ!9Z~5{=l{clxjkCXe{{424 zkU#|AU;6D}1^;p_}b^Z#F+-3YTddmE%wuJBW&eW47API;f(nYEl9*O1FbKYd%S6 zj+#%-g$$O{N#lRHb!od?p+z-Dw@vYR1(*|I`W&sj8~v4_^w{f@t7kw_`MDJ>8id;X z>D#vAw^to?P<*uu`X=PS%C)AbeN!{yq5hsd7TE&RKXKq_b4!~)fE*pSEUG9Ay;4bJ zrA?tQw$5-VrW_pbrF5WcNkH`Pv#Vf z*V!2sH2NFD3*;ZQqpqCC8~L8MQ42ABI`mUIP^jI2n!eIekTM{1l+hIehw=lknmmhj?yN9l9AhT-H9oo1e09iw!_^Z2** z?=wc-m$b&KKX)cN2-Q4%?6by!NK-@<;ohGkJZd^^{igYq?&bM=Z+zHLc4Qm%--Ij4 z>QW~gSU$wB%j?4PjG3^AD;|{&6vj1amuDdDVt{B}Q`H{wD6h(HxWJ0CA&f%$jCs{boX(97!2$fudkfayFtsXxZWaN*Pcdn zJFqiR#rH9S7WC-%Iu@p8PHyBfm4nkWf6dlC*tsgWMNmy&Z;vQ>mrykB`t)?WwyK%{d>);PKM($kN`+_AmW zD*^4(vq1>40;^?mvKVU5NQM!OyCB`vhXgr`q`Cz5Ki;}+wm>Q#{k991=AuL9O?XkS zaTWmk2J&xg^SNj+)8OB0G>%|@dOJHh#7iYo*G-LoQ%)Y3gPSw1uNP%v6e!37X{2^_ zd|5aV+A-lagl%BvHh;W#%u(o_!6{zHcanFjzX6?1$Q@`dlGEvWg%8WoH{lNBCH82>%-A4AHpMx z_8jHJLMMzR1NCS7c!fFC0r^EH%8GrbejKw@DiZ{euPZVpI&oq|ExwEW3b@qIQj0rsfTv&jY2uM6Ry`HKYieBXB_UA7xI9pvAdfJHRs{~4<~{fk)Clc6_7 zy$cO_**4Z2gu=VHsKhjYm*sx&wWl2l->Ks+WHnWO=dn@r^L4zy)9=iWaltfgElYtS zs(~%}nkHty+3g%CSwk;++S_;NZm~qN*}&MrwAtK}7!V><6vKi8n154!@_C@rLpL$l zN;#DQ0*pnd|L!~e=@xlCcytTE1D#!c7BB=7#28LrX$ zhZ5nr7uO6S#!1GBBsrtrRp-`b6E#jvgXtQ=^9YuNeC4?cxipDXVp zurf>-C&&G0-@NFGK99N_AIx(k97Z$>zo^&xKLE!-IKK~id=K|7R3)PPC(7fWacw6Q zI?$ERACFfEH~!F%v@ji$UY4%LwHg)mVqZy(3vDJ}Gy>xVU{?Pc#@pt1qGm#c{GhQZ z2ePl}SdR&$?pZHl$Cx~>_0K-e4xeb);b*<>(XV^-d-;(rw9wr{L>L~PKO(Hxgr3+= zJ_6`Z-)n_GQMRo$x?KQwW`s%c6#Ts0(XFN@v9^-^ONy{ElD4nt#8e+q_Jzwg9o!Dg zo#p#H|FaA88s7g8f#3a3;Di4=aPyCa9!>h50ux_OBo~@PfyO(f?`d${Yl06PSh*vR zoNuIM7B1$Su2Gli6~ZTY#fyL03KxIJjS2 zw;yb6rzl8Lor>-qZL-}z9lk@VehF~y(hbr8C;$eVK;b6`4*3_ z({$aCK0^m|UBGJ9VYTWImhC+kT4*Ec*FDzjaWdTxkWhfy@z}!uEtCEzPm@)bROOn# zuIZzjYtvKeEaVX6dDMs%B(p`1H<;<)g;Bj<@qg&SnbgK@l)iLek zKLdJ|bQY&>4U-bHS_|mklH3W0E_mPzs!{$8T5hjjT%Rx_1b1z(WhVr--GN;^p2<9T zvr18$C{L6^(9X5Ip-b5ok4(AIJaIVUOTGqvJM9Oc;#mdGAM0fKQ)xf(nFs=UfDk|( zL8l)qX+H}s)J}vE*c0FKn1TKRaF-~!1k(nnp9)AN`K8b@C}#LGrdB=hSNDZNoHyZd z_(NqJs+HBX*vA0I9^`?mKPeEGWKR1lZSw&XHeB;p(}C8{B0Tf&^Z5f`AZ>o^3s)3| z4JV`xDEOmiX^455;ZthmvOk=MUy(kSHS1Gk;6oDRWusW>!*~Q!OYIgpo6%em^WWTi z7Qy)rXct}2Uv`_J+dEm2kp331z5$%Oy1Cdb`qlIU7P!BB%O5EVF#o>FI|a3@cueIX z)~(~SSx!_e9aIBwBcFMxlcg*K-Gphu7&?Y053c|Cos zq?>JN-^4+`2HgByHK-wFn)(9{ZXrK$3>G91kK-|^J(bU9Gaiwe}+1DT4-3NO=s%d z;NQDKD2?^wZ$$X*Z$$U2kD`135ALsNl7HI^%#KmW9Q&va=Ltrs?;M?L{4LJ8&4Dv* z*>@`ImX$N8n9_mRv8NjYCM;4pHyv%Eg%;vO*ca&M_r2$vvMrH-JK57{6SZ_MyT#u% znTZ*oA6Z9j`wLw>M#ZubX+WIDbvJgg=9}Cxee%tj=Yc;Bgw+-b$U{Da+8=4XPmDHf z`!u_zUf6#s1rti})>oNeIR*08# zy8Tgvr+#_3_QackSGKq7>(j>5yi-9DK0sPhtUlDmmI8Ih^UvK{A|RWWhO^0ZpmBRN zG8)d&8haNY5nUfU8F{R>LI^CLr#cXn=k{y{Gh3^1d#-asHQ!R1x!qAN+!t(;e3GVqyzE!15q+K){^H?SITi(8usuX z1*N*Fp=?Mq_%G9bOxYy$_tTTw(tfB1`ax-QD>my|XrYB%8Yaxc!@PY@p!GP5Hb8%_ z#6Aq5uOs2wTk=0pNmTlT9~RiyfaFmm(1xpW7Ceu8iOIOrFA zjAyU9sZ@%jL-rS@UM^jF`S3SN3s3z@gAV)cXN&%Xc{=E&Z1X#vrJ))JCUnq^bg`jN zmgBdilxE*^x}<<%`9mp%VJ7Fy^|p&033AN5!t_2~P4yuY^r z{W0avYEOvqk6GKh1pO_x!IS0L>Nzs⩔Oq){JRc!tWfDjU)o-$`@e$^8XI&*S!gJ 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 XSf}#Pi<8m|0xm;6W8F$^yU70oIDq2= literal 0 HcmV?d00001 diff --git a/docs/source/index.rst b/docs/source/index.rst index 0c2610a85..494a0ed61 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -69,6 +69,7 @@ NumPyro documentation examples/covtype examples/thompson_sampling tutorials/bayesian_hierarchical_stacking + examples/ssbvm_mixture Indices and tables diff --git a/examples/ssbvm_mixture.py b/examples/ssbvm_mixture.py new file mode 100644 index 000000000..8c0bc4af9 --- /dev/null +++ b/examples/ssbvm_mixture.py @@ -0,0 +1,302 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +r""" +Example: Sine-skewed sine (bivariate von Mises) mixture +======================================================= + +This example models the dihedral angles that occur in the backbone of a protein as a mixture of skewed +directional distributions. The backbone angle pairs, called :math:`\phi` and :math:`\psi`, are a canonical +representation for the fold of a protein. In this model, we fix the third dihedral angle (omega) as it usually only +takes angles 0 and pi radian, with the latter being the most common. We model the angle pairs as a distribution on +the torus using the sine distribution [1] and break point-wise (toroidal) symmetry using sine-skewing [2]. + +.. image:: ../_static/img/examples/ssbvm_mixture_torus_top.png + :align: center + :scale: 30% + +**References:** + + 1. Singh et al. (2002). Probabilistic model for two dependent circular variables. Biometrika. + 2. Jose Ameijeiras-Alonso and Christophe Ley (2021). Sine-skewed toroidal distributions and their application + in protein bioinformatics. Biostatistics. + +.. image:: ../_static/img/examples/ssbvm_mixture.png + :align: center + :scale: 125% +""" + +import argparse +import math +from math import pi + +import matplotlib.colors +import matplotlib.pyplot as plt +import numpy as np +from sklearn.cluster import KMeans + +from jax import numpy as jnp, random + +import numpyro +from numpyro.distributions import ( + Beta, + Categorical, + Dirichlet, + Gamma, + Normal, + SineBivariateVonMises, + SineSkewed, + Uniform, + VonMises, +) +from numpyro.distributions.transforms import L1BallTransform +from numpyro.examples.datasets import NINE_MERS, load_dataset +from numpyro.infer import MCMC, NUTS, Predictive, init_to_value +from numpyro.infer.reparam import CircularReparam + +AMINO_ACIDS = [ + "M", + "N", + "I", + "F", + "E", + "L", + "R", + "D", + "G", + "K", + "Y", + "T", + "H", + "S", + "P", + "A", + "V", + "Q", + "W", + "C", +] + + +# The support of the von Mises is [-π,π) with a periodic boundary at ±π. However, the support of +# the implemented von Mises distribution is just the interval [-π,π) without the periodic boundary. If the +# loc is close to one of the boundaries (-π or π), the sampler must traverse the entire interval to cross the +# boundary. This produces a bias, especially if the concentration is high. The interval around +# zero will have a low probability, making the jump to the other boundary unlikely for the sampler. +# Using the `CircularReparam` introduces the periodic boundary by transforming the real line to [-π,π). +# The sampler can sample from the real line, thus crossing the periodic boundary without having to traverse the +# the entire interval, which eliminates the bias. +@numpyro.handlers.reparam( + config={"phi_loc": CircularReparam(), "psi_loc": CircularReparam()} +) +def ss_model(data, num_data, num_mix_comp=2): + # Mixture prior + mix_weights = numpyro.sample("mix_weights", Dirichlet(jnp.ones((num_mix_comp,)))) + + # Hprior BvM + # Bayesian Inference and Decision Theory by Kathryn Blackmond Laskey + beta_mean_phi = numpyro.sample("beta_mean_phi", Uniform(0.0, 1.0)) + beta_count_phi = numpyro.sample( + "beta_count_phi", Gamma(1.0, 1.0 / num_mix_comp) + ) # shape, rate + halpha_phi = beta_mean_phi * beta_count_phi + beta_mean_psi = numpyro.sample("beta_mean_psi", Uniform(0, 1.0)) + beta_count_psi = numpyro.sample( + "beta_count_psi", Gamma(1.0, 1.0 / num_mix_comp) + ) # shape, rate + halpha_psi = beta_mean_psi * beta_count_psi + + with numpyro.plate("mixture", num_mix_comp): + # BvM priors + + # Place gap in forbidden region of the Ramachandran plot (protein backbone dihedral angle pairs) + phi_loc = numpyro.sample("phi_loc", VonMises(pi, 2.0)) + psi_loc = numpyro.sample("psi_loc", VonMises(0.0, 0.1)) + + phi_conc = numpyro.sample( + "phi_conc", Beta(halpha_phi, beta_count_phi - halpha_phi) + ) + psi_conc = numpyro.sample( + "psi_conc", Beta(halpha_psi, beta_count_psi - halpha_psi) + ) + corr_scale = numpyro.sample("corr_scale", Beta(2.0, 10.0)) + + # Skewness prior + ball_transform = L1BallTransform() + skewness = numpyro.sample("skewness", Normal(0, 0.5).expand((2,)).to_event(1)) + skewness = ball_transform(skewness) + + with numpyro.plate("obs_plate", num_data, dim=-1): + assign = numpyro.sample( + "mix_comp", Categorical(mix_weights), infer={"enumerate": "parallel"} + ) + sine = SineBivariateVonMises( + phi_loc=phi_loc[assign], + psi_loc=psi_loc[assign], + # These concentrations are an order of magnitude lower than expected (550-1000)! + phi_concentration=70 * phi_conc[assign], + psi_concentration=70 * psi_conc[assign], + weighted_correlation=corr_scale[assign], + ) + return numpyro.sample("phi_psi", SineSkewed(sine, skewness[assign]), obs=data) + + +def run_hmc(rng_key, model, data, num_mix_comp, args, bvm_init_locs): + kernel = NUTS( + model, init_strategy=init_to_value(values=bvm_init_locs), max_tree_depth=7 + ) + mcmc = MCMC(kernel, num_samples=args.num_samples, num_warmup=args.num_warmup) + mcmc.run(rng_key, data, len(data), num_mix_comp) + mcmc.print_summary() + post_samples = mcmc.get_samples() + return post_samples + + +def fetch_aa_dihedrals(aa): + _, fetch = load_dataset(NINE_MERS, split=aa) + return jnp.stack(fetch()) + + +def num_mix_comps(amino_acid): + num_mix = {"G": 10, "P": 7} + return num_mix.get(amino_acid, 9) + + +def ramachandran_plot(data, pred_data, aas, file_name="ssbvm_mixture.pdf"): + amino_acids = {"S": "Serine", "P": "Proline", "G": "Glycine"} + fig, axss = plt.subplots(2, len(aas)) + cdata = data + for i in range(len(axss)): + if i == 1: + cdata = pred_data + for ax, aa in zip(axss[i], aas): + aa_data = cdata[aa] + nbins = 50 + ax.hexbin( + aa_data[..., 0].reshape(-1), + aa_data[..., 1].reshape(-1), + norm=matplotlib.colors.LogNorm(), + bins=nbins, + gridsize=100, + cmap="Blues", + ) + + # label the contours + ax.set_aspect("equal", "box") + ax.set_xlim([-math.pi, math.pi]) + ax.set_ylim([-math.pi, math.pi]) + ax.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2)) + ax.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 12)) + ax.xaxis.set_major_formatter(plt.FuncFormatter(multiple_formatter())) + ax.yaxis.set_major_locator(plt.MultipleLocator(np.pi / 2)) + ax.yaxis.set_minor_locator(plt.MultipleLocator(np.pi / 12)) + ax.yaxis.set_major_formatter(plt.FuncFormatter(multiple_formatter())) + if i == 0: + axtop = ax.secondary_xaxis("top") + axtop.set_xlabel(amino_acids[aa]) + axtop.xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2)) + axtop.xaxis.set_minor_locator(plt.MultipleLocator(np.pi / 12)) + axtop.xaxis.set_major_formatter(plt.FuncFormatter(multiple_formatter())) + + if i == 1: + ax.set_xlabel(r"$\phi$") + + for i in range(len(axss)): + axss[i, 0].set_ylabel(r"$\psi$") + axss[i, 0].yaxis.set_major_locator(plt.MultipleLocator(np.pi / 2)) + axss[i, 0].yaxis.set_minor_locator(plt.MultipleLocator(np.pi / 12)) + axss[i, 0].yaxis.set_major_formatter(plt.FuncFormatter(multiple_formatter())) + axright = axss[i, -1].secondary_yaxis("right") + axright.set_ylabel("data" if i == 0 else "simulation") + axright.yaxis.set_major_locator(plt.MultipleLocator(np.pi / 2)) + axright.yaxis.set_minor_locator(plt.MultipleLocator(np.pi / 12)) + axright.yaxis.set_major_formatter(plt.FuncFormatter(multiple_formatter())) + + for ax in axss[:, 1:].reshape(-1): + ax.tick_params(labelleft=False) + ax.tick_params(labelleft=False) + + for ax in axss[0, :].reshape(-1): + ax.tick_params(labelbottom=False) + ax.tick_params(labelbottom=False) + + if file_name: + fig.tight_layout() + plt.savefig(file_name, bbox_inches="tight") + + +def multiple_formatter(denominator=2, number=np.pi, latex=r"\pi"): + def gcd(a, b): + while b: + a, b = b, a % b + return a + + def _multiple_formatter(x, pos): + den = denominator + num = int(np.rint(den * x / number)) + com = gcd(num, den) + (num, den) = (int(num / com), int(den / com)) + if den == 1: + if num == 0: + return r"$0$" + if num == 1: + return r"$%s$" % latex + elif num == -1: + return r"$-%s$" % latex + else: + return r"$%s%s$" % (num, latex) + else: + if num == 1: + return r"$\frac{%s}{%s}$" % (latex, den) + elif num == -1: + return r"$\frac{-%s}{%s}$" % (latex, den) + else: + return r"$\frac{%s%s}{%s}$" % (num, latex, den) + + return _multiple_formatter + + +def main(args): + data = {} + pred_datas = {} + rng_key = random.PRNGKey(args.rng_seed) + for aa in args.amino_acids: + rng_key, inf_key, pred_key = random.split(rng_key, 3) + data[aa] = fetch_aa_dihedrals(aa) + num_mix_comp = num_mix_comps(aa) + + # Use kmeans to initialize the chain location. + kmeans = KMeans(num_mix_comp) + kmeans.fit(data[aa]) + means = { + "phi_loc": kmeans.cluster_centers_[:, 0], + "psi_loc": kmeans.cluster_centers_[:, 1], + } + + posterior_samples = { + "ss": run_hmc(inf_key, ss_model, data[aa], num_mix_comp, args, means) + } + predictive = Predictive(ss_model, posterior_samples["ss"], parallel=True) + + pred_datas[aa] = predictive(pred_key, None, 1, num_mix_comp)["phi_psi"].reshape( + -1, 2 + ) + + ramachandran_plot(data, pred_datas, args.amino_acids) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Sine-skewed sine (bivariate von mises) mixture model example" + ) + parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=500, type=int) + parser.add_argument("--amino-acids", nargs="+", default=["S", "P", "G"]) + parser.add_argument("--rng_seed", type=int, default=123) + parser.add_argument("--device", default="gpu", type=str, help='use "cpu" or "gpu".') + + args = parser.parse_args() + assert all( + aa in AMINO_ACIDS for aa in args.amino_acids + ), f"{list(filter(lambda aa: aa not in AMINO_ACIDS, args.amino_acids))} are not amino acids." + main(args) diff --git a/numpyro/examples/datasets.py b/numpyro/examples/datasets.py index 116b2360a..d8f2e6784 100644 --- a/numpyro/examples/datasets.py +++ b/numpyro/examples/datasets.py @@ -68,6 +68,11 @@ ["https://archive.ics.uci.edu/ml/machine-learning-databases/00280/HIGGS.csv.gz"], ) +NINE_MERS = dset( + "9mers", + ["https://github.com/pyro-ppl/datasets/blob/master/9mers_data.pkl?raw=true"], +) + def _download(dset): for url in dset.urls: @@ -276,6 +281,12 @@ def _load_higgs(num_datapoints): } # standard split -500_000: as test +def _load_9mers(): + _download(NINE_MERS) + file_path = os.path.join(DATA_DIR, "9mers_data.pkl") + return pickle.load(open(file_path, "rb")) + + def _load(dset, num_datapoints=-1): if dset == BASEBALL: return _load_baseball() @@ -295,6 +306,8 @@ def _load(dset, num_datapoints=-1): return _load_jsb_chorales() elif dset == HIGGS: return _load_higgs(num_datapoints) + elif dset == NINE_MERS: + return _load_9mers() raise ValueError("Dataset - {} not found.".format(dset.name)) @@ -313,9 +326,15 @@ def iter_dataset(dset, batch_size=None, split="train", shuffle=True): def load_dataset( - dset, batch_size=None, split="train", shuffle=True, num_datapoints=None + dset, + batch_size=None, + split="train", + shuffle=True, + num_datapoints=None, ): - arrays = _load(dset, num_datapoints)[split] + data = _load(dset, num_datapoints) + if isinstance(data, dict): + arrays = data[split] num_records = len(arrays[0]) idxs = np.arange(num_records) if not batch_size: diff --git a/test/test_distributions.py b/test/test_distributions.py index 0facbd2c4..1e36aaf88 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -413,6 +413,39 @@ def get_sp_dist(jax_dist): T(dist.Pareto, 1.0, 2.0), T(dist.Pareto, jnp.array([1.0, 0.5]), jnp.array([0.3, 2.0])), T(dist.Pareto, jnp.array([[1.0], [3.0]]), jnp.array([1.0, 0.5])), + T( + dist.SineBivariateVonMises, + jnp.array([0.0]), + jnp.array([0.0]), + jnp.array([5.0]), + jnp.array([6.0]), + jnp.array([2.0]), + ), + T( + dist.SineBivariateVonMises, + jnp.array([3.003]), + jnp.array([-1.343]), # check test_gof, test_mean_var, + jnp.array([5.0]), + jnp.array([6.0]), + jnp.array([2.0]), + ), # check test_distribution_constraints + T( + dist.SineBivariateVonMises, + jnp.array([-math.pi / 3]), + jnp.array(-1), + jnp.array(0.4), + jnp.array(10.0), + jnp.array(0.9), + ), + T( + dist.SineBivariateVonMises, + jnp.array([math.pi - 0.2, 1.0]), + jnp.array([0.0, 1.0]), + jnp.array([5.0, 5.0]), + jnp.array([7.0, 0.5]), + None, + jnp.array([0.5, 0.1]), + ), T(dist.SoftLaplace, 1.0, 1.0), T(dist.SoftLaplace, jnp.array([-1.0, 50.0]), jnp.array([4.0, 100.0])), T(dist.StudentT, 1.0, 1.0, 0.5), diff --git a/test/test_examples.py b/test/test_examples.py index 58c26d248..412038996 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -43,6 +43,7 @@ "prodlda.py --num-steps 10 --hidden 10 --nn-framework flax", "prodlda.py --num-steps 10 --hidden 10 --nn-framework haiku", "sparse_regression.py --num-samples 10 --num-warmup 10 --num-data 10 --num-dimensions 10", + "ssbvm_mixture.py --num-samples 10 --num-warmup 10", "stochastic_volatility.py --num-samples 100 --num-warmup 100", "ucbadmit.py --num-chains 2", "vae.py -n 1", From 8236e3442dde1e13fb982f7706365c8d88c7c312 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 3 Nov 2021 20:11:06 -0400 Subject: [PATCH 199/222] Make docs build pass (#1204) --- docs/source/conf.py | 3 ++- notebooks/source/bayesian_hierarchical_stacking.ipynb | 2 +- numpyro/distributions/directional.py | 8 +++++--- 3 files changed, 8 insertions(+), 5 deletions(-) diff --git a/docs/source/conf.py b/docs/source/conf.py index 48c6e836c..f9cbcc18e 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -95,7 +95,8 @@ # You can specify multiple suffix as a list of string: # # source_suffix = ['.rst', '.md'] -source_suffix = [".rst", ".ipynb"] +# NOTE: `.rst` is the default suffix of sphinx, and nbsphinx will +# automatically add support for `.ipynb` suffix. # do not execute cells nbsphinx_execute = "never" diff --git a/notebooks/source/bayesian_hierarchical_stacking.ipynb b/notebooks/source/bayesian_hierarchical_stacking.ipynb index 40ba794a2..0b4fb8673 100644 --- a/notebooks/source/bayesian_hierarchical_stacking.ipynb +++ b/notebooks/source/bayesian_hierarchical_stacking.ipynb @@ -737,7 +737,7 @@ "\n", "Such a matrix $W$ would be required to have each column sum to $1$. Hence, we calculate each row $W_i$ of $W$ as:\n", "\n", - "$$ W_i = \\text{softmax}(X\\text{_stacking}_i \\cdot \\beta), $$\n", + "$$ W_i = \\text{softmax}(X\\_\\text{stacking}_i \\cdot \\beta), $$\n", "\n", "where $\\beta$ is a matrix whose values we seek to determine. For the discrete features, $\\beta$ is given a hierarchical structure over the possible inputs. Continuous features, on the other hand, get no hierarchical structure in this case study and just vary according to the input values.\n", "\n", diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index 6fb19d7ff..cfe91318e 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -154,10 +154,11 @@ def variance(self): class SineSkewed(Distribution): - """Sine-skewing [1] is a procedure for producing a distribution that breaks pointwise symmetry on a torus + r"""Sine-skewing [1] is a procedure for producing a distribution that breaks pointwise symmetry on a torus distribution. The new distribution is called the Sine Skewed X distribution, where X is the name of the (symmetric) base distribution. Torus distributions are distributions with support on products of circles - (i.e., ⨂^d S^1 where S^1=[-pi,pi) ). So, a 0-torus is a point, the 1-torus is a circle, + (i.e., :math:`\otimes S^1` where :math:`S^1 = [-pi,pi)`). + So, a 0-torus is a point, the 1-torus is a circle, and the 2-torus is commonly associated with the donut shape. The sine skewed X distribution is parameterized by a weight parameter for each dimension of the event of X. @@ -284,7 +285,8 @@ def mean(self): class SineBivariateVonMises(Distribution): - r"""Unimodal distribution of two dependent angles on the 2-torus (S^1 ⨂ S^1) given by + r"""Unimodal distribution of two dependent angles on the 2-torus + (:math:`S^1 \otimes S^1`) given by .. math:: C^{-1}\exp(\kappa_1\cos(x_1-\mu_1) + \kappa_2\cos(x_2 -\mu_2) + \rho\sin(x_1 - \mu_1)\sin(x_2 - \mu_2)) From 32eb622e70a428e549c27f2f754be802420bb845 Mon Sep 17 00:00:00 2001 From: Fritz Obermeyer Date: Fri, 5 Nov 2021 15:46:15 -0400 Subject: [PATCH 200/222] Add link to render_model() link in tutorial (#1215) --- notebooks/source/model_rendering.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index c1be6d73b..cdd8266c2 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -7,7 +7,7 @@ "source": [ "# Automatic rendering of NumPyro models\n", "\n", - "In this tutorial we will demonstrate how to create beautiful visualizations of your probabilistic graphical models." + "In this tutorial we will demonstrate how to create beautiful visualizations of your probabilistic graphical models using [ `numpyro.render_model()` ](https://num.pyro.ai/en/stable/utilities.html#render-model)." ] }, { From 5ba39c7e46fc18d22769f7c2c3acbfe89630fd40 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Sat, 6 Nov 2021 01:52:28 +0000 Subject: [PATCH 201/222] Add example of jax.lax.scan in AR2 model (#1216) * Add example of jax.lax.scan in AR2 model Co-authored-by: dykim29 * describe AR2 process * fix other typos * add ---unroll-loop arg * limit data for unroll-loop test Co-authored-by: dykim29 --- README.md | 4 +- docs/source/_static/img/examples/ar2.png | Bin 0 -> 118603 bytes docs/source/index.rst | 1 + examples/ar2.py | 136 +++++++++++++++++++++++ examples/hsgp.py | 2 +- examples/ucbadmit.py | 6 +- numpyro/contrib/indexing.py | 2 +- numpyro/distributions/continuous.py | 2 +- test/test_examples.py | 2 + 9 files changed, 147 insertions(+), 8 deletions(-) create mode 100644 docs/source/_static/img/examples/ar2.png create mode 100644 examples/ar2.py diff --git a/README.md b/README.md index cd3a2270c..42443b2bd 100644 --- a/README.md +++ b/README.md @@ -140,7 +140,7 @@ Expected log joint density: -46.09 ``` -Note that for the class of distributions with `loc,scale` paramaters such as `Normal`, `Cauchy`, `StudentT`, we also provide a [LocScaleReparam](http://num.pyro.ai/en/latest/reparam.html#loc-scale-decentering) reparameterizer to achieve the same purpose. The corresponding code will be +Note that for the class of distributions with `loc,scale` parameters such as `Normal`, `Cauchy`, `StudentT`, we also provide a [LocScaleReparam](http://num.pyro.ai/en/latest/reparam.html#loc-scale-decentering) reparameterizer to achieve the same purpose. The corresponding code will be with numpyro.handlers.reparam(config={'theta': LocScaleReparam(centered=0)}): theta = numpyro.sample('theta', dist.Normal(mu, tau)) @@ -278,7 +278,7 @@ In the near term, we plan to work on the following. Please open new issues for f - Improving robustness of inference on different models, profiling and performance tuning. - Supporting more functionality as part of the [pyro-api](https://github.com/pyro-ppl/pyro-api) generic modeling interface. - - More inference algorithms, particularly those that require second order derivaties or use HMC. + - More inference algorithms, particularly those that require second order derivatives or use HMC. - Integration with [Funsor](https://github.com/pyro-ppl/funsor) to support inference algorithms with delayed sampling. - Other areas motivated by Pyro's research goals and application focus, and interest from the community. diff --git a/docs/source/_static/img/examples/ar2.png b/docs/source/_static/img/examples/ar2.png new file mode 100644 index 0000000000000000000000000000000000000000..a640575c0e41ac136f6e55025cf1de72266ca94c GIT binary patch literal 118603 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

    Dcx7s%g;S|V();^=H4L!d_w;*5 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%0AVuxMl1>QOGlNr^Ww8*&ou3fm%I^$dvMIp1bHs_ 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

    oIzTAtFt3(7n48v)-n_t8NQSh~DprYLq-g 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%0ANQ*8 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 q3t(CQCKTWf+!XHk@c#mdxbHjw literal 0 HcmV?d00001 diff --git a/docs/source/index.rst b/docs/source/index.rst index 494a0ed61..2e9d2b72e 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -70,6 +70,7 @@ NumPyro documentation examples/thompson_sampling tutorials/bayesian_hierarchical_stacking examples/ssbvm_mixture + examples/ar2 Indices and tables diff --git a/examples/ar2.py b/examples/ar2.py new file mode 100644 index 000000000..0e61d46fb --- /dev/null +++ b/examples/ar2.py @@ -0,0 +1,136 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +r""" +Example: AR2 process +==================== + +In this example we show how to use ``jax.lax.scan`` +to avoid writing a (slow) Python for-loop. In this toy +example, with ``--num-data=1000``, the improvement is +of almost 10x. + +To demonstrate, we will be implementing an AR2 process. +The idea is that we have some times series + +.. math:: + + y_0, y_1, ..., y_T + +and we seek parameters :math:`c`, :math:`\alpha_1`, and :math:`\alpha_2` +such that for each :math:`t` between :math:`2` and :math:`T`, we have + +.. math:: + + y_t = c + \alpha_1 y_{t-1} + \alpha_2 y_{t-2} + \epsilon_t + +where :math:`\epsilon_t` is an error term. + +.. image:: ../_static/img/examples/ar2.png + :align: center +""" + +import argparse +import os +import time + +import matplotlib +import matplotlib.pyplot as plt +import numpy as np + +import jax +from jax import random +import jax.numpy as jnp + +import numpyro +import numpyro.distributions as dist + +matplotlib.use("Agg") + + +def ar2(y, unroll_loop=False): + alpha_1 = numpyro.sample("alpha_1", dist.Normal(0, 1)) + alpha_2 = numpyro.sample("alpha_2", dist.Normal(0, 1)) + const = numpyro.sample("const", dist.Normal(0, 1)) + sigma = numpyro.sample("sigma", dist.Normal(0, 1)) + + def transition_fn(carry, y): + y_1, y_2 = carry + pred = const + alpha_1 * y_1 + alpha_2 * y_2 + return (y, y_1), pred + + if unroll_loop: + preds = [] + for i in range(2, len(y)): + preds.append(const + alpha_1 * y[i - 1] + alpha_2 * y[i - 2]) + preds = jnp.asarray(preds) + else: + _, preds = jax.lax.scan(transition_fn, (y[1], y[0]), y[2:]) + + mu = numpyro.deterministic("mu", preds) + numpyro.sample("obs", dist.Normal(mu, sigma), obs=y[2:]) + + +def run_inference(model, args, rng_key, y): + start = time.time() + sampler = numpyro.infer.NUTS(model) + mcmc = numpyro.infer.MCMC( + sampler, + num_warmup=args.num_warmup, + num_samples=args.num_samples, + num_chains=args.num_chains, + progress_bar=False if "NUMPYRO_SPHINXBUILD" in os.environ else True, + ) + mcmc.run(rng_key, y=y, unroll_loop=args.unroll_loop) + mcmc.print_summary() + print("\nMCMC elapsed time:", time.time() - start) + return mcmc.get_samples() + + +def main(args): + # generate artifical dataset + num_data = args.num_data + t = np.arange(0, num_data) + y = np.sin(t) + np.random.randn(num_data) * 0.1 + + # do inference + rng_key, _ = random.split(random.PRNGKey(0)) + samples = run_inference(ar2, args, rng_key, y) + + # do prediction + mean_prediction = samples["mu"].mean(axis=0) + + # make plots + fig, ax = plt.subplots(figsize=(8, 6), constrained_layout=True) + + # plot training data + ax.plot(t, y, color="blue", label="True values") + # plot mean prediction + # note that we can't make predictions for the first two points, + # because they don't have lagged values to use for prediction. + ax.plot(t[2:], mean_prediction, color="orange", label="Mean predictions") + ax.set(xlabel="time", ylabel="y", title="AR2 process") + ax.legend() + + plt.savefig("ar2_plot.pdf") + + +if __name__ == "__main__": + assert numpyro.__version__.startswith("0.8.0") + parser = argparse.ArgumentParser(description="AR2 example") + parser.add_argument("--num-data", nargs="?", default=142, type=int) + parser.add_argument("-n", "--num-samples", nargs="?", default=1000, type=int) + parser.add_argument("--num-warmup", nargs="?", default=1000, type=int) + parser.add_argument("--num-chains", nargs="?", default=1, type=int) + parser.add_argument("--device", default="cpu", type=str, help='use "cpu" or "gpu".') + parser.add_argument( + "--unroll-loop", + action="store_true", + help="whether to unroll for-loop (note: slower)", + ) + args = parser.parse_args() + + numpyro.set_platform(args.device) + numpyro.set_host_device_count(args.num_chains) + + main(args) diff --git a/examples/hsgp.py b/examples/hsgp.py index 6c7684b05..cf8454010 100644 --- a/examples/hsgp.py +++ b/examples/hsgp.py @@ -282,7 +282,7 @@ def yearday_effect(day_of_year): scale_global = 0.1 tau = sample( "tau", dist.HalfNormal(2 * scale_global) - ) # Orignial uses half-t with 100df + ) # Original uses half-t with 100df c_aux = sample("c_aux", dist.InverseGamma(0.5 * slab_df, 0.5 * slab_df)) c = slab_scale * jnp.sqrt(c_aux) diff --git a/examples/ucbadmit.py b/examples/ucbadmit.py index 51d38e131..d575bde74 100644 --- a/examples/ucbadmit.py +++ b/examples/ucbadmit.py @@ -29,11 +29,11 @@ ====== ====== ============== ======= This example replicates the multilevel model `m_glmm5` at [3], which is used to evaluate whether -the data contain evidence of gender biased in admissions accross departments. This is a form of +the data contain evidence of gender biased in admissions across departments. This is a form of Generalized Linear Mixed Models for binomial regression problem, which models - - varying intercepts accross departments, - - varying slopes (or the effects of being male) accross departments, + - varying intercepts across departments, + - varying slopes (or the effects of being male) across departments, - correlation between intercepts and slopes, and uses non-centered parameterization (or whitening). diff --git a/numpyro/contrib/indexing.py b/numpyro/contrib/indexing.py index a62a64ddf..3dfc4efd8 100644 --- a/numpyro/contrib/indexing.py +++ b/numpyro/contrib/indexing.py @@ -74,7 +74,7 @@ def vindex(tensor, args): :param jnp.ndarray tensor: A tensor to be indexed. :param tuple args: An index, as args to ``__getitem__``. - :returns: A nonstandard interpetation of ``tensor[args]``. + :returns: A nonstandard interpretation of ``tensor[args]``. :rtype: jnp.ndarray """ if not isinstance(args, tuple): diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 4060f7f0e..af2a9b452 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -535,7 +535,7 @@ def icdf(self, q): class LKJ(TransformedDistribution): r""" LKJ distribution for correlation matrices. The distribution is controlled by ``concentration`` - parameter :math:`\eta` to make the probability of the correlation matrix :math:`M` propotional + parameter :math:`\eta` to make the probability of the correlation matrix :math:`M` proportional to :math:`\det(M)^{\eta - 1}`. Because of that, when ``concentration == 1``, we have a uniform distribution over correlation matrices. diff --git a/test/test_examples.py b/test/test_examples.py index 412038996..1bf164887 100644 --- a/test/test_examples.py +++ b/test/test_examples.py @@ -47,6 +47,8 @@ "stochastic_volatility.py --num-samples 100 --num-warmup 100", "ucbadmit.py --num-chains 2", "vae.py -n 1", + "ar2.py --num-samples 10 --num-warmup 10 --num-chains 2", + "ar2.py --num-samples 10 --num-warmup 10 --num-chains 2 --num-data 10 --unroll-loop", ] From a30e0d4dbf1d566ed8156711245f37e758b10c5d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ola=20R=C3=B8nning?= Date: Mon, 8 Nov 2021 14:12:05 +0100 Subject: [PATCH 202/222] Updated docs for BvM. (#1213) * Updated docs for BvM. * Fixed typo. --- numpyro/distributions/directional.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/numpyro/distributions/directional.py b/numpyro/distributions/directional.py index cfe91318e..18af58b69 100644 --- a/numpyro/distributions/directional.py +++ b/numpyro/distributions/directional.py @@ -309,7 +309,8 @@ class SineBivariateVonMises(Distribution): .. math:: \frac{\rho}{\kappa_1\kappa_2} \rightarrow 1 - because the distribution becomes increasingly bimodal. + because the distribution becomes increasingly bimodal. To avoid bimodality use the `weighted_correlation` + parameter with a skew away from one (e.g., Beta(1,3)). The `weighted_correlation` should be in [0,1]. .. note:: The correlation and weighted_correlation params are mutually exclusive. @@ -325,7 +326,7 @@ class SineBivariateVonMises(Distribution): :param np.ndarray psi_concentration: concentration of second angle :param np.ndarray correlation: correlation between the two angles :param np.ndarray weighted_correlation: set correlation to weigthed_corr * sqrt(phi_conc*psi_conc) - to avoid bimodality (see note). + to avoid bimodality (see note). The `weighted_correlation` should be in [0,1]. """ arg_constraints = { From e9053e87b8e85dd9feefa1218b517e84efd87503 Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Mon, 8 Nov 2021 09:48:39 -0500 Subject: [PATCH 203/222] fix pyro citation in README (#1218) --- README.md | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/README.md b/README.md index 42443b2bd..cd94f33ec 100644 --- a/README.md +++ b/README.md @@ -300,12 +300,22 @@ If you use NumPyro, please consider citing: as well as ``` -@article{bingham2018pyro, - author = {Bingham, Eli and Chen, Jonathan P. and Jankowiak, Martin and Obermeyer, Fritz and - Pradhan, Neeraj and Karaletsos, Theofanis and Singh, Rohit and Szerlip, Paul and - Horsfall, Paul and Goodman, Noah D.}, - title = {{Pyro: Deep Universal Probabilistic Programming}}, - journal = {arXiv preprint arXiv:1810.09538}, - year = {2018} +@article{bingham2019pyro, + author = {Eli Bingham and + Jonathan P. Chen and + Martin Jankowiak and + Fritz Obermeyer and + Neeraj Pradhan and + Theofanis Karaletsos and + Rohit Singh and + Paul A. Szerlip and + Paul Horsfall and + Noah D. Goodman}, + title = {Pyro: Deep Universal Probabilistic Programming}, + journal = {J. Mach. Learn. Res.}, + volume = {20}, + pages = {28:1--28:6}, + year = {2019}, + url = {http://jmlr.org/papers/v20/18-403.html} } ``` From a22d3213a20770786d2b615edcf1c265ff9d97b3 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Fri, 12 Nov 2021 13:52:47 +0000 Subject: [PATCH 204/222] Bump JAX, update imports (#1221) * update jax imports as per breaking changes * allow for jax pre-0.2.25 * namespace * namespace * lint * dont use packaging.version --- numpyro/contrib/optim.py | 2 +- numpyro/infer/autoguide.py | 11 +++++++++-- numpyro/infer/svi.py | 16 ++++++++++++---- numpyro/nn/auto_reg_nn.py | 12 ++++++++++-- numpyro/nn/block_neural_arn.py | 10 +++++++++- numpyro/nn/masked_dense.py | 2 +- numpyro/optim.py | 14 +++++++++++--- numpyro/primitives.py | 6 +++--- numpyro/util.py | 13 +++++++++++++ test/infer/test_autoguide.py | 10 +++++++++- test/infer/test_svi.py | 11 ++++++++--- test/test_flows.py | 9 ++++++++- test/test_nn.py | 10 +++++++++- 13 files changed, 103 insertions(+), 23 deletions(-) diff --git a/numpyro/contrib/optim.py b/numpyro/contrib/optim.py index 5f759dcdc..575d6b696 100644 --- a/numpyro/contrib/optim.py +++ b/numpyro/contrib/optim.py @@ -22,7 +22,7 @@ def optax_to_numpyro(transformation: optax.GradientTransformation) -> _NumPyroOp ``optax.GradientTransformation`` so that it can be used with ``numpyro.infer.svi.SVI``. It is a lightweight wrapper that recreates the ``(init_fn, update_fn, get_params_fn)`` interface defined by - :mod:`jax.experimental.optimizers`. + :mod:`jax.example_libraries.optimizers`. :param transformation: An ``optax.GradientTransformation`` instance to wrap. :return: An instance of ``numpyro.optim._NumPyroOptim`` wrapping the supplied diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 186d12053..798021fe5 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -11,7 +11,14 @@ import jax from jax import grad, hessian, lax, random, tree_map -from jax.experimental import stax + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries import stax +else: + from jax.experimental import stax + import jax.numpy as jnp import numpyro @@ -1205,7 +1212,7 @@ class AutoIAFNormal(AutoContinuous): :param bool skip_connections: whether to add skip connections from the input to the output of each flow. Defaults to False. :param callable nonlinearity: the nonlinearity to use in the feedforward network. - Defaults to :func:`jax.experimental.stax.Elu`. + Defaults to :func:`jax.example_libraries.stax.Elu`. """ def __init__( diff --git a/numpyro/infer/svi.py b/numpyro/infer/svi.py index 646d11fc6..f73698e4a 100644 --- a/numpyro/infer/svi.py +++ b/numpyro/infer/svi.py @@ -7,6 +7,14 @@ import tqdm import jax + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries import optimizers +else: + from jax.experimental import optimizers + from jax import jit, lax, random import jax.numpy as jnp from jax.tree_util import tree_map @@ -110,7 +118,7 @@ class SVI(object): :param guide: Python callable with Pyro primitives for the guide (recognition network). :param optim: An instance of :class:`~numpyro.optim._NumpyroOptim`, a - ``jax.experimental.optimizers.Optimizer`` or an Optax + ``jax.example_libraries.optimizers.Optimizer`` or an Optax ``GradientTransformation``. If you pass an Optax optimizer it will automatically be wrapped using :func:`numpyro.contrib.optim.optax_to_numpyro`. @@ -132,7 +140,7 @@ def __init__(self, model, guide, optim, loss, **static_kwargs): if isinstance(optim, _NumPyroOptim): self.optim = optim - elif isinstance(optim, jax.experimental.optimizers.Optimizer): + elif isinstance(optim, optimizers.Optimizer): self.optim = _NumPyroOptim(lambda *args: args, *optim) else: try: @@ -143,7 +151,7 @@ def __init__(self, model, guide, optim, loss, **static_kwargs): raise ImportError( "It looks like you tried to use an optimizer that isn't an " "instance of numpyro.optim._NumPyroOptim or " - "jax.experimental.optimizers.Optimizer. There is experimental " + "jax.example_libraries.optimizers.Optimizer. There is experimental " "support for Optax optimizers, but you need to install Optax. " "It can be installed with `pip install optax`." ) @@ -151,7 +159,7 @@ def __init__(self, model, guide, optim, loss, **static_kwargs): if not isinstance(optim, optax.GradientTransformation): raise TypeError( "Expected either an instance of numpyro.optim._NumPyroOptim, " - "jax.experimental.optimizers.Optimizer or " + "jax.example_libraries.optimizers.Optimizer or " "optax.GradientTransformation. Got {}".format(type(optim)) ) diff --git a/numpyro/nn/auto_reg_nn.py b/numpyro/nn/auto_reg_nn.py index d39a70d0e..c00ebbd3a 100644 --- a/numpyro/nn/auto_reg_nn.py +++ b/numpyro/nn/auto_reg_nn.py @@ -5,7 +5,15 @@ import numpy as np -from jax.experimental import stax +import jax + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries import stax +else: + from jax.experimental import stax + import jax.numpy as jnp from numpyro.nn.masked_dense import MaskedDense @@ -73,7 +81,7 @@ def AutoregressiveNN( """ An implementation of a MADE-like auto-regressive neural network. - Similar to the purely functional layer implemented in jax.experimental.stax, + Similar to the purely functional layer implemented in jax.example_libraries.stax, the `AutoregressiveNN` class has `init_fun` and `apply_fun` methods, where `init_fun` takes an rng_key key and an input shape and returns an (output_shape, params) pair, and `apply_fun` takes params and inputs diff --git a/numpyro/nn/block_neural_arn.py b/numpyro/nn/block_neural_arn.py index b1dc22176..e893e5f6f 100644 --- a/numpyro/nn/block_neural_arn.py +++ b/numpyro/nn/block_neural_arn.py @@ -3,8 +3,16 @@ import numpy as np +import jax from jax import random -from jax.experimental import stax + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries import stax +else: + from jax.experimental import stax + from jax.nn import sigmoid, softplus from jax.nn.initializers import glorot_uniform, normal, uniform import jax.numpy as jnp diff --git a/numpyro/nn/masked_dense.py b/numpyro/nn/masked_dense.py index c211a2685..4c24442eb 100644 --- a/numpyro/nn/masked_dense.py +++ b/numpyro/nn/masked_dense.py @@ -8,7 +8,7 @@ def MaskedDense(mask, bias=True, W_init=glorot_normal(), b_init=normal()): """ - As in jax.experimental.stax, each layer constructor function returns + As in jax.example_libraries.stax, each layer constructor function returns an (init_fun, apply_fun) pair, where `init_fun` takes an rng_key key and an input shape and returns an (output_shape, params) pair, and `apply_fun` takes params, inputs, and an rng_key key and applies the layer. diff --git a/numpyro/optim.py b/numpyro/optim.py index bc33f36b3..55816e4c1 100644 --- a/numpyro/optim.py +++ b/numpyro/optim.py @@ -3,15 +3,23 @@ """ Optimizer classes defined here are light wrappers over the corresponding optimizers -sourced from :mod:`jax.experimental.optimizers` with an interface that is better +sourced from :mod:`jax.example_libraries.optimizers` with an interface that is better suited for working with NumPyro inference algorithms. """ from collections import namedtuple from typing import Any, Callable, Tuple, TypeVar +import jax from jax import lax, value_and_grad -from jax.experimental import optimizers + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries import optimizers +else: + from jax.experimental import optimizers + from jax.flatten_util import ravel_pytree import jax.numpy as jnp from jax.scipy.optimize import minimize @@ -112,7 +120,7 @@ def get_params(self, state: _IterOptState) -> _Params: def _add_doc(fn): def _wrapped(cls): - cls.__doc__ = "Wrapper class for the JAX optimizer: :func:`~jax.experimental.optimizers.{}`".format( + cls.__doc__ = "Wrapper class for the JAX optimizer: :func:`~jax.example_libraries.optimizers.{}`".format( fn.__name__ ) return cls diff --git a/numpyro/primitives.py b/numpyro/primitives.py index bb2e67d2c..670564a9d 100644 --- a/numpyro/primitives.py +++ b/numpyro/primitives.py @@ -205,7 +205,7 @@ def sample( def param(name, init_value=None, **kwargs): """ Annotate the given site as an optimizable parameter for use with - :mod:`jax.experimental.optimizers`. For an example of how `param` statements + :mod:`jax.example_libraries.optimizers`. For an example of how `param` statements can be used in inference algorithms, refer to :class:`~numpyro.infer.SVI`. :param str name: name of site. @@ -357,12 +357,12 @@ def model(): def module(name, nn, input_shape=None): """ - Declare a :mod:`~jax.experimental.stax` style neural network inside a + Declare a :mod:`~jax.example_libraries.stax` style neural network inside a model so that its parameters are registered for optimization via :func:`~numpyro.primitives.param` statements. :param str name: name of the module to be registered. - :param tuple nn: a tuple of `(init_fn, apply_fn)` obtained by a :mod:`~jax.experimental.stax` + :param tuple nn: a tuple of `(init_fn, apply_fn)` obtained by a :mod:`~jax.example_libraries.stax` constructor function. :param tuple input_shape: shape of the input taken by the neural network. diff --git a/numpyro/util.py b/numpyro/util.py index fbc0b6154..33e638837 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -652,3 +652,16 @@ def _format_table(rows): " ".join(cell.rjust(width) for cell, width in zip(row, cell_widths)) for row in rows ) + + +def _versiontuple(version): + """ + :param str version: Version, in string format. + Parse version string into tuple of ints. + + Only to be used for the standard 'major.minor.patch' format, + such as ``'0.2.13'``. + + Source: https://stackoverflow.com/a/11887825/4451315 + """ + return tuple([int(number) for number in version.split(".")]) diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index bbbd6a179..0833764d0 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -6,8 +6,16 @@ from numpy.testing import assert_allclose import pytest +import jax from jax import jacobian, jit, lax, random -from jax.experimental.stax import Dense + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries.stax import Dense +else: + from jax.experimental.stax import Dense + import jax.numpy as jnp from jax.test_util import check_eq diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index 90a679738..202fa90a2 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -10,6 +10,13 @@ import jax.numpy as jnp from jax.test_util import check_close +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries import optimizers +else: + from jax.experimental import optimizers + import numpyro from numpyro import optim import numpyro.distributions as dist @@ -50,9 +57,7 @@ def renyi_loss_fn(x): @pytest.mark.parametrize("elbo", [Trace_ELBO(), RenyiELBO(num_particles=10)]) -@pytest.mark.parametrize( - "optimizer", [optim.Adam(0.05), jax.experimental.optimizers.adam(0.05)] -) +@pytest.mark.parametrize("optimizer", [optim.Adam(0.05), optimizers.adam(0.05)]) def test_beta_bernoulli(elbo, optimizer): data = jnp.array([1.0] * 8 + [0.0] * 2) diff --git a/test/test_flows.py b/test/test_flows.py index 769644fc3..f169fefb0 100644 --- a/test/test_flows.py +++ b/test/test_flows.py @@ -7,8 +7,15 @@ from numpy.testing import assert_allclose import pytest +import jax from jax import jacfwd, random -from jax.experimental import stax + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries import stax +else: + from jax.experimental import stax from numpyro.distributions.flows import ( BlockNeuralAutoregressiveTransform, diff --git a/test/test_nn.py b/test/test_nn.py index 97b45a7ed..e60ee0d87 100644 --- a/test/test_nn.py +++ b/test/test_nn.py @@ -7,8 +7,16 @@ from numpy.testing import assert_allclose, assert_array_equal import pytest +import jax from jax import jacfwd, random, vmap -from jax.experimental.stax import serial + +from numpyro.util import _versiontuple + +if _versiontuple(jax.__version__) >= (0, 2, 25): + from jax.example_libraries.stax import serial +else: + from jax.experimental.stax import serial + import jax.numpy as jnp from numpyro.distributions.util import matrix_to_tril_vec From 078d5f7012f81cf87341dea8eedd6ee0e0e067fa Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Fri, 12 Nov 2021 15:44:48 +0000 Subject: [PATCH 205/222] Fix links in bad posterior geometry (#1223) * fix links * only update markdown --- notebooks/source/bad_posterior_geometry.ipynb | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/notebooks/source/bad_posterior_geometry.ipynb b/notebooks/source/bad_posterior_geometry.ipynb index 62abec938..50a15ce95 100644 --- a/notebooks/source/bad_posterior_geometry.ipynb +++ b/notebooks/source/bad_posterior_geometry.ipynb @@ -155,7 +155,7 @@ "There are basically two ways to implement this kind of reparameterization in NumPyro:\n", "\n", "- manually (i.e. by hand)\n", - "- using [`numpyro.infer.reparam`](http://num.pyro.ai/en/stable/reparam.html), which automates a few common reparameterization strategies\n", + "- using [numpyro.infer.reparam](http://num.pyro.ai/en/stable/reparam.html), which automates a few common reparameterization strategies\n", "\n", "To begin with let's do the reparameterization by hand." ] @@ -184,9 +184,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Next we do the reparameterization using [`numpyro.infer.reparam`](http://num.pyro.ai/en/stable/reparam.html). \n", + "Next we do the reparameterization using [numpyro.infer.reparam](http://num.pyro.ai/en/stable/reparam.html). \n", "There are at least two ways to do this. \n", - "First let's use [`LocScaleReparam`](http://num.pyro.ai/en/stable/reparam.html#numpyro.infer.reparam.LocScaleReparam)." + "First let's use [LocScaleReparam](http://num.pyro.ai/en/stable/reparam.html#numpyro.infer.reparam.LocScaleReparam)." ] }, { @@ -207,7 +207,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "To show the versatility of the [`numpyro.infer.reparam`](http://num.pyro.ai/en/stable/reparam.html) library let's do the reparameterization using [`TransformReparam`](http://num.pyro.ai/en/stable/reparam.html#numpyro.infer.reparam.TransformReparam) instead." + "To show the versatility of the [numpyro.infer.reparam](http://num.pyro.ai/en/stable/reparam.html) library let's do the reparameterization using [TransformReparam](http://num.pyro.ai/en/stable/reparam.html#numpyro.infer.reparam.TransformReparam) instead." ] }, { @@ -309,7 +309,7 @@ "source": [ "### Aside: numpyro.deterministic\n", "\n", - "In `_rep_hs_model1` above we used [`numpyro.deterministic`](http://num.pyro.ai/en/stable/primitives.html?highlight=deterministic#numpyro.primitives.deterministic) to define `scaled_betas`.\n", + "In `_rep_hs_model1` above we used [numpyro.deterministic](http://num.pyro.ai/en/stable/primitives.html?highlight=deterministic#numpyro.primitives.deterministic) to define `scaled_betas`.\n", "We note that using this primitive is not strictly necessary; however, it has the consequence that `scaled_betas` will appear in the trace and will thus appear in the summary reported by `mcmc.print_summary()`. \n", "In other words we could also have written:\n", "\n", From d3a4ca116d8d99372fae030fe04990db6a522055 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Fri, 12 Nov 2021 15:44:56 +0000 Subject: [PATCH 206/222] fixup stacking (#1220) --- .../bayesian_hierarchical_stacking.ipynb | 38 +++++++++---------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/notebooks/source/bayesian_hierarchical_stacking.ipynb b/notebooks/source/bayesian_hierarchical_stacking.ipynb index 0b4fb8673..25bf9153f 100644 --- a/notebooks/source/bayesian_hierarchical_stacking.ipynb +++ b/notebooks/source/bayesian_hierarchical_stacking.ipynb @@ -77,13 +77,12 @@ "source": [ "import os\n", "\n", + "from IPython.display import set_matplotlib_formats\n", "import arviz as az\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", - "import scipy\n", "from scipy.interpolate import BSpline\n", - "import scipy.stats as stats\n", "import seaborn as sns\n", "\n", "import jax\n", @@ -97,7 +96,7 @@ " set_matplotlib_formats(\"svg\")\n", "\n", "numpyro.set_host_device_count(4)\n", - "assert numpyro.__version__.startswith(\"0.7.2\")" + "assert numpyro.__version__.startswith(\"0.8.0\")" ] }, { @@ -828,7 +827,7 @@ " # log probability of LOO training scores weighted by stacking weights.\n", " log_w = jax.nn.log_softmax(f, axis=1)\n", " # stacking weights (constrained to sum to 1)\n", - " w = numpyro.deterministic(\"w\", jnp.exp(log_w))\n", + " numpyro.deterministic(\"w\", jnp.exp(log_w))\n", " logp = jax.nn.logsumexp(lpd_point + log_w, axis=1)\n", " numpyro.factor(\"logp\", jnp.sum(logp))\n", "\n", @@ -889,7 +888,7 @@ "source": [ "We can now extract the weights with which to weight the different models from the posterior, and then visualise how they vary across the training set.\n", "\n", - "Let's compare them with what the weights would've been if we'd just used fixed stacking weights derived from the LOO scores." + "Let's compare them with what the weights would've been if we'd just used fixed stacking weights (computed using ArviZ - see [their docs](https://arviz-devs.github.io/arviz/api/generated/arviz.compare.html) for details)." ] }, { @@ -909,7 +908,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABHgAAAGqCAYAAABwPPPAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3hcV5n48e/0US+W3Issl2PHNT0hJIRUSEgD0hNSKaFuYYFl2V1g2f2xLCxlgQCJnU4K6ZX0kEZIdY19XCTLKrbVu6bP749zZzQaj6RRH0nv53n8WDq6c++5c9/b3nvOubZoNIoQQgghhBBCCCGEmLzsE10BIYQQQgghhBBCCDEykuARQgghhBBCCCGEmOQkwSOEEEIIIYQQQggxyUmCRwghhBBCCCGEEGKSkwSPEEIIIYQQQgghxCQnCR4hhBBCCCGEEEKISc450RUQQgil1PeBf08q7gCqgeeBH2mtG8e7XkOllHoFKNNal43jMk8FXgZu0lr/rp9p9gEHtdYnWL9/H/N9L9Za7xuXio6QUupa4DbgRK31W2lM93Gt9SujXIdTMd/1dVrr2weZ9hTga8CxwGwgAlQBTwE/1Fq3j2bdBqhHGVAJ/EBr/f0BposCd2itrx2Peo01pdTtwDVaa9sQP3ctacSZEMORfLxOd/+cjKzz4Wyt9YoxXsa4nnOFECLTSQseIUQm+SzmhvhY4ELgAeBLwEtKKdcE1itdXwTOm+hKpOEPmO+4bqIrMgaewKzbexNVAaXU54BXgCLgn4BTMbH9LPB3wHNKKWfC9P9nJSQm0rHA9ye4DqPp+5h1GjNKqa1WQkiI4arDxOkfxnOhSqmjraRuRs5vCDLinKuUKlFKRayEnRBCTChpwSOEyCTbtdY7E35/SSllw7Q2OQV4cWKqlR6ttZ7oOqRDa13H1EzuoLVuApomuBr/CuwAztZahxPKn1ZKVQP/DZwJPGOVnwJ8ML5V7Etr/e5ELn+0WS3T9o3V/JVSxcCqsZq/mB601gFgIva9UzJ8fmnJoHPuycCQWgsKIcRYkQSPECLTbbH+L0ksVEpdh+kCsxLwAduA72utX7T+/gKwHphrXUQnfvZDIKi1Xmf9fjbwL8DRQBTYhOkW9ueEz8wFfgScAcwEmoGXgH/WWldb07xCUnNxpdR5wLeBI4EwsAv4idb6gYRpbse0WFoB/Bo4zarHK8BXtNYH0/+6Bpeqi5ZSag7wX8AnMS1PaoC7gf/SWvutaa7FdF/5JCaJcTQwU2vdrpRag2k18XEgG9Md6S5rXQNpfH4+8GPgLMCL2Z4/TNwGFodS6r+Aa4EZwFbga1rrvyYtI95FSylVhNl2FwKFmG3wU631PQnfySLgB8A5QAFQCzyKiamhdqeaD7ySlNyJ+T/gt1rrnoTuGQBrlVLXYHX/UkrNAP4N+Awm3g4CLwDfTYwHpZTXmu5yTFewSuD3wK+01imfqFut4Z7B7B8f1VrvTO6iZXXr24TZJj+1pm0B7gX+RWsdtKZzYLb79UAx5mb1G8B/Aiv76zqhlHoTcGitj08ou8ya/y1a6y8klH8fs38Wa607lFLHYbbVRwAXJpn2c6313QmfuZ2kLlrW/P8NKMckf34ALLTWMbm7Yr9xlhBjALcppW6LfV4p9Q3gRmAxEAK2Y/aBx1J9Dwl1GzT+h7iPHYdpNXYVJp63At/QWr/dz/LPwHSH/bLW+uakv30R+B1wutb6pXT2lYSuSFcBV1h1Pht4Ffim1vpnScu4BLgf+LTW+pF+6pjWPprm/p7ONDOsac7D7INNwJ8x++CBAdbzeK31VqXUkcCvgGMwXY7/hOmimbhOZSR10bL2xV9itsd/YM4Lh4CbtdY/SfhsNvAT4FIgC3gN+DLwNHBIa31qP9/jK8DHEpb1l9i0SqkLMeertZiExYeYfeueVPMabH5WWTlwM3ASZp94AtNFrTNhmkHPwQMsO37OTfdcak13ObAcE9snY87PTwJftx4UxOa/Qms9O2m5b2G6n5XFjjXWnyqVUlXSZUwIMZGki5YQItOttP7fHiuwkjsbgTcxN0RXYhLWT1s3QQB3YG7Mzk2cmVJqlTXPO63fz8Xc7HYAnwYuwSRvnlJKnZPw0UcxN5T/iLlo/Jb1+3NWK6PDKKVOtz5XB3zKmv9B4H7rgjaRA3gY+BvmAvUn1vRj3nRfKZWHufE6E/gu5jvdiFnH21N85AfAQ8DpQLdSqhST7FqCudA9E3gEc3PygzQ+Xwi8AZwAfB24APOdPamUOi3FZ/OBqzHN88uBPyqlUp7PrGTG88DFwPcwN4d/Be62ulKhlHJjkienAl/BbN+brbr8PtV8B7EVOEMp9aXErlhgnthrrXusX2PdM8DcWByLufkBEwufw9z0nIpJmFwMPJQUb/djEir/C3wCcxP5C0wCrT+/w8TueUkt5pItAjZgvotPYW6S/gmTWI35V8z3+gTmRvhe4EHrswN5ATjSukmNORVzE53cGuBjwFtWcudI4C+Ym/KrMbGyCbjLSkSkZMXRH4F6emPhX4Dz+/nIQHH2BKbraGy6Y4E6pdSXgZ8B92CSmJdiEqUPK6VOGqBuhQwS/8PYx36GSYLE6r8Mc0zz9FONlzFJhE+n+NvFVn1eGca+8ndY+wNmO+3FxHWqZTSTlACJSXe5ae7v6R4TXsScD/7Lqv+/YPaxvyTFbfJ67rMSSM8BC4DPY5I/AUyyNB3HYbZtLMG0C/hvpVTi9vmt9V38HhPHf8EcR4oGmfcXrenAxO4XrXW+FBNTtZjYvQhz3r1bKXXjUOdn8WL2h4es9bgbkwz7VmyCIZyD05XuudSN6Qb+LGZ//W9M0ueOIS7v+8At1s/nkwFdxoQQ05u04BFCZCTrpud04JvARq31toQ/zwIe1lp/NWH6WswNxGcxF9oPAb/B3EwkPhG+GPOk7o/W7/9jTX9hQquE56yy/8QkjYoxF65/p7X+k/W5N5VS2zA3GnlAqlYeizAX+ddprbuseb+LuXi9AnNhGZML/Elr/XPr91eVUhdZ38FYuwlYinnyHHvC/xcrkfAfSqkfa603J0xfqbX+39gvSqklwFvAj7XWb1jFr1lJrCuAf05aXvLnP49pSXGE1nqHVfY6sAdzg/pSwmcbkrb7akzSTWFaciS7EPNU+BytdaxL1F+UUkdjbpTvxNyEbQfu1Fo/bE3zhlLqI8BnlVKfi8VGmv4Oc8NyM/B9ZVqTvQ68qLXeHZso1j1DKQXQFOsmpZQqABoxLWViNxtvKqVWWPMuwzwpPhZzQ5HY6uIvSqkjgCuUUv+ZXDGl1Het9b4o1uppAOuBo7XW71uffRe4DBOT/2slO74KvKe1jiU8XlBKNWMSPVUDzPt5THLoeExyAczN+23AN5VSM7XW9VZC4gTMTTaYfbIF+ITWui02L6t1x4+UUhu01qEUy/sa5gb7s9oasF0p9Q7mxjmVfuNMa71DKRXrGrIvYbudDWzVWv844XMvAO9by+5POvE/1H2sJWGbxFr/xFpmvJNcAa11WCn1J+BLSqkirXWL9blSzHb5hdY6opQa6r4S0lp/J6EedwA/VEqtix1TrGTJOZgWZP19T+ku90IG39/TmeZSYB1whdb6XmuaV5VSLZjkwWWYJHh/6/lVTKvTzyUs4wXrO17J4I4ElmjTnTZ2ftuB2fcets5JVwEPaa2/Z33mJetY8v+AfhO3WmutlGqyfk7sHvaf1jIujbU+tM6F6zD76q1DnB+Yc+AXtdbPWvP7CyaBczamNR2kcQ7ub136MZRz6RNa619YP79mHTuvVEot1FrvT2dhVsu9WJfnrXqSvLhACDF1SYJHCJFJdlgXqIkeBr6TWJB4A5Vgj/X/AmuabqXUg8BVSqkZsSbXmATPi1rrA9bNykpME//4TYnWOqSUehJzo5kFdGESOF+wbnLf1FpHtdabMEmllLTWG+l7E4DWutW6GF6Q4iOPJv1eARyvlHIPcOMTc7NS6uYB/j5QN6+zMTeqyd03Yi0ETgQSEzzPJU6kzduGUj213IPpYpTsuaTfzwRqYje31jyDpG4F8mjS77EkQgmpnYlJ6PUZvymxa5DWei/mpi/ZHsx5cg6Q1sW+Nb83rRuFv8c8Bb/S+odS6n3g21rrFwb4fBupv7fEGK/ErBscvj0ujv2cuD9ZT+h/BHxea/0Eg9sfS+5Y8+1USjXQ20JgHqaVXPKT8QdTlCV7C+gEPgq8rJSajUnSXYzpFnUyJkl7PKYVwHNWy4vTgHsTkjsxj2Bu4JaS+uZ2LfC+Tngbn9a6Sin1EqZVRrJHk34fLM7A7GPnKKVuAu7WWndYN8r/PcBnII34H8Y+llz/Cuv/gVp33IdJ2J1PbyuGizAtIu6x6jHUfeX5pOnuxLQ4ugb4B6vsXEyXs7v6q9gQljvo/p7mNB/HvPkuuWvdn63yk+l7bE9ez+Os6V5KKn8S8xBiMG/HkjuW5O23CrNdko+lt2ESPEOilFqISSL+t07oWqq1jiqlngb+WSm1SGs9UNI2lZ7EOlpJwmqs/Sjdc3BCq8d0PZr0e3/n0uTpnsMcq49gCMd8IYTIJJLgEUJkkovoHRjVjWmp8BVM4ueC2JNrZcZG+A7mgn8+5gYwJrGrzu3AdZhm17+2brqPoPcCeJ71//eVGecjlbla671Kqc9ibnpeB5qtJ/P3A49qrSOpPmg9mf4m5ollGZDTTz1jkpMwsQvRdLrT/ifmxjqVwZ6AzgPKVP9vQZmX9HtD8gTKjB/zecz3O1gXgeTPz8V0D0lH8nSxmwJHP9PPBVoHS5Appc7H3NweiUlaJHaDGnJ3Zq11LWbbf9O6eToZE9/nA39WSp2utf7LAPU5GXMDfCJQmlSH2M9zrf/T+e6Ox7TgqMTqnpiGVEnBQMLyZ1r/H0icwLo5q8B0o0pJax20nuZ/1Co6FdOybRumu9IpmATPqZgWO+9Yy/MA16r+3141j9QJnpmkTsZqUid4hhpnYL7fckzXmV8ppd4GHgc2JCaWUkgr/oe4jw3nWPIm5qb2M/QmeC4Gdmqt44OAD3Ff6bOvW0m1VzAtzL5ltba6GNgzWIuyNJebzv6ezjTzrGm6k+rfo5RqpXffi0k+ps3GtKLyJ5WnO7h9n+2ntQ5YydrB9r1DSqnk5Gc6Ysf42hR/iy1jLgO3ykulXh8+FliQ3v0orXMwpmvfUKQb/8lJnHrr/9IhLk8IITKGJHiEEJlkp+47JsjbSqlHMQM9/go42uo29DywBpOoeRFowySE/pY0v9cwT+6uxgy4eDGmNU7yIJ7/S/9Pj+sAtNbPK6UWY57+fhIzJsklwDNKqXNTXMSCeep9obXsRzE3sFHMWBKpjOQ1szVWi6LDKKUGa/0D5kn4xf38LfnmpU93JWUGlv0F5unntZibhDBm0NjksYYO+zzmSbc7jToOx6DzVmZg0UcwSYSvYJIgQcz4HteNtAJWU/97gHusxM1fMGO4pEzwKKWOwTz5r8SMVaEBP+bJ/78kTBpLLKbz3X0Ck+g7B/ghh3fpSWWweIwlVlMlONOJ5ReAHygzUPOpwGtWi4HXsVo8YcbfedF68h/73H303yqmsp9y7wjqmRatdStwptUd6jzMceL/Af+klDpFa/1hPx9NJ0aHuo8Neb2s7/5+4GtKqVzMd3YqCWP8DGNfSdW18Q5M8v1MK8l3DqabTr+GsNx0jiXpTDPQ92fj8FhKXs/+3qiUbrJ4rPe9oXwmti4pH2SMkkHPwUOU7neQvE7prqu8MUsIkbEkwSOEyGjWk8vNwAVWcmc15gnur7XWsT78sXFgkj8bVUrdiXk6WI4Zq+JhbY2HA1Rb/zv6S44kzc+PaWL/pDXGwvcx4wh8DDMAbZxSKh8zWOqTWuuvJZR7MYOfZpJqzJgUW/prjTSIz2FaWZybOP6JUiqn/48ctvwTlFK2xESZ9XmHHvpbrJLnnaeUKkjs1mN1vXNbZVdjbgjO1Vo3JEzjGurCrK5GpwDPWTf8fWitX1NKHcI84e/P5Zjz8+Va6/cS5p3cFScWvwswycPYdB7MW3USv7cNWusblVK/A76llPrzQC2I0hRb5qzEQmXG5lkMtA7y+ReAn2O6T51Kb7eu1zADypZiWjB9wypvxLwxLyud/TVFXWelKF86xPkMSmu9FTN+yH8ppdZiWsZ8C5OYSSWd+B/pPpau+zADaX8Sc5xy0jteGYzOvvIgJul9GaaVVw4DdM8a4nLT2d/TmaYGOEsplZNwvoi1yiwkdUuXRA1AYYouQQsH+Vy6+tv3Shig5dwAaqz/56f420Cte0ZqSOfgMTCb3q6v0NsyKhZjEcyb+pLNYWwTXkIIMWzyFi0hREazLuDXY1qoROlNTFcnTfr31v/JXSjuxNwY/Cfmlajx7ilWN5odmEE6+7xdRin1T9ZYGiiljlZK3ZZ4M2XVJTY+Q6pxORyYp3zJ9fyqtQ4DdfUYb89junz0eWOJUupYpdSvlFIzU38szgkcTLrxPB7zpiasFhoDeQPziu1TEz5vx9wk/6mfz6QrNiBt8tuB/gzExhxyAt2YBEJs+WWYLlUwtG11Aqbr3j+m+qMyb3GbCWxJ+lPiMg6LcWUGXr4uadr+1u0PmK4HiQ9xYjdw/4C5oblLmYHMR2IPZhydU5PKLyKNJKY2A6cfwHQJUvS2aHofk8j5CiZR9Zw1fQgzIPPZVvInTil1nVLqe6qfN9phumcdpcwb42KfmYd569FwxBIxDmteLqXU/6qkt/5orbdgWhEONHZPOvE/0n0sLdaYS7swx4KLgL9qrSsSJhnxvmIlTB7CdFe8BngjaRmppLvcdPb3dKZ5HnP8viBpmvOt8n7H0LK8Z9UpeWDf/t7aNlSxMdFOTSq/hvREoTdutNY1mK6N56uENxJaP3/KTKJrUs0o1fzSle45eAwlv6XrTMy6xI7PLZhEXfx4psyb/JLH0OtzPBBCiIkkLXiEEJlkldU1AMyF0nx6X1Ecu7ndiRmv4stKqR2YLlfXYW4I64CTlFKnAK9rrSNa60ql1KuYp8W1HD7o5XcwTf+fV+atQwFMt6qvY55kg+nP/1mgXCn1S2s5M62/N6WYJ1rrFqXUFuAya/l1mBuKFZhX8q5RSp2Bebo/0X6H6TJ0t1Lqm5gL7iMwXTMOYS5yB/IK8HWl1HcwrS+OAb6MeevKF4AblFKPD/D5mzFv8rrb6orSiNnui4Drh7lOMX/CbKdfKqUimK4dn8G0sondDL2CufH6X2UG5l6OeV38zZhxdK5WSt2W5vIex9y8fk8ptRzzNqkDmFduH4tpjVJN3y5GB4BTlVKXYJImr2Di7xfKDJw9F9NS7DbMa50vUUpVW4M5PwV8V5k3V72HGRz2KsygpbFxO+K0GXz8Skzc/R7ztqBhscbRuROzL/4U84rrFZhtvwMzcO5gXsRs63asMXKs+b5tzWdX0sCu/4YZB+tlpdS/YGLz45iua3/op6skmFg8C7hPKfV/mDft/AtmX/x42ivdKzYuyeXKvFnpbUyrpbuVUv9mrYsdM4DwagZ+PXY68f8KI9vHhuI+zFg/hfQeA2NeYXT2ldsx+9/Z9L5yfiDpLjed/T2daR7CdAf7lXVO2ok5Jv6HVf7QIPW9G/h34A9KqW9hWoRcxii14NFa1ykz+PEV1nnwr5iBnS8iIQk2gFj8/rNSapvW+lFMt82HgXuVUhsx5+BrMYMgpxrIe7D5pSudc/BYuVop5cTsvydhWvk+oLWOjeHzFNYr1hOOxf+M2b8Tx8GKrf83lOli+lDiYNVCCDGepAWPECKTPIi5eH4H85T1V5i3cJymtb4dzCCXmIvNRkxLidsxrRVuwrxKuQRzg5KYwI4NGPrH5C5IWuvH6X2K9xDm9danANdorX9qTVOLGSS3FXNT/CrmFez1wMla62ZSuxzzJPBW4AHMALGfBX6CGT/jPjJgMEerC8hHMRf3P8K0pPgBps5n6MFfEf5vmBuaf8JcEJ+JGYPkfzAJi59jvr/+lt9iLf91TOuTZzFdZ87WWr8y3PWy5h3EtNK4H/O9v2DV73Ktdaw112+A/8Nsrz9jbvKuxIyf8j5m8NzBbnBiy4tgkiZfxjT/34iJ5UcwYxz9Hjgy6Q0538UkQ+4ATtVaP4L5Tk/GfBfftP79EJMQucaaP5hxoH5p/f0lTLLzG5gWa/3V8V1M98JLVP+DFafrm8AtmETEY5jt/hlMwiadcTCex+yzbybdEL2G2TeS3xD2Lmb/rMa0xnsBs92+jbkhTElr/SdMq6o1mG3xz5jvPdZiY0jjlmitd2ESox/BbOOFmJvDDZjWhM9jxt06FbguIdZSzSud+B/RPjZE92K6oLgwx4BEo7Wv/AUzoH4gxTJSSWu56ezvaU4TwiQEH8DsKy9ikqv3AWcNdkzUWh/CjHtVi0nM3osZp+fzaaxruq7BxPJ3McfuozGJkTCDx/PvMa2A/h3zCnSspMz5mMTiI5hE2DzgU9YxaUjzS1c65+AxdDWmldUzmO/xLkzCNOZOzD72EcwYZl/DbMPkwabvxxyzvoTZF6UljxBiwtii0VEbX1AIITKSMgN0PgwckTSIsxBiDCilPgRCWuu1E12XgSilfotJDs8YIFErxoBSahOwQ2t9+UTXZaqwuih2YgYmH63uYFOOUup2TIIsS2vtm+DqCCHEqJIWPEKIKc0aE+CfgecluSPE6FJKfV0pdXfi2DfKDHi+nNSvJZ8QSqmzlFIPK6UWJZQ5MS03qiW5M76UUucB6zCtNMUwKKV+aHUZTnQKpjXgpvGvkRBCiEwgY/AIIaYkaxDWlZgm1Uda/4QQo6sT01XGppS6BTNuyw8wb5j5xcRV6zC1mC4zC5RSP8CM2fVFTFeofrt2idGllFqPORb/FNNl9q8TW6NJ7+vWOEKPYLpT/Rhow3SbFEIIMQ1JCx4hxFR1FmZgzqOAc7TW2ye2OkJMPVrrjZjxd1Zhxoa5GzPw8ZnWG5kygrX/n4UZG+hOegeE/pLW+v8msm7TzAPAb4EngBsnuC6T3b8D38IkLp/FDDi9FThFa5389kYhhBDThIzBI4QQQgghhBBCCDHJSQseIYQQQgghhBBCiElOEjxCCCGEEEIIIYQQk5wkeIQQQgghhBBCCCEmOUnwCCGEEEIIIYQQQkxykuARQgghhBBCCCGEmOQkwSOEEEIIIYQQQggxyUmCRwghhBBCCCGEEGKSkwSPEEIIIYQQQgghxCQnCR4hhBBCCCGEEEKISU4SPEIIIYQQQgghhBCTnCR4hBBCCCGEEEIIISY5SfAIIYQQQgghhBBCTHLOia6AEABKqZuBj1u/LgHqgB7r92O11h1pzuerwCyt9b8OMM084Fmt9eoRVHlUpFnfMmCP1vqw/VUp5QEu1VrfOYRlHg88CGzSWp839FoPjVIqCuwFQpik8l7gK1rrirFedkIdXgT+SWv9/ijMq4wU20Mp9X1gvtb6RqXU/wOqtNa/G+nyhli3U4FbtdZLU/xt2HUaaL4DfObzWutbhros67NlpP6OM2bfFUIIMXqSrhViqrTWZ4/yOfxWoEZr/f2RzithnhcB52mtrx9kuiiwQGtdk+Jvwz5nJs1nFnC81vrxYX7++1jXMknlg16vCiEygyR4REbQWt8U+1kptQ+4Smv9+jDm8+s0pqkFMuIGMZ36DuJI4HNA2gke4CzgFa311SNc9lCcGrugsRINvwTGPLkUo7U+fbyWZS3vn8dzeekYzzoppRzA/wAjvlhNlEn7rhBCiFF3aqrkx3ifw4dKa/0I8MhwP6+Umg18i9E5Z34cOAMYVoKnP6NwvSqEGCeS4BEZz2o98F9ADRDUWl+plLoR+EdMDB8ArtZaVyW1ongFc4L7NLAYeBW4AliE1TpAKXUtcC7QDpyMeXJ0sdZ6u9WK4BGgEHgWmA88qLW+PaFuNwAf11pfZf3+IfCI1vpflFJ2oBFYDijgF0CRVXaF1roiqb5HAfdbs74b+AzwdWCfNe/rgb+z5vEt4CWrfvlKqde01icrpX4EXAzYrO/rKq11XUJ9Pwt8A3AqpZ4GfpLiu70Y+Hfru60DPq+13mvVdRawADgaeMGq7/eBedZ0Tw64MY2XgPMT6nTYtrS2Ry2wWGt9yJrup9Y0fw/8K3Al4AUeBf5Bax1OqLsDCAJf11q/kpg0HCB2rqWfWEhjnfpQSt2OibEfKaWOAG4G5gB+4Dqt9btDjOtrre+sAHhPa/0tpdS3gS9a9XzS+lxs+f8CXAW4gRu11i8n1elo4A9AnrWca7XWlUqpE4FfAzlAxPr+XhhgPZ3A76zvywFsAa7FbJMCpdRO4JNWPTYAMwAX8K9a63uteXwC+JlVvguTsExezt1AizXdqOy7QgghJofYORw4HviY1vp8q/w54DGt9W+UUhcAP8Kcv/ZgrrMalVIzgHuBZcCHQDfmvJs4/9OBH2itP2r9/jTQorW+0vo9dm7zkfp8fi3mGuOMNM4/5yilvmjN42da658BbwLzrXPmWuALwFcw13Lt1nL6XIsopVZjEkL5mHPsL635/BpzjZertb5sgOsKG+acehHmeukWrfX/JC1jPvA65tr5LAa5vtZaR63v4sfAIeDnwG1aa1vyNhVCjB0Zg0dMFkcCv7NugmdiTmBnaq2XYU7k/TUZPQ84E5NkOQ34SIppzgF+q7VeDryMSaIA/BR4Tmu9GPgz5olIspeBEwGUUqWYE3FsGWuAKsxFwBPAd60uLr8EHkgxrz8A/2utU5tV5xg74NZar8UkOH5kJT7+GfirldxZBVwCrLbW5ZHkOmutH8R8dw9qrc+xihO/24WYC4YLtdYrgKeA3yfM4lPA9ZhWFBcDn9RaHwP8J/DtFOvUh1LKjblIe9z6PeW21Fq3YBJIlyZ8/CLgPuvzlwDHYbrzLQFiLcB+C5yrtV4JfJmERNJAy0uYpL9YGBYryfcocKc1zy8Bj1mJERhaXJ8FfMlK7nwUuBFYh9kWHwU+a003H9hqfQc3A99LUbX7gO8lxEnsydwfgP+xtv2PMcmbgZyNubhbgbl43o7ZH64HwlrrFVrrSsy+9KRVp+uBDUopl1IqB7gH081wubXO/5H0HX4bk9T8uxTLH8m+K4QQYnL5BTBPKXWWldDJA25WSpUDdwGXa63LMeeD2Pnr20CDdT74Cua8lexNYLV1XnIApcBKAKVUISYZs4mBz+cxg51/yrTWR2OuT36klHJhzov7rXOvB3MePM76/X8wDzOS/Tvm+mEV5rx7BuYcHLvGu2yQ64orMddRy4FjgK8ppY6LzVwplWWt73e11m+mWP5h19dKqWLMddgZmOubVN+1EGKMSYJHTBY9WuuXALTW9UB+QjPe14Dyfj73oNa6R2vdhWkdsDDFNB9qrd+zfn4/YZqTMU990Fo/imnN0oc248g4rZPoycDzQLF1wv4o8KJVXqO1ft76zL3AUiuZAsRPpEfHlgf8BvPkJsZGbzesDzA38claMRclVyqlirTW/6fTG5sn/t1iTtYva633WL/fCnw84QLmTa11vda6CfMk6BmrfCswd4BlvGI9mToEHAvcBoNuy3uBywGUUmsBh9b6LcxFxUatdZvWOmTV8dPWZ+qBLymlFmmtX9da/0NiJdKInf5iIZlDKbUz8R/w1RTTrQBmAhut5b8BNNCbBBxKXO/SWu+2fj4HeEpr3aG1DgCnAg9bf2vXvX3vD4sVpdRyoERrHdt2v8a0FgNYT2/ycaD9KqYBOAKTfMvWWv+r1vrZFNNdgLlIBfM00Iu5YD4JqNZab7P+9i1MAjNW13OBy4DLtNbhFPMd9r4rhBAi47ySdG7t02XJOg98HtPy5MeYlsMR4BOYruexc8nvgPOtZM0pWOc1rfU+4C/JC9Va9wCbMUmJdcBOoMka9+0k6zODnc9jBjv/3G39/wHmXFiS9HcfEAVuUErN0lr/SWv9kxTfVT3wGav1d5PW+kKttT9pvQa6rjgHc40c1Fq3YxJa7yR8fCPwhNb6jymWDamvr4/HXKtss7bLzf18VggxhqSLlpgsmmM/WCfsHyqlzsd0C8nDnFxSaUv4OWxNn+40RYnLxXQZSiXWiucUTHPcRZiLhJOBO6z5LLGSADF+TDImpgiIaq1bAbTWQaVUfWK9tNbdA62H1rpWKfVp4JvA/ymlXsW0+Kjup94xietYiukKE5tnm9WMN3YBkjjYdRjoHKhOCRLH4DkF+It1UVJP/9vyceAWpdRi4EJ6Ew+FwDeVUl+wfndiLrLAPBH7HvCeUqoa+DutdfxiLo3YSSdewGqdklgQ626XNF0hkA3sUErFyvIxXZVaGFpcJ26nEhIuGmOxYS2jfZB1KCFhPa0kWWxQyyuBryul8qzPDdisWmv9tlLqa8DXgDuUUk9gWk4lOxv4ntXKLWLN127VpTVhfoGE9bBjunVpeuMs2Uj3XSGEEJkj5Rg8ibTW7yul2jHn4VhCpxA4Jek6qw1zri2m77mihdRi13I2TIue2EOIozAP6wrp/3yeaLDzT7u1HmFrPn3O0db13+nAd4EfWN3Dvqy13po0n29b0zwAeJVS/6W1/m3iBINcVySff7usz4B56OPBtKTuT6rzr5x7hcgAkuARk9GlmBv5U7TpX/15zI3paGsHchN+n9PPdLGLgpMw49Essn4+DrgB02Jlh9WVqQ+lVGyg4XbAppTK1lp3Wy1mSpOnH4zW+mXgZavry08xT7iG8t0cstYlVr8izA1541DrMkAdX1VKVWFaOLnoZ1tqrbushMHFmO5H11mzqAMe1ykG/NNa7wWus7pGfQ74I2Z8oJjxip2YOkyLmhXJf1BmDJ5EQ6lbIwlP/awxBtLViGllZtdaR6zWZvOw+uBj3r6xSSm1jP4Tp3HadPt70GqavRH4JxIGirTm/yfgEq3108q8+S32hrzk9cjGXIzHfBS4HdP16udDWMd0910hhBCTiNWyM4RJapyjtX4ac659QWv92RTTt2DGr4spBVK9xfNlTHdvF/ADTKvkT2JaV28EAvR/Pr824dcRn3+01h8AF1vd2r+FaZF0UtI0nZgEz3eVUscCf1ZKJSdkBrquSD7/zqL33Pw+Ztye55VSL2itq9Ksupx7hcgA0kVLTEYzgX26d/C8S+h7Qhktb1vzRin1KfrvgvQypr+x02qB81frc7XWE5G/AXOUeT05SqlypdRdVssYIH6i3hFbHmbw3GgadQxiBlm2WX3Sf2PduHdhmhunM49Ez2OegsWa8H4J05c8NMBnhsTqIqQwTaAH25Z/xLQIyU7oivMYcLWVDEAp9UWl1DVKqVKl1PNKqXyrafBbHL7+4xU7MVVAjTKDW6OUKlFK3Wsl4JINpW6PY5qfF1nJwEdJv6/7bswAk7FubTdgxt4pBbqAndY8v2DVud/vRyl1nVLqXwG01s2YbRrFxKXdagmUY/171/rYNzAXyrmY7lqzrYtTMGMD/Jv1c8TqKngd8C8q4ZFpGtLdd4UQQkwS1rnzl5gu0V8DfmOVPQucHLt2UUodp5T6pfWxv2K6EaOUWoJ5cJDKW/SOa7fN+v2jmFeD7yL98/lwzj9BIFcp5VRKrVFK/Ukp5bZatb5Lims5pdQTyoy9iFXfNnrPv4VW+UDXFY8DlyulPNY6vE7vWyortdabMGMebUy8Xh3Ee8BapdRS60HbjYN9QAgx+iTBIyaje4EZSqk91s/fAxYopX42ysv5FvBpq8nv6ZiLhMNOslrr/ZiT6dtW0VZgFeZtUbG+3Z/FdJvagRnU9k9a6+R5fRlzI7sdc0Ncm2p5SV7HXDzUAW9gmg/vsuZxKb03y2mxmkbfiBk4cCem29kXhzKPfsT71WNac3zRam482LZ8FtME+v6EeT2KGbT6fWt+5wPPaq0bMAMavqPM28zuwyQvEo1X7ABgbePLgK9adX0VeDHWFHq4dbPGIvofzKCPH2Kett2bPN0AdboYE2u7MW/HuAmTEHwa02rnr5jv+C1SjFeQ4DHgaKXUbiu2jwD+FzM+0+vAfqvsJ8AHSqkPgL2Ybfgkpin8Z4C7lVK7MG8P+W5SfXcDP8SMQTVQN8BEae27QgghJpUfYAbs36q1fhvTdepHWusDmLF5HrHORb+m97rh/wGLlFKVwP/RO15dH9b4NbWYhEjEemDnwXTXGsr5fDjnny2Yrk0HMa1gKoHt1rXc9zEPRpL9H/BHa33fx7xwYDfwHHCaUuodBr6uuB9zjbUbMx7QBn34YMo/xnTrSjXG4GGs7fBdzIPPv2HG/BFCjDNbNCrXvEL0RylliyVirJPlj7TWj43T8hqAM7TWm8dqeZOBdYFzsdb6w4mui5g8xnvfFUIIIWB6n3+S1n0V8LrWumiCqyXEtCIteIToh1LqfzBvs0IptQLzhoH3BvzQyJb3J8yTH5RSp2FaNww6BspUppS6DDggyR0xFOO97wohhBAwvc8/Vvfu2tiQBJiW5H+dwCoJMS1JCx4h+qGUmgPcBZRh3hDwX1rrO8ZweSsxrw8vxoxR8k8Jr7KedpRSz2MGAPysNXiyEGkZ731XCCGEADn/KKUuwnSLs2O6a99gjacnhBgnkuARQgghhBBCCCGEmOSki5YQQgghhBBCCCHEJOcc7wU2NHSMeZOhoqJsWlq6x3oxGUnWffqt+3Rdb5B1l3WfXqbresPYrXtpaV66r/+V65cxJus+/dZ9uq43yLrLuk8v03W9YWzXvb9rmCnZgsfpTPdNulOPrPv0M13XG2Tdp6vpuu7Tdb1h+qz7dFnPVGTdp5/put4g6z5dTdd1n67rDROz7lMywSOEEEIIIYQQQggxnUiCRwghhBBCCCGEEGKSkwSPEEIIIYQQQgghxCQnCR4hhBBCCCGEEEKISU4SPEIIIYQQQgghhBCTnCR4hBBCCCGEEEIIISY5SfAIIYQQQgghhBBCTHKS4BFCCCGEEEIIIYSY5JwTXQEhhBgPv/rVz9i+fRs2m41vfOMfWbly1URXSQghhBBCCCFGjbTgEUJkJH8wTH1LN/5geMTz+uCD96ipqeb3v7+N73znX/nFL346CjUUQgghhBBCiMwhLXiEEBklHIlw/0t7+GBXA83tforzPRy5vJRLT1uKwz68nPR7773DySefCkBZ2WI6Otrp6uokJyd3FGsuhBDDFwlFqKlqxuV2ANDdFSAry01PT4DsHPewy4D4z5lcVlPVjNPpyIi6DKVsJNsmVpa47qMxv8kSEzVVzQSD4Yyoy3jHxFjs65MlJibrvj4aMTHe+3qmxMlU3dcHK4t9h+NNWvAIITLK/S/t4YV3a2hq9xMFmtr9vPBuDfe/tGfY82xqaqKwsDD+e2FhEU1NTSOvrBBCjJLurgAbf/UG3V0BursC3HXzW3R1+rnr5rdGVJb4cyaXbfzVGxlTl6GUjcb2Slz30d7+mRwTG3/1RsbUZbxjYiz29ckSE5N1Xx+NmBjvfT1T4mSq7uuDlXV3BSbkesIWjUbHdYENDR1jvsDS0jwaGjrGejEZSdZ9+q37VFpvfzDM9255i6Z2/2F/m5Hv5UefPx6PyxEvS3fd//u//5OPfOSkeCuem266gX/+539j4cJFo1b38TaVtvtQTdd1n67rDWO37qWlebZ0px2r65dIKGIuAqM2Dh1op2hGNm63g0MHOpg5O4/6gx0jKgPiP2dSmctpp6c7iNPtmNRlo729xqMsE7b/VI6TTNrWEhOZUZZJ23oqxkkmbWuX085TD20F4LxL11E6KxeX24HdOfrtavq7hpEWPEKIjNHW6ac5RXIHoKXDR1tn6r8NpqSkpE+LncbGRkpKSoY1LyGEGE2xJ6SHDrTz3GPbuX/jOxw60MFzj22n/mDHiMsSf86ksqce2orT7Zj0ZaO9vcajLBO2/1SOk0za1hITmVGWSdt6KsZJJm3rWHIH4In7N8db640nSfAIITJGQa6H4nxPyr8V5XkpyE39t8Ecd9wJvPLKiwBovZOSkhKys3OGXU8hhBBCCCGEyDTSRWuKkXWffus+1db7jy/s4oV3aw4rP+OY+VxxxvI+ZUNZ95tv/j82b/4Am83GP/zDt1m2bPngH8pgU227D8V0Xffput4gXbSkSX3mlmVS94nJHhNTJU4yaVtLTGRGWSZt66kYJ5m0raWLlhBCJLn0tKWcccx8ZuR7sdvM2DtnHDOfS09bOqL53nTT1/jd7zZy880bJn1yRwgxddiddnILvGCL8txj23F7HGCD5x7bTjQ68rLEnzOprHBGNi89s3PSl4329hqPskzY/lM5TjJpW0tMZEZZJm3rqRgnmbStC2dkx8/vhcVZzF9UPCbJnYFIC54pRtZ9+q37VF1vfzBMW6efglxPn4GVE03VdU+HrPv0W/fput4wtVvwxERCEYKB8LR9TXooFJ6Ur04ejdcQBwPhafma9FAoPCVfnZzOdgiFRn9fnywxMVn39dGIifHe1zMlTqbqvj5YWXaOm1lzCsbs2q2/axhJ8Ewxsu7Tb92n63qDrLus+/QyXdcbpkeCB2Qby7pPL9N1vUHWXdZ9epmu6w1ju+7SRUsIIYQQQgghhBBiipIEjxBCCCGEEEIIIcQkJwkeIYQQQgghhBBCiElOEjxCCCGEEEIIIYQQk5wkeIQQ00ZFxR4uueQCHnro/omuihBCCCGEEEKMKknwCCEyTiAcHPD34ejp6eHnP/8fjj76uBHPSwghhBBCCCEyjSR4hBAZpaG7kZ+99xueqHgWgCcqnuVn7/2Ghu7GEc3X5XLx05/+kpKSktGophBCCCGEEEJkFEnwCCEyRiAc5NZtd1PTWcfzVa/w200beL7qFWo667h1290jasnjdDrxeLyjWFshhBg9DkeUgK8VAK/bj8MRwWGP4nX7TZnLj9Mqy/KYMo/Lj9MRxuGALHegT5ndDlme/svcLj9ORyheZrOB2+nH5Qhht9v6ljlTTRfEZustczn9uJzBhM/a4tMllpnpAkllAYL+Dmw2U2a3mzKX09+3zBHEnVBmlhsrS6iLI4jb6YuX2e3gcoaSymy4HCE8rr7TOR1mOkgsC+Nxxcr82O3RvmXuAI74dP74dA57FKcjEi/zuk2ZwxHp3a5uP5FwCIcj2qfM4YimKOsbE56BYsKeKiYSp/MdHhNO32Ex4XH5UsSEL0VM+A6LCfcgMRHwtfUfE44ALkdgyDFhpusvJvxpxUTydE5HCHd8uybGRO+2PqzMHcDh6D8m+uzrKWLC4YjisKcoSxUTCWUed0JM9Dl2xGIi+dgxcEx4XH6cznCKmAgfHhMpjyeHx0Qo0JVGnARSHicSy/qPiUDKmHClHRP+UYiJFGXuANFIuM8xwcQEOB0RvPHpxjkmPEnHE0d0wHPHwOeTpHOHFRMBX2u8zOkMpdj+fctSn0+GEhOBFDGRfDxJERNJ299mA2daMWFLGRMTRRI8QoiM4Xa4WF2yEofNQTgaZnuzJhwN47A5WF2yErfDNdFVFEKIUedwRIn6K9nzwR1ke7uo2XkfBKqJBvaxf/tdZHu6qNUPEPHvh1A1VVvvINvTxYFdDxLxVWELVlO17TZTtudhwj2V2MM17NuygWxvFwf3Pkqoey+OSB37ttxKtqeT+oonCHbtxhE5wL4tt5Ll7qJh31P4OnfijB6kcvMtZLk7aax6hp62D3FSHy9r2v8cPa1bcdsaqNz8B7yuTpprXqCnZQuueFk7zbUv09XyAS5bI5Wbf4/X1U7bgVfpbHwXlz2x7DUO7X8Dj6OZys2/x+Nspf3gG7QfeguPs4XKzb/H7Wilo+GvtB58A6+zhcrNf8DjbKWz4W1aDryKx9lmyhwtdDW/R0vNK3hd7VRuvgW3vZWupvdpqn4Rr6udfZtvwWVrort1E/VVz+J1dbBvy624bU342rbSsO9psj2mzGVrJNC+nUMVT1plG3HSSKBzBwf3Pk62p5OqbbfhoJ5gp+bg7odN2dY7sEcPEeraxYFdD5Lt6WT/9ruwRw4Q7tlDjb6fbE8n1R/eTUdrBRHfXqp33ku2p4vqHfdAqJaov5LqD+8h29NFzc57IVDTJybq9ANEAvshuD8hJv5kYiKUKiZq2bdlI9meLg7ufSwpJrqor3j8sJg4VPkU/k6NI3qAfZtvIcvdRWPVn62YONQbJ/ufo6dtO25bfTwmmpJjwm1iorvlA1y2BvQ7v8Hr6qC17i90Nb2HOzFODr5GR8PbeBxNJiYcbbQffIOOQ3/D47TixNFKe1JMuB0t8ZjwWjHhdbbS1fQuLTUvW2W34La30NX0Ps1WTFRuvgWX3cRE4/5nyeoTE1to2PcM2e7emPC3b+NQxRMJMdFAoHMHh/Y+RrbbioloPcHOnRzc/Ug8JhzRekJdmsqt95Ht6WL/9juxRw4S7t5NjX7AbP/td2MLHSDiq6B6530mTnbcgy1UR9RX0RsTO+6FYC1R/z6qt99tjhM77+uNiW13mjjZ9Sci/v3YQvup2nY72d4uDux+iHBPJbZQQkzssY4T4Tpz7PB0cWjvYwQ7U8XETlMWj4ln6OlIjoln6WnbjsuKiSxXB03Vz9NY+w5ue6MVEx0017xEd/Om+HEiy9VOS90rdDUmxcSBV+lsfBu3PUVMxI8dbSliopXOhr/RmhQTnU3v0lL7crzM7Wilq+k9mqtf6BsTLR/QuP85sqxjh9vWjK91Mw37niHL3Rsn/vatHKp80oqTDbhoJNDxoRUTHezbupHO1v0EO3ckxMTtOKKHCHZp6nab40TV9juwRw4lxEQn1dvvxh4+YB0nTOxUf3j3EGKiGoJVVG2/k2xvUkxsvd0cJ3Y/RNiXHBMPE+rZiyNcG4+Jg3sfI9i1Jx4T5tjxJIFOnRQTT+Pr2IEzegj9zu/iMeFr3dYbE9b5pLt5i7WtTUy01LxoxUSDFTvttNS+TFdTqvPJOwkx0U77wdfpOPRW35ioNzHhSYiJjvq3aDvwWkJMtNHZ+HafmPA4Wulueo/mmsTjRLOJiern4zHhsjVZMfHneEw4wgcmLMkjCR4hREY5r/xsVhQt7VO2omgp55WfPUE1EkKIsRNL7uzbdi8l845l//b7IRoh5G9l39Z7KJ13LPt3PEA0EiAc7KByy12UzD+O6h0PEg73EAl3U7HlTkrmHUvNzocJBzqJRvxUbr6DknnHUbPzEYK+ViBExabbmDH3WGp3PYG/uwG7LUrF5tuYMfdo6nY/ia/rIE6Hg72bNjBj7lEc2PMM3R21uFxu9n6wgeLZ6zmw91m62vbh9uawd9OtFM1ax6HK5+ls2Yvbm8veDzZQNGsN9ftepqNJ480qZO8Ht1JYupqGqr/QWr+NrJwSKj7YQEHpETTsf5XW+i1k5ZSy94NbyZ+xgsbqN2k59D45+XNMWfFymmvfoqnubXIL5rN30wbyipbQcuAdGmveJK9wERWbNpBbuJiWQ+/TsP9V8maUs/eDDeQWLKT10AfU73+FgpJlVGy6jez8+bQ3bOVQ5YsUla6gYvNtZOXOob3pQw5W/JmiWauo2HQ73pxZdDTvonbPUxTNWk3F5jvxZpfQ1bqH2l2PUzx7DZVb7sTtLaS7rZKaXY9SPGc9lVvuwuXJo6d9P9U7H6J47pHs23oPTlcWvs4DVH/4J0rmHE3VtntxON34Og5Qtf1+SuceQ9X2e7HbHAR7GhNi4j4gSsjfYmJi/rHs//ABotEg4UA7lVvvTogJX0JMHNcnJio2327KdN+YKJl3LLW7HsPf02RiYtNGZsw9hrrdT+DvOoTDbqdi00aK5x5N3Z6n6YnHxEaK5xzJgb1/pru9Cpc7i72bNlA8ex2HKp+jq09MrKW+8kU6mjSerAL2frCBwplrqK96ifbGD/Fmz2Dvpr4xkZ03k70fbKCgZAWNNa/Tcuh9svNns/eDDeQXL6ep9q80x2Ligw3kFS+hua43JvZu2kBu0WKaD7xHQ/VrJiY2bbRiYhP1+18hv2QZFZs2kpM/n/Z6ExOFpSvYa8VEW+OHHKx4jqKZK6nYbMVEk6Zuz9NWTNzRJyaKZq+hcqsVE62V1Ox6jOI56+Ix0d1eRfXOh5kx50j2bb0LpysbX2ct1TsepGTuUezbdg8Olxt/90GqPryf0rkmTux2J4GeevZtv4+S+cdStf0+bDYI+ZrZt/UeSqyYIBo2MbHlLkrmH2vFhJ9wqJOKLXdRMu84qnc8RDjYRTTio2LzHZTMt2Ii0AYEqdjcGxMBXzN2WyQeE7WJMbE5FhNP0dNRh8tpYmLGnCM5sPdZutv343JnUbHJHDsOVj5PV2sFLk8uez+4laJZazlU+SIdzbusmLiVwplrOFT1somJnBns2bSBwtJVNOz/C631W8nKicXEyr4xsWkD+TMUjTVv0lz3TkJMLKW57m801vw1HhN5ReU0H3iXxurXySu2YqKwjNaD71O//y+9MVEwn7b6LRza9xKFpYq9m24jK38ubY3bOFj5PEUzV1K5+XaycmfT3rSDA3ufoWjmKiq23IE3p4TOlt3U7n7CxMSWO/FkF9HZsrdvTHgL6G6voiYeE3fjcufg66xOigkPvq6DVH34gBUTf8TucKWMiaCvKSEm7rdiopXKLXdTMu9Yqj/8U9+YmH8c1TutmAj3WDFxLDX6YYKBdogGrWPHMdTuepSgrxm7Ldw3Jrrr4zExY+4x1O15kp6OOpxOpzmfzDnKOk70jYkDe5+jq20fnqzY+WQthypfoKN5d/w4UTRzDYeqXqK9aQfe7CL2HhYTpQkx8RothzZZx4lbrZh4g5YD75JbMM86n5iYaKr7G7mFC9m76VYrJt6hsfqNvjFx6H0a9v+F/BlLrZhYQFv9ZhMTJcutmJhHezwmVlC5+Tb83Y1UbN6II3yAaDQy7tcVkuARQmSUJyqeZWfLnj5lO1v2xMfkEUKIqcJhjxL172Pf1nuYv/xcmureIRoJM2PuUVTrx03ZwfeJhAPMmHcc1fox5i37BC0HNxMO9VA6/wT273yUuUvOorV+O8FAB6ULP0L1zkeZs+QM2hp3EPC1MWvRyVTveITZ5afT0bwHf08js8tOZf/OR5lVdiqdLfvo6TrE7MUfZ/+OR5i16BS622ro7qhjTvkZ7N/xCDMXnkRP50G62vYzd+lZ7N/xMCXzT8Tf3UhnayXzln6C/TsepWTesQR6Wmlv3sW8ZZ9k/45HmDH3aEKBTtoadzB/+blU73yUotnrCQd9tDVst8oeo3DWaqKREC2HtjB/+flU68cpLD0CgOaDH7BAXUDNrifIn6GwO5w01r7LghUXULPrSfKKl+BweWms+RsLVlxIza6nyC0sw+nJo6H6TRauuJDa3c+QnT8fd1Yh9ftfZ+HKi6jd8yzZuXPw5pRycN9fWLjy09TteQ5vzkyy8uZwsOJFFq78NAcqXsSTVUx2wQIO7H2BhSs/zcHKl3F58sktKqNuz7MsXHERB/e9gsudS17xUur2/JkFKy+kvuo1HE4vBaUrqN39FAtWXEBD9ZvY7E4KS1dRs+spFqjzaKh5Cxs2imavo0Y/wYLln6Kp9m2iRJkxx4oJdS5Nde8TiQSYMfdYqvXjzFv2ycNiYt7Ss2it30Yw0Enpgo+wf+cjzF1yFm2NOwj62piZEBPtTbvx9zSZmNjxCLMXf5zOlgp6uupNTOw0MdHVtp+ejjpmJ8ZERx3d7TXMXXIW1TtNTPi6Guhs3cfcPjHRTEfzXismHmXG3KMJ+ttpb9rFvGXnJMXEh31iIhIO0lK/LR4TBaUrgSjNBzebmNBPkF+isNmcNB9IigmHl8bahJgoKsPpzqWh5q9WTDxNdv4C3N7EmPizFRMlHKr6CwtXXmRiIncmWbmzOVj5khUTL+DJmkF2wfykmCgwMbH3WRautGLCkxgTF3Go6lUcziwKSlZQu/tpFqy4gPr9b2B3uCgsXUXtrqdYoM6nofqv2OwOimatpUY/yQL1KRpr3gaiFM8+MiEm3iMSCTJj7jFU73yMecvPsWLCR+n8403Z0rNpqd9KKNBlxcSjzF1yJm0NOwj625m58GSqdzzKnPIzaG/ahb+nmVmLPmbFxGl0tFTgTxkTB/rERHdHHd3t1cwpPzMhJurpbK1i7tKz2b/jEUrmHYe/p5nOeEw8clhM7N/5KMWz1xMKdtPWsCMhJtYQCQf6xERh6RFEoxFaDosJO80H3rO2/5PkFS/F7nDTWPu2FSdPkVu0GKcrm4aat+IxkVOwELenkIb9b5iY2P0M2flz8WSVcKjq1YSYmIU3ZyYHK19mwQorJrJLyM6bz4EKKyYqXsKdVUhuQYqYKCqnbs+fWRiLCVc2+TMUtbufYcGKC6nf/zoOh4eC0iNMTKxIjIk1JiaW942JGv0E89WnaKp71zqfHEP1zseZv/wcWg5uIhzyW0kdKyYOxWLixISY+JCgv4OZCz9K9Y5HrePELvw9LcxadIqJifJYTDRY55NHmLXoY3S27aOn4yCzy0+3YuJkujtq6G6vicdE6fyP0NN5iK62Kut8EouJJjpbKhJi4hgC/lbam3YnxMSRCTHxKap3PkaRFROt9duYv/w8EyczVxGNhmk5uIX5yjp2lKwEm53mA+/Hzyd5xcusmHgnHhN5CTGxICEmXJ78pJiYhyerOCEmno13v4xGw1Rs3khHSwU2W3Rcry0kwSOEyBiBcJBtjTvi3bJWFat4d61tjTtGNAbPzp07+OpXv8AzzzzJn/50H1/96hdob28bxdoLIcTQRLFhd7ix2exEwkHsDg+RSBCb3WWVBXA4vETDIex2pykLBXA4vdZ0jt7pnF6ikRA2mwNsdsKhAA5nFtFICGwObHYHkbDfmi6MzW7HZnMQCSWU2RzY7E7CsbJoCJvNht3uMGUuL9FoGLBhszmJhHymLBIGwBabzukF66ml3eFM+GzEms5FOPbZ+HQuUxdXFhABItjtLuuzWdZ0CWVOLxAlGo1id8TKsiAaJRqN4HC4e9eXKNFI2CyjT1nIzC/sx+H0QDRKJBLC7nBb373HbKdI0JpfAIfDbZXFpjPbDWxEIkEcTo+1PdymLBzE7nQTiQSx290Q39ZWmcMNNjOdw+mxpjPbPxwOYHd6iISTYsIZi4nY9vdbMRGKx0Q4FIuJWJw44t9RxIoTmz322azemIhv/6z0YsKaX29M9H42OSZM7CTERJ/prJhwJsaJ04r3LIiGgSh2u8uUJcSEzeFKWIYVE4lxYsWE3eG2PhsrC/dua9fhMWF3ePvGhPWd9saEp0+cxLZnJBzojYlwyMROKBY7NqIJ+7rZ/iYmHA4P0XAIm8NlYiJi7evhAHa704qTgBVjQWwOZ/zY4XB6rLo7rX3dmi4xJhKPE1ZMxLZ/JByMx0Q4HhOh3pgI+3E6vURiMWFzWNOZ7RqLiT7xZEuOCStO4vPL6t3/rTJHUln8s31iwp8UEyaeeueXGBNZVkxErNjpe5ww2zWxzMREPJ5iMeFwW/tU7DjR93jS95hg9luwmTKnx9qX3fGYiB07HPE4sWIiHOiNiYg5/pu/ueLHidgxwW5PjJPkmOg9T8TOHaYO5jhhtzkPP3fEYyKQcJxwWseJQEJMOPrs15FYnCTEk4kJu9mGKWIiHPbjdGX1nk8SYyKSsP1TxUQ87iLmLBqPnd4yu8NlzS+7z7kjcX4mJnrPE8TKHK54LCbGSd+YiB07erd/xCpLZLM7zHbCluZVweiwRaPjm1FqaOgY8wWWlubR0NAx1ovJSLLu02/dp9p6N3Q3cuu2u1ldspLzys/miYpn2da4gxtXX0Vpdt83YE21dR8KWffpt+7Tdb1h7Na9tDQv7auusbp+sdvBHq6lcvPtzF16Nm2NuwgF2pm56BSqdzzCnCVn0tFcQcDXEn9KOnvxaXS1VplWF1arm9llH6e7vZaeroPxVjezFp1MT2c9PR21zFlyFtU7H6F0wUn4u5voaqti3jLTwqJ0/gkEfG10tlbEn5KWzD2GULCb9qbd8VY3xXOOIhwO0N64s/fJ6ex1RKNR2uq3MV+dR7V+nKKZq8Fmp+XQFhao86nZ9QQFJSuxO9w0H/gg/pQ0f8YyHK5smuvejT8lzS0qx+UpoLHmLRauvJDa3X8mt3AR7qxi0xLHekqanT8fb85M6ve/Zj05f46s3Dlk5c3l0D7T6uJgxYt4ckrJKVhoWl2suIiD+17GnVVMXlE5B/Y+bz1N/wtubwH5M5ZTt+dZq9XN6zjdORSUrKR2zzMsXHEhDdV/xe70UDRzDTW7n2bhigtoqPkbdrvTtLqxWuI01b0HwIy5R1O983FTdvADiIStllixp+lbiUQCVqubx5i37JO0NXxIKNjNzAUnUb3zUeYu/QRtjTsJBTqSYmIvAV8rs8s+xv6djzJn8el0tu7rJyYOMcd6mj5r0Sn0dB2ipz0WEw9TuuCjJiba9zNv6dm9MeFvs56mx2LiWILBLjr6xMTRhEN+2psSY2I90WiItvoP+8YENlrqtybExBHY7C5aDibGxHIcrqx4TNTseoq84iW43Pk01v4t/uS8Nyb+auJkz7Pk5C/Ak11CQ/XrJib2PkdW3lyycmfHn7AfqHgRb2JMrLyIg5Uv48kqJreo3LS6WHFhPCbyipdxYO9zVky8gdOdfVhMOJxeCmeupmb30yxYcT6NNW8nxcT5NNW+Azab1RLrCRMTBz6AaGJMnEvLwS1EIgFK5h9vWl0s+ySt9dtNSxyrhYWJk52EAp3MXGRaWMxZchYdzXv6xkT56XS2JMXE4o/T1VaLLzkmOg/S01EXj4mZCz+KryspJhacQKCnzbTYs1pYlMw7jmCgi86WPfGWWL0xoeOtbkxMhK0We7GYWGPFhHWc0E9QUJocE0+SP0P1HxN1b8db3eQWLsbtLTQtcYYYE1k5M8nOn8/BfS8nxMQMcgvLOFD5YkJMFJJXvNSKiYuor3oVpzuPghJljh0rLqS++g2criwKSldRu/sZ6zjxFna7q09MNNa+g81uY8ZsKyZWnEdT3QdAxLS60U9YMbGZSCTYJyZa6rcTSYyJpZ+0jhO9MTF36Vm0NyXExI5HmLPkDDpaKgn0NDO77OO955O2atM6q/w09u94lFllH6On4wA9nXXMKU+MiUa626vjLbFKF3wEf08LXa374ueTkvnHE/R30Nmytzcm5h5NOOSjvXFXPCaK56wnEkkjJmYegc3mpOXgpt6YKFE4nF6a697vPXYUL8XpzqWx7p3+Y2L3n8kpXIgnq4SG6jdYsOKifmLiBbJyZiXExKc5WPkSnqwZ5BSWcbDyxXiLzVQx4euqx+5wU77+RvKLy2hs7ByLy4d+r2GkBY8QIqOUZpfwj0d/JT7mznnlZ/OPR3/lsOSOEEJMBZEIRBzzWLzuWtqb9jBfXYg7awYuTxHl66+jvWkP85afjyd7Jg5XHuXrrqe9aQ9zl30Kb+4c7I5clqy/gfbm3cxZeg7Z+QuxObJZcuQNtDfvZc6ST5BTuBjsbsrX30BH815ml59JXvEyojYXS9bfQEdLBbMWn0HejJVEozaWrL+BztYqZi78OIWlq4lEopSvv5Gu1ipmLvwYhbPWEQ6FWXLkjXS1VVMy/6MUzTmGUDDAkvU30tVeS8n8k5gx93iCgR7K199Id8cBiueeSMmCj+D3dVK+/np6Og8xY+5xlC48hYC/nfJ11+Prqqdo9tHMLPs4vu4Wytdfh6+7kcJZRzJ78Zn0dDayeN11+HtaKJi5jtnln6Cn4xCL115L0NdGQcka5i49l+72gyxeew0hfwd5M45g3vLz6Wqvo2zN5wgHe8gtVsxXF9HRVsviNZ8jHPKTU7iUBSs/S2drNWVrriISDpFTUM7CIy6ho3kfi1ZfAUBWwSIWrbqU9uYKFq26DGx2svIWULb6CtqbK1h4xCXY7C48OXMpW3sVbU17WbjyEuzOLDzZs1m89mram/awYOVncbpy8ObMYvHaz5lkmroIl6cAV1aJFRO7mL/iogFiooDyddfR1rybucvOS4qJPVZMzMfmyGLJkTfQ0bKXOeVnk1NQBnYP5etvjMdEbtESojZ3b0yUnU7ejBVEicXEPmYtOi0pJvYxc9HHKJy5jnA4FhP7KZl/CkWzjzIxcaQVEwtOonjucQkxUceMeSdSMv8j+P2xmDhI8dzjKF1wMn5fO0vW32BiYs4xzFxkxcS6xJg4g57OJsrXXYe/p5mCWeuZXX42PZ0NLF53LQFfKwWla5i79By6Ow5SnhQT3W0mJkKxmFh+IZ1ttSxeczXhkJ/comUsWPkZOlurWbTmSismlrBw5SV0tFSxaPUVRKNRsgvKWLTqUhMnqy4Dm42svIWUrb6c9ua9LFx1mYmJ3HmUrbmS9pYKFh5xcW9MrLma9qbd8ZjweE1MtDXtZv6Kz+D05OPKKqV83bXmJlldhDurGJenmPJ119HRtJt5yy/Ak12Kw11oYqIpFhOzsTvzTEw07WHusnPIzptnjhPrrZhY8glyCsqwWTHR3lzB7PKzyC1aArGYaK5g1uLTyZuhiGJnyZE3mpgoO438kiOIRDEx0bbfiom1STFxMkWzjiISDlnHiRpKFnyEGXOPIxjwUX7kDXR31DJj3gmUzP8IAX8X5etvOCwmyhNjYuGp+LpbzbGju4HC2Ucxa/Hp9HQ1WzHRNGBMmGPHNQT97eSXrGLesvN6YyLQRe6MFcxffgFd7XVWTPjILVrOghWfobN1P4vWXE0kHIwfOzpaqyhbfSWRSISc/MUsOuJS2psrWbTqcrDZyCkso2zVZfFjh83m7I2JJuvY4XDjzZ7L4jVXWceJi3E6s/FkzbaOE3tYkBwTzbutmCiKx0R7Y1JMrL+etqbdzFt2vomJ+PlkN3OXnYs3bx42Rw5L1l9PR/Me5iz5JDn5h8dETtESorh6jx2LzyCveDlRHCYmWioPj4nW/cxceCqFM9cQDkcoP/IGulp7YyIc6hsTxXOPIxi0YqK9lhnzPkLJ/BMJBLpZsv4GejoOUjz3eEoWfBS/r8OUdR2ieM6xzFz4MXw9/cTE+uvxd8di4ix6uhqTYuKT9HTUm/NJYky017F47ecIBbvJm7GCecsvoKu9lsVrP2diong581d8ms62Ghatvprs/AWUr7+RYLQEm218W++AtOCZcmTdp9+6T9f1Bll3WffpZbquN0ztFjwxdjvk50ZpbbfhcQUIhV1EMa989QfcuF0BwlaZ2xnAF3DjdgYIR11Eo3bcTr9V5iccdROJ2PC4gvgCLqvMRSRix+Pq/Wwk6iQSdcQ/63IGiEYdRKJOaxmu1GWOAFHshCMua36Hl/mDLpz2WJkTjzuIP+DCYQ9gw0Yo4kooC5KX66W1PZxQFsJGNGm6EDZbhGDIjdcdxB90W9OFCYaTymzh+HSBkBu7LYyNUHw6U5Y4XYBAyIPdFsZuCxGIL8OF3RbBYY+VBQiE3NhsURw285nYZ222SFKZGxtRHI4ggaAbjztA0CpzOkxdPa4AefmFtLR247QH4mWhiJtoFFyOhLIRxkQ0asPtjMVEgHDESSQ6jJhwBIiSOk7CEWdSTCSVOQNEoyYmCvKitHXYcNqDgI1QnzgxXbLDCdvfaQ8SJUo44k6KkwihiBuPK7b9g9iIJMVEsE/sxLc/IYJhTz8x0Rs7vTFhtofdHsGRHCf2/mIi2Dd2iJKXi9nX+4mJYNiNDXAmbv+Iy4qJYEJMuInCwDHh8hOOuIgmbNfeOEmKnXhMJMRJ1Nnnsy6nn2jUOeyYyMvLoaUtlPrY4Q4kbGtb0rFjKDGReOyIxUSUYNjVNyYS4qTf7U8Imz3dmAha2z/x2GHKPO4AeflFtLR0JsWEBxuR+HEiMU5GFBPWdKljwmzr4cXE4ecTExMu69iRsF2jDiI4yc+N0NpuS/84MeKY6FvWf0wkHyfSPJ9glYWTzjG2IEFr//cHzTF8LK/d+ruGkQTPFCPrPv3WfbquN8i6y7pPL9N1vWF6JHhAtrGs+/QyXdcbZN1l3aeX6breMDEJHumiJYQQQgghhBBCCDHJSYJHCCGEEEIIIYQQYpKTBI8QQgghhBBCCCHEJOec6AoIIcR4+e1vf8nmzZsIh8NcffW1fOxjp010lYQQQgghhBBiVEiCRwgxLbz//rtUVOzl97+/jba2Vq677kpJ8AghhBBCCCGmDEnwCCEySjQSIVhf36fMNXMmNvvIepSuW3ckK1euAiA3Nw+fz0c4HMbhcIxovkIIIYQQQgiRCSTBI4TIKMH6evZ97zt9ysp+9GPcs2ePaL4Oh4OsrCwAnnzyMU488SOS3BFCCCGEEEJMGZLgEUJMK6+99gpPPvkYP//5bya6KkIIIYQQQggxaiTBI4SYNv72t79y550b+dnP/o/c3NyJro4QQgghhBBCjBpJ8AghpoXOzk5++9tf8otf/Jb8/IKJro4QQgghhBBCjCpJ8AghMopr5kzKfvTjw8pG6sUXn6O1tZV//dfe8X2+970fMnuEY/sIIYQQQgghRCaQBI8QIqPY7PYRD6icygUXfJoLLvj0qM9XCCGEEEIIITLByN47LIQQQgghhBBCCCEmnCR4hBBCCCGEEEIIISY5SfAIIYQQQgghhBBCTHKS4BFCCCGEEEIIIYSY5CTBI4QQQgghhBBCCDHJSYJHCCGEEEIIIYQQYpKT16QLIaY8n8/Hf/7n92lpacbv93PttTdy0kknT3S1hBBCCCGEEGLUSIJHCJFxIpEo7a09AOQXZmG320Y0vzfeeJUVK1Zy5ZXXcPDgAf7u774iCR4hhBBCCCHElCIJHiFExmlv7eHeP7wNwOVfOI7C4uwRze/008+K/3zo0CFmzpw5ovkJIYQQQgghRKaRBI8QImPEWu60t/riZYk/j7Q1z5e+dD319Yf4yU9+MZJqCiGEEEIIIUTGkQSPECJjJLbciXnqgS3xn0famud3v9vI7t2a//iPf+X22+/FZhtZ1y8hhBBCCCGEyBRpJXiUUj8HTgCiwDe01u+kmOb/ASdqrU8d1RoKIcQI7dy5g6KiImbNms2yZYpwOExrawtFRcUTXTUhhBBCCCGEGBWDJniUUh8DlmmtT1RKrQQ2AicmTXMEcAoQHJNaCiGmhfzCLC7/wnG0t/riLXfOvWQt+YXe+N+HY/Pm9zl48CDf+MY/0tzcRHd3NwUFhaNVbSGEEEIIIYSYcPY0pjkdeBRAa70DKFJK5SdN8zPgX0a3akKI6cZut1FYnB1P6ADkF3opLM6msDh72OPvXHjhZ2hpaebLX76Rf/qnv+Mf/uHb2O3pHP6EEEIIIYQQYnJIp4vWbOC9hN8brLJ2AKXUtcBfgH3pLLCoKBun0zGkSg5HaWnemC8jU8m6Tz9Tbb3t9CZyiotzmFGa2++06a17Hr/5za9GoWaZZapt96GYrus+XdcbJn7d5fpl7Mm6Tz/Tdb1B1n26mq7rPl3XG8Z/3YczyHL8zkspVQxcB5wBzEvnwy0t3cNY5NCUlubR0NAx5svJRMNd90goQndXgOwcN3bn+LVsGM3lTtftPhXXOxKJcvkXjgMgFIn0u35Tcd3TJes+/dZ9uq43jN26D+WiS65fxpas+/Rb9+m63iDrLus+vUzX9YaxXff+rmHSuaOuw7TYiZkLHLB+Pg0oBV4DHgGOsgZkFpNMd1eAu25+i+6uwLRYrshssa5aI+mWJYQQQgghhBDTSToteJ4DfgD8Xil1FFCnte4A0Fo/CDwIoJQqA27XWv/9GNVVTCGxljttzT0A8f+BcW9FJAYW21Yg20YIIYQQQgghMtWgCR6t9ZtKqfeUUm8CEeAr1rg7bVrrR8a6gmLsJN64JydaxvpGPtZyJ+bx+zfHf776phPILfCm+piYAInbSraNEEIIIYQQQmSmtMbg0Vp/J6loc4pp9gGnjrxKYrwkJ1mgN9Ey1jfy2Tlurr7pBNqae3j8/s2cf+k6Coqz4n8TEy+5lRWMXwJQjJ2JGm9LCCGEEEIIMbaGM8iymCJiSRbgsETLWCdZ7E57nwRSQXGWtAzJMBOZABRjJ7ZdZRsKIYQQQggxtcjj22kslmTJLfDGW8/EEi3yZF/EEoDnX7ouXnb+peu4+qYTJm0rK7/fxyWXXMDTTz8x0VURYtqLhCJ0tvmIhCITXRUhhBBCiClB7uIF0HszP9437hO1XDG4WAIwlvyD8U8ARiLBUZ3f7bdvID+/YFTnORnEbqQ723x9xtuSm2sxkeQtikIIIYQQo0u6aAng8C5TU325IvN1t+6kte5FCueeTnbhihHPr6pqH/v2VXLiiSeNQu0mF+luJzKJvEVRCCGEEGJsSIJHCDGgxLGaxqulVXfrTpqrnyIS6qK5+imz7BEmeX7965/z93//LZ555snRqOKkMpHjbQmRTN6iKIQQQggxNiTBI4QY0Hi3skpM7gCjkuR55pknWbVqDXPnzhu1ek4mqbahDGwuhBBCCCHE1CIJHiFExohEgrTWvRhP7sTLQ1201r2IN38JdrtryPP961/foK6uljfffJ2GhnpcLhelpTM59tjjR6vqk4aMeyUmWiwGk1uTxf4mhBBCCCGGRxI8QoiMYbe7KJx7ep8WPAB2Zw6Fc08fVnIH4Ic//H/xnzds+D1z5sydlskdkHGvxMRLjkFpTSaEEEIIMTpkJEMhREbJLlxB8YJzsTtzAJPcKV5w7qgMtCyEyBzSmkwIIYQQYnRJCx4hRMaJJXNG8y1aMTfc8MVRm5cQYvikNZkQQgghxOiSBI8QIiNlF64Y9pg7QgghhBBCCDHdSBctIUTGkuSOEEIIIYQQQqRHEjxCCCGEEEIIIYQQk5wkeIQQIkNEQhE623xEQpGJrooQQgghhBBikpEEjxBCZIjurgB33fwW3V2Bia6KmIZiCUZJMgohhBBCTE6S4BFCCCFEPMEoSUYhhBBCiMlJ3qIlhJjy3n//Xf7t375DWVk5AEuWLOXv//5bE1wrIxKKxG+m25p7+vyfnePG7pQ8vBhbsRiMxR1IDAohhBBCTEaS4OlH7IJXLm6FmDjBSASXfXT2v/Xrj+JHP/rJqMxrNMVaTSR6/P7NAFx90wnkFngnolppk2Pl5DfZY1AIIYQQQhhyNd4PGQtDiInlD0f4w44aAuGpPRZIdo6bq286gatvOoHzL10HwPmXruPqm04gO8c9wbUbnBwrhRBCCCGEyAzSgieBdJUQInO8WNtEbbefF2qbOGdh6Yjnt29fJd/+9t/T3t7O9dd/nmOPPWEUajlydqf9sBYSBcVZGd1qQo6VU0ssydjW3BNvuXP+pesoKM6aFElGIYQQQghhSIIngTRT70u6XkxtiTfpmbSN/eEIL9Y28UFTOwAfNHUAcPq8GXgcw6vjggULue66z3PaaWdSV1fL1772Re6//1FcLteo1Xs0xG60M/2mWo6VU0uqJGPJ7FyCgfAE1UgIIYQQQgxHZtzRiYwkXS+mtkx8Y04wEuHWnTW8fqiVLus1zV2hMK8fauXWnTUEI8PrrlVaOpPTTz8Lm83GvHnzmTFjBg0N9aNZ9VERu9HOlGSbmF4SuwsG/eGMOjYIIYQQQojBSQueBLGLWyDeVF2aqQsxflx2OzeumG+14OmgKxQmx+ngyBl5nDFvxrAHXH7uuWdobGzkiiuupqmpkebmZkpLZ45y7acPOVZOTYkteTrbfBNcGyGEEEIIMVSS4EkwGcfCGG0ytsbUl+mvRPY47PExd14/1MqRM/JGPAbPRz96Ct///vd4/fW/EAwG+eY3v5Nx3bMmEzlWTk1y/BdCCCGEmNwkwdOPyTIWxmiTsTWmvsmyjU+fN4PKjh7OmDdjxPPKzs7hJz/5+SjUSiSbrsfKqWiyHBuEEEIIIURqkuDpR6on1NOBdL2Y+ibLG3M8DjtfWDl/2N2yxPiYrsfKqUiO/0IIIYQQk5skeEQf0vVi6ptM23iyJHfkjXOZQbbDyN6ON5mODUIIIYQQ4nDT8wpYpEW6XkxtiW/MkW08MvLGucwg22H03o4nx38hhBBCiMlHWvCIfknXi7E10a0NZPuOXPKA1YkDV0/nViRi/I324OlyfBBCCCGEmHwkwSPEBIk9aZfBSyev5EFpY2MagQxKO54k0SYDJAshhBBCCEnwCDGu5DXEU0vygNWxAWljfxPjQxJtQgghhBBCSIJHiHElT9mnluRuLDIg7cTI9ETbeHTHnCxvxxNCCCGEEGNHmgsIMZ6iE10BIaaeWKItltSJJdpyC7wZ0SpuPAZ/Tv4OoPd7yITvQAghhBBCjD1pwSPEOHJ5HJx1wSpKZ+XS0ebr09pAnrJPXvLGocyQSdthorpjxr6D2M9CCCGEEGL6kASPEOMgcRDY5x7bzvmXriPP6spTUCTdeiY7eeNQZsik7TBR3TEz6TsQQgghhBDjSxI8QoyDVIPAnvbJFZx1wSpcHseoLiux5YAM3CzExEhsSZM8NpC0rBFCCCGEEGNB7vyEGIFIKEJnm49IKDLkz770zE6ee2w7wUB4VOsUSybddfNbBIPhYddPDG4k219MbbGWNKnGBhpp0lXiTgghhBBCpCIJHiFGIN3BU2NP88+/dB1g3m5z9U0njOp4IbGbvtg4HwBdHVb9OsducNfpbDwGzxUimcSdEEIIIYRIRbpoCTFEwxk8dTxepx276Yt1/QJoONABQGtzN9iky9ZomKjBc8XkNRqDP0dCEWqqmgkGwxJ3QgghhBAiJUnwCDFEIxk8dSzf8hObd8Af5v6N7/T52xMPbEmrfmJwEzV4rpi8RmPgY4k7IYQQQggxGEnwCDFEIxk8dSzfcBObd3tCFy0x+qbz4Lmx1kvSYmT8Zee4uf7rJ8Vb8EynuBNCCCGEEOmRBI8QQ5QqSTMWXa6Gy5PljHfR8ngcPPHAFrkRHEWZvv3HUqwVibQYGX92p535cwpoaOiIl02XuBNCCCGEEOmRBI8YNfJ67szgcjmYNTfP/BI1/8mNoBguGXNICCGEEEKIyUESPGLUJI4RMV2e8I/lmDrDldjCJBKKZFz9Ms1Iuh1l4vYfbTL2y/CMZXe26RB3QgghhBBi6OTRqxixVK/nbmvuobPNRyQUmcCajb1YMiVTWzFkev0ywUheOT0dvt9YMuHqm07g/EvXAXD+peskwTCIsXyV+XSIOyGEEEIIMXTSgkeMmDzhF5ONdDsanoKiLPO/dPkTQgghhBAi40zpBM90eONL8rg3EyH2hD/2ZheAq790IpFIhKwsecIvMo8kJdOX+F1d+YXjJ7g2mS92TE5OHIIkD4ciE85tQgghhBCTzZRO8EyHN74kj3szEVK9VSgSiXDPH/5mvnv31PzuxeQ1nFedT4eE8WA8WU7pmjWI5ORhLHEIkjwcikw4twkhhBBCTDZTLsETCUWoqWomGAxP6a4XyU+JwaxnTVUzLrdjzNZzsJvc0z65AqfbQXurPL0WmWs4rzqfDgnjRKmOMY0HOykozprAWmW+5BaNscRh7G9iYBN1bhNCCCGEmAqmXIJnsK4X2TnuKfEUfqK6mAx0k5ud42bOggLu+cPfDqvTWNdLTD+xZO54JDRh+o3VI93Yhic5eSjjFQ2NxJ0QQgghxPBNuQRPdo6b679+UrwFT3LXi+n2FH4gyWMcjPRm1e60Y3fYRqNqQgxqtPblgV45PZ1vNlONrTVYN7bxZLcDRIhEMjPJJq8yF0IIIYQQ423KJXjsTjvz5xTQ0NARLyuZnUswEE458OVkfQrf381XyaxcXG5HWvNIHuOgv5vVobRikO4JYqyN9iC2qbpriaF3YxvthPFAotEIjughQv4OHFnlhMOZdwyXuEptsDgZjXObEEIIIcR0NeUSPKn4e0J9ug3B5H8K39/N1/xFxX2SW6NhKK0YpHvC9GOzmVZb0Wh0XJY3noPYDmcw5qkm8TsYaJ3TTRiPlN1uo7NlHxWbNhCNhFm46jIcWUsyMskjDjdYnIznuU0IIYQQYqqZ0gme+I3J+Nx3Toh0b74S9TeIZWwe/T1RjU2Xzk2udE/ILGPVusJut+GyNQE2gtFiIpGptbMNZzDmqWawliipjidOu59oKEIU76i25LHbbTiiB9n9wQaikRAA+7ffNymTPF63n1DYRWgS1Xk8DefcJoQQQggx3U3pBE/sxiQSikzZp/DD6QYwUIuc679xIkW54At4iET6X8ZgN7nSPWH0jMbruceidUUsubN3063YgPL1nydoH/skz0R1A5SkZWrJx5OTT59PT+ub9LQ5KZpzEpA9astyOQIcqngtntwxohyqfIGyNQvpCXtGbVljyevqYf/2uyldcDKunOXxJI/TESUcsTFOjeGGxGYDj6MdbE58waFv06E+WJBziBBCCCHE0KWV4FFK/Rw4AdMW5hta63cS/vZ54AYgDGwGvqK1zqjL07F8Cj8aN9/jrd8xDmZnk+2uZ9fb97B47bVgnx1P8iR/Vm5yx89IBhMe6k1VuhKTO5GQD4CKTbekleQZaWuiieoGKDecgzv59PnMm72bjkZzivB4HBTM+SjB0OgcL/xBF7OWnAfREO1Nu8wysktZtPoaegLjn9zxuv0Ewx7C4SF8xtXD/g/vxtd5gOodD7Bg5SW4cpYDEQKdO8nOX4g/lJ9RSR6bDdyOdio234LDmcOi1Z8bcpJnOg9YLoQQQggxXga9s1JKfQxYprU+EZPI+VXC37KBy4CTtdYnASuAE8eorqNitBMUsYvW2A3rZBC7UY21egBMcsdTT+XWO4iEA1Rs3ogjctB6U83hnx3KTbnXE8ImL9cac5FQhM42H5FQb1YuFp+J49Q8fv/mEcesx+Vn/4f3x5M7AOGQj+odD+Bx+Qf8bKxOI61D7I15kmwcnli8JMfMUMWOqdd95cg+yR2AxprXaT/4Bi7H6B0f/QEPi1ZdTF7x8nhyZzgtSkbK6+6h+sN7IFiNI82xf73u3uROTPWOByBYi69tCzU7H6Zi0wY8zvaMOWbGkjuVm28hFOjC311P1bY78bq6hzSfWJycf+m6eNn5l66TBwZCCCGEEKMonbv004FHAbTWO4AipVS+9Xu31vp0rXXQSvYUAAfHqrKjYTgJimSJN0aJb/IZ6Y3SeItdcF/7tY+Q422mcssdEDX1j0ZCVGzeiJPG+CC6w+F1d1G74x7cjt4bltG6sZzKhhNjqZKNY3VT5Qu4WbTqSpzuvHiZy1PAwlVX4Auknm9snZJbEw03DuxOO/MXFU+alnOZZrQSbbFjqtvrwubIOuzvDlc2UdvobiO3t5DZSy9k0ZrxT+5EQhFctk72b7+bno4ac9xMM8kTjdpxe4v6lBXOXIu/+xB1u58EIBToyKgkj9cdYN+W2wgFuuJl/u56anc9iNcdTHs+qR4sxFrfyT4shBBCCDE60umiNRt4L+H3BqusPVaglPoO8A3gF1rrioFmVlSUjdM59q86LS3NG3yiYaqpau5/DJuvn8T8OQVjtux0DGfdfd1RPNkl+Lvq42VZuXPwZhVQkJ07rHr4uhrY/f7tBHqaqNy8geXHfIGs3Nl9vr/R/r7GcruPp6HGWGlpHv5uc7PlcjkO+x5qqprjP5fMymX+ouJRqGUey4/5Arve/QM2m51lR3+erNxZ9LcFxmq/mSrbfCh8XQ0EfBFKS4f+nbU2d9PZ4aOjrbelVUebH5fLQW6el8Li4SVMWpsdFM0+Ea/XRX3ViwDMXfoJSuefiNM9+kmY/MJSgH7jbay0NR+k+sM/4u+2nmVEI1RuuYOl66+jaMYybPaBzm95eI/4NPt32Ghr2I7N5mBO+ensevd3faYKBTpoPfQ+c5ecicPZt+vSUOI9tq1Hsl2j0QiL11zO7vdvjY995HBls3DFhWTnF8e//9iygAGX53I4uP7rJw06XSoTva9PheuXTCfrPv1M1/UGWffparqu+1Rab18gREu7n6J8D1734OmUwdb9v/7rv9i8eTM2m43vfve7rF27dkT1G84gy4c9U9Ra/1gp9UvgaaXU61rrN/r7cEvL0Jp1D0dpad6Yvk7V5Xb0O2izy+2Y0Fe5Dn/dPSxa9Tmqtt2Jv7uerPwFzF95Ge1dLuga+vy87i72bbmNQI9JLIQCHex69w8sWnM9LY29g0s0HuokGAyPyhhGY73dx1O6MRYJRQgGwgSD4XjLmFTfaTDYO0hIMBju93sa6vg4NlsO5etuAJuNLl82nT39f/+hUBiny0EoePiAJQPVaSCTbZvbbDacjhDB0PBuEm028Dg7qNy8gdzCckoWnY0/OLSxZzrbfIcl2h794weAGQslOJQBZZLZPeTNPA6bDWx2J1lFR9HSFgZGdxtNxHaP7Ru5OWFstr7bz4aNSNRGc0v3YeOWHc7OzMWfAuzMmHc8vlA+5etvpGLTrYRDZh8umnM0+bM+QnNLEOhtJTPU9Y5t65FuV7t9JuXrrqdi80bsDjfl626kO1BAV0JdEuMqtrz+jieebBcAwXD6+/1YbfOhXHBOheuXTCbrPv3WfbquN8i6y7pPL1NlvcORCPe/tIcPdjXQ3O6nON/DkctLufS0pTiSxzWxDLbuH3zwHrt37+XXv76Vffsq+f73f8jvf39bWvXp7xomnQRPHabFTsxc4ACAUqoYWK21flVr3aOUegY4Ceg3wTMVpDtoc7oDMNvt4HEF6PH3dm2x2Wy4nUH8wfF70ZkvmM2i1Z+jYf+LlC46A1/g8O4W6bDZIBoJEg729CkPh3y0N7fx/BO18bLxHmRzsgyKPViMxW+conDX7wYfuDTdVw4P9W1b0Sj4QvlprdOM4hBf/qe1VO+L8sgfNwFMmbfZpcNms+G2t9B66AMKZ52Ef4gDDycmd4L+dloObSJKlNJFnxhSkqe/QdZHazsEQy5yS44jCgRDU+dFjbF9w2a38enLP4GXP+PrqsVmc7BozTVEHHPTSO4Y/qCHmYvPJRh2EwlHidiK40me/NIjmLHgTALBzNknIhHAPpvydddjd3gJRIqIWqNADzSQe+LxSQZSFkIIIcRkdv9Le3jh3Zr4703t/vjvV5yxfFjzfO+9dzj55FMBKCtbTEdHO11dneTkDK8HDaQ3Bs9zwGcBlFJHAXVa61gaygXcrpSK1eA4QA+7Nhko1cC16X6mu3PwAZjtdrCHa6naelt80EqbzYbb0UpD1ZN4Xb5+PzsWfMFsShaeM+zkDpib/kC4iPL1n8fhNPOx2V2Ur78BXLM57ZwV8WnHe5DNyTgodqqBwWPr4fKY7g6J4+yk+k5jCaP+xrsY7fFxknldnezbehtVWzeyoMyGN8s8wR+tMTgcjsxN1kFvcqdi0y007H+NptqX8DhNDKZ7jPG6ffHkTkzroc0017yM2xka4JPmrWdZngA22/iMhRIMuwiFXWlPPxnG5Yrth+ddvJaH793DzPKLyc5fyKI11xC1p5/cifEH3fHPRKNRApFilh795REnd8ZqjLhIBEK22X2SOzDwQO4DvU1PCCGEEGKy8AfDfLCrIeXfPtjViD9FD4V0NDU1UVhYGP+9sLCIpqamYc0rZtDHq1rrN5VS7yml3gQiwFeUUtcCbVrrR5RSPwReVkqFMK9Jf3xENcowg72iOtXNdzAY5lBdBx6PacafeNOc2HIkltyp3Hw70WiYqm13ULbmWiKRABWbbiEc7CYU6Gbusk/jCw7+5NPpCBIJD3yjlw5/cORjDJgbFpPk2bf1dhatupKQrZSsHCgo7r3JGI9XXCd2E0i84YH+uyF5XEGCYdeQb9rGQuyGPHbjBr31bzzYScms3D7xN5zvdCxfYex1dZruer4WAKq2buQLf389bW3eeKJnJFyOEGF/DZ6sOUPurtSfkbT0Sv5sYnIn1gWnue5tAGbMO42mtsiAx5iYYMjFzLLTqdWPxMscTi/Fc48jGHEBqW+m7XYbjuhB9m15mEWrr8Yfyk3rFdwOR4ho1E4kMvbJs6G2HBuOoXY/TJbYqi4aidLZ5Wb+yisIhNyxselHJBqN0hPIGfF8xnJfNnET7fNdZmUd3iLs6i+dSCQSob2t9wHFYMdcIYQQQohM1dbpp7k99ZuCWzp8tHX6mVk08jEno+lcpA8irfbzWuvvJBVtTvjb7cDtI67JGBrOzVpys/N+kzQputL4e0I899j2+O+JTzZjF9gmuVMXT+4AhIJdBHoOsH/Hw4SDpjVPZ8se6nY/zMzFFxAIZvVbf5czRFfjuxCcjcNVRjg88a9fiSV5lhz1ZXwB94QlS4Z6w+Nx+6mveIKSBaeAfWZGJHlg8PVIlWwcCZfbQXSET+C9niDV2++LJ3fAjMdU8+HdlK37PD3+kd3ohYLddLd8wIG9z5BfsopZ5Z8alSTPYIndoXzWYQ/T3V4VT+7EtDfuYMbcj9LWbMZY6e8YExMKO/DkHcE8BbX6ERxOL+XrbyQYndFvS4lYcqdi0waikRD7tmykbO31+EO5A3bbczrD+Fu34fIW4PAsIhwemxvygbr3jHYiYDhJpMHOHf29MW4iJW7X5PG7RuvYMNh3GYlEuOcPf+tT9u6bFYTDUc66YLV01RJCCCHEpFKQ66E430NTiiRPUZ6Xgtzh3X+UlJT0abHT2NhISUnJsOsJwxtkedIZzs1a8s10qiRNosQnmna7nbMuWIXLaeeph7Zy3qXrKLS6Q8QusKNRzNtWbLb4g3e3p4BwsPuwsWt8nQdoa+4ganekrL/LGaKz4W0O7XsBsLFo9RU4vOX9JnnGcxyaaDRKt6/vTUW648GMXiVSlNk47G0okVAEl9PHwd2P0dG8m/am3aZbWQYleQaSKtmYruRxWbJy3Fz/lRU4nK4RdRfxB9zMV5/pM4Cs3eFmwRGXjvjm2OUI0VjzLgf2PgNAe6NJqo5WkmcoBmsl5s1fzdylIer2PAWA053HojXX87v/3YyvxyR4BjvGQG+SZ8EKBzkF8/CFCvtN7ths9EnuAAR8rfEkjy+am3IZTmcYX+tW6nY/DtgoW3PVmCV5BkpaXvPVEymZAb6gN76ONhtDejU3pE4idbX7cbnB5Rr4GJjq3DHaidR0RUIRaqqacbkdA4/pluYYcWPJk+XsczxZUFbAuRcW4HA6iTrc/bQ1E0IIIYTITB6XgyOXl/YZgyfmyOUleFzD6wFz3HEnsGHD77nwws+g9U5KSkrIzh5Zi+4pneBJtxVOKsk3vLEnoLG/JUt1o3LWBasAyLfGPkkUjULYPpvy9TfEb8CigDd/CQuPuJz9H94LRHG6cph/xHVs/M1OzvzUyvjyPd4Q0agTmy2SkNwBiFK17Y8DJnlG0jphNIwkETEcLo+Dsy5YRemsXDrafDz+wGa+9A9H4/GECYR6EwEup4+Dex6hp2MvYAaKrti0gfL1NxC1zUyrW8tY6u/JfMmsXFzukXWrS9wmWTluPnvlImo+vA27w22SAcHhHWhiY4vEBpCNRsNWq5OSEX+fTns3tbuf7lPW3ridgpIVOHNXEw4PbQHD6coXM1jrKrvTS1bheuYuhfr9r1K+7gaaWzzx5M5QhMIOnDkryCkooHuAUfltNhs2HNhsDqL0dt202V2keBkikJzcAYiyb+vdY5rkSSUn101BXhd7P7iThauuAPssotEoHmcnVdv+SNmqS7Dbi9Ia4yV52+TkecjN6SDcU4vdVo7defixKNW5w+V24O8JkZPrmZDjZqrj9mDJ+tFIRtntNjwuP76Am3Cw/xZXsa5aAC6XA4/V/XJBWQGnnZVN9Y57wGZj8dprwLGA8CRImgshhBBCxFx62lLAjLnT0uGjKM/LkctL4uXDsWbNOpRayZe+dD02m41/+Idvj7ieUzrBM9RWOImSkxCDPQFNdfNdNMP0w7Pbe2+mnI4wbmeQnkCWuTmxkjwH9jzD/JWX0thg49VnOzjngsup2/MY+XMuY+NvdtLTFYjX/8vfOo6W2lfJKVhEVn4ZXa0VSbWJ0t22n/yshYQxF9kjuXmd7IKBMM89tp2rbzqBguIszvvsElpqn6S7fT/lR95IIFhMZ4ef/LwQ4WBrn89GIyFCgXZsnhKi0Yn9jvp7Mj9/UfGovXowJ9fD579+BFVbNxAKdkGwq7fFxygkeaLR8KgkdwCCkVwWrbqUqu33x8tmzDsBT/4yAsGhL2Asxy4BCIYdZBWuZ2nJKnoCXrxZkSElkROFrXFxbDZwOiMEgykGzo5ECdlL40nkSNiPJ7uURas/1++2dNiCtDVsTSqN0t64g+L58wgz/ESB122ON4kDuKd6o9enrzyS+QvD7NuygXCoh4pNt1J+pBmwfd+WjQR8rex67w8sWX8jQXv/3dNSycnz8JnLF9Baey/hkI8FKy/F4Vh6WOIq1bnjrAtW8dxj27nyC8eTXzz8QehH02DJ+pEm0+12G04aqNr6IAtXXUVTm2tI+0h+vpvzPlNI1ba7gShEo1RuuYPFa6/B4ZQkjxBCCCEmD4fdzhVnLOczH1tCW6efglzPsFvuJLrppq+NQu16TekEz1Bb4aQr1VPTVBfSOXl9n546HWH8bVupqnye8vWfJxAxT6AjkZnMXnoZjQ0m6VJV0Ua3X5E/53M8eM9uehLe+PSxs+bTUf8qzQfeprnubRasvJh5Kz5L7c4H6bQSPaULPkr+7I8SDPUOYDvWN6+ZKNVT+LKlXgItr9PZshuAig9upWztDTx27x66u4J89qqLoPkRAr4mwMaClZdi95THb6gzxVh1E8nODlK5+S6T3LEEfC3U7Lyf+Udcjc8/vEGRY0me2M8DsdnAbosSjgw8jlQobKd49loikQjVO/7EjHknUDTv1GF3KRvJ2CXpfjYYdhAMmxPBUJPIAE4nhBLGUfc4O2k58DcK55yMP8V6JyZ5anc9zoKVlw6YqPMHvcxbfjG1u/5EV2slAEVzjqZ4wRkj6qrndfdQ/eEfiUYjLFx1VTzJk/wduD0O5i+MxJM7MWF/C9V77iXgazXrFfKxd9OtLFl/IwHbjAFjKrZtujr85GZ3WMkdM+/qHfezcNVlOLKW9EnypDp35Fn1TEzYj4eBWqKOZV+nWHInlhys3LyBxWtv4HNfPpHWpu74+WOgfcTtCVJT+WrfikYjNFS9ypzlFxOOZN4YRkIIIYQQA/G4HKMyoPJYmdIJnuHcQCWLXejn5nnI8nQTDrtobgun9WatxGbqseROrdX1oWLTLfEkT0eH77DkS3VlO063g09feaTpVnT/Zq7/2lEEO96k+cDbvdPt+FOfJE92/jzyZvVN7kxXyUmt+gON5Lh2xpM7AJGwn31bN3LD177G3l0+Hrx7G1/8u6s4sPtuZpadicO7ZFSSO6M97tFYdXPzBdwsXHk5FZtvJRI2iUWHK5t56jP4A25GckeZzqjwdjs4ovWEA91Wl6CBb6YdDjeuHMWyY75M1J4/oiTESMYuGcln003WeV3ddLbsJLtwDcGwi57Oeuu16W0E/R2Ulp0zYJJnwRFXpTXukS8hyePOKh7xa7tjyZ2ejloA9m+/u0+SB3q/A5sNHM4wTndunwSPzWYnmvyqqmiUaDRihjEbILRi2yY3D1pqXkwa7DpK3e4nWXrUl+kOew77jMttunfmFXjpiL3BrqUHbOPX8jFVa6LTPrkCp9sx6Jsahys5uQMQ9LdRuWUDi9fdAPRuu4Hi3BfwMH/FJVTvuI+e9moAcgoWM3f5Z/CNIKaEEEIIIURqUzrBMxrsTjv5RVm4bM3sefcWCmcdiSv7eCD9N2s5HVGCXTqe3AGsrge3sPToL9PB4U27XnpmJ0C8WxFAVpaDnuauw6YNB7sJhpzMWf5ZsrKzaG07/G5nPN6skgkSEynJT+FnzyuldOEsetorCPrbrE/YWLDi0wTDHgqKbYSCYTq6PJStu4FA0D2s5E6qZM5Ej3uUrmgUgrYSytfdSMXmW7HZnSYRGS5MK0HjdkYJhIbXwiGW3ImNSWXGfRn8jXChsJ2wrZRoOIrNZloAjXRQ7JG0kBrqZ9NJ1nld3VRtuwN/dwMzF/dQNHMNu9+7LR7HrfVbAAZM8gxlUGtf0Mvc5Z8lin2EyZ0ANTvviyd3wAwaX/3hvX0STonfgS8Ii1ZfE19fh9OL0zuLxetusBJa7dgdHsrX32B190sv6RiJuClZ+Ami0QCdzbuA3sGuGxvBmxU5LDGS/EZEGL+Wj7HEVX+tiRLfUjWU7seJ83c5wwSCh59/olFrgsM+Y8qystMfKN8XyGLBysuo3nEfdpuTeepifMHMPQYKIYQQQkxm0yLBM5KbNbvdhsvWTMWmWwiHfDTV/pW8khAnn74s7YvqcMSGN3c+TncuoUBnvDx/xgoiURfZOc5Bky9X33QCNoeTecs+CfS+MWju0nPJKlxHMOwkFHaS784FDh+PJRPerDIaEscSSvWkOjmRkrh+eYVeQlEvi9ddT+XmjQT97SxafTmOrCWEEpIS0Sj0+If/vUyWZE5/4kme9Tdis7vSTu54XT00H3iT4rkn4Qukt95OZwhbNEI46k5I7piBh3sH9y3DbgthI0wglHq+0WgUm82G29FKKNCOwzl/wC5eDjvY7cF+W7rF9pdIKEJnm29IrSJGu3VVYnIHoLNpFx5vfkKS0mhv0swqOx1GME5OIn9w5OPMBEJuZi8+i8rNtxONhk2hzc6ssjNpa43ich+eVAHwBbNZtPoaanc9yNxlFxII5wGweN0NVG27m7LVl+ILFQ9pLCe7006YbOYsvZCDex6lp/MAi9Zczx9+vg1fTzDl/pqT6+HKLxyP3W6jrWX8EuMelx9btJtApBBStEQdafdjmw08jnYa9r9C6cKzDku4RKNRQtYxoGLTrUTCftzeQsrWXo8/lIvdyZBi3BfIYsGKywCbJHeEEEIIIcZQZg0sMkZiN1zDabbudXXHkzsxHY3vsGhhHavWzUxrHtEoBML5LF53I053LgBFs46kZNHZ+IPu3i4EBd74RXos+WJ32rE77RQWuwl2a/Tbv2TOkjPIL1nVJ7kzFBP1mt/REEue3HXzW/FED/S+QjhxnIrONh+dbb74212yc9xEo+AP5bF43Q2Urb0aZ/Zi7OF6vC7/iL6XWCKgs83X27IraqO9uYfOVt9h9YqEMnt00WgUgtFSAuGClMmdxPWNhCJ4XT3U6AdorH6Dmp3343X7Usy1L5czRHfTe7QdfBWvy0/9vpfiyR2rFhzY+wwep4+O+reor3wSj8ufcl6x5E7lplup3HIH0eB+HPbUd/8OOxCspv3ga7idgZTTxMTiLTHWRovH5cfhGDhD4XRAV+uueHIHoLu9mvbGXSxYcWG8zO7wUH7kjfjD+SOqk9MRJsfbY76jURCJQMQxj8XrrsVmc4DNTtnqa3joj4fY+Ku/Dvi9+oLZzFNXEAjnEzXj8+IP5VG29gZyChbGkzs2G2R5/GmPjeMPepm95ELK1t5I9T7ibzJLtW863Hbyi7PILUx9bB4tiXX3uPw0VD3L7nd/iz1Uhy0aiR/Hrv/6SfFkY6rzRTr1iiV3KjZvoOXgJup2PYTXdfj+GolECWGSPN7cWfHkznAHSPcFsyS5I4QQQggxxqZFC57BeN0BgmFXyq4gwbCL0oUf42DFs/EypzsPnEtZviqboz5SDgz+1DQxydN68F0K53w0ZVeKVEkGpyNCoHMHNTsfAmD3u79l2dE3EYrmEgwdvgkHa+Uy3q8pHw9DeWOauVHMxenNIdS9l6pt95I/QzF7yQUpX5k8nOUDHDrQPmHdO0bDQK12Yutrs8FXv3MsNfpButuqzN/aqsygzCsu7bclj8sZoqvpvT771bzl51O986H44L6erBksXnstzQfepb7q5fh0s8rPwx/sHS8lMbkTGxx639a7KFtzNQ7Xwj4teWLJncqtd0A0QjQaoXDOKQRCbtzOIA57EF8we1Te8jUQr9tH3e5HmDH3eBzexf12QwuFwVuwipllndTve8msr91JyfyPkls4j2jURt2epyk/8kZC0ZIhvVEqmdMRxt++nYrdj7N4zees727Ys4uLRADHPBavvZZIJEpDYz4H6/aaP1pJ0JxcDw53ipY8gb7HN9O6zk1uvvm+bDZwO9qp3HQ7C1ZeAvY5aX0HTU1w9+/e67OdK3fXsbAsF8fcOcyYESEQchEK93ZfSjcB7HaZlmHpxpDX1UOg5yBOz0Ic9hANVc/SemiTqdOW21m0+hqee+wgZ12wmsVLS/u8MS9Wp5xcN1nuLiJRV8rzSkxicicUMPPpbN1L3a6HrHFx+u6vZvymEhatvg5fwD3m+4UQQgghhBiZadGCZyBedw81O++FYG3Kp+nBkJOcGUczu/xswBqzYfX1/OmuivgT03Sf5saSPPmzP9bvRXhyayOHA8I9e+PJHYBIOMju927GYetOOY/EVi493aPf8gAOb8Ex1mLLSxz3aCStYez2aDy5A1Ham3ZycO9jePtpITIcoUCYsy5YxZVfOJ7zL10HmDfODHSTGFvPTG3hk7wdcvO8RELtdLft7zNdd9t+wsHWlK0qnI7gYcmdxpo3aax5k/krPkNO4WI8WTMoW3sNzQff75PcaW/8kEMVT+B29rY4cLuCHKp8rs+bv4hGqNn5EB53b/w77GAL7Y8nd2LLbT3wKlkeH611r1C5+VY8zk6i4b7rmdgibKTbxuv2UbfrYTqbd1O17R4ivsoBW/IEQy7ySo9nZtlpZkykdTcQts/G6crCnXcEy4/9xqgld2p3PQrRCJVb74Tg/lFtydPZU8IDd9XxwO3vx8sPHWjnnj/8ja7Ooe938eTO5g0EfK1UbN6II3IgrZY82TlurvrSCfH9cs1RpRx7XA8F2e9TVNDOrnd/hb9tK05HOP6ZdFqCelx+mqqfw2VrTDWEzWG8rh72f3g3+7beBaE6Ohreiyd3AKLRMFXb7uCCS5fQ1txDTVVzn/izO+3kFXrJ8nax94M/0LDvaTyu/o/5NhsE/C19ugoD9HTWAak/F4lE6fFLckcIIYQQIhAODvj7cFVU7OGSSy7goYfuH/G8pnULHq+7J/52j8ott7N47bU4XPMOe5oeS/LMc3rJKVhMjz+XS647ZlhdeaJRCIYOH9SyP+EweHPm4s4qItDTEi/Pm7GCKJ4+0yZ3U/JmuSgs9BONhvD7s1M+IR+uxBYr49EaZbDXvGfnmO4LjYc60xqTwuvyseNdk9yJaW/aSXbBQrJnnNDnVdTpKCy083ffO5aWFictjeYVwnkFHkpm5eB0ObE7TEwNNu7RYOP32O22Ed3Ij1Tyduho9/HYAwc47exLaKp6APN92ihbczVd3UU4XeEhdWUJhZ3MW34x2CIEw148WTMOm8aTXYrfFyGKudH1B5zMLv8UoWBXPNHkcGWzeN0N1lhK5vtyOX20t1THkzsx7qxCmmpepbHWrNe+LRtZsOo6Nm7cRMBvbvCHM4htKh6Xldxp2WOVRKnadg+LVl+B3bOYSD+DeseSPMWzj8IXzInHQCjssFqZDD8m7HYbEX+VSe7EWEmeZcd8hUi0aFRu7kOhKA2HUielE6X7xrlYcifWEiUaCVGxeSPl624gapuV1pu1wCR31q7toLnub8xb9kn2bNpIJOSjdvfjzFsGnoI1fVry9Mfj8lNf+RRtDdtoq99K+fobCVLSbz1iyR1f5wEAKjffybKjv0Bb44f0dNTFpyuc+wlee7GGHVuagL7xZ7OBx9lBxaZbCQU60hhsGxzuhSxafQVV2/4IRHE4syhffyOBcAFj+t51IYQQQohJrKG7kVu33c3qkpWcV342T1Q8y7bGHdy4+ipKs0uGPd+enh5+/vP/4eijjxuVek7bFjyJyR3A3NBsuZ2ovwZb8ut4MUked/5a/OF8bI7hj+kzHL5gDmVrrsedVQRAwcw1zCw7p083FTA33xt/9QaP378Zb5aLz15VRtXWDdTu/CMez+A3VukY7ZY0iVwDpBtjXRFiT9yhb2sYu9PO/EXFaY9J4Qt6WHDEJX3K8oqXkV+yfsjJHZczRHfrJio3/4HiYj9FJdk4nHYWlbtw2ytweyIDdu9INX5Pqu/U4wrgjB7E6Zi41j2ptsNRJyzGlVVG2ZqrsdkclK25Gl9wDht+mXqMlVDYRXZCqziAGfM+QuGcUwiG3PiCXnyBbEJhO64cxYKVF8enK1nwMXbq2fzup2/3mbcvmMV8dSnZBQtxuLL7vPkrEopgC/fQVPMqgZ5WZi48Jf65WWWnEfJ30ljTm7QK+Fqp3n4bN33zqMNaXo3O2FXDu4kOhlx0+7NHPcEXiURxZ80hK39Bn/KimevAljNqLTcSY+e0T67grAtW4bL2zXYr/jvbfHR3pjfukc3mxOHsOxC03e7C7vAA6Y3H4/VGWbe2g9aDL7Bw5YXs3/kokYTx1mp3P06wa9egYyV53b54cgcgEg5QsenWflvyuJxRWg+9E0/ugGmts+f9DZStvpys3LkAFM07l/fedceTO6mWG0vuxLTWb6G55iVcztQHsnDYht1bzqLVV+BwZlG29gb8wcJRjatMb4kohBBCCDEUgXCQW7fdTU1nHc9XvcJvN23g+apXqOms49Ztd4+oJY/L5eKnP/0lJSXDTxIlmr4teKIc9iQfoLPdh90bxJvtOexvg72ueSAjbXkRS/K0HPgbhXNOOiy5A8RbsbQ0dpOT00nHwfsJBToJBTqp23UvC4+4Ct8I34wzWEua4bds8NNe/zYFs47BFzi8jum+BSx2E5mV5aazzRcvS07yhMN2nNnLWHDEpVR/eD95xcuYs/SiIQ8CasaSeZ+DFX8GoGLTBsqP/AJf/fZRVH94F/7uBuYuOw9vwZp+x/dJ5zv1uAI07Hua1votLDjiElzZywmFxz8/2992cGd5sNkXoU74R1pbbHS0+5i/KL9PIjBxO4RCTrJnHM2saJTujlZyZnyEQOjwxEnADxHbYuavuJiejkPgWs+OrTsBaLW6rLjcDuxOezzJA0H8od7BoR0OPy21r9De8A4AxXOOZubCU+hsraRg1jFEQp001r5FJNybUCieewJRm4eCYkd8HUejlZo/6GXuss9Qt/shOlv2AjbTesdbnvL4YrOZgd7DEWfK7ydRui1fUolGbSw64lKqPryfnvbqPoPAD7QsSL1/JfK4w/gDjr6vQvf1ff34E/dv5rRPrsDpduDxmO88VezEluvvDuJye1m0+nNUbbsTf3e91RLl8wQiRWm/Ot3tduMsLqXlQJSutmryi5fSWr8t/neXp4CsvPn4Q/0f+52OMIQ76emo6fsdhQP4uxtwZhcTjvb9foIhGwWzjsff3RhPCtlsDsrWfo6eQA4LVl6Br/sAoeg8lq3sYceWJs6/dB0ls3JxuR0J83Exe/GZ1OiH42UOZxbFc48nGHHRXzIxHLYRCM2naOF1bPy15qKrjhzVVpiT/U2CQgghhBCJ3A4Xq0tWcqDrEOFomO3NGgCHzcHqkpW4HanfzJsOp9OJ0zl6aZlp24LHF8xiwRFXkJU3zxTY7CxceTXPPdVO06HuUR1fxmEHR6QOr6tn8IkHrHMO+bNPTZncAeKtWMqWeOg89GCfcRZ8nQeo2/UQHtfI+gkO1pJmODwuP/X7nubQvpep3n4PXnf/31Ns+f0tL3YT2dOT+m1biWJJniXrbxxWcsfpiNDTuiWe3AHIL15CNNwZT+4A1O1+Al/bVpyO1E/UE9cp1Vg9ickdgOoPHyDYvWvYLXkc9mha44MMVThio/4QPPfYh3hddZx2lpfN7+zr961nrU0hgqykqqac2v3+lPtcd1eAW37+Fk0ts/nww1m8/1Y1F185i9M+uZAn7t/Mxl+9cVhLHl8wP95yp7vTj9cToKPpg/g0zQfeIxTsYv7ycwmGvQSj5k1BdoeJp9nlnyBnxlEEQ85RebNa8jHEZyV5couXDZrcMd1v/kBTzQu4HQOPU5PqjV8Oe2TQbe1x+TlY8RhNde+y6IhLmVN+1oDJncRlDdbSxuvq4tDeh/G6elsQZue4mV9WyJVfOJ7zEuJ9zoICnntsO088YOL88fs3H7aM2HJj2928Tv1z5BQs6je5M1BrkojNgSOrnLI1V3Kw8mW8OTMpnLUWMMmdxeuuxx/K67cVU2zsoj0fbGDu0rNxewvjf1uw4rO4chThfrrd+YMeZi4+l4LS1dhsDhavu46IYy6RCPhC2di9S3F6+r4pa/6i4j7JtFDYgTtvJfPVpwHi3a2C0eJ+HyjEvo+Gg93ccfM2Ojv8o9IKM92WiIPxunwjPlcKIYQQQoy288rPZkXR0j5lK4qWcl5Cr4RMMH1b8AC+gEny1Hx4H9kzPsqjDzRyoLZj1MbbAOutPaFq9m65A09WCYtWXxNvRTOcJ+7B0ODTtTTbKJjzKZqq7iMaNWOIOJxZeAo/TktLhOzcYa9O2i1p0hVL7rTVbwXMYJ/V2+9hwaor027JMxLhsJ3o/2fvvePjuOv8/+fU3ZW06sVqVnGRS+SS3iEJJEBID+lOsZ3Q23GUK9zxO9qFO477clw4QipJgFBCQgiBAEkgCaTHPa6SLdmymtW1Zervj9WsdqXd1a60kmVnno9HwJrd6Z+Znfdr3u/XW6pG1xMHQ4pkIEs6wQTbYtkSuQUNSLIP0whSVLGKvOIlDHbviGtrDXB439M0nbYMI0FL+1THVJYFAgObo+KOQ/uOn7Hs9M9hmLkZ7a8k2VihVhQ1D0Msj3Q4IvOx6Agfzr8d8vNVPnhlAW3bHwHgfZdcj8EKNM2O+97krKVxz5HYay66Hltg8YoF5Kj7OLznMUqL17DhU+/GxheX0eBgGRbBUQ3MXtq2/46Fy6+k7e3HsK2IyKb6yjCFYswxzU0fawcdGDyAr2h1tDvdTMZbqiyGkO6lcvGVGJaaUNyxTQtFHqZ18/3o4SH6D78OQEnNe6bM5HGQJRN9dA+enNKkXjAeJUznvscZPrKL4SORNxHFVWcSDCf+aXDGycQSTZicyeNVRjmw9UHCwV7Cgd6xe18OoizikUU8PiXOmyoViiolLA0FsHK9VC+7gbCuJszcmSqbxDQFJE8D9c03MnRkNxX1F6F6iyisODG1uCOaaMM7ot5FbW8/zsLll9Ox9/dUNFyAkrtsUpbdxOvMEXkq6s9Ds4qi1yMQFWimEhkdkad2+Yfw5i5IKe4A6LrGrx5+i5HhccHQ0EyOdI+i1Eh4Msz+imZz2fDQ/80suzNiQP5LLEunpunaGWecuri4uLi4uLhkiydbfs/OqI9mhJ39e3my5ffzSuR5x2bwOIQ0H9XLb0DyLuSUsyMtz7Plt+GIO61bIl17woFuDmx7MPp2MtEb92ygehQEuYa65lsRBAlJ9lG7cj2CUorXO/30sWwjCCDYAYZ6dsRND450oAU6EUVhyuwDYcIXpuMRlCwYUqSIt87+LffhVUYnfW5ZNrpdTOOajRRXnozqK6Jtx88RJZnC8ubxbRzrfBTSclLvTAIMwyanaAX5Jcviplc3XYFmZCY8RMSdFg5se4R9m+5FtrsRx+4AmY5FR/iI7/hmg3lgTNyxAZuDO3+CKh5EVePP08RMsEuvXc1HPn8mN38s/ppz1uPLsZGsXXS1/haA0b5NhAdfoGKBnNhjKaSTlzvCwKGfEBzpoLP1WRYuvxJBlCmpeS+yrzkq4sCY+bldirdwTdz06TBxDCbrwBXWPUnLPn3eEG3bI+KOQ//h1xk4/AKyOJ6FlyxrQg+H0Ed20f72z5J6wXiUUFTccehpe56+jpdQ5MTjwBknsSK4k2kTO3ZixR2AcKBn7N4X7wUWK14kGhPOfVgPmynXG9KUpJk76XRCM00BwdNAUfX5BDUf/vJzUoo7ABYSqq8EQYgIjJYZjog8K67Gl784YQlloussrHsIm/HiTizpdO8yTAk5d1lKcUcUBSTRwiMe5MobasnzRzJBK6v91DUEKC0No2tmwnlT4eyT4pFSZiJOhSPujPTvIzDYxsFdj7qZPC4uLi4uLi7zAs3U2db7NqZtIgkSK4ubkAQJ0zbZ1vt21rppZYPjLoNHEMA0Mmu5G9Y9eHxQUBx5MM6W34ZHDbN708NxXj/hQDc9bX/EX35hXOABU3tZpIukivhUD4jV1K+6jaFBm5FAHjl5iUu7pkOyDI5MsG3QrCIaVt0aMbgeyzaqWX41krcOyzJR5WFMOwfdmCxMeZVRLDOIIZRGg6NseQQ54s7hvRFB4cDWB6hrvpWQHp8xY1k2ulhMRf257H7tLgA6W59jQcN5FJY3M9j7NovWrMcQFqTlwZTobX1Y81Cx+DIg0umruukKPP4VaXX2cRgXdyKdc2xLZ9+me2lYtZ7RQFFWxqIsanQeeplY3w9/yRI8OXkMdg4iqfnR4x+XGSNAXYPKYNezlNScS0iPX68gQI4vyKHDz8RN7+98g/ySxQhqE8MT/JZyfDYDnS9hGpH9CQd66Wx9lsVr1yPK+YwGJl8Ltk1GxzQZE8dgJhmBUY8ZBXKLT2Pg8B+in4myF1teyvCQjS8v8boA3t7STkGexeGDv44sc8zwt37VBoZH8vF4lYifjS2R46+JE3gAfHmVWPb0fxoEQcAyA2jhgbjpWqgfywwgCLlRMWZihlTsv2Pvw46fViZkeh5MU8Akct2lkylpWYBURcPq22jdfD+2bVJQugJBLiGkTe5wGJv5lMybaiZExMLE9xiPEgZzCC00QNuOnyLJHm756HqefryDc87LoW3Hj5BlH3XNGzDwTelhFOvB5OxLb+cIBcW+uHtXur+lHlXj8J5fjflSRYiIPD+jetl1hLXs/Xa5uLi4uLi4uGSKKilsPOGmpF20ZuLBs3Pn23zve9+hs/Mwsizz3HN/4hvf+A/y8wumtTwhXTPKbNHTMzxrKxQEUIRewiOHUP0r0ROUw6RiZDCUVWNIUQTJOkzLpvui4oXPX4vtuZDHfrIXe0LAn431lpX56ekZ76iCZRMIaHjHgrr5iCiCaByidcsDVC+7ktz8WmzbJDTaTdv2n1K28F34y07HsMYDBydDQAsP0rhmA6ZQTkmJn67Dg9FAygnonJbp6QZSsmQSGtxMx57fxE33+EqoW3UbYT0HSbTi3tBLkogs9NLy1j2YY1146k64Hl9uBSGjICsdajxqGDPcA3JlVIgQBMj32wwOpU518nnC7N98D+FgfDee3MImjgyfxp9+uz9u+nTHolcJ0bEn0gbcX7KU/OLFHNrzW4qq3w9yE4Kkxp0Hy7BQ5SDdrb9iZKAFT045dSfcTEiPz3aSBIPQ0BYO7x0/J0ULTqK26WIOtoeigfz6T5+FrpkM9gUxjWF84ksEh/YAIKt5NKzeiGbmZ60zVCJig/lfP7o5Ov5g6mDeuQed//5llFd5yJH30rX/aUTZy8IVtzEaLMDjjWQtlZWNj3cgur6Pf+FkOnbdjxbqj1t2XskqDnWeQENTTfTcKrLOSM+rdO3/EwALV1yHlLMYM4mB98R9g8TXlygKSHYnLZvuxbaMSBbbmo2YQsWU10KicsF015voWCYim+a/ogii2cFA11uU1L4noUdatrZl0v09DTxKmMHu11BUH4d2/xZHBMotqKe87l20bn0o+hJCVnKpW7UBTS9AkJLfU6baHyCj31JJtEFvp3Xrj2JeiMQbkE9n39OhrMyftiPZbD6/OMzWfh4LuPv+ztv3d+p+g7vv7r6/szie9lsz9TgxZ+LfE5nNfU/2DHPcZPA44k7LpnuwTI2qxQa+wtUZiTwzMVRNhGUBYiWNa9bTsuk+vP4qqhZfw//c+fokcWfWEIWsZu7MBpYFyNUsO/3vsCyTrv1/JLdgIYd2PwXY9LQ9D0B+xRnohjKp/KNl0700rtmAbedmxSPIsiU8udUIooJtjafb5RYtxkZBlQYZHdiHr6AZ3Yxc0KZpYYslNK7ZSMumeygoX4XqqyOgqUy3LfZEwpoHUarFMiPLEwRQ6GHvm09Qu+KGlCVgwbCHulW3sn/LA2hjIk9u0WJC1ln86em9SefLlIiB8JX0d76M4snj0J5IBlT/oacpqoY3XvFx0pmLxz12fBoduyPiDjBWxvijSSKPacv4ilZTtUSgY8+TFFWeREn1e+jq1OOyIUaHNR6977Xo3xdfdRZ5RQKh0Q7qV22YdXEHJmelTCcj8NmnI53CVp1UximnXYJuljI8mk9ufvy9KdF4Hx6RqV91G/u3jIs8+SUrGAis5cVnWykuKwEi9zsdhbyyUwHw5JSlFHeSrS/R/lmWDeICGtdsYP+WH1G/6hZ0s4yR4eCUIleidUznunbu58mEtmzhZPIU15QR1hP/wM/VtkzE8Tgrrmjm4O7fEHsvKq87m/adj8VlmBr6KF0tv6O07nIspj62wKR9cvYnk99S0xKQlFoamm8eE3nslAbkLi4uLi4uLi5Hg4lizkwyd2aL40LgmSjuAHTsfYqqxaQUeSa2Ls+2gS+MizyLTvwwopxLIODhpg+fBiR/MH4nYlkRkaRtx4+pXvJ+9r31ALHBSE/b8/jyKvDlL+bwnqei4g6Abens3/ojlp/+GZwhPZMSMsuCYKCIkoU3cKTtx9iWTnHVaZTUng9WgNbN92BooyxoCJNbcjK6qUT8PkY18vxFLD7p41iWQjhNM9y0t2tsHQB5fg+K1EvL5nuwTJ0DWx+krvmWlCJPSMulfkzkUb1FVC6+kiNHYN1HStMei6ocAgQ0I7loqJk+CkqXsffNu+Om9x96mvMvvA1L9GITuW5tK8DoUFvc98KBHoxwH6KcG3d9GoaEt3AVi9ZUIKil9PVaPPT9l+Lm7Tk8zIWXrcTjkXjyZ1t46pctfPjvPoDXJxDW8hBmXoE1q0wUAuoXV4Hs5VcPb+byG8rSmteXoxLSvVGRR/ZUMBA4hacfbwUmlyzqhkJu6anYSCnFnUTrcv6dCMuysaxyFp34SfoHREw9zEP/N7MMSWe9iiIlNNeOJRtCW7pYFmhW8h/4udwWh4hB+9sMdm9lpG8Ptcsu5+DupzC0yFuk/s7NNK6+lX2b7sXUI95IPn81FQ2XENZVxBRPB+kIbpnuX6zIY1m6K+64uLi4uLi4uEyD+VmzkyGyZDDQvTkq7jj0HnwJWUpseORVA4hGO9I0W01PRJU1fOpI1LQ2FssC3S4jpPnizGlj299OZaJ5vONVDTp2P0ZopJPB7u2UVp8S93le0VIkTy2jowILFl2M6iuJfiaICvXN61C943WKiUyApyLWsLave5Rf/6KTupW3UlJzFsVV58WJOwCdrX9gtO8NFEmP+n2MDIcJarlZF3dg3FPkiZ9sQhZ6ouIOjJnYbn0QrxpIuYyIyHMbVUuvJGx4MxqLHiVMb9sz9B16HlVJbsZsWTaCXExhxZq46fmlK5G95dhjMVvE2LiExtXrEaLRpEB9803YSnXCUh7DkDClarQkLbyffXonzzyxnfzC8e47gaCKZvpTlpzMBtPJCHTGbez5kFUPl9+4hpy81MuZaMYb0vOoX7WeioYPonjyo99LZHxrmEra4k7suqa6vkaGw2x+fYCOtkEG+iJjM5XZcbrrndguPBXZzsw8VjAMm5zC5RSUN2MaIdp3Pk7N0ouRVT85BYspqr6IsFlM45rbkZQcPLlVVC25Dn0sE3KuURUb0xJAqUXwNLjijouLi4uLi4vLNDguMnh0Q6ZwwTlYpk5fx6sAqN5C6letT9hm1asGIiU+gV7qm29C8tRlFNxMRJU1+juep+/wGzSu2QAx7acdTN2c5CtxrAQeggA+j0ZI82TFSyYRYV2maukVtG6+l95Dr1JafSql1afSe+hVcgoWEzDO5Ht3vsq6j5yOKOdS33wr+7c+gB4eonHNekyhAkGYWVCSyLD2x/e3sWhpNScX2+jD26LijkNP+4sUlK8G5i4YEQSwbWuSEaptm6RTf5Qoy2eqsehRwvQc+D0DXZui04przkPT1YSeKWFdpazufWDDQPcmcgqWUVLz/kn+JJFSnkoaV6+nZfP91C6/FuSFKYO72PbR6z91Fr1dI5N8WXy+mZuAz5SZZATGno+ZLCek54IABcXj18ZcZI/EeubIqsQzT2yPfpau6XSske9MjIhnIzNzukx1nSW6lhTZwLSUad17w7qH8voPgA2DPVsxDJO65vW07h6krTVMQbFIrj+fRWvuwDQlwrovZeZOuvukyGFATGiOnwivEqTv8F8prjxz7DfbFXdcXFxcXFxcXKbDcSHwAGiGSnH1+QCM9O2hftVthI28SfHuuLjTA8D+rQ/PSORxxJ0jhyLCQMume1m0ZgPGBJHHEQ9iA5r5FHgkI+rz8sbD1DffjCGWTlvkSRS8ONg2hI08GlZvoHXzvfR1vkXjmo8geWro6clHkPys+8h4EBHSIyKPZQYxKJ0kqE2HRL4S57xnKSUVOSjiEUJGmJLqUzhyKOLxIik5NKzaSG+3wMAsdseZ1IGnP0RYy6Nh1Xpat9yHbRmovmLqm2+b1OUrXRKNRWe9RUXQc+CZOHGnr+MVAIqqz6N/0EpoqBrWVUoXXkRuwULU3KXopjdh8GhZNoHRYhYs+Qi/+VUr735fFXkFU9dSibJITWUBuj7e2jlWvMhT5/e1lYpj4d6Qilix9Pz3L+PCy1ZiaCbPPr2TS65ZRWFJRGRMJb7FLiObpsjTQRQFvEoA3VDRYzqtpbqnJVxOzHlNNO/E3wlV1hjsfIn80hUgLpjWtod1D0XVF5FTuJbn/zjM7h1vxf0urvvo6QgF+WPbl/nyJ47VyG/in5GUHPxlp00p8niVIAd3/YLAYCuBgXaql11L2Jj8YsbFxcXFxcXFxWVqjquaIEfkWXLyHQnFHVWx6G1/PiruRLBp2/FTvClKTpKhyDYjvW9GxR0g2n5alQIZlx/MNxxxp2XzPRjaMC2b7kGmF1Gc3ttVJ3hx3spPJFbkaVxzO4NDOTz9pMaTv2xJWDoU0nPR7bJpiTtOOVbsOUpUPldSkUOe7witm++np/1FRFGlpOoUJCWHwqrr2bPb5Efff5knx7ISfv3oZh76/ssp9zNTnOPmZD6c/76FDHY9y8jQEA2r1uPNrZiRuDPVekMhG19e5aTPvbkLCI6aca2fJx5TzfTgKVyLKUQC+mRlOYZhcc93N9PeOhSdFlsyl+pacoS5ucqGSzR25jtzfYyc9V167epo2VxZpR+AwuKclOVdzvGNFUsTja25QhQFFOEIe17/H4IDm1CkcUEx0T0t1fiQJROfGko6byyqrDHQ8Wd62l+gZfO9SFYntj29/TdML4ZQxannLuGSa1YDiUv1ZkrsC4/u/c8y3PMKipy4TBoi4s6hMXEHIDDcxqGdj+JVgknncXFxcXFxcXFxSc5xk8HjoBkqBUV+hkcntyPTdJHSmvMJB44wOhB5oBREmYZV6wlqPjLtdqQbArnFK1EPv4EWGm8/XVB+Ls/97gAnnrkYPaaFcez/Zyu7Y7YQBCHGuDrygG6ZYVo23cOitbejCcWz0o3IEXnAj8dr8p5LVgDJ3/RPLFNKl9g35Tm5atLyueIii12v3B9tc9/T/hJltWfRuPoW+gdyWVCtcOMdpzE0GOLJLHbHiX27H2u8OzLYT2nRNkb7NjHat4mc5nUsPnEDQyPZuZRjy2Kcsdp5KERl9QlULoLD+54GoGrJZbz4F4m3t7wSnXeiea+DYUTOUaIstonZSQDYAkN9QQRB4OEfTJ3BMdfZLpIYQhZGCYXy0+5QJ0sRf5GZXDOZZovEMtfHKNH6ZGebp9CHE5VKjgyFCYUMauoL8czSfTPR8XXEnZZN92AaoRjz/jVxmTyJtn/imJUlk/DQdg62/4X65tsYHXP8VlSJkcGI6ONcB4qk0XfoZfo6IsfBtgxaNt/LkhNvRxTLM86iFGURnxx/P8p2qZ4ih+nv+HPcC4/u/c8C4C89LdpxMLpNooBlDDM6dCBuemC4HUMbANsL03yZ4OLi4uLi4uJyLHHXXf+PzZs3YZom69bdyrvedf60lzV/FYZZIqR7qV76IXILGxBEmcbVGzDFBdMuOxoYUPAUX4HqjZj+Fi64gO07itn0WhfhoBHN5vj1hAyPbGV3zBa2bSNKHiQlPitEVnMQRE9GgerEN/JTmaza9tj6p2GUPK1tGQpHzsnI+Dlx1q0ZHmqaLo9bxnBfC4fadSxLxONTyC/2UTjBpHg65s6WYeFRwsiSFfd239mW6jpPVNxx2L/1IUYGWpHE7GQ2OOudOGZ/8F+vIHlPoHLR+6luuhyUJt7e0pt6YRmsL9aXxbQserpGGOgLUDGW9XE0MzgcLMNCsAIMdj7HkQMPkJczQmAkPOV2KbJBaHATqjSIMIN4daqMj/mOxyenlTESm/3jUFbp55kntqOHzRRzJkaWLFQ5POX3nOOr62b0/uSRR6LijkPH3qcIDe1AD2kps9fityEi7hza/ThasI/9W+/HnxdGUSVGhydfcyNDI4z074tbhm0ZjA62IQrJM2KOKraAKE0WPEVRJZGqZ1k2w4ECShdeA1H/NIGSug/xq592MjI89TlzcXFxcXFxcZkrbMtC6+yM+8/Ogk/Im2++TkvLPn7wg/v59re/y//7f9+e0fKOuwyedHBEHtsKoNslMzIO9uWoQDElS29iZLAFW1xE88kqzSc3xBm9Host0cPGuM+LHhpA9RVR37w+41KgiW/k0zVZnQ0SbcuFl60ESNy1yRRR8pZTu+wq2nf+Em9uJQtX3khvrxh3DmdimB0Y1Xjo/17mk186lcN7HqewfBVe7+JJ31MVAZHJpQumNorisUhXr51uJkggKFBYvBYbAT0spD22J3kIxWTrONeII7TJqoSpmzzzxHZOO7uSD1zm43BnadLsoLlEEkP0tv8xKrC1b7+PwpobeOyRA1y57sSE26XIBqNH3qCz5ffIai4NqzeimQUZC6SJjl84oKOoUspzOJOsn6nmlSQB00y9I7G+Vooi4fFNbbo7k+yficiShTa8g9HB/ZQsvDBh97WJx3d0WOPR+yI+Wx/7/KkUlDXTd/i16PcVTz6BUAk/f+hVwiEDGM8wKqvIY3hCNk5+gYw2spNDux+PLkML9nFo10NcdeNVdB8e5sLLVkbn/fWjmwlrPupWrOPg2w9FS4oXNL6P0ppT6R/IXOSKZbbM/XVTpaDiTAB62v4MRLY5t+REdCPxo4aiKEAdtctv4uDbj1C88CrCehXnfUA9Jn4jXVxcXFxcXN456N3d7P/nL8VNq//av6MumJ5PosPq1WtZvjwSj+bl+QmFQpimiSRN7UmaiHekwAMRkUcQvNMu8XEQZZHcfC/DQ/D8HwTe9T41LjiZaPQ6Fx1sskXUE2fVejr2PE7Vkium5fMSW2L06yyWMc2E89+/DFmNXDSGFgmYhgaCiJIwKaB1RJ765ptQcyoJaT7yCuKXl8qkOFmAHBtYXvqhxXS1/IrRgX2M9O+lcvEVNJ1QMsG02UPl4sth3+MMH9kFQNWSSyipOoW+gfTf6icrIYmsI7UoaYwZkYsyk+ZNNrbTFfhCIYNnntjO+e9fxk13rEYwNtPd+hf8Bcu4/TPvIxQ+ekGfIlsMdb4alz1lGkEGDv6YD918G4l0jlhxB8DQRmndfE/GIs9MBNJU5zrd9Saa16OECQ3vxZO3BM1Ifk5mWhrmXKdDA5PFLVmWCAaTX1+OuHNw12PRaYlEnonHt/9IIPrvwUGB0poLAOg7/BqKJ5/6VRvo71e55rbi6DVSVumPikIOznm69RNnkO8vR5SUaLkrQE7+Qrq7Q1TXVWFZFrl5HkQpomDlF/nQLS91J9zCgW0PUrTgJHJLTkRWcoDJ5ceZMJvlepqhREUeSfalFHecbfHIHsLBSiqXfYynf7Wf8z6gHjO/kS4uLi4uLi4uM0WSJHy+SGz8m988wRlnnDltcQfewQIPpNVROm18OSrvet+ypAFoum9NIy2ws7ddM8UReaqWXkdIm95wmRhQHE2RyzkPWticFJA9+bMtAAk9YnJyVSSpgd6eMDm5VlrZEFMF187nH7yqAY/wAqPDLdHPDu/9Faee9kH+9mIbe3f1R7dLlL1ULroceBx/8VK8hauQFC+QnbKNRMHfVOdrqrGdjsCXk6tSU1/IjXechizraMOvMdT9EgCBwZ3IikRF4wcJ60enqtQwRQorTqS/600MbSQ6vbzuAkRvHoI4ed9lSaen/YX45WijDPVsI7fsDLQQ086uSUUiH6V0vb/SmdejhOlq/Q1DPdsprjqV4urzU4o80yUnV6WytoBH7p7s8wRw4x2n8cjdryS8vmTRRBt+O07c6e98E4CS2veiGZNLiRwxyRF8wRF9cyiqPh9ZzaWwYi1hw0+OP37eXH9yYdTjVTAoj3YItEydooq1FFRewI8fepUb71gQ3Y+J11JIz6Gu+VZMS0kplMwnNEMhv/wMIm3S09tmXbO57/ubp/6ii4uLi4uLi8txygsvPM9vfvME3/nO/85oOcfGE+MxwFRvRZ3PHb+VRIGWIIAq9SOIXkJa5m1iLcPi4IG+Kcs2MsW2mba4E0u2SwOcYNTnUwkGtbRKVpzzEA7qk8oiEpUYxYo0wLSzIVKheGRUMYdQ3It5AUH0ctJZ1ZxxfhNATNDnYcGiyzFtGcNIT92dTtCf6HwlNKJNc+w7JBKMIm/yRbw5CqoQZM++l+I+H+rdTtGCVUjepVOWBc0Gtg2alU/D6o20br4HQxuhctEH8RWtwjATXxshLYfG1Rtp2XwPph7JCimtORN/2SlohkhgNJTWeEomkCmKhKJOPv+JTIrTLXGbat6SUiEq7gD0dbwKMCsijyiL5OV7ku67riUvVbIFG9syJk23LIOJZvrpir5F5WcTNsQ4Ad6ZV5YkdMy4ayV2nNs2GEJE5OnvfIOSmgsIBiOeRLGbk+hams5vwWyRbsmfbmY2FmIzB93SLBcXFxcXF5d3Gq+88jd+9KP7+Pa3/4e8vLwZLcsVeEj90CqKApJooKcZSE9FsqwOQQBF6GXfm/fgyS2ndvn1GT/Yz6QcYy7IdmmAs7/Om3xI36NFUSQqqvyRcz5WFhEbkEUFEVvgwstWooVNAiMR08+BKYSRVJ4zEzt1bfj0Gci0YVv1iILAQPdWQGDhiuv57RPDnHuRJ+H+hPX0ujc5TCfoT3S+ZjLG0hH4bBtGQjkU11xK38FfR6eXL3w3sq8e3Th66W22DZqZT8OqjQSGDqDmLUsq7kS+b6NZRVGRp6hiDQUV59B3xAJCaQttyQSysjI/PT2Ty3WmKrObLooiYYQ6ouKOQ1/HqxRXnoQglM+o5FWWhWjHNYdE+56Tq6JrJoP9ya8v05TxFDRTvQQO7YmMo4LyVZTXv3/StTNR9PV4pKiwE3vcdCP5uRkZHBfrko1zR+Qprn4PYV0BIqZ8qfYjE2bit5Qus/UbM9dd3lxcXFxcXFxcMkUpL6f+a/8+adpMGRkZ4a67/h///d93kZ9fMPUMU+AKPCR/aBVFAZlehrq2kl9x5ozeUKcK+nP9KqrcN9aSXCM4dJD2t3+Slsgzk3KM+UTsfqRdRjImvgzEeGZMJb44xAYUiQIyZ0xceNlKnnkiPqB9cgphJF3PFMUjINkHObDtp4BN9dIPAgIF5c2g1HPuRXrW3mbPJOjP1hhLN4iTJBVP/jJql3lo3/lzyuvejb/8DHRjaoPedJluMOxk8qj5J2CaUzv+OiLP4hM/hmnJ9B2xpp1dk24G3HTK7CauAyaPE0WVENVqqhZfTMfep6Lz1C67Gksoxp6BWb1H0QgMbCe3cAWhBOJl7L6ne30ZphQVeUYG9ycUd2JxRN/YjJqpjluq+3oibDtSwgTZN59PJb5kcn+dCbIMxuTEKRcXFxcXFxeXYx5BFGdsqJyIP/3pGQYGBvjyl8cNnP/5n/+NBdNclyvwJMERdyKiSxjL1CmseldaIo8qa5iWihnTNS3Vw/xnv3wa+968H8scb38cHDpIV+vTlDdcRliLZA8lekifSTnGbOJRwoBFWE8vCyl2P9ItI5mO+JKIRAFxbNlGpqTjOSOJNlaolQPbfowTUR7a/RsqF12IN6+SYFgiryA7WWMws6B/rseYKIuIshdZWsrSUz6JSV5WxR1IHAynK/rYNmmJO+PftwlqOWN/hVJ+NxVzkeUw1TjRTRFf4WqqFkfahdcuuxolrwnDjB+rmQhoHkWj98Dv6e96C3/JbioXXT5J5JkoyK7/1Fn0do1MadruiDy+wuVTZr3FltGmWy40E5Fmts3nRVFAFQdAUOkdFNK+v07E1CxGx7IXhyZ0CIs9v14lxFDvJvylazPOMHRxcXFxcXFxeady2WVXctllV2Ztee9YgSdVVkKe34MsHomKOwC9h/4GQGHVuzAsFVnS0fTJQadHCdO9/7cULzgJSVkYFXlSPcyHNZWFK6+jdcuDYEdmUL2FVNRfSEgbD5xig4n1nz4LfVSbaCeR1v7OdmaPcwwsI0Tl4isI6em/AYf0vWGcDB5FFnnql1sBuOTa1RRmoQ19pl49ieZ1SCSk2IgonnxESY2OMYDhvhb8JWtntO1TMVttkrONYUqYQtGcmY7PRYmjz6dy4x2nIYoCg/3TL59K128r3XOdSJBJNq9uyvgKV9N06hJ0K3eSuAPpH8tYcQcY6w73eEKRx0GURWoqC9D1iPg6lVAZ2b70xdK5KhfKhvl8st8xSRIpyB9h31v34sktp6T2iqiBf6bZd6Mj4Tija5gs8HqVEId2/5zRgVaCwx2UN1zsijwuLi4uLi4uLkeBd6zAkyorYeNnTscIHIgLvAEGe3dQUnsOttlNb9vLlC28KO4hNra7zGDPdhqab46KPKke5m0AuZaGVbfQuuVBVE8+9avWE9IjBkuJRJDRYY1H73uN9Z86K63Sm0wyZGaCI+4MdkcEF/b+KqXIk252yMQA1PG9eOaJ7dx4x2nReQuz3KFL10yeeWI76z56elSQy7TcJVFwbVk2hlhG45oNtGy6F8sMk1e0mKolVyUNbBPhBPq6bqYdsGUawM6Wp0s6ZFvcSVRSo6gS4aAxKTsBsi+GBoNatGNSpuMplnQFlHTPdaLlpZpXN2V0Mz9uWqalfIIgYJsDUXHHYfjILkprupCUupSG2imvrzkStLORhTMTwTXR/fPZ3+7kyhtqad38E0wjSGDwAJb5GJdd9x6e+OnetLPvnGMoiiIXXrYSICqmxwrpseIOwGDPNgBX5HFxcXFxcXFxOQocdwJPum+2U71Jl2QVT94qFjQadLb8DgDFU0DDmtsxtCFaNt2LbenYphF9iI0VdwCwLVq3/ihO5EmFaYKk1NK4ej2ymh8Vd2D8If789y+LPmj3HI6Yq/Z0DlNYkpO0e4vzkD4yFOYDVyzimSdbs+LRI4oCXjVESPNiaCaBUY3iYoHu/U+PizvAcN8e2PsrFiy+Mu2HfaddcWyHoKNlID0x+MokEJsquI4VeXra/kxFwwczEndgboS7mZR3zTcSldRMLPWbqRdKuhztTKps+3elK9YKAnhUnbCmYAqlLFxxLW07Ho3OU730cgSlGmOKbmmprq+5ErSzkYUzk4yhROLr+k+sYv/W72Ma40JlaKQNf8krnH3+Wl74U1tay050Pp3fn/wCL3kFXiRJQA93R8Udh8Ge7ZQtPGdaxttzYRbt4uLi4uLi4nK8ctwJPOkKAVO9SdcNkdySE1kAHDn0NxrW3I6pj0TFHYh/UwkWRnhCRxvbwtBHkBUTp0QgVVBnmiCIVRh64m2WVWmy50xMG1/Hm2KiMPLLH73JVTfWIWvPcvW69/KLh7ZijPlMpBNYTHwbLqsSktXJntcepL75ZgLhYh76/sts/MwZFJafMCbwjD/UF5SvwrQSe6hMfAMOUFbp59H7XmPdR05HUaSkJqY+X2Re5/+TtY32KGEENMJGfsbBxsTgK9uBoiPylDdcSmhCyZ8oClgzMK6dDY62KDETLMNCUSVuvOM0hgZDPDkm6pYuyJs0LZteKM66MzHjTbWM2PmzLciMDIUJhQzKKvLIy/dktMx0Mr0EATzyMO3bf0btsg8RNvORcpZERZ7qpZfjyV+ZsOwrHaZT8pkNjtZ1kUgcGg3I1C67mv1bH8K5D8uqHzn3DF77a+uMsu8MzYx0GvNFHh1M00ZWqqlddjXtO38x9i2B+uabMIXSaRlvz/dukC4uLi4uLi4u85njRuBJtzV1IpJ6TRgyuSUnUlDWjG560IMHouKOQ2jkMAImIT2HmmXXcnDnowSGIm9Ia5dfjZIbb0A61dvaRPpDuoa/jjdFbOtkURS46sY6Bjt+gqkHUPXHuXrd5fziob0plxVLbCB42yfPxCP30LL5XmzLoGXzfdQ330ZJWQ7hsI23eBF1J1zPgW0/AWxqll2FJS5ioE8jP19BlGwMa3zYJToesnOuhPRNTPPUxG2jPUqYzn2PExhqp3H1RjSraEatnGcDy7IJTxDAPEoYS+9DlCowzKlbscPcBLLHcjvj2LHklPUVFPvw+BQ8PgVREqLTsr2P2eiYlInZ9XTFwVgROdMAe6pML0fcad18L3p4iJbN99C4emNU5Fl2+ufQDO+0xR2Ye0Nwh/lwXTi/E7KiIKh11DevY//Wh5DVPOqa13P3d7YRCuoZl5jGiu95+Z5IRzVl/BwZpoSS1zQm8vyS+uabEDz1GRmRw9S/4S4uLi4uLi4uLlNz3Ag86QZQmb5J1w0ZfewwKblLqV12Fe07fwmAx1dCXfOthPRIh5yQ7ouKPCXVp04Sd6bLRMNfAI9H4smfbUn5NlYQoKgwSMvmiLgDoAV7EYQn+NgX1hHW0jNejQoHeSo53v6ouANgWwb7t97PpVffxOBweGzbalm48vpI9zFxET/8zss0Li3iwvd70YwRfIVr0Cccl5xclfWfPmuSF8pMsisccSdi3Eo0oJyPIk8sHiVMV8uTDPXuoHbFtSg5SyaJPPO1e9p8QpUtNENMKIaJosiNd5yGzzc3gWM2vVpgPENm3UfOwLIssCPXqyiLeJQwptaDKFemvP8kWl5RSU7S78+UWHEHwNBG4kSeQDg3a+sqr8zjiusW8dfnO9j6Vk/WljtXTKdMKVZkMi2Q1DoaVt2C4i0kGMrjQ7eeBKQ/3jIpzXREnuVn/D0h3ZtS3BEE8KkaId0TJ0JO9Rvu4uLi4uLi4uIyNceNwJMuM3mTroUFTHERNcuuoufA82PiTnxQEhF5rsew5KyIO7EoikRFlT/yx9hz8VRvY21Li2u/DmDqASTRmjJwmHiswiGD3h4TxVOEFhwPmhRPIcGgzBM/3YxpRMyGPvz3Z2FaBt0dQRqXFnHWuSLtOyM+G5WLIWeCyCPKIvqoFtetJfbcxGZcpCNeqIpJb9sfouKOs98tm+9hyUmfIBCenwJIrLgD0L7j0YQiT6K363NlfHws4FE0BjpfomjBqRwZkiaJYQ/9X6Qr3rqPnk6eOt5+e7bKbGbLq8WyrOg1s+6jp1NSKkS9wKYqd4pdnqJKXHjZSgIj48byM8kIm3gsIx2cTCwzPgPSsgxs2wAEnJuaIET+PR0NNidX5bZPnYFX7qZ9x12sXn0Ba049EUT1mLouslGmZFoColJH2LARpOmXl8YKgamOoWFKGKYv5bIEARShl71vPkR9880YYum8K0N1cXFxcXFxcUmGZdkMDUSekfMLfYhiZhnLEwmFQnz961+hv7+PcDjMrbdu5KyzzpnRMo8bgSfdN+Spvpfn96DIBrqR+LA4D90bP3s69asWEdQSPzBnapSbLrEBmTXmoZPqgdu2wRArop2abMtAVnJpWL2RsFnAVD3WJx4r07AIhXzUrVjHwbcfJhzoxpNTxoIlN3L3f23i4quao8cyMGLy0P+9EhV3+tp/FV3u4b1PUbUYvIWrMUw56fpiz0267eAddEOitPYchvt2YWij0enVSy8lbCQ+ZqqiIQk6IT3vqGT4KDKM9m2NijsO7Tt+xrLTP4dhjmdXHE/Gx9nEMixkKUT3/mcY7N7CYPc26lfdxs0fO52BI6nFsGyX2ciSiSLpcfeJbIlIPp/KjR8+PfoDA+Dz6nS1PMNQb6TE6tDux6leSlqeNnrYnOTvNZOMsInH0rZBM4toXHM7LZt+iGkEEWUvi9ZsRLdLotebKAooQh+2pWOI5VhTmNNPRFZFVLGX1i0/wrZN+g8/Q+UiBV/R6oSljsc72RBPsnVdOOJOy6Z7sEyNlk330LhmY1TkyUaWm4uLi4uLi4vLbDI0EOQnd78KwPV3nEph8cyy31966S8sW7acG2+8hc7Ow3zmMx93BR6HdN+QJ/ueIIBCD4Od2yhYcBbamAiQyNi0uyNIuNhHTu7UWTCzRboP3ZZlg7iAxjUbaNv+U+pX3YpmFqYlYCRaR36RD93yUnfCzXS1/paKxg9wpFfEMKxJ3bvWffR0ZClM4MgLk5Y93L+X3OKVcQJPqnMYK2ipioluSCnf8EcCygIaVm+kdfM9GNooC1deh5q3GE2bfM5URePIgd8z1LeLxjUb0cy5L+PSDcgtbia/dH+cyFO74kNoRuJz7RhrO23S3+nIUojuA78j0B8xQNdC/ezfcj/1q9YD49kFmYhh0/GzkSWT8NA2Drb/hfrm9dFMv2wFy8GgxiM/GM9KqltUhDa6OyruOBza/ThNpzVgmP6Uy8vJm/2MMNu20ayIyHNg+0PUrbwR3S6JHltH3GnZdA+WZdC4ZgNkKPKo0iB73nwA2x73Kzu87ykWrvQj+ZZiprYxO+pk6kMjiTaqohEMz+925IIgxIk7AJYZjoo8ulCSlSw3FxcXFxcXF5fZwMncGRoIRafF/nu62TwXXHBh9N9dXV2Ul5fPbEM5jgQeh0SdpJJ9zxEMHHGnZfM9WKaObRkUVr0LzVCPC68TR+RZtPajBDVPSuFiYsesZAJWSM+hvPEKQppErt/itk+dgaqOGwU7D+sjg9DVt5yKYpuRvrcA8Jc0Ubno8qSZTomyHJzleZUwPW1/oGzhuwgb/rRFHi3Yi5pby+iRN8krXh5XWueIO/1dke1zgo6jIfKEdQ8VjZcAjHnwXIOSszRp9kEiY+1jAVkWMIzsH1tF1gkN7YqbpoX6CY8eQlbqM16eVw1i6UNj2STp3bQdcefQ7icA2L/lPupXrZ9UzplNDuzr5+CyOoqLmhnt3xqdXrv8anRz6jcLc5UR5og8Das/TDjGgyVW3HHae7dsujctkSf2nqUWeylasJa+w69HP/fmVeHNqyWkJZ5fUWx0fWbptdkiEx8aSbSxtQO07niK+gTlwvMJ27YRZQ+SkhNXMiwrPkTJgx1TuXcsd+pzcXFxcXFxOT6JzdxxeGqsmzXMPJvnIx9ZT3d3F9/61n9PexkOwlwHsD09w7O+wkTdlJIxUdxxKK0+g8KqdxEKyXEZPBNb/6bK4BEEkCUL3ZhZlo9HCWLZMrqRuNV4LOnsu0cJAiJh3YOigB7zcD0yGIoGGI6AlUr0EUUQzQ5sywSlFnNCIOYs790X1VJTuQtDG04p7qTCq4Tp2PsYI317UDz5NKzeECfyJNt3QQBV0RnoeJGe9hfw+Eqpa76FkJ6LIpsMHn6e3oMvxc0jKTksOenjBMKpPSVmC6eLlp2ki1Yszn5HfE6Sf2+qz+cKVdEIDbxNTuGyGZczOvvujNHAcJi83AH62n8cvZ5rmq5A9a9ACwtpiZcOXjVI2/ZHCI120rjqNiy5akqRR5Is9JEdHNz5WNx01VtE/eoNhLTsmBhbhoWumfR2jcRl3NTUeRjq/BP9XW8l7OKXznIzOUYTURULTc/8fudVdQ6+/RCBoYPxy/MV07D6DoLh+GA/9lqfeM8qLhHpO/hH+g6/jjevioUrbySk+ZAkG1UcwrRz0MbupaqiMdT1CoUVJ84LgSQ2gydRmVLFmJjriDtOK3TVWzTrIuJMiXRRG6F1y33ooQFUb+HYNuelNX8mv+uZUFbmT1vdm2/PL8cb7r6/8/b9nbrf4O67u+/vLI6H/R7oC0wSeGJJJvBksu979uzia1/7Vx544CdjnpSpSfYM884zJZiAKJoEhtommX8O9e1CFI3om+28Am/0Qdt5sz2VuKNKQwx1vYAqJ3l1nAZeNcjBtx9hqPNFFFmfeoZ0lrfzp3S1PEWOJ8Boz98iYoJhMTIYmtR2e2Sso5VzDBKJO62b76d164NgtCNNOCTO29jaxmqKqy5gQeNlMxZ3APTwEK2b78UjR4SNVCjSuLgDEA72cmDrg3iVUQxTpqjyZGQ1PjBa0PDeaJne0SCsezDFqrR9Q0RRQBX78CqBhJ+rso5H6keWMjQ1yTKqonGk/Q8c3P0EnfuewKuEp54pDZzMh18+/BaP/+wwxbU3IEoKxdUXY0lLMEwp7lpOde2KIuR6R2jb8QihkQ6wLVq23I9odCCKqeM7yxLx5i5AlOLF2NyCemw7e6broixSU1c87lFF5L5kizmU1l3I4hM/PK0ufsmOUTo/Ml41SF/77/CqqTsTJiKkKdQsuxaPryQ6TVb91DffTChJt79k96y+IxbF1RdQueiiOHHHDu9n16vfZbDzRVRZj47F7gPPsX/rfXiV0YTrmUuc4z/xtyb2fIiCDXpbVNwBpxRxfuxDMmwbwkYeDavWk1tYn5G44+Li4uLi4uJyNMkv9HH9Hady8TWrotMuvmYV199xKtffcSr5hdNLCti58226ujoBWLKkCdM0GRjon9G2viMEHkXWkwYdpinhK1rNgsb3RaepvmLqm2+b9tt2R9xp3fxDetr+TN+hZ6cl8njVIO07HiE43EFP+wszFnm8apD2t39KcOggBaWLaNvxMzpb/0B361PIUuQteGxJwK8f3cxD3385+kY/llhxx7ZNsC1at0wWeWIDRt3yEE7iJTM1YQJD7XFT9PAwWvDIlAKPLGn0HoovswsHexkd2Isk2mhmIQ2rN0ZFnuqll+HJPyHrXdAyJRPfF5le9r31Qw5s+9EkkUeVdQY7X2L3a/+DHth91EQeJ6DuP/wGAENHdmZN5HGExEuvXc1gf4iR0UIWn/xpvAUrEaX0hTpRBI88RGfrs4SGO8Y/sC32b/sRPjX1dWzboNulNK65PSryFFWspbTuIsKzYL7u7HdsSUtY92AIC7I2flVZRxV6kKXkBjZeNUjbtofpO/w67W//dHoij55LXfOteHwlyKqfxjUbCBv5SbPOHFEv0T2rr8/GV3xanLizf+vDgE1P+wuYoXaOtD8THYtasH/eiDyQukzJRkCScxCl+Apr2ZMPwtG9Z02FI/JUN93gijsuLi4uLi4uxwyiKFBYnEN+4Xgsm1/opbA4h8LinGl309q8+U1++tNHAOjrO0IgEKCgoHBm2zqjuY8BFFlnqPtvKd9u6oZMbsmJLGh837i4kyDVPR1vgFhxx+ne1NfxakqRx3kTPTIYwhprM+5VxsUdh572Fxjq+iuKlLnI41XDUXGndtmlHOl4k8BQGwCDPdvoP/Q7Pv7FU7n02tXReS69dnXS/VVljc7WP8aZmWJbdLb8AUXOTlZGLJpZwKI1GxFl56ISqDvhBgRP3ZQmrCE9l8Y1GxDE8ayKivoL8BaswDDHfEHGRJ7aZVfNC3EnXURRYGSgbcy8NEw40B0n8jjiTk/7X4BIR66jIfIIggDmYDSgdhg6shM91IkkzcwDZWLmQ47fQ0jLQfakztaJW4YIkt3N7te/j79oEb68ypjtl6hvvpmgNrVIEyvylFSdOibuzE42WLKMm2y1nlZlncHuv7LnjbsID21LKPI44k5o9DAAwaH2GYs8jWs2phR30sEwxvZBGomKOxA5l6IkMdi9Ne77WrCf0Eg70jy49J3zmmjs2jbolNG4emNURMwpqKNm2bWEknR2nE/YNoS0487+z8XFxcXFxcUlYy6//Cr6+/v42Mc28vnPf4a/+7svIoozk2iOa4HHEXd6DjyPFjzC/q0PTCnyNKzakNTHINVDd/Q7ok1w6EBca26IiCiSmFiYcd5Ex2bLmLZCfsmK+C8KIv6ixZh25g/HhqlQWn06npxSBFGelA0z2LMdRQpQVDqetZSqFC2kqdQs+xC+/NroNG9eFbUrrieURhCcKZZlo9slLFqzEUn2UXfCDYjeRkxzamHAssAUyqMiT0X9BeSVnRrnaeSIPHLeinkn7ogiSbOUvGqIvW/di2WOi2rhQDeH9z6J12ujjbZExR2H9h0/QxaHpsx8SoUk2uR6Q2kHw7ZtYwkl1K64Nm561ZJLEDw1mGZ2BImZGLR6lQAtm+7FNsO07fwVZbVn4surRBAkGlbfiiVVp93RyRF5iqovIKyrURHXEXCPBRxxp+fAnwE4tPuJSSKPKAqY2iChQFfcvKHhDixjJK3SromE9FxCemoDdYjP2nJIJEoblpeK+vOjf9u2Se+hN1m48ta4UrqqJZcg5y6Z9522IF7kySteMm/FHUEQ8Kn6jO41Li4uLi4uLi7zBadUayZlWbF4PF6+8pWvc9dd93DvvQ9x9tnnzniZx63AI0sGI72v0nPg+eg0PTxIePQgPk8o4Ty6IRPUZnaiTFNA9S+navHF0WmSkkPj6o2TUtJT+d6EQyJ5ZadSUf+eyAeCmLbRayIMU0TJbaK87t0MdG+jatFFMZ8K1Devw6Akozf/Ic1H7fLr8OXXxpmZzhaOyLPklE8mFXcEQUBK4JPiiDxNp356krjjYNt2WoJRNhAE8MqDeJXEY9FBkmzQD+CREwsyIc3DotXrEMRx0U/xFlK5+GLCYQFPXj35pcvj5qmovwDTzp12doQk2th6Gztf+S/QD6Yt8himiJKzJCryVC25BG/hKgwju940U4mwydBNhbLasyJ/2BZtO39FRf27WHzihozEHQfbJmrm64i4icod5yOSJKIH26LijsOh3U8gMRAVbizLxhIX0NB8CwiRYx4RxG7DoGxWu9BNzNqCxKK0bihj99ILAMgtbKCk9iIeufcA9c0bECVlVsbibOOIPJVLrj6q4o4gCAnvTYIgoEoDtG1/AI80M0HZxcXFxcXFxWU+4JRqzaQsa7Y5bvOkLVsmr2gJ3Qf+gm3pCKLMwmVX0LX/OSoXvQ9JqcOchlCSDoYp4y1cTdVi6DrwHI2rN6JZk1tuT9WCXZS95JWdiiCI5OTXTlvcGd+uiMhTgIAnp5jaZVfRvvMx6pvXIaiR4+G8FQfSyoJwRB7n37ONZdkEQsmDGVXsRwv1InkbMScYFFsWBMLZ6WKUKYIgRM+/IIAi9LL3zXvILaijcvEVhPTJ+yRJNlaohQPbfoys5iX0JLEsyCttpHH1bbRsvh9ZjZiYho28iN+F7qGi8VIAhnrfTpi9FL+d4FF0Qlrizx1xZ/+WHwE2rVseoGHVrUhKTVqZD47I03Ta36FbvnkVUOuGgr/8DAC6DzyPx1uEmlONZuZNq+QptiOVI+I6/z+dDlVziWlaeHJqKapYS3/XW9Hp5XXnYQn5cfcy0wJJqaWh+Rb2b3uYhlW3YElVGQti0yWde5Yj8qi+YhRfHQdawgz0heg45GHxSZ9mdFRACwmIs/CLKAiRTDvDUNCznB1o2xBOcq3OBZF7WQ+CqKCZhTH3uIi407Lph5h6gNYt91G/aj39/R68PmVej30XFxcXFxcXl2OZ47pNuuOp0brlQWqXfpDO/c8TDvSAIEZEDWXhjEUeWTKxbDlhAChLBqqsE9RyEr7JntgSF0jYgl2WDCxbSiruxIoH6bRik0QTGxFRsPEoYUKaN+3jIIqRqM2y5tcDuiAI5KiD7H79B5hGkIUrrkP1L0bTjv52iiLI9CBKfsKGF0XoHfPMiQT//uIlk0SeWHHH8Q5JZjxbVubnyJFhJLsLSc6NijuxeJQwWqAN2VefUtxRpUE6dj9OddPVk0oVRVFAsjrY99Y90W2KzCiyeO0d6FTMasZGImaj7aIi6wQHtpJX1DRl22mvqqEbSsLrJ7Z990TWffR08gpmlnUxFy0nPYpG74Hf09/1FuV15+EvPz3p+JHEiNdXUPPMurgz3X3Xghr3ffevCbPXsnFOJhJpDT5M6+Z7Kas9B1/hmhmJPPOpzagjVLds+iGiqNKwZiOaWQjYqNJgVNxxUDz55FVcg6gUk5uf+XF226Qf/7j7/s7b93fqfoO77+6+v7N4p+43zO6+vyPbpDtlOUtOvH1c3IFIR5ytD2HrbVO2PU6FKusE+l5FEfoSpmgZpkwg7Esa9KZbYmCYclJxR5U1VDF1h5uJmFZELDJMkdGQL21xJ9KNphW0A5HSoXmCIAioYn9U3AEIjRxktOcVfOrR7YoT6TZ2iH1v3s3BXT8l1xukZdO9UXEHYLhvD73tz6Iq41GxR9E4uOtXxAophjZMz4HnUeTJ5zoy1hckFHcgkskjepdOKe60br6H0cEDCf2qLMtGUgvx+avipufk1yIq+XMu7swWuqHgLVybhrgT5ODbj2DrbQnLAo8HwrpKad1F1DevSynuQCSTZzQ0O+KORwnjUTI3bZ6IrMjc9JFx3x7Hs2e6vk2piBV39PAQHXufIjiwCSWDe/V8JVbcsUwdQx+lddM9qNJY+Z5tRf6LwbZMBMEG5mc6s4uLi4uLi4vL8cBxLfBAJPC1BQ+yEl8+JAgikuRhug+bjgFpZ8sfaNn0w6QiTyokyZpR7Z4qa/R3PM+e1+9CH92dkciTKbEZJfu3Powd3j+nIo9HCU9q/+2gyDq9B1+IijvlC8/G0EY53PIH9m+d3DZ8rnDEndbND2DbJoHBNroO/JmFy68kdtyp3kJKa89F08cvx2DYS+PqDUjy+LjNK1xEWd2FaHriDADLslP66iQzMo4Vdxxz8GSm5CHNR+2KG/D5q4H47j2JusEdqxhG6uvSqwZp3/FjAkPtUbF4osgT28J8oqCQbTFhNgnrKoJnUUpxZzbxKGF69j/NoV0/w6um9qyaiomiuiOoT9e3KRVeJRAVdxw69j5FaGjbrHexm465dSb4VI227T/GMscbBxj6KId2/RJV0dDtYhrX3I401vVQVnKpWXEbv3jkAANHAsfFPcLFxcXFxcXFZT5y3As8EAlKq5uuJadgIQCCKNO4ej2mWDmtt80Tu8uYRihjkUeWDPTh7SjCEfL8nklvkacKlh1x58ihSAlI+9s/Rx/djWlkv0X55HIhe05FHo8Sprv1KQ5sezBhFzRNlylbeCH5pcui4k5fZ8Q3JBzoGZtv7kUenxqidcuDca3kjxx6FS3YR90J1wMCqreQ+lXrJxlw27aNZhXTONY1LK9wEVVLr0ro1TNTBEHANsOYRrwBsGkEsW1jkjmqI/KUVJ8e170nUTe44xFH3AkOH4pMGMsIRG+PE3liW5hPFBSONQ8S0zw6wbgj7gx0byEweICDOx+dscgDM+u2li6WJeMvWRY3TZS9ET81e/a8pzxKGFXsQRJn75wFNQ91zbcgKeOeZqq3KHI/CCtjhvjF1K/agMdXQn7Vddz3vzsJjmr8+tHNx/09wsXFxcXFxcXlaHFsRRkzIKT7qGm6ltyixhhxZ3rihCQaDHS+FTfNNEIM9+1GFIwp55clg9DgFg7u+hX7Nt2DR+knvyg+8EsVLEuSSHhkb1TccWh/++eEA73T2qeU2ytqHDn4MnG+K9j0Hvwrsji7D+mOuDPYs21MrPlRQpEnpHuoW3EVBWUr6O/eGvdZONBDYKgFeY79fEOah/oTbop2F4JIK/m80lWInkbqV61LKO44OCLPohM/PG1xJ9JiPbXoaFk2RkwbeRjv/BYxTk20bz6Kqt8bl7mTqBvcfH9LLwgCOZ5QZtlvNghigsEkiCS7o8yFoDAXCMLsZ4c4qHLE/2ege0t0miPyaMGBGS17Jt3W0iVsqJRUn09x1alj6/SyaM1GdDuzboUOsmQRDvan7EblUcL0HniGPa9/HyvcMmsij23baGZhJEtHyUH1Fo3dy8bLGi3LRjeLqV25AVEp5b0fjHTzOxaz2FxcXFxcXFxcYrEsfeovZUA4HOKaay7jt799csbLescIPBAReaqXXjMjccdZTsOq9ciqPzqtvO48cktOxJjCQNMRdzr2/AYAywixb9M9KMIRRFFIK1g2TQuvfxH5ZSvjlr2g8X2oviJkySTXG0LM0tkN6x6qll5FXmFjdFpeYSNVS68irHuys5IEqIpOT9vvGezZNr4tjsiT4C2+6i1ElEtYtOa2uLbhCxrfh8e/DGOOrS9MSwCllobmm0EQ41rJm5YISkNSccfBtm1Cev60xB1JBNE4iCr2pyHyRPyqGtdsQPEUJO38FoumR5bpiJGOUTgwJ2/pFVmfUaDvdPrZ88b30Ed2pS3yRMTi66IZgQgiDatuBaUmqVfWXAgKDrNVKieKArLdhSoemZO2kKalUFC+iolltEULTkRSZr9jXzbQzIjIU1p79ozFHSOwh12v/i8eeTihyOOIO5GuZzYHtv1kTkSeRWtunyTuRBEFNNNLjt9zzGexubi4uLi4uLgABAZ20rnzbgIDO7O2zAceuJf8/IKsLCutJ6ympqbvNDU1/a2pqemvTU1Np0z47LympqaXm5qaXmpqarqvqanpqD+1hbp7kLra4/5TgxH36pCmzkjcgbHWtGY+jas3IKv+KbvLxKLIBj1tf4mbZhkh+rveRBL1tIPlsO6houGDUZFnQeP7yC05EUEQ0YbfZufL30Y0O7Im8oR0L1VLryavsDEi7jRdHS3NmS0MU6Wk6vQ4sQagfOG7MMz4Yy2PfSWoKRhC1Vg2ihw9LroxC/2P08AReRat2RAVdxxmOg5TIYmA0U7Llgdo2XxPRiLPohM/OqW4c7RRZJ3hnlc4sOPneNTMyxIntnFu3/mLDEUeLzVN15FbWB8Vd9JpE58uoiigKlNnA8binN7ZKJWLdFA7TMvme2mJEaRnE9MSENQ66pvX4Yg81U1X4PGvQJJnT1jOFh4lhEcaQLc8FCw4d8biTtuOR9HDg7Ruvm+SyCPLAqP92+Na2jsiTzbMqZNh2zYho2BKQ3I4frLYXFxcXFxcXN65BAZ20tf+FEb4CH3tT2VF5DlwYD/797dyxhlnZWEL0xB4mpqa3gUs2bVr1xnABuC7E75yN3D1rl27zgL8wPuysmUzQOvv5+1/+nLcf+bQQFbX4Yg8i9Z+JG1xByCkeWlYvQHFkx+dVlR5EoWV52YsQjgiT33zOnJLTsS2Bfo6N3Fw12PYtknr5vtnReSpWjr74g5EBBBTqKBxzcaoyFO77GqUvKa4TClV1gj2vUYocCRmvgU0nfbZoyruOJiWgClWxYk7s4kj7rRueRBsC1MPZCTyBEJqRuKOE7g5RsIwu2UYjrjTvf9Zho7spnPPrzIWebzK8KQ2zu07f4ER2Jt2R6yQ7qW66boZizuKrJPjCUQFE1EUUIQ+jrT9Do+S3n4JAqhiH4owwlB/dkvlxsWd+7AtY8xzbO5FnpoxcWeqLMn5gEcJ0bXv1+x54y4kuxPTUqYl7kiijRncR9uOR6PTHJEntlTVMGxyi1bgL14SN3/10kvRjOzfqyXJJscbzuj8z2UWm4uLi4uLi4tLtnHEHcuIPINZxmhWRJ7vfe87fPKTn83GJgLpZfBcADwOsGvXrreBoqampvyYz0/atWvXwbF/9wAlWdu6eY5tQ1DzZdRdxrYhbPijIk9R5UmU1L4XTY8EwpkGy2Hdg+BZFAkgQvtp2/HLmHVFRB5VHEjp25AJId07K0a/yYgVeWqXfyihuNPf8TyH9z3Nvk0P4FUD0fkCId9RF3ccZjNbZyIeJczBnb+Ma1Ns6gE6W3+HqmS3XhQmdyaC2SvDkKVxccdhuC8i8qhK+ua7lq3ElRwCyGountwFWHb6F0tIU2cs7oz0vMru17+HIhxBkkQUoY+WTT+kv/NNulqenFLkcVpW73vrbg7u/AmqGkSUIvuQjVI5jxKmfecvsK3xjCLTCHFo969R5dk3ynVEHjVv+ZTijiCQNUF7ujjiztCRndiWQcume5HszmmJYTYiqq8EUY6/5/ryKicZNYd1LwsWXxEVeaqXXoYn/4SsC2KSZCPoh9jz2neR6Z2Tcj0XFxcXFxcXl6OJZekMdPwpKu5EpxujkenT9OR5+unfsHJlM1VV1dnYTADSiX4XAG/E/N0zNm0IYNeuXUMATU1NlcCFwJdTLayoKAd5lt1uh/oOT5omKzLFZf4E3z5a+Fl68keRZDUum8fh4IG+6L9LK/KoqSueconhQC3evEpCI+P7X1h+Ap6cAvye+bTvmWPbOVhmLZI8LnLp4WE69v05ajYdGumkbfvDLFpzK96cd4zOCEBZ3Nj2s/jEjex54wfRtuc5+bXULb8KT07RrG2DIkms/1QktTDP76WwOGeKOTLHNHRsrZJIyc64aJaTX0VOTg4F6tSlIhH8eJdfTrsAA93bkNVclpx0Bzn+qqxvczIMPUDXgb/Stf9PABzY8VMaVl7D3rfuwzQiYtVQ7w4EQWDh8stRvYWTllFamsfoYBt73rgHy9QIBw7j4SmuuvFifvnIHiwzcowURZowRjJj8dr17Hnj7mjLb09OOQ3N1+PNLWYmd5bgaDfYFr68BRnPm2h/AsMdGNoI/pJFiY2wZxnTCHNozx8ZOjL+Jici8tzHyjM/h2da96U8lp50B7vfuBvLCJFfupy6FVcmHA/gx7vyGgLDh/AXLUJSsivG25bJUN9e9m55AGyLlk33sPSkO8gtWZjV9SRjJmM4G8zF8wsc/f08mrj7/s7jnbrf4O77O5V36r4fD/utCh+kbcdjGNpwdJqs+lm4/IMUlSeP1VPt+5tvvkJ7ezuvvfY3Ojs7UVWVJUvqOfPMM6e9ncJUpRhNTU13A0/t2rXribG/XwTW79q1a3fMd8qB3wL/uGvXrmdSLa+nZ3jWUxk8fYfZ+oV/iJu2/Otfxayone1VZw3LsKJv3XNy1bQzIfJzNfZuepDQyGEKy1dRVv/+WTVCdlCDw5PK4KT8QjTf7F3MPnWY3a9+N64NOUDt8quRc1dimvPXQyablJX56ekZjpsmCKBKg7RuvgfFW0zt8uvmrERstpFECyu0jwPbfwrYlC18FwUVZ6JlkEnn4FHC9B16juKqM9DMgoQdw2YDWbYJDbwVNVuHiAhXtGA1h3b/Jv67qp/GtXcQ0uLFq7IyP6PDvex57buYRrzPir9kOYd7T6agqJCCYl9G95BECAJ45GFaN9+LKHmpO+FmQvr0BbzI8kZo3XIftmXSsHoDmpmf9vGfOOYdT6XWTfdgGiEaVt+KJVUlNb2eTbxKgAPbHiQc6IlOW7jiWuScJRjm9M5BpGzvCL0HX6R04YWEp8iilCQx663tBYGoD1NsdqAoeVh04h1oZtGsXj+J7nNZWm7ag2Qunl9maz+PBdx9f+ft+zt1v8Hdd3ff31kcT/sdW6YlyrkU115MTuGypN/PZN/vvfcHVFZW8YEPXJLW95M9w6STwdNBJGPHoQqIpoiMlWs9DfzTVOLOXKEWFbH861+NmyblFzLHTZRmhFP2kimenBIWrriRwe43yS8/ZU7EHQBzaIC3/yk+eWv5178KsyjwhA0/javXR7xBxkSeBY3vQ81bim7MTaQuCMyZKJAJtg2aWUDjmjtAkI8bcQfAtEQk7yLqVl5HaPQw/rIzpiXuQKTEsbD6vWiGNKfn0TQF8oqWongK0MODAASG2ilacCILV1xD246fAWPizpqNhJOY2IY0D3Un3Ejr5vuj14DqLUT0ncVfn9/HdRsqp3UfmUhsaSlIWRN39NAAAK2b781Y5Blf3ri4Y+ijY8t7gIbVt8JREHlCeg51J9wSFXlmKu7AWMtxsYSFyy6nf3Bq4Sbb4o6DrPpRPPnR8wbgySlFEL3YmXmCu7i4uLi4uLgcczhizkDHnyisuiCluHO0SOeJ8xngaoCmpqYTgY5du3bFylDfBr6za9eu383C9k0Lb3kZZkVt3H+zmUky3wjpOeSVnT1n4s50kDOwxlGDwwm7olkWmFIljavXIwgSVYvfP6emyqIIqtSfthHuXGPbENL9aYk7HiU4b/cjEaYlInoXsaD+3dMWdxx0PTviTrJxmoiIYJI35sUVaYlYVnsOvoIVyDlLqV1xDYonPyLuGP6k22dZYElVNKy+DUGQUL2F1DevR/YUc92GU7Jqch0dTzMQdwC8qk77jp/EiQSGNkzb9ofxqpl7+ngUnc59v42KO5FtNWl/++d41ex7TqWDI/LUN6+bsbjjYFk2ctoliNknOmZXrUcZKw/z+aupXXHDcSUgu7i4uLi4uLikIqdwGQuW3ZF1cWfDhg+nnb2Tiikj4V27dv21qanpjaampr8CFvDxpqamW4FB4PfAzcCSpqamjWOz/HjXrl13z3jLXGaEPo/fpnqUMMM9b5JftoaQPnVgkCo7yLIAqZKm0z6Lx+enf2Bu8rREESTzMHvfvA9/SRMVjZfMa0EtFV4lyMFdj6J4Cimfo5K+bGBa4ljAOz9SPjPNYosVeYaP7CC3eG1UrFJylrJobT1BzTul+BS5BqpoXLMeSfET0vPInWzrNW8IaSo1yz4U6WI2VlomSh5ql187NvYyU9tCmkzlkssxdjxCcLgDAEnJoX7VbQTDmS8vW4T0HES1EWMWSkVVWcO0FMw5zk6KFXk6W3/HgsaLXXHHxcXFxcXF5R2HKM7sBfNsklaqw65du740YdLmmH8fG9Ggy7zAo4Tp3v9bBru3MtS3i5qma9MSeVJhWRAI55Cbn8NcBPuOuOOUhg317gA4JkUeR9wJDLYBbQDHlMgznxA9mWfLOAGzr/hkNGM8y8MwRQwz/dIqywLEKnR9HtYLTsC2bTSriMY1t9Oy6YfYtkXjmo0YlE6721xI81G74kbadzyCFhqgcc3taGYhU3nMzTaz0T3Po2j0tj1DQXkzkrLwqIk8FQ1XENLmf8t6FxcXFxcXF5d3EvOjh/Q7jKNhSDzbSPmFU/oexYo7AIHBNg7uejQrIs9c4lND7Hzl/jhz56HeHXhySiioeDeacWy0DfYqoRhxJ8Jg9xYEQaS07n1oevbKe453vMooYW8/RaefTP/Lr2c0r22DYWSnhOdYIVbksW1zRuKOgyPyYOmEzYKsiDuCEPH4mbhtojh52lyghYboOfA7Bro20d/5FvWrbj56Io/uijsuLi4uLi4uLvMNV+A5ChwNQ+LZRvP5J21/rLgjCIA1wmDP9rjvBAbb0ENdiErDMROghnWVmmVX0j5mhAvgza2gqPI0QtrRF3dEMfKWPxhOLdAYlkrxgpPjBB4EkaKKNZjm/E07nG94lVH2b7kPLdTPgovPB8hY5Hkn4og8zr+zQaRcyEc2yrIcM2g91Iek1mKakWvbqwQwtAEEqXJOhRVVDnNw9zMMdG0am2Kzf8uPjprI4+Li4uLi4uLiMv9wBZ4keBQNw1SZpWYk7zhsGwy7mPrmdezf+lC0zW7NsqsQ1IUpW5qnkx00lximiDJmhNu+42d4cytYeMI6QtrU5rOiKCBLGpo+OwKKKIJkd7N/yy+pO2EdIT0v6XcNUyTHU0/Nkss4uOcJEEQaVtyAYpUQcoPFtIgVdwA6O5+l5rrLqL7uGszR8JyP02MtO/Bol1AlI77T1yD1zTcieRpQxOBYd6zeORdWBMGKjrNxbPTwEB7FAtyMGhcXFxcXFxeXdzozrws4DvGqITp2PwpGO5J7hFIysXNQsq5BAKYlICgLqW9eB4JIzbKrUPOWT9lhRvP5511XNEfkqW9el5m4Qw+9B36LRwllfZsccadl072EAz3s33IfXmUk5Tx6bz9HfvoCCxZcQE3VB2j/ziPofX1Z37bjEUW26O98dVLQ3dHyNHJp/lEZp052YOx/EwUfB0EAjzJz+UkULSRxfgo102FyG3ebA9sfRRX6oq3PnewZQi14Y7p3zSZh3UdD8w3kFNRFp1UvvRyPfwWG5Yo7Li4uLi4uLi4ubgbPJLxqiIM7HyUweIDWwQM0rLoFSa51M3mSMLHcbKpSM9MSkJSFLD/9c4R1T1baBx8tDFNEVBsJaVMHt46407LpXiwzjGWEqVh0KWE9fSPdVAjCuLhjW5HW0FpogP1b7qN+1fqUmTz9L7+OpYUxBkcY3deale15J6AbIoULzkQLDTLYvQUAUVJoXLORYDjz8yoIAl5lBMtWCM+y/5EggEcapmv/H6iof/+0PbAkycYKtSKIylg2S5Y3lMRZSSG7DITsXDsTURSLngPPxbVxL6k6me72F8fEHQebAzt/TtNJn4A56sbu8RVRs+xaDu58lKKKtXjyV2KY2RN3ZNlElTVCmhfLzeJzcXFxcXFxcUmIblko4szj2DfffJ1/+ZcvUV/fCMCiRYv57Ge/MKNlugJPDF4lyMGdPyMweCAywbZo3fIgDatuQZRrsvbAO99KjpIhSzo2ImYWAwgnWHPyVySyX0Iyl2Uq6fgGTRR3AIaO7ATIssgjIghCnPuIIMjA1ON28M2tWdmG45FU4ymseyivfz8Aw0fepnHN7eh26ZStzSciCAKq1M/eN+8hv3gpZWVnofcFJq0vGzjiTuuWe9HDQ+jhoWkZnUfEnX0c2PYTEAQamm+eFZEnkWdZ87e+CcWV2V3RGJomUrbwveihQUYGWgDoO/wWS0/+CFpggNGhyO+DIMrUVF5MuGsEipMLqNkmpHmpbroW01KyLu6EBrbSsvc3NK66DeQqV+RxcXFxcXFxcZlA2LS4Z+dBbl9Wg5qFcp81a07ka1/7Vha2LIIr8MQigG1PiE5sG9u20giR02cqQ+L5gCIZBAe2IEgKHn/23hLPhcH0/DOxNtFD/VFxxyE02okgZCcatm3QKaVxzUZaNt2DZWp4fKXUNd9CSM9NaxkLb7oByeMBXUPqagfmt3/LXDHVeHJEngX15xMy8qct7rRsugdTD9DftQkrFELt8NP+wKOT1jeROAFK16ZYV7y4A9PrZhcn7mCDbdO69UezJvJkQjYE3pDupWrp1XTs/gWB4UM0rtlAyCigpvFS2vY8RijYRW3VJbT9z49p+PjHsrwHU5MtUdjBEXc69vwagJYt97sij4uLi4uLi4tLAv506AiHAmH+eOgIH1hYdrQ3ZxKuwBNDSPNRu/w62t/+KcGhdkCgftXNCO+wDiURcWczHXufAqC6iayKPO80LEtE9i1i4YpradsRCdhVbyH1q9YT1qf27kmXWJHn0O7HqV1+/ZTiTlw2ma7x9lfiM8uO9e5uc0VY9wCejOdTg8PIeTZ7xsQdh8HBnRTXn0T5+86n+3fPplxGrAC18KYbaNhwG97aGlAiZV6x2YGCIKBrg+havDdTeLQbbI1IB6qpUSSNg+0vEtetyrboPfQ3FixagGnNbolZKrIl8DoiD3YYzSrEsmy07hGKzRUotWex/78fJNRxOJubflSQJAEz0BIVdwCwLVq23M/SUz5B2C7MWLTMBqIo4FNDhHQ12sHMxcXFxcXFxeVoETYt/nToCG8dibwkfetIxHv2guoSPDPI5Nm/v5UvfvGzDA0NsX797Zxyyukz2k5X4JmAI/IcfPtRyuvPe8eLOwCHdj2eVOSZWG52NLsGDfXJSLqBYM0/wyTDFJFzlrBwxbV0tvw+Iu4YeVkPnByRp3bFzYS0qYPs2GwyJ2vnWOdY6iRlDg3Q8dMnKb3oVLq6no9Ol9Vc8qQ6Wl56OqPltT38YyAiaJgVtZF1xHxuWTaSXB3XzU6SvTSu2YhmFZJue/GQ5qGm6VradzpiOOQVL6Fy0eWEZtk/aC4J6V7Ai3NcpPxCVECwxGjmznwsr80E07Tx5tXg81cRHO6ITi9asBaLnKMi7ni0ALbUz65ND1O//FqUUR8hOzRrvksuLi4uLi4uLqnQrUhZ1qHAeEXGqGHyYtcArcNB7lheMy1Pntrahdx22+2cf/576eg4xCc/+WEeffRxFGX6HZddgScBIc1HzfIb0A3lmBN3Qt09SN09cdMyCW4FwSQwfGjS9OBwB778ZUxsxTux3CyTQCcbJUEJ39Z/5ctJvn10cUSehjX1hDTPlIHTdIUK22ZKcSfRsuejMDYdsl2iN9ueWX0vvQpAxUXvpqvreWQ1l6rii2j51v9hDKfugjYdHKPz+uZ1tL/9cxpXr0e3S9Lyk4olpPuoXXYd7Tt/iiR7qVp8JSE98yymqUh0/NWiIsJJvj+bHAvltdMhpPmoXXEj7TseITjcQVHlSZTUvhftKIh1oihgS/3s2/YgtmXQsv1haqs+iDQqQZ4r8Li4uLi4uLjMPYoosnFZzVgGzzCjhkmuLLG2xM97qkumbbhcVlbOBRdcCEB1dQ0lJSX09HRTVVU97W11BZ4kpJP9MB/R+vsnG5L+x51IaQoFmuGhrO4iAAa6NgFQXHUqxdXnoxkzPyZzURIk5+bNWxNrwxQxzPSC4OkIFemKQseSMHa0mYug3hF5qi6+EH/FEvSeMEu+9MXo59kev47Is+TkT451TJpemoYj8tgIsyLuQOLj7y3zM9wzPCvre6fiiDzDPZvJLT1xSnFnpplyE+eX8gvRc/KR6Y2KOwDYFu0dv2HxqtsQRWHaY9XFxcXFxcXFZSZ4JDHqufNi1wBrS/wz9uB55pmn6e3t5YYb1nHkSC99fX2UlZXPaJmuwPMOwBgdmSSkOKKPrKoYo5EsAUGSsUURO78wKvKIkpo1cQfmpiTI0LRoeYrDfBB35oKEHYcSCHyCZaGWFFN7yzXs//4DmMHQvBbGjjaiCB55FNNW0fTpp0ymou+lV9H7h/DevBCjtCrus1TnIE40FQB77LwJNpZgIlqJb/OmJRAIeUi3LCsZId2HGhxGGpp+5mA2OVa6FM5HQpqPfP9qtINdcbmasefSEWbMKQT6qQSgifeq5V//KgogeUW8ORUER8YzSVVPEbKUi+aKOy4uLi4uLi5HmQuqS2gdDvKe6pIZL+vss8/lK1/5Z1588c/ous7f//2XZlSeBa7A847FEX0aNtxG6733x322/OtfxfTVUrrwQkDMmrgzG8QGc7IiY+jGMR/MRQOjKToiOcSV5SWYJ5HAt+Lr/0b959bTPfASi774MfbdeVfawthM3twfS/44DqIIkt3N7tfupaTqVAqrzk0p8vjUEHbQQO/tj5ueaD8TiRFibmbHwhFNdSnEr/f+nvctOg+/4OdQqJ2DQ4c5pexEREue1WM/nzrXHY9lVM65c3zGYPauG62nN+W5dM51w4bbUi5nOmPCHBpg+2e+wgnf+Srt7b8hFOhE9ZZQ4T0Tsy8ERdPcKRcXFxcXFxeXLOGRxGl77kwkJyeXb33rO1nYqnGOe4En3aDmnRC0Rj1vgHScMzUje34Hs+X5EhvM5dghjO4ezKGBaMaKcx6yfY5mc1ylG0A5xJblpTOPWlKMVKayf9tTWGaYw+bzLPrixyJKxsTvJth+y7J4+8v/Gjct3WA+W0JAqoB3JhkcE/dXUGTEYoF9m+/HtnR6D74EkFTk8Sqj7N/yIGW1Z3Pk13+m/5U3Uu5ntsQIUYLNvdt5tvUlNnft4JoVH+TuN3+MaZmc8N4mcimYVyLMXDOd63A+3dePl3Mnqyo4mZtJBGzbNBl8bTu1p3yQ3oHXKK86F617FLWw8Kj4Lrm4uLi4uLi4TCQb4s5scdwLPOk+GM/kAXo+PXyrRUWTgltHSJE8nmi2TrriQcJ1zEC0iKX5P+7MKBCfar2J/Iec8zDVOcp0n+ZkXIXD0fPktL2eaXaSUlBA/efWs2/bg1hmJFzSQwMc5nka624hOGHhzvbHioPemumbfmWLVMc1kWgiBYcnlQRO5U208KYbKH73yeza/ANsS49+p/fgSygeP77iUzGM8Xm9yigHtj5IONjLwd2Ps+CDFwDEiTyzhWXC6tITOK++nef2/5Xvv/4QAB875RZy7GNLBJgN0i1dTFVCBOlfu/NJHEqXiZmDRWeejNbdx+jelqytIzabMNVvUNtDjyD8WKL5f/6TIEVQXuT6Lrm4uLi4uLi4pMFxL/BkSlyWy1h3p/n+YB6Lt7yM4QmtZNXgcCQwiXlj6ogHmQTr6XovpEumXjmzKaSlu+xMy6dmgtPy2tkWs6J2SnEnel7HBCGYkCkljJm0TMS2sUUp6QnIljh4tJjO2JE8Hg794klKTj+Z3p6/RaervhL8JSsJjWs+eNUAB7ZExB2Hzs4/UXnJezCDQYa27MjeziRBtVROrlrNc/v/GvlbUmgsXIhoiZPOeKYd7GZDsEi0TCUvD30kvnPYbN1/E5UuzvX9ZD4RmzlYev7Z5LxrEapSQOcDTyX+/gwF6In3Kim/MG482KaJ3j8CFW5dlouLi4uLi4tLurgCzwRiA1mH6TyYx6WiO8s+SkKRk9EQm8HgiAeZZNFkWjp0PJLtYzCT0rWo4GaMKw3OeXUEIed7sedYlGUWrb6NfZvvxzLDKJ4CGlZvIGzkzXBvjj96fvccZZxH6eln0NvzN1RfCfXNtxLSc+O+Z9sSXn9lnMAjiAqK5EfrPjLr2ymIcDB8kP96+W4AqvwVdAx38c2XvseXzvo4OWZ+3Pczvc9NJVhMpywuWSe32RJdXNJDKS/Cv3Qlh9v+AAg0fOYGFKE4ei6TnWvN548734m+F3tvm3ivMgF17O/YZRzr/kkuLi4uLi4uLnPJcS/wZLujSroB+Wy+Hc4mybJoErWwnY8P2pZgocshFMOLZc3HLUzNTErXYsunUr1Jn1iyZAKiINC4ZiMHd/6chStvImzkpWPLFJk/QZZQuuMj3etxqowRZzmOsXYm25ApjshTee57KKhYQfhQP5LdF7ddYfyU138AgMHurQiiwqITbsEaFGn45CdmdfsABAS8kgdVVLjtpJtYUbKUX+58in39B5AEKbr+6LHPcgZaul5Cced1DrLgjhfmaryXnHcWIW8v3W0vjk2xad3+Y+pX3Ywk5mBaQtrnOtH3JorNwJT3KhcXFxcXFxcXl/Q57gWedB9Go8HPFEFHqoA8tuX4fCQTsStRC9u5WncmdAx38uSW59i49gaOKDq+L95Bpb8CjxARHpS8POhqR1ZVln8lsj9OO/iZrD/d8oTp7HempWvTKeWyLBtDLKWueT0hTU0q7iS6LhJlCaXrcZOuP85URs7OcorL/PSM+XKkFBTSFBOSiSA9v3uO8KEuvFcv4O1//be4eRwvFwOoqHgXoiBTUnUKhrgAq3j8e7MZrFqWTZlcwTff8w/IhgdBE7lsyfsxMfAYkWyj2GM/8XjPFbH3lbnMBEx0HSp5eeMd+Mbu3YJlRY9N7OexyzkaokO6490hVkiL7tvYfQ+SZ5PmNy9jYHTXhKk2w0d2UlhViWnNrKPi8djhzMXFxcXFxcVlPnHcCzzpkqiMKV2iAXlXe1oGkumS7c5e5BcmFQ68SgAQCelTd86aTgZHNh7sJwZplmCxW+9m84Ed/OOfvsmwNopX9vCPiz9JmVSBZdmRc5KgtGSiCJIsAJxYZudka6UrqmQroJmNLmSWZRMMpw7YnO2f6s171k3Kv/LlJN/OjHSznBxiz1eifU4nW6/q6kuwvMSJO3OBZdkomi/6t2J6UPAk/G40IyRGlHbEjWPJcyxdkl6HuWP+LjH3bodYATNunjSYLUE7llS/DxOFtHTK8aT8QrzUs7D8BA62PMHoUBsAxVWnUlx1HmFj+uJOooxQLeY6O9YMqV1cXFxcXFxc5iuuwDOBuXgwT8TRbEftVYK0bX8EWfFRtfTqpCLPxGMT13Fmyi1KTroP+ImCtAa1HM/eJxjWRgH4wlkfHRd3MiDRshOJQ+mWT2U7aJlNESQdjvU379PJckqYbTQm+MWZsU9If+r4xZMUrD11xts8m0T3LYmwMbG7XLYz4CCxUDyfsmYyJfaad7Y3W/fIRGTbyNkZE0Ggetm1HNz1KN7cBZRUnz8jcSfRtsZu57FoSO3i4uLi4uLiMl9xBZ4JZCuQTTfLJWVnqjkI4CPizsOERg8D0LH7F1QtvRo9wXdnyx9hug/4lmTwasdmwuZ4Kc0Tu57h1uZrUfGlmDPCdESYdMun0t2nTAXFWGFBzvGx/CtfRlIUTIQp550JqmKj6cIsLDl7zEaWUzLS7SqW7U5Rscsb6pORdGNWsx2SjeN0BLKpSFTqF5dV42zDDNeTCdPpopjt7oKZkmibZzruQ7qP6qZrsW1pxuKOi4uLi4uLi4vL3OEKPBmSbkCeNHiZwNHsTOVVw7RtfyQq7gCMDLRweO+vqG64NK6EI9abIjbgEUUhmi0T+2/IXhZL7HKFMY3BtiHEKI9seQyv7OGzZ9zBT7b+is2dO9i8YDunlZ3MVJ7L8+HNcWwJVPTt/9AA0tBAwmOVqPtR87e+iVlcGZl3FrbRqwY5cvAFSqrPTauELxvIuZlncsxFllO6Xl1TbdN0hYBsjFlBELDTddROwEw6BM51hmSm96CE19d/3Ik0NAgxzebjMnOOcnfBhB3RsjDuw/rUIrmLi4uLi4uLi8v8whV4UhBbnuD4VFiSDGPlCRNT77MVvETfyM4gCEsH3VRY0HAB+7c+jBO8CIJEefVZ6EfGjDxDoaTBaFgK0BPspdpbA0Bb+BBl3mI8ZsTUNZ1gVJENxMLkgYQmB9k/1MYifyOyrXAw1Eaht5A88vHZfj512npKc4opkyr43Fkf5qUDr7GmrDkq7hytkrtMmQ9iUyK8aqR8LzTSQXi0O2kJ30yOc6J5bW8OZlFF3LTpnLPpCEWpSOTVNZOuYnONIIAq9iJIXkJa7tQzJGAmHQLnutQv40y6BMJdtjoizqXXTOy4d8rrJposz8fx6eLi4uLi4uLiMjNcgScFsW9m0zGpzFbw4ryRTdcYNuEy0gi4TVNE8tRR33wT+7c+jCCI1FR/kJZv/JBgWySATfYm2JDD3P3mw+zq3cfHT70VSRD57qv30Vi4kE+esgHFmDrTQ5ENRo+8Tni0h5p1H+LgQz+P+9yUNX687TFe69jM9SdcTpW/gv9++YcU+gr48jmfQdF9NOUtRRQkLMumIq+UcyvPxo7ZyZmck2yLQ1nJfJjD1tKx4g5EsrucEr6JIs9MjvNsBv2ZdiSbDulm6x1tBAEUoZd9b92DrOZRv+o2rIKiORFAU5nszjWJrkPHgD6Ryb5NdoT2bIu4KUWpmHFvAmRBLJ0Jifzbsv1ixMXFxcXFxcXF5TgVeEbCo9iiiWBJCAKYso6oK0d7s1IS13a7phpIbAw7k3bUCUvEYkQeCSlO3EmFYqlcvuwi/uOl7/O9VyPil0/x8amTb0CxPVOGRI6409nyDABFS9ay6vvfRu8LRPdJsTxc2nQh27p38ZNtjwMgIHBj85UopmNwK2LFZDrZaUQF6bbOzrY4ZIZC0zbNnkmXt+kgigJGuI/QyOG46aODB7DMEQTBN2WZz3ztjpON7TrWglJH3GnZdA+WqaEF+9i/5X7qV92G5k0ugCXaz+n4u6Qy2U2XbPkPZZqRo5mJHMkmE3cPz1CQT5dQdw9Sd09kfWPTBGn2fsazdQ0n82/zKEFQZEzf7IqwLi4uLi4uLi7vFI47gceUdH6/92VKfSWsLFzOsD3EI5se45ZV1+A1p1eSMJtkGkDNRimPaYpIaj32kc60xB0A2xKoy63jgoazeablL3hkD//fWRsZ3PNrqpuuJGwl3x5Z0hk98kZU3AHo73oLRJGSmvegGZ7IA75lU6aUc9myi/jpticAWFm+lKaixaCJ09/fDFtnT4dUHZhmQqLxohYVEZ7xkuOxLBtBroxmd4GNIEg0rL4Vg9K0PFzmuuwsXdElG9uVrvgnFuSz7Ov/hjBmgm0LNkquPyvlbLIiY4yJHFPN6/No7H3jQawYQ3It2EfH7ieoWnoNIS3xT8FsjWNbAE0J4DFysG0IywFkS0Gykgvx6Z43XQoj2zKCJWW8XdHjKwgEjFG6RnoxhdRjPdm403z+rAsVWn//tDv7TYfZvIa9SohDu38BNlQ3XU3I9fxxcXFxcXFxcZkxx53AowthfrHjt5iWyYdWfJA/tPyFgdAQb3Vt5awFp2MZ2VnPTMptYpmtACpTTEtA0iYfnKQeJqLN7sG9/KH1BTyyh8+fcj1DO3+FHh6gdfO9NKzekLT8w0JElDyT1iVJXuyxQNh5cxy2w9QPC3yx5jL6VZO7W37DS4de5fQFJyOZM8vKmk7r7NkiXXEi0XjxlvkZ7hnO+jbFZncd2P4TGlbdgiVVM50GPVFfqbEuP5D9bJ751srdlHReGt6BYeucW3MmASvAD958iDvW3og/rzbOYms6mXnFZX56eobT2sdgWKXuhHW0bLoX24pkpKjeIqqWXJpU3EmGM1ZjvckcE/Z0z+moPsrX//wjvnT2J5BEkW+9eBfnN57FmQtOSynyTIUuhfjFrt/QXL6MVSUr0fM9FP7jJ6jIK0O0xei2JkPz+RFy/HSbnXzzhYcImxq3N36Q4i/cTklOEX7Vj2DHX5tHe9zNRRlitomIOz9ndKAVgEO7fuGKPC4uLi4uLi4uWeC4E3h8Zi7/cM7H+c5ff8ji/FK25ZZyes2JnFKxNmNxJzaQcbxoHKPKmZTbpLveidNm+6E9E7NbXQjx7P6X8Egq/3XeZzi87cdo4QEA9PBQVOTRffGBrDn2P97CVVQtgY49TwJQWnMWhZXnwHAYaagrYcvhVV//V3yyl5cPvsHJC1YjMb/L7jLhaAeJyXBEnmWn/R1BzTstcQeSdPqZBybS2cQWTWwbRDuSOWJIGo/v/B0BPUhfaIDlcjlX56yBtkOInmGwYzI9kmRKaHkyFiZeM29m22aDIZTTuGYDLZvuRRnz4AnpeYiigImRdsZLdKx2tU/bfFg3dfpDg3zjhe8iCRJ9oQEODnViLjBndF0H7SAvH3yTF9te5aJF7+L5/X8jbGp84tRbWVmwAsucWkA3BJ03D28lbGrcuuYaGkoa+Ppf/odcNYcvnfUJPEbO9LzVjrGyvtnCo2h07P5FVNwBGB1spWP3L6lq+hAhbbL47+Li4uLi4uLikh7HlcDjZH1US/CfZ36Ejt0/5yNN7+WgpSDZyqTvxZLqbXkik8rZzLI5WsF+JutVTC+3NV/LkDGMKoiYRjB+PiOEZYaBfEjgyGMYUlTk0YJ9FFaeg2aoSENdSVsOyyh8+dzP4JW8+EdMzKH4cxCyy0CYmzbe02G+BnipWt1DROQZNdM/rul6HB1tollFEM0smm5WkS2abB94G0EQWFm4jBAhnt79J/7hnI/zjb98jz+2vMhJNZcR+tYP6QA6xuZLJYjYgs09mx5hMDzMZ0+7PXsiz9oNjFoGAxbkSgI9Rjdtg4dYVdyMOI2ypnSYOPbFwnzOCJ3I3w6+CcDqiuVcs+wSJCOz4H5iJmUR8O1TP81nXvkvfr/vzwDcvPpqmgqWpt1ZT7IULlh4LmsrT6BUKUO2Ff7xnE/ikVQ8Rk5mOx6Dc3+N/f0xhwaQhgZQ8vLQR0YmbVM2M9zmiyeWYSqU1p7NyEAr478NAqW1Z6Gb6pxui4uLi4uLi4vL8cZxJfCYQwPs/trXWfTFj3F413Po4UE63v4FhUsuxgr2og5EnEoSZYccK9kEcR4cYyUSTnkEZF/kmBjwx/6tmD5KxRwMW6B+zQb2b7oX0wghSioNa9ZjCmXYVnL/CsOQ8BaswldoohnpPNjbFArF2CaYQ+2TvSi+9U0orpxyKZkKLbNlNAqzJ9ylu81BaYT+8ABVajU2FvuD7SzIqUA1p18qMdHjyFtbM+1lzQax3YeydR8w5DA/fPPHGJbButVX8/z+v9I72sdptScii9MTTTTB5IOe5XhzPfgOH0G0+2cckAuiwLahPn7w+sMUeQu4Zc2H+O4r9xE0Qnzjgi9Frq8ZNo1K2jErZrtHpGH29R2I/t022EHQCuEXPHHrF4SIeIYpIeUXsuzrX0VAQFYkDN2Iy6R0BDtPbTVfrLkM27bpU00EyYNgC9FlpnMdyqaHCqkK27SxsCkSStIycE+HhNlaX/lyWmNRLZp+17Pp+Olkoxxv0nZYApJaR33zOvZvfQiAkPmhngAA63FJREFU+uabEDz1mKYwxdwuLi4uLi4uLi6pOK4EHoBFX/oEhwf/hB4eHJtiM7TnKYpXXMeBex8m0HIgYXaIPYfPlZoUGiu7yEUQQZODKIYHrKmNg+OCkwQlEhNFDkGILF82VQRLwpR0DEFP6020LVocCLVTnlOGx8ghLI3SHeyl1rsQLOeA2fRbfdz1+kP83drrOLLzMUqXXcnXXvsxd5x0E8VCacqA0TAlIP0AeKbBJ2QutMy1WXA2SGebdTnEf7/8Qw4Pd/HZM+5gKDzM3W88wtoFK7l11XXIGWZTTCS2fXgi0vWxynbmwWx0JFN1H18466Pc+dJdPLT5FwB86ZyP83+vPsSwNkpz+TLETIWeQIjQt35ICBgYmzTTcWeZNo35DZxctZqX2l/jzpfuAuCG5ivIE/1ZETGm6phlKhrfe+V+ugNHOLP2JDySh+f2/5XvvHw3/3DWp5D1yLgTBBgWBnmp7TUuWHgOZp6XV0cPsbRkEcvKG+npGUaMOYeJygBLvngH//7mI3zm9I005S3NqMQw1kg8G/edbOAtL2N4goA/mxmA2SjHS0SsyAO2K+64uLi4uLi4uGSJ407g0fsGULwFMQIPiJKKouZjDCY3orXJzFxkuuU2mhTkZ2//mu7RXj55ynr6wgPc+fxdfOTkdSzJW4yQhsiTLoIAQwzwzT9/jxtOuJwTSpfz/IGXePXQW3z2tDtSdhUTRYH28CHufPEuFhUt5KOn3sL3Xrmf/QMH+ed3fZoqpRrLsiOeI6LIcHiEf3v5IT598nV8/dUfEzLCSMIMOl3NQcvhbDFfSh+mYqKgIgGfXXYNf//qd/nPv/4fAIooc/HS96BYU7e6z4SZtI0/FgQ22xYo85WQp+YyGBoCQLAFTq5ehW4aXLH0AwgHD7InyfzO8bEEm57RXgJ6cMruTalINSY9tpf3LjqHl9pfi0wXRE6pWoWkZ+Z9k/QeOLbeZMbahpjPhrU38Je2v3Fx43sREMhVfZxctRrFGB93pqzxw9ceYW/ffobCwxR7C3ls59OU+Ir42ns+jynZBPT4sqaJVPkrqPYvoMZfGS3Rcpkb0/OpcEQewBV3XFxcXFxcXFyyxHEn8LR+914aPrUB8iAw0oYoeWhcsxGrV0M70pd0PtGWMhIPpltuY2MzFB5mX/8Bvv7i/2MwPIxm6oyER7DzLASyJ/BApFvNqBbg+6//iMXF9ezt20+umoNmaXhJLvBYlk2Zt5TlZUvY0bObz/3+3wBYVbGcYrUIyxwPPv12Af90zqf4/B++xlde/AEA37zgSxRQMqmdtiDaYAvRN+KiRFzgNZcth7NFNgUIQRDQlUhGl20JGGIYUzDxmNP3/nAwRkcmv4X/xlc5uWoVr3VsBuADSy+g2ludtW5zDnPZLc4QNWQUsAQEAUzJQDRm91YXkkb571d+yGBoiBp/JYdHu/nmi9/jn9/1KUrUEkRdQS0oZdk3/g3BFnG8RxzRUvP5Ef1+nj/0F37W+hsWFdXxSf9Faa1bEAQQbGwLbARCponZ18++f/2XuO8t//pXEXPz6TW7ufPFSOZOkbeA/tAgd754F39/5kfwmemP2WT3QGlM4ElmrG35/JRKZVza+D7EsU54F9adj2wp8Z3FDJU7TryJO1/6X57f/zcAchQfnz090tFqb2A/g4Hk93QAVVD5wpkfj2YFuUSYL6bnpuUKOy4uLi4uLi4u2eS4Enik/EKWf+3fkBWZ/MKVHD70ByoWnodOKYLeFv2ekx3iW7qY8MgQqqQiWOaMfAXSxWPmcMeJ67jzpe/RMdIFwHUnXMra0tUIZnYNTm0bKtVqPn/mR/jmi99jb99+BAT++ZxPU0Ax9hQ5Gqrp4/aTbuCzv/tKdNqGtdcha/H+LLqg8ULbq3HTnt//Nz7Q+B5kczywsiWTHQM7qc2vpkAsIiAMs61nJ2vLVkdbnhu5+Vhjx9/x+0kk7CQSgtSiIsJTHZR5jCAI9Nu93PncXXzslJupyavm6b3Pcmi4k/WrrpuRL04yAkYgKu4A/GbXH2gqWUSdry6mDC8zJp6bucy8MiWdvxz8Kw2FtSzyL2LQHOCx7U9x/corUCeUJU7lZ5XJvUBEpNRXTHlOCbesvpbO0S7+6293Y1vgsX3YgOb1gze5KGwZcGbVqWimzrm1p+PtSC1eQGTMDHCEgeAQ1Z6FbG/rZlht50SjOOH3bdvGtExM2+SG5is4s+ZkfrLtcXb27sWawzoky7IRY7plSaYy6W5k25Aj5XBiZTN/aPkLAIuKFlKgFgDgFwqRFtTS94XbIzMUVrL0X/4RSVVBiNxLpfzCoyruJMqkUvLyJo07OTd3UqfG6Vw3qTK34q7LDA3Q56tBvIuLi4uLi4uLSzzHjcBjiyajBRJqbi35JX7a+zopW3wJup6DZdmoYwadw/ow3YF+JFGiIjhCy1fvjFtOtt9iJnrgtvI99AbHg7fXDm3m1Mq1eFJk1EwVKES/N0HkMASd3Udaon/b2LQNHmJlYT6CnVpQCkuj/M/L98VN+59X7uNjp9wW9fARRYFevZdf73oGv5rLx065lR+88RC/3/dnVi9YQYOvEcuyEQQ4Yhzhf197kAKPn8+ecTt3v/4IHSNd5J/uZ1neMsJikMOjndT6ahBtiQ6tgwJPPr4E3YMSZQ94y/yM9A4zKg4jCVKknbFooIlBfFZuWh5Hich2cJMsCAvn5tEz2stweIT/eOn7LC5pYFfvPgq8+RjoqKQv8CTaZiGBAclgaBhFlPni2R9jKDzK/7xyH3858DLXL69EZnqB8cRzk8lxSuTLk2i7kxEiwGM7nwbgxuYr+PWuPzAUHqa5fDknl54Yly02lZ9VJvcC1fRxc/OHAJA0lRq1hjvf848ohg87g+pPxfRy4cLzsQ0BKd9KKUAFgn6E4SFGhjoQbQsrV6fcZ3L31p+zovGGhMu3bahQFnDne/4JyVIQwgofWnYppqCTP2JjDk7tiTQVsSbW00UNDmMMDTCsD3OiVsTJtVcw6LG5a+/j/Gr3b7mu+RIkW0IoKuQ/37gL07bgIPzTOZ+i2lMTPeZHW4BIlt1nVtRG/kjko/Yfd2JoWrTDFghI+QVpnYdU2YSx4z3T7Lmj1dnRxcXFxcXFxcUlM44LgccSTbb1b+fet37KF8/6GOZIKd955W7Kc0tYd8KHUPGh+fwIOX4CZhf3vPoEnzv9w6jdqf0bskGiB+6cL34YzdS5vvlytnTuYHvPbn6x8zfcsOJqBD2x6DJloDCGXOyDvkjLckkS2T28j1++/Vty1RyuXXkJP9r8S77/+o/42vmfp1goS2oeKooC/eEBDgweorliObefeAP/9/pD7Dqyj8HwEBVyLrZtR0q51DLWrb6KFaVLKBJL+IezP8mmzm1U+6qjHbdsGwqkQi5ecgFP7fkTX3n+vwA4tXoNDf46dCHMI9t/yWuHNrPxxOsp9RXzH3/7P8pzSvjiWR9H0ROLG6IoENQtRoI6OiPo0jDfePG7lOeU8vFTbuWvB1/n0e2/5nNnfJhGXwP2NNy0tZw8hJy86LyiDNoMSpiSnUvB52dx3hI+fPJNkWPduw+PpPKPZ3+SXCs/I0+cdEuiKvLK+OdzP02ZXEGlavEv7/4MVboPu6M7ft5ZyGxL15en+T/uTFtgy7X9/N3pt/NfL/+Qh7c8BsDFSy5gdekJs+7BEpthZdsCsuablo+RbUTG2ZQC1Fe+zM6YafsB7xduJ9/jJ1f205tk+ZYFqjWezaSYHjyiF31oP7v+aWpPpKnI1MQ6oQhuWeycMA5Wfv0rlPiKIl3JBIFhYZBvvvA/mLZFlb+CjuEuvvXX7/MPZ32cBUpV1o2RBQFMWUcc8yoyRA0RKeut5fXRYXZ+5Wtx05Z//WvzynMKxo6HYCBakccISzKQLGVSWa6Li4uLi4uLi8vccVwIPAIgiSKGZXDnS3eRq/gYDA+zIK887nu2DeVSBf9yzmdRDB+CPXpUtneBv4wNa69jTclqTl2wll/v+R0XL3lvUnEnXQxR448tb7CyZBk5dh791hFKfEWcW3caFy16NyVyKVVnVbCl+238UkHKjjmWZbNAreJf3/VZ8pV8pLCH29fcyJA+RJlcHtf+XDIVTis7GdGWMU0bv1DA2ZVngBmfMSNbKu9ddC5P7flTdNoVy9+PanlBgPcvPp9NnTu4582fRD+/asUH4sq8AAxJI2CPkk8h+7sDhKUBBgYNHvhhK/94RzPlOaXsOrKPL/zxa4SMMD7FS4HHjyCIUwYfiYLNsF+lVzWpVKvQxBCvHn6LUyvXohiRbjbZzPAxBYP9AwfH99UyGAgN4vfmz7jVW8Lt9BdSJuWPnU8x0hq6p21OTI3TFaEMTZskZDrHNtTdg9TdE/fZooIiZEFCtyMq3OLieiQ7MwPhWMJSABERxfSCaKPLIdQMM3NmAz2JUdIFC8+jI6Dg+fjnAWioLUYIBZKWnwmCQI/ZRXCwY9KyzBnkaaR7XSRrGz5peUj84zmfRLYVCr35DAVG8cleTlu0lkuWXsimrm38eOvjeGQPkV+F7AkNjmH9A2/8jI1rb8CDh78c/CvFvkJWFzcjZFHk0Ux90jRLyK46OdN7liBAt9nJlq6dvKvmTLyBAH1d7ZT6SzFHA5HvxJSazTfDeRcXFxcXFxeX45XjQ+CxJFYWruCmVVfy8JbHGAwPU5tfxc3NH0LS1bjv2jbIundK/5kp1ylEyp2coFuSBEwzvWV6BA9rilchWhIqPq5eehkYMzNXFiXYPbCH+958lIUF1axfey3f/tvdDIdH+M8L/5lcqwDTsKny1FC+sCLqeZMSS6BMWoA9tl+q6aNMyokTdxwES4oeUyUwUSQREAv9DOdIfHvMhNmneAnqIf79he/xD2d/kny7kCpvFZcvu4ifb/8NiqSwsmwpK4qXYWvjx8YQNf7U9hee3PUHPnXaBiwxh/u330uZr4SbLr2Ef/3eJv7fl9bxL3/+JiEjUqz2+TM/QqlUHs0mSkWiYNP3xTv49qHf8LkzP8zv9j7Hps4djGqjXFR3AbYhZK18QZDgje63+N3e5yjw5vO+Re/iZ9t/w7deuos73/tP+KyZBUlJtzOuHXTm14UgREQQ2VIRLRlLNDBEDY+ZM+vtpbX+/knnK/dLH0G3DJaWNLKnr5Xvvnoff3/GR6j31WcskmlSkHs2/Ri/J4+bTriStqFDfPfV+/jimR9lgVp1VEUeK8HKBQSe2Pskt668hd+9GqC1Y4Qfrstnz3TLz2agKc5GWY/XGC/X9Jl5/P2ZH0W2ZYSwwuriVaw8vwmvmZvWtZ4JlmTyx70vsLN3L9/+2/9xQnkTf2h5gVw1h5XnLUWxZm6C7iCMHfRopytA1Azoaidkl8GENunTYabnRpdD/O/fHqAn0EdAD3K2XUXPV7+Db8NtMzJvFoTx21Hsv11cXFxcXFxcXNLjuBB4AEIEo51WAA6PdNMV6I7zY5iIUOBn2df/beyBWsAWrLTeYgoC9JhdmLbFAqUSTQixqW8nK4uXRd7yp4Foxxz6KcQdQQA7QctkS7AwJR3JVAgToqF4IWsrV7Ktaxe7+w4yHB7h0qb3otre8VIpCyTSz2aYGPDbto0mB5BtFdGUsSQDQ9RRY0qoEokkFV/+O4SGGiwsTqw8gZtWX8mf9r3EM/v+zKgeIF8t4MBoG4+9/TSF3nxuWfshBkNDvNm9mRNKlxGyQvgpREahqaSR3wgC333lXkRBwLQtTq88naEhi4vOqmFH776ouAPw6LYn+fBJ6/BMMwgrzylBtwze6HybPX37WVhQzbkLz4iW0qRCECKZBLYoIguJg3IH24Q15SewZcFOrlt5GflSAWW5pXSNdKPaMw/qTEnHQMNj5iIIoMlBZNODMOZNJAhCWgKPY34tSSKmaTEqDvHvL/4v71t8HmdXn8pfD73O7/Y+x5fO+jg5Zv6MtztTVEnh4iUX8IFF59MyeIAfvvkTirwFCIgJhV1L0hELc6MZDSYmgiAg+QuxMBkIDrKjZzeHhg7TMdyFbdsMa6OUKzPreieKApocRDG82BboYghLsPGkaaYti5OzRiryyiLnUNK48sIavPiR7f6Uy7FtmzKpAsM/wl7ihQVJM2EOzOeni9cY9y0TLQnVysHKYuaOg2BIfHDRexkOj/DKobc4PNJNjuLjH8/+JKqRm/SFwVSZMpM/F7CtSAbPxE5XosfDiu98G9Tk4keq9QljtytnPkkSkEaGkpoyJ8OWDVTTxz+e+1n+5bk7ORIcRvOnfpQQxUhpIEzunOigyyFGjBGKxRIs0WLIGsIrevFYPizxKKfLubi4uLi4uLgcIxwXAo8tG/x8x5McHDrMxUvey0nVJ/Fvz/87//W3u/n39/zDpK5PEMkE+W3PK+SqOby79iwGtAHuev1BPnnqevx26jeHYTnAN/78PSzb4vNnfoQdPbt5fOfvef/i87hk0fvAGC8FEgsKWPb1ryKQXqceQQBNCSIbkcDbkMMErQCHtA4Wf+3LeESVEX0UWZTYHGxnuLODM2pO4idbH6dzuJvbT76e6vx6cjxLWLOgmQsazkHS1ES7MS0C0jD/+dL3ed+S8zh1wVre6NzEb/c8yxfO/GjKFsuD4WHCowE+feaneavjZf79hbv4h7M/wbsbziDXyh/rxPUKkiDy+bM+yq93PktfqJfrmy/jdy3P8cy+v/D5Mz9Cna+eJfmLuP6Ey3lk62OYts2S4kZOqTiZ7oJOzqpooiswgN+Ty6dP38DPtz3FriP72NS1jTPKT52WD4tP8bG4uJ7l5WdQmlNBVa4fn507ZRgpigK9Zg+WbSJSDoyim0PUFPpZ+vWvRL4kgKT6ECurCGhDmFhsXH0DoqFgG7Asv4ml+YsnZVwJgoAmB1BML2HDxBA1TMFI2k7dFDWea3+RNw5v5e9O/zCaqfH1P3+Xm5qvZHnBMgQEes1u8uV8EhWb2ILNiDiAX8inQ+uk2JuPz1OMpY0wEhplVAvwx31/4bTa0/njvr8wqgUIGWFyxfREI4eJAapcVweDw5gkLp9LFFiX55ZSl+NlV38LTfmL+bd3/z2iKWNjgi3GeamYosGrnW/wyNZf8anTNlBXWMPX/vLfFHjy+eQpt+E1c/ni2R/nn569k4NDhwH43Bkfpr5gCYKWOOh0li8ZCpYNI0aIkaCOqUuUFfjwSAKiKNBjdPGtv3yfT5+2gcqcCn6182lGtBFuOuFDqBOE4onHxQbIUfB98Q7KckqQRBEltwCPL5c7F/4TWzvf5pW+Z7l51YcwD059/HUxTK+i4f3C7cie4lk3n0+Fp7oKsbCYpm/8fwgICE6W5Cx1bRIEMCUD0Yj8HBqihowyqYuciER5bun4dsoqXskTzXBMRKpMGUGAQIGCkluLbYEhhxm1Rjl0YBd5X7gdwRPfCa3wmg9xUPJSoIwQ0EKUymVoYgjF9ETFk2TrEwQIiSP0hvqp8dRgCAa7hvaybDSXXf/0L3HfT3WudSnM0/v+yHsXnc+o7uGsmlNYXHYiipI3riBNwBIsdg3vZol/EWDz9tBe6vJr8Zq5McsN8fO3f83Lh97iX9/1WXZ07qYst5jt3Xt476JzeP3QFt6f8+6kx9nFxcXFxcXFxSXCcSHwCIbMh5ZfQmlOMefWv5eugMbfnXE7OUpOpIsNMZkUY8/ipqTx3P6/EjbCnL7wLARJoqGwDs0SCMojCIjRTlG6FMK2QbW8CAKIgsC6VVdyz5s/4fXDm6krqOa6Ey7l5Mo1DOj9GLZBmVSBickW4xCD0hCnV56M3dERZ4oKsOwbX0XI8Ue2S7Lo1nv49z9/j40n3sCy4sU8t/9FynKLuWf3r8hVfNx+yq3c/+YvuGn1lTz4xu8JGWGKQnCBWE951UkMHuxiedFJ/HD7YW4+4ULufesn3LLqmriH6WkfZ0EgaAQZCA3x4Kaf87eSN9h9pAWPpDKqB8mR8pMG87k5+RwMKewf6uNA3wH+/oyP/P/s/XWUHOfZ9Qv/Cpq7p6eHmUHSjJglCyxZtmWUGWRmhpDDeZ4kjhPbITPEdswsk8yyJYsZRjDMPD3QjAXnjx6PLMvJyTnv+5z3+5LZa3ktq7q6+qa6p65d+9oXJsWKUU8EqzJGLp18ESeVLMIgp3BC8Un8desD3LfxEeKaQrY9g1SbC02MEZOtNAy3kpuUTYGzEKfZzMa+L+n29aIa8jgwEOEHC+/g+b0vc+vcKznQV8uMjKn/r8gd0WjEL8Q5uXwlb9YNcVJhDmsb3uXCKivZxhzQQZVjSIoRQ8iP4kuoJQQENEGjJ9KFOaOA95s6mJdrZiRQg5pTxZr+z5mbP43n973FL078OXtb3ejKPrZ37eQnC2/DMuoZI2gi0rdUIl+XU//9+kf4wcI7cHt06vp3safnALfMuuq4cuAAiqDS6umgw9tNZ8CHJzKCN+Kj3dvFRFcFXaEefr/lUebmTueaopVk/fL7+KIBcpOykASRDrw8v/Mtrpx6Hr/f/Bh3zb+bNXsGub4qDbWtkwcqrsbnSuXPO9s5e9J55Noc/3Ja3NF+QcxuHQsuVQOsaRrgtKIMDIr2ncqwSf/9y+OuMxL28tihl3BZnPxq8fcQNYkNXZvJc2Yz0VmJR/Xy+oH3uGrKhZg0C7lJWYiCQNNID2ZjCiNhL2dWnoQqqKhGgbBmIKoerQglSkk0+UJMsFqO658gQEDw8fSul7l51uWoqo3NXdvRdJ3B5gwaWv389Ko5WE3QHxwkEAvyhy2PUZScR9NwG2nWFFSUY66n6xB1WJBsSYmKdLJOnbeeh3Y8iyzKTM6YQO1gE7fMvZNsqxmDHmV921a6fL0sKz2FZOs/V39JksCIpnIoPsJXQxv5RdEF//Kc/SOIokBI9CPrBmTVhCJFUYQ4Vs2RUH+ZZNRoop/SaIXDQDzASMRLSskMPLLMEw0vUZUxgRUFS5AEGU2T/pdzdnRRRZGimFQrmpYg6wVJ4tUDb3Nx9SoMuoHN3dvIScqmwl4+RvKoYpzNPdv5oOFzbEYrN5eeheQP42k4QrYjE1EXkZNTiJr+tX024WHTz4ObnuD7828gw5bFlvadiKLAa43vc3r5cgpMeWPnm3Oy8ZRX8VpNB5dX2+n3tyKmCfx509PcOvsqMg1Z/KNic4IAijFOXDPx6M6/c8PM1bR5unjzyFp+W/rd1da+C6Io0OpvY0vnbmbkLeXp/S3cPXsZrx0ZINXi55Q//w6T53hfuz7/AH899CbXz7iUuKbw9/1vUOIq4K451yONlrA3YOLKGZfS6etlJOLhtUPvYzNYuW7mxfx+06N4o35KUwopsZT8y6nQ4xjHOMYxjnGMYxz/ifi3IHgAzKqNlaWnsrbVzYEBLz+aU4lZ1VGEOAbRiEf3o+kxnGIyMWIMBof56eLbqRvs4JUjvczLFllRvpJWn8qR3g8ZDo9w04zLEZF5q34toHPRxLMJaWF+v+ERfrHkTpYWzccim3l6z6ssLpxLNDPC7zY/gqqp/G75j5EEiZaRbr5o2cDk7Nno3xFouUODGHGQJDtp8beiohLXFB7f/QKXTbmA3sAAsXicW2ZfwUA4yEjUSYEznzxHNveccCv/veFPFJCE+/En8V97PU2OVD6u7UMH3qoPsqLodHTRCCoIIijEQTAlklWERHrXv6qw0HWdNDGDnyy6jf/a8Kex8uv3nHAr6VLGd19HFHGuWIGSWcYXh3qIqTqXTDoDk+xAj319ioAmCuzo8zEnM4917W7afCHOq1rFGwffRhZl7ph/DfdteoQ75t3G83t6OLN0CXajBUG08MaBZ7lixhU0DIdY2+Qmruls6ZK4YfYNWHQDCzLnoGnCv+S79G2lRDwrC7cmsr6ui1A8xkctfpbmn43BkIQg6vg0H4/veJ6bZ16B0++n7htvw50nLKTg6mt4p6mXwXCMz1riLC+aRpdvkJASJtueycVTLmJbt4+dvSFWT5qMUZSQR2/Lb6dUfJ0apaPhjfoxykZ6g3Hebmjlgso8RiKbiGtxvkuvZVItXD3lEr5wbmVPf5wsWzLnTFjJifkLERSZVEsKWbZ0jrgbqcmdQr9phLgcJz0vg1ZPB55IkD7/AOF4lDvn3832njieaJwN3QGWmzPxxzS+avcyHInR5nOS67CBpOLHi1mwfGfq4tf9+fr//XjY0rmL5QWLUUXoCqjs6B2hwGmhOs30ncoi2W5n4r2/QRN03MFBQvEwbboHp8nBjxfcilGxEBR9vFf/KZquc0HVGXzStAGn2UFnoJsUs4sSezHXz1qNLmSwtTvGDbOuxCxJ/O6rh7luzg/4vHWAk0qWkWKxUeAsoGZQYU9fNz+aW4ZJVUE92jJd0tjeuYfG4VaavcP44nGOjBym19/P7XNu56vd/bzzVROXn1zJRGcl106/hGf2vUrTcBs2g5V7Ft6KVbODAAHRR0yJYTPYeKtuLadXLCPJmERHoJtkSxKpVhc3zbycHGs2HcF+PmoNMSfbzCyXnbvnXs+7DevY1x+jKtVB1n//kGSD4zg1jCJFiUtwpC9OTlIVP15UhanH+0/vEUHS0VUhsZ8IcSRdBk1AleIYdCO6rjOkuvndVw+zuGAuZ1Ss4MOGz9ncsYufLboDl5xOvS9Eqc2EoOiE7SZ0ewZbOhvpiPeSO1CKL6py2bSLqemtISKEGYnGSbOkYT7ef/gft1NIVHYSvlbmyFGODNXz3P7X+dWS72MzOWkabMFqKiXTkceju56jIrWUj5u+xG60ce+yHxEJGFFUjSSbgQmppbgsTn44/2ZcAwHq7v8lEcAHOE9eQfqllyL+k+p6kiygKon1rgkKvYF+ArEghwc7iJHEJ00bWJA/k58vuYN0YwZibx+y3U7y5ZfTlZnPu/0hIorGh80RTi2uJBiPIAgifcFBklOSQTZhVMRjPNJ0UcOjDSMqqTy1v4MzJ5zFA1ufwCybsBosuMzJuP9Be78NTdMpTq7g2lnfY09fmNXVBbxdP0iHP0KHP4KKgxX5uST/5kekCCYEBIZCwyRlZGPolOnyDxPTYhglA5dNOQ9ZNY3tyHFB4uk97Vw0+SJ2dG1hZfmJrGveRIo1k5ga57TyZVSkFRP1jZM74xjHOMYxjnGMYxz/DP8eBI8k4NN11hzupmEkUfr8wV3NXDghm3Csk5KUUrr8UdYceo4fLrqLzxs3sKt7P3cvvB1ByqfN42VWZg5buwLs6vNyRdVSavp2IiCiEqdhqIXB0DAzc6awt/cgt8y9gndqP2FXzwHuPemXDIQ8bGzfwcb2HQCcO/E0ZM0IoolpOUsocObyVl0fi7OTsOTn4Vq1ip6HHwEgGAvxxy2PjBnq5juzuWv+dfT6PeQlTyamhJmRu4BQzEdQi/JuwyBXTl6JIIh80rSBMytPIq7EQRARDDIqR2vH6DrYjQ4MmBFElb5YD7WDTVRmLMAiS6xv+phlxQtJFlLRdR1B0kET0PWvfX800I5Vj6iiQvtQ9zHH2r1dpKenI6qJ5TRGkgggpKZRGxN4bv/R6kgvHR7kzDKRBTkuiKgMqoMYhFQcRgNfdA6yvmMQHbDKudw2706+aP4EXyTAZVOvZHOXn5FInMGIi66AxuHBAW6eeyP+OGzuGiQ+GtzUDkU4rcyKpuvEVZ2YqGPnG4TCN30gRI24HMWkWogmJRNzSEiIiJJAQDHQ5Q3iiSROVjSd4YiIWbIRFSPs6tpPm6eL+7Y8ys9KjlU+OM+/gFpflDZvwg8opukcdMc4pTibqZnVpNqKeLsR+kerzrx8xMuivCmYTEkIUQWPNkIgHiTHmIsixKn3NVOSVIhBtZBrL2b1tDt5u66PmKqxvkPg1nk/wCYaQdPQRS1Bbo5WINNNCnFNwmau4qsWL0ZJ5JyKKSiShKSCVXPwgwU30eJp5/WD7+MODXNR9Zmsa9nER41fsnrKOZxcupjS1Ar+ursddyjBzjV5I6yaW85fdjXhDiX6uaPHS4snzA/nlfGXL/5GYXI+F09cdUzaUVwOMxLzkCFnISAQEL2sOfIRdYPNLC1Zznv1vewbSKgB3qzrYb/LwmWVeZhzson09I5dR1dV1Mx8FCnKhsY9rO9K+HDlODIxSEZ0BWx6Ej9YcDMPbH2cNw5/gEE08NNFt/Jh4yaODBzhx4vvwGzI4r3GIMORONMzCyl2JXH1rNt59UgP/pjCnOw5FCXbWdvUy+HBxB7zp10trKpIpzzJjvw18aCILMlbQLYjjxavgZ29Q1xZfSFCROHRVxoB2FLTy/knlmOyGwl/wysqokbxRLzYTA6iYog/bHqUYlc+5anFbOnYRcNgM5dNPZftXfs4OFDHb5f9EKNuJqRJHBw00eEbpifQi2lCLuUpdiZlLuL12mHqhmNcNCEXm82BNFqpTyWRllU/0ookp/NJywh2o8RlVWmYszNJ/ultY34+vYF+gjYRk6ihCSq7BvYxLbMKBInPmr9gZvYU0i1pvN/wCcuKTyBNysAgyhglA580byCoRNjUvh2X2YlJNjGiajxb0873Z5eRYlB4v/ETFhXOZXHRMnb1DvNxyxA64DA5WJC/iHfq36UsbQmt3hGWZqWhxtXvrJ52bGUw8AtePqpfx3mVZ6IIGr6Yh4r0SiwGCyMxjaFYlLzkCv68s4MLJlazq3sHHzd9idVg4ZeL7+aTjW7e29iMqumU5jq546Ip/NeSH2CIm4+pwCgYDGiLlvJei5szS1LQNQWDdiyhGZcjbOvbz6ysaRg1M72xfvKSsrl59uVE9QxeOezm4skXUeHKxqYnoRAj4LKT+dO7EbOKOdjUT0RJSHT6gzHcYYFkU5Tb596AyeCizdNAjAyKnE4cImgKCKJOb7wfbxTWd3QyHInhjmRw5/w7STLqSKJEqDuhOHSecQbxpiZCdXVEtSiyqB+foiYK6EgcHAgjiCKqphNRj8qGInENVRR5d3gv1ZkViIKAM9OGLcnGksJ55CdXIQpgFHSyzVlo8cQ8xQ2wp99LqzdE3bCNPGcJBY5kJNHKV50xTq88g+mZJSSZHLjxM45xjGMc4xjHOMYxjn+M/7XSTf8/AlHXMYoCpclWxNFn0mybGVmMMhhys7fPwwdNPi6efDE7uj1kOAr5zUk/4/1GL/VDCtdMLWJz1zDbejwoms5Lh/0Upy5DluyYVTs/WnAzJxbPJzupgJGwn2AsRNNwG7NyprOp089p5WchIGCSjGTbM1hWtBCDbqQ7FGUwHCek5VI/HOSNJjfOn/2ChvwybFVVACSbnXgjPl4//AGCIHDDrMuoHWgkP7mKp/d3UJU5jcGwygG3xnuNXnTgjdoAAcXG7Lx5JJnsgEDc40EUBCYPdXNljg0BuGNWMdV2K3JcRZGjPHfgDdLsObxW2827DT1kO/N56eDbqHIUTY6zbWAnAcGHKAr48LBnaD/aN15Ji6KARwlwyN2MSTJy1bQLMUlGnt//Jj2RHsTRwY9ZHMSzs9lpcOM1RjFLg1w92YXdIGEQBa6sTiHdPIIWixGUVWqGFD5vdSOLArWD/jGCqssfx2xIZU7uLNLtWWzpFukNwpWTCxgMx/myfZD+YJSXD/cjo3N+hZmyZDMmSeSGaTk8sqeZsKbS4g/zRn03fjGEZJSJS2G2DexMpN6JGv2Km5+uuw8PcRr8AbyxETzxEIeHfDy6t5WvOga5YXoRsiiwvDCJhTk6BiHIg1sfQxRFTilbwtSsKci5pQhyguSyVVTQ5A2zq2eYO2YVYRAFZmZZmZDczcPb/sinTV8Sjo+wosiG05RIx5qW4WBhnhNNjeITPLxVu5Y/bH6UzkgHG7o289COZ3mn4WMwqMSBPX1eAvEE8dQfjFE3FECVBBRjiCPeWt6q/4C4FCVuDBPVVfYP+PikNaHOiKka7zR46PRHwAwhWaNhpJfXDr7PhdVnYpZNvH7oAz5q/JKylCKKkvPZ0Lad4XCEqybnMDc7kQY2K8OOb8dOrhJ9LE5JBLWzsywsyg3xs89/jTs4xPlVZyOPppwpUhRFjvDSobf59Ya/0Bxswssw2zr3cOX0yylOLiASD7OoIJXCpMT1Us0yy4tSEINeov0DOKoT907SiScSTk4mJgf5tG0969u2kePIYn7uLHr8/Tyy61miUgh0cFmcSKLEosI5/PCEG9EFBwsLV3DplHMJKmZeOORlOJJgaUyykcFwnFeODOKPJdb/F+3DGCSJgiQb0uge4zRJoIfQhW/INiSBiGBiR5+Vrd2B0f3ER0R2cslpEwE4fVEuRovGF+0DpNoKSLOmcMXU87Ebbfxhy2NEpCAGjKwoXczunhoiSpQ5udOYlTud4pQKXGYnP5h/I6Ig0OjrptkXYnefJzG+mk6K1cSmLg+v1Q6jA95onKcPuOkOK+gWjYiUICdMZivDsSxePDyMqut4owq1Qyr1AZ2eNCv3tr/Nz5tf5rftb/PR4B50UaM90M6LB97CEwvS4VfpD4zwectGPm/dwKaOXTy3/3XiUhSnmMxPF91OZVo5J5efQVV6JT9f+mM6AwYe3ZdQ/j2+r5Vab4wMez57e+twh2Ns7vKO3f97e0P4YiqLi85gXWuQz1qH6AhH0Q0ioUE3tT/7xTH/Kf6jZtJxQ4RXD73L5o5d+DWNnmCQw+4WtnSF+MniHxFUbMRViecP9hHTdN6uH2F52RVcPeMqJqSUYjAk4/ZFyExJrPPmbi+/enonSiihUPq6jdaJE0j96c9YM6ywq9/LEY+fETWMKh9N6UPWWNf2FS/VrOGL9s1EDSoPbX+GQFxDFfL4qDmIJxpnv9tKRLeAJBCXRPp0A490rkUVYV6OyrJCB6IA101Nxyy08czu5xgIKzxX00Geq5z3GofY0DFER7iXqBRCFEUy7fm80xih058gErf3BOgN2EmxZhCIhegVw9h+cjOxladhv+t2zD+6nmGjklB6kjBHBhCNEoIA3kg3Snw7WTaF1490sroqi1y7mYkpVlZVOMiyGMhJSqM8bQpJ5mzq3M04LalUZU3ni/YIX7RHKEmdwJGRegRZQ7IZebKmg/eb+gDY2BlkT38aWY4iMhyT2NPnw2go4Kv2PbQOd/wjm59xjGMc4xjHOMYxjnGM4t9CwaNpYNZ0lmS5MEoi23qGubIqj7CmcmSwjM0tQ2TaTBgMmXza2srJxel4Qj7mZml44jbcoSgzs5PpD0WJqRolySYKkgxImgoCxNQ4wViMDR0BTq04i4e2/ZnvLbgJWUrnkT0d9ARCXD/7OmwGHUGHzoCH4YiVbLuFrkE/W7qGAChz2anxRfm0xc0Pv3c3BcP9+GUNp8nB3QtuJRTzEFYg3TGddxoGOLM8mxavjizGkUQRURDQdJ1UiwFfVCXTlofNoJOqiwQnVFJjTCI3MwlXUy2XTJ9HEhLaqDGDoFm4fNotvF6bSBdyh2KElFQumnINqqDR7mvjxQNvJ9I+Zl3Owzuewxf186sl2WTKOYiSgKpoICZxYsmpnF62hCxTFkWL8tnYvp1McybaqDeCLIv0xgZ5dt9rOIw2frDgJnQ1wIoiOzpmypxmUJwIqoxB0ki3mNjR46XG7WNVZQ4HB7z0BaPcOasQIgJhJYPukR5OzDcSUGyIgsBI+GgA5Y3GGQyHqBs4zKqKRWgY2NnTz4wsF63eCGvqewgrKgcGDBQlGxkOdvHigbfJXZRJji0bSU/l+tnXsaPXx/ZuD3fMykHRDKxt7sQfU/ADb9f3sKoim9JkIz/9/Gc4TUl4oz4MokyS0c6EjGperO3lvIsvRsvMot6eysd9QRRN57NWN2dXZJNhVdjdNch/LfsenzV8xd6ePXzWvJE75v+Ylw/3MSk1gD/mIqxEaRis48LJq6kf+g0PbnuSSyefTW5SFmdWrEBApNa9B1nrZlX5It5tdHN5lQur7Gc4HMYdGuatIx8yEBxkWvYk9vQc5ISCWRQ5LNw6M4en9vXhNBm4YIIDl0FF1kR29g5hkpMoSymiPLWYytQSDvTXAnBh9Rk8t+91Vk08nY9bRjBKGkvyHXQFdBakWmn/2V8BmHP33TTYXMzINHL/5kT1nxtmXc3O3hiLs2zEhTBr6teyrHghy4oXcrC/jrAa4S/b/saVM67i/u3NrJ50Nq2eAGBhZYmFZ2uinF5mRVF7ONLfR+4v78JRPJWs4T5GzE4OB6MMu/dTnVnJjq593DTnekySDX/Mz8T0ckyiiQA+frfxYaZlTSLdmsInTZuoSF/Jnj4/pxYnUr++N6eIj5rdTM9yUTvoo3YowCWT8tjY6abFE+Liial82TbAvBwzmp7E9p4QS/IUsiwiJsXwjcpNKoGYj3KXTLtPJKZq5DmMFLmsKDYjV5xZwcKZOXQHwmzoGKYyxcqPF30fq9FMnjMbd2AIUZdo9reyMH8W2zr3cKDvCAsLZ1OeOp2n93VSnGRla+duGoZamZe/kHR7CvfMK+eBHY2UJNvINMmIKQr5jkyeP9hPstnAldWZuMzwccPnHHE3cvvsqzGFbCzMcZJq0Xi1dojiJCsVKTae3NfGdVOzKEstp8vXyaT0cs4qPQVRkcm353F6+TJGIgIvHe7hqsmnsLf7KzLsadw8+3KKnAXEtBhDsSF2dO9jRdlp/HVXB5dVrSQQi+AOx4iOqj5imsZwOEZlajnuYDt5DiPnVch82iYRVjRumJZJT0DlxUNHFVuP7mvlrPIsZqW6jvs70OPvx5ntQhYMvFjzFqsmnoLNYKV+OIovClMyZuKLCaypH2JmtouBUJTh0X0komh0BzRWFJVRmlLIw3tauWJFCb2eJvbvtbNhVz8efxS3N0xuuomIEsK1ZDGGiy7lTwe7UEaVgZ+3+TivMoc0qwVVDiMLVojEObFwIXt7D1GQPIEv2txcNPlcLAYna5sHCCsJkrZpJMKeviGWF2bTMhjj7UY3t8y+gTfrepmRaWBujguDKLO2bg0ry0/mxjnfxx0SOCHfykO72wjEVbZ0D9MfsnBysUquRcUYF7h9Zj6ftQ6xu8/H2WVOylIcNA138fjOp7lh1mo0VzofNLrJdchMyc0kz1mAqBlQpTgHRmqZlDYJd1gl1RwHAfb17mNJ0QnMz0tlJNjLqop0/LERXjnwBtfMvAyDZOHjlmEcRplTyk/joDvIOw0KgVGy9L0mmfMqc1ElkUF/Nyfmi+zqM1M/HGFGZhJnV+Twbn0X+wYSSrkPm/1MTK3GaEhBjDPuwTOOcYxjHOMYxzjG8U/wb6Hg+RqaojEt3ckVkwsRFA1VA09E5cKJeczMcvHsgXZUHT5uGeaTNi+5zhyKLBb29g2TYYlyZpmLNIuR6jQ/v13/38TEMDGjgiDZmZa7lG3dHrZ0Rbn/lN9wZNjKw3s60IH64TAftcjYjHm0eLpJtqRQO+Tlod3NxDWNG6YWcc2UQgA+au5H1eGve9vZLTs4qHi4ec5NNHlEGoc7Sbak0+TROKs8G08kztv1Pbxe20XtkJ/zKnNINRu4cnI+b9f38EmLm6FQmFhqKsLtd/DZQIi3B2OI8+czNdVKBF/CFFoU0MQwSSYD2baj1ZhyHQbMksALB16nZaSdJUXzGAqNcO/Gh/BF/ZxevpwUYyoIEDdIYJZ5q76Hz9v8ZNhyQRJJkzI5pfAU/D4RFYjJIRoDTbiMLs6qXIE/FuRXG/7IHzY9RrIpwtT0JKSYEUlLcIuGmEhVmp1V5WYUXUfGz1nlmVw8MQ+zIrKrrp9HX2nAItn449a/MBRsYGO7m1XlLqZmWHGZDdw1s5QSu5lFhVPIsSfxUVMfUU2m2Gnl3YYEuWMUBdJsTp7e34bVlM/d86/jo4b1uKNhfFGdXX1G1rcPE1Y0Htvbx2AoxC0zcqlwmRGAZQUWpmc4GAl1MjVrMrfNu4lFBXMoTSknxzmBT1qCNHvD9Myai2nyZLp1cSzoaxwJUey0kG6xcVLJImyCnTMmrGB+3kzOn3Q6mVaZG6flIyDw6pE+jgyGyXVO4LG97Vwx7TKum3Exm9p3cvPsqzEaXRwaOkyKJZmoEmRyuoPlhals6/gCRZOJqCr+aIDb517F9KwqzLKDgeAwT+x+GW/Uy/7urSwvtHPhxGxyTA7MUjJtoRjr2gZZ1xpkZeWFNAx2UtNfh0U2Y5QMvFe3jlvn3YE7UkTtUIADAyFqh1Tuml3KgK+Dsnt/Rfm9/wVOgR/MKeOF/c8DML9gDqKYxmetA3SFo4T1MJs6dvKbTX8lpsVZXrIQu8HKOVUXcGBAI8kko2Ll87YQ7zYOgCBx5+xionE3/YFBNvpq8aVn8MT+NnzOFN5uGeS9pkFynRXs7NzPNTMuomE4wtrmAa6feRXz82eyq38vsiBRkJTDtMxqFhaeRE7ySXzSMsRwJI7FkMuje9sYDkdYXZ3PIbePTV3DDIZjPH+wnSUF6ayelE9Yga3dI2zsDFCZYmVVuYsP6t/HIpuPMVoWdQmjEKemdy0XTczGaZI5rzKNVw514VdVlswuZn27lyf29aDpUDsUojcIb9b20uUdItuRwZftm9netZevOrah6ipnVq7AYcrm3YY+OvwRjIZyUqzZpFnTsJiKePlwD2g651XkcFZpNmJMI8PgoizJytLCFFYUWfjTlgd4aPvTfNj4BcPhEeK6gigKeKND7O/5ghumFTI5M4lnaxJ72pv1Pk4oOpXVU6+iPzB41PhZslKatpS3GxJKu7frA0zPXYk/pvJu3adEtQjP7nsFFZHStJl82a4Q13Q+b1NQdIlg+AAXT0wG4MIJydQPfIiieomoMn/e1Y7VaOf8CdmcXGTjvo0PcLD3S66oTsJulJFFgbtmlSDrLfQ0HThu/4+pMe7f+jhP7H2BhqEWworIxKyTybRZiWsCb9QOoGg6qVYjrx7u5KDbxzVTixCAs8tTWVWeQpevh686vAyFY7xa243BlMwZy3K48cLyxH5lSKQXNij9ROZOwBHx8r1peWRYjRhEgasm5/HS4U4ahn10+YN81NqHV/BhFx3cMvcmDrhhc5cfuzmHZJPACblhlhakIgpw9+wCpmfY2dHl4ePWAU4vzeKgO07jSIhPWsPEFIG5OcnMzK4m05HHh80jdAXCWGQJl3nUlB0ocFhINlnoD/XiZYTHdj5GZUqUCpeVKRkpvHaki6GIkyumXUqypYyPWnQGwzEODITY1WfBq0n0xwfw6TGGQgFavF4e39dCp9/LE7te5Fcn3k2WyckZJZnk2zLJsMgkGwQumnw+I1GZoDqB5pEQLrOFuqEwmg7zc1xj7VuU76IwycFAoIcj7nqGgm1Mz1CwGySmZmi0jzRzYlEGuY6Egi/DauKU4kySTeZxcmcc4xjHOMYxjnGM4/8G/1YED4ANyLaZ0IhzZGAnNqkGkwRpViNploT9rFESmZebQkyDjza0cGVVAYHoAJPTUrhycj5FznR+dMItSJqIQbLwZbuPV494ADgyFKTXrzA9M5kl+ckAOIwy104pwCgqdHq7OdS3E0nbw0lFSezpHSHDJmKSRQqSzBhH05iSTDLpViM22cRQxMLaJjflaZOpHxritJJUBoIBBkIR7pxdjCwKKKpKqcvMmRXZ/HV3K/6YwqHBAJmOSraMqDxa04Oq64xE4jywr4smf5idvQcJij76lX42dWyn29dMjrWDUpeVWVl24rHd3PPZj9nbW0MgGuLUsqUApFtTOKFwNsuKF2LQjIQlaBwJ8Nj+Ntq8YVo8IdZ1DNIajFLTMcId92/lBw9voqajhyf3vsSDW5+gbriRBQWzjpmbLKsDi3qsxj4uR3hqz8t80fwRq6uyaRo+wOdNH5JpFQjHNIpKU5k7OZvXP+ziskmXkiVnc9mEfEzoLC1I5uKJuUgxFUkxUp5WQsQfYXVlLmXJNt6o7eLy6jzOKs/iokn5fNbST1TVePFQNyZDEedUrWZLZ4iwopJuNY2l97lMMjajxP7evczLkVmQa2dr+6cEYkO8dvB9FhedxJ5+nRVly7CbM3ilNkBfMJEC8V7zIEOROOdU5rCs0IEsCqyelITLoGGOG7BgZXPXdj5q+BKLaGVqxkQ+a9qAhsCWHiOVqXay7Mm81+BhJBKndthCur0YEBgIxfjzziaykgp5YtdLXFR9FkYxziklmWTZUhiKWgnEDbR5Okm35+CJ+NCFZC6svgR/NMDDO55jbcPnTMlwYpZCiEYju9w+HtvXiqpDSFH5y64WDIZ8LplyHr9a+j1+vvhOcpLy8IRjtPsiY/N2yO2nzTPCpuFaflj/LN+vf4YWe4y/bn+MQCzEvSf9mhznMl6vS9w3T+5vY0evxm9P+jUVKUVkO/LY2V1DfnIxX3XKOM1WFhek8dT+doYjcaKqxpP7BvHFNARBZnf3QVZPuwp32MLK0iwe39tJqzdESFF5oy7EgqLTiWoZfNbqo2bAz153mC6/jw/q1/FZy1ecX3U6yZY03OEY/UGVOTkuLq3K56PmfsKKxitHBujxhTirPIPzK50ATMuwU+qy0uIN8kxNQkWyu8/P+40+ch1JJJkc/HXns8SNCQ8lQYA4MVIMKdw44zImOB3cOqOUxhEVX0wlGIePm/rIS7KwuCAVl9nAZVX57OodZm+/F4Mhmy2dB1jbsI55edP5omULRc58SlOrWNOg0OxJrLF9/TEKXFPITzmVd+qHUHV4cHczOQ4LNkNiSxc0CTEmsyQvnYIkC/5YgNaRTkySkZ8uugOH7iQmh/njtic47K4n2SwTVVRUTUcUYEVRBh809rOtJ0hFWgXv1H+CYFKJaDo9gTCRUdVJSFEZCMUodBYwFBrh1YPvsbRkAWm2LPb0aXQHEgqZLn+Uda0jLChcSNtwDaeXptE5cpCV5UvpCwbp8Ntwh2Js745gMwhE4j3MypnChRNXMhJo5eQiG6eXZpBtMDA1rRK70QqiiGhKeExZ8nKxGqwMBAepG2zi4urzEIUkPm8dYV+/l1KXDVkSePFQB+iwojgDRVNRlD5OLUmjwmVCEo0ccJvY2ZtIYesLxnivMYxscOAxNnHbJRMIGnp5fOeLOLJyeaD7fTZH6nm3cQ1XTM7jiskFvFbbjVmS0BDZ0BFmc+cwQcXAkKbxXM0gB91hdOC5miHWd/iYmjmJRbmpnFaShctgRFVM1A8HuKy6gG5/mE9b+oGESvGRvR0E4wJz82aialFOL5EwinFeOtTJxZNySLMYWVrgYG6OxG+/+h1vHF7LEXcD7Z4uPKE+zp+Yx1v1/XQHonzSMoDdXIZBkjDLRx8DHCYD7qCb9a1biapmsp3Teavei6rD+00Rrpp+KybBjqBLxIMxZNWIrAiElQgBxcBQOM5IROUHcyuoHfLzVn0vLx/uxBdTmZHl5IS8FNz+rWzt+Ip1rRv5pOkrJmWU82H9u9w9p5B3jrxJujWJDNHA1VUFyKLAtVMKyRBkbMZ/C8HxOMYxjnGMYxzjGMf/KP5tCB4N6B4J88iag/z6ye00dPjJsmewuX0buQ4jRlHnyslZWGSRq6rzCMZUXjrYSU6Wky+3tlPtmgh6iM+a3uOBLU+Qak1jWBX5e00bpS4bywrTkUWBs8uzqRsO8PDuZublush1mLmsKpcUo4GoZiWqxJiUOYPy1FIchhFOLUnhmT3PkmmVmJVpZ3VVPiZJ5OZpRaSYLTR5XbxR10uKxYhOEh82efi8bZjqdCeZVgMtQ/s5rSSTiybm8n7tu2TbTBQ6E0GNADQNe5mTncRVk3MQALtB4rZZ+QyHGnnj0Lv8+qs/c9/mh0mzZaELObiDbs4syWRFcQbrWzcCYDVYOKn0BO7b9CgFzhx+vfwn2AxW2rw9eCWdTV1DCcNMU+IBO8koU5Zi48l9rWTlOnA5Eu15Z10ny/NPwmawIIoCD2x5AgCnKWF8eu+mh/DoQ2M+CoIAQSXIkYEG/FE/E1NseMPDrG/dRKO7mbhB5OmDbcyYlkNrV4ANXyo883oX3//TBnwjAtlGOzlm03HVuyRFY1KyjTSrkVBsgMnpDrzRGIOjJsBxTSPFauLIUIh9AwFePtxJfyjKqSWZuMwGzq1MYmfnOt44tIaa/p2ckJ+ExWBke+ceVlaewc5enZ09HmQpmbdqu7hzVgnFTguSIHDDtHxePdLFnt5+8uwxTi918dahV9ndewBVjKOLKpmOPNa3beXZA6/y3xv/Qn5yAe5gkCSjkYV5qXzY1Id7NHVkT1+AqGLiulm38nlblOFInI2dPn5+4s/wRnw8sPUJOn1tlKVPZW3T4Kgp6bm819DLxVMu4b3GYXb3xTi94hRm50wnPymHgUAHv/jiXh7b8TTTM4xcWZ2CLAo4jDL3zC2n1GFiZtYkbGIKqYYsVpYupMBq5M7pJWTbzBQ7rdw2rZg8swldjxNRokSVKG3DXVw17SJunLkaSdBwmRWSjAllgd0oMyHVgkGSOLViBTXuOHPyZtPj6+D8SjuRWIC+QITVVfkYJREBuKw6j0Ckk7cOvcPt827k/UY3n7cN4YnGWTJ6PwKcW5kJgsAbdf1j6T/vN/YyFLVz6dSL+Lx5I9u6D9EflnlqXyvzc5KZm+OiNxChN5ggrcKKyledwwyFRojFu5ie6WRJQTL3b/oz83NsLMxNARLk35nl6VgkgTSzi9VTzuaZfa8RM8TQzTK7Bvay130AQZEwGWXWtQ3QMBzkyimFvFHbzebuYV461ElhkpXrpxXzbmMvBwZ8ALxV7yMuTOO3y3+Gqmn85ITbOa38RDyROHfPKaXclfCDmZNtxioryEIcaXQMTJLIUDCK/i2Fg6xG2dm5HQGBy6edy81zLqc/6CaqKYTjMW6ccRWnlS2n5mAPtkCEm6fnc8XkQmoGvLT7wuzs8WA1z2D1tEtRBIm/13QQUzWum1oAwKWTXBTYfWQ7bJSmFFKdUcnnzZsYCMU4uzybiyZmAXB6qZ1FeRqx+AgfNX6Kw9DHjq6dFLlK2NRtZmdvOLHe+wM8ua+bhYWzObfidIgamJM5gykZaUxIMeLTPCDo+MwC6X+8l4w//QHXL++i8A9/QHEljfX7QF8N/kgbp5WoDIejrKnr5tJJWZgkkao0I1MyTKwscbC+5UsW56fSPFzH9z/+GRdOSGdVeeI6k9Mt3D4zn2d2PcX7DR9jSQvz3P7X6AsOkGlLY1nJQnIc+dQPNROJe4koKrl2C5dV5/NOfQ/1wwF04Ml93QyEYpxTmYXdkDC5npZpo9ipEIsHsekCC3NcxCM6v39yO+beCEcGPOg63DIjoTAqdlq5dJIFmxxCj8t81uolrptZXpjJnJwkvmj6mIsnZZFjj/Ds3tc4d9JKGoZaaB3p5OrpF1LsKmYgGKHLn9hXdGBD+xCSoHNuRRKZNiOL81MoS3KTapZZULiUYFyjfihIaNTnyxuNYzKYieoyewb3EZYCyLKIX9DY5zby1L5u3mvo4YT8VDZ1DrKyJJNipwWAoXCY5YWpzM9NYlfXHjIdaaTbU7l7/nX8YdPjdPl6efPQG7R7uugKBPASxw78cG45DsaNd8YxjnGMYxzjGMc4/lX8WxA8oijQ2O3jF09uY+eRfuo7Rrj/xX3s2a1y7/J7SMZAoc2KBZU7Z5eh6QJv1PXRE4wSSzOxZF4hoi4gaTJOo5Xp2VOIaEYe3dNBw0iIV490kWkzceP0YvYPeNjQMYiqw0O721ldlU+ew0azL8SzBzpYNelc3m8YJNlawGeNH2GR+mj3dhKPB3j8tcO0NQ5zUXkOf3lhH7ouUJJs55yKbBYXpPHS4Q5Cisq+fj9v1fWxpCCDyamTmZmRTLrBxDkTV/DqgefIt3WT7zCxuMBB+/A6YkqAQquRxXmpnFueQ5pkYEb6RCaml+GPBUmzuDAbsnnpUDdLilYSD4d44+CrAAiCgCzKDAQHiakxbplzE68c7iXVmkVl+iReOtTN+o4h/l7TTkmyjdVVeZxelsWrh7vQgWcPdnLxBZO55PSJDAyH2bM3xonFC0m1ZrKseBkLC2Zx7/J7OKvyZOKaQlxTYPSBXdfBJaby8yV3ctfc6zjS4CVfncvPT/gxJjGfFw53ENN01na7ufKSaUyuzMIfimGzGHA5zGhxHUnRvnNNCHGNG6YWIxPBF+kl1xbi6impCMBZZSm0e73EFJUbpieIsUyrxMysJM4uT+blAy9zRsXJzMqZwoS0YtyBXqZmTGVO/nI+aBKxGGQun1zIm3V91A8HeXh3MxdOzOO6aYW809CHNxpnbbOHoJLE9Mw0wvEwL9a8jSLF0HQbET2L6VmT2dd3CG/ER6bNzrtHnmFmlsILB9u5YEIOc7ITQeb3ZpeQ5bDwxL5WegIJgmpXX4i36/qwmpzcPvdGWjxmnj/kRdF0Sl0OugIxSl1JvN8Uxh2KsbPXS7J1JudVX0JhciFhJUKpq5BD7nru/uTnfFD3KicVJXPhhBxcgoDZaMGi2umPxhnRFAyqCVExgBrhgonZnF+Zg6RojMQ97O87PDbmO3v2E1PilDvKsYoS7UM7uKI6AwE4r8KGxSAzEPSjaA7WNg0wKXM+ZtnCbzbch9M0yCG3D5lBlhfaWZSfQrXTTrkzm6unX4g34sYpH2ZFoZ019T1IxDi9NJOKFAstQztA6+WSiRZy7SaMksiP51YwPz0JX2SI3634JZ7YRN5r9KHq8PyhboIxlQkpNq6bkmjfqooszi/Nxi4JTM2o5JKJeaQajNw0azUuwcApBemkWoxcMTmfPIMJKSpw7qTT6A8OUT/YQrvfyzuN3dQNtbOpYyeqHCMWiHJWUQaL8lL4qmOQ1dX5pI+qCNu9IxhFuGpyNunWBAk2P8dKhSvAX7c/wZO7XyKuxnGYMnjmQDsH+r2cX5lLnsOMTR6GSJwik86qcieyKHBeQSYP/20XXu/RqlySJHBw+AgfNKzj8mnnsqfnIM/sfR1FV+iJdvCzL39HvbuFZKWYvbUjPPLqEbSwhkkS8UaP1iOvTndxZNDHY3s76A1GEkRYWOGMsixKk1NItSbzx81PMSGtjJbhDk4pP403ant47mA7eQ6ZaRlO0HoJxb38cetT6LrO6wffxh0a4vcb/8I1k3NYkJ1I4ZmX7eLWGQXooThi3IBklpF1I6HoCL/76vfs6z/IC4fe4vGm9+gSDNQEFNS8Iu7f2cSI0URlailL8k9gZ/c+9vTWUGBPZ3lOKqeVpiELQW6bWUKOzULr4BHy7FYuqTofPawxI20q9634CW8cWkOPdz8TU61MSdd4cMsfuX7WpUzJrGIklsyZE1bxi6X3MBKFDm8PmpDFZdNWE4kPkW4aYUo67Ov3cFlV/ph5+vxcG+iDuEx+Lp6UQ4bVxBll6RTYkxBVCbfShzc6QEgcZkJhCpoeoTrdTKbViKffz6yMZM4py6bEkUaSJZ2mQJjdfR4+bg4gILG80MmBvoOkmQWybVYahlrQdI1iVz6iYObQQAOd3lbKbWZ+OLsMh1FmaoaDG6bmkS4ZsckCF07IZnFeGlMyp9DiM/Pk/kGeOdBGRFU5pzIHgDtnF7G+fYCdvW42d+7m6b0vEyWCWZKoSLHgMMoE4yqftw5Qne7AYZK4dFIeZlnk4ol52GWFcNzNhdVn8O6RT/m0aSMRJYJRNrCy/ETm5E3jtjnX0OY18lXnCLookCyIoH73Hj+OcYxjHOMYxzjGMY7j8W9B8EQUjWfXHj7u+NpN7XiGRFRFQ4xryFjRdZ01o74sANt7htnv9qLIErJuYmXZMlQtxuG+HZxXIVI8qpYRCZFskliSnzYmaZ+cnoRJEtndO8I7Db2cXJJBm1eibjjEO/WDnFu1mgF/P+F4hD9seYQTF6bw7rpGag/147AZ+KSpj1y7iUKnGZfJQFly4g29JEB+kkjrSCc7a/p47aNagqEYQ0MaaZZ0dnfv4qKJeSzMTackpZzaYZ3Pd3STJxrobvPwm7/twR0ZoT8wyJXTr2RRyWpeOeJGB54+2IlXkChPm8Diwnn85dT/4rqZF/POkU/43Ypf0uxRqXH7SbOV80VbHytLUzm52IkOyEKcgiQLQ+EowXjCkyMYV3BHY2Sm2ZhclkJFVZwvW7YwGNbJd00mNymLlpFOlhcu4t5l95AuZSZKsougyFF0DdLFLHRVZOOBDt7+tJNo2MrhkQDdgYS6whuNU+PxU12RxtTydH5yxWzM8j9/qyuKAgOBXp7Y8wIPbnmMQGwIVR3hxulF5CUl8W7DIOs7hhgJK5xUlM7kNAOPbH+ITKvIzbMuJ6hYuHzqatItaWzZEmXDxiD7DvZyUVk2k9OduINRuv0J1UFE1QnGVYIxld5REkbRdA66QwRiMe6cdz0/XngLRt3O/kEf79T3sax0JdmOTAC2dezh1jlXkWGxcFZ5NukWA0sLXMzLTsZlNvHsgTYumZTLzKyEEuqc8mRSTfX85PNf0zbcwtQMJ2eXZ3DrzBLavUFqBwMIAggcVXfkJtn4085mVpSdzPqWrdwwezUAZSlFtHk6mZuTRqHNQlQQ+LRtAMUo81pdN2/VdTOsBcGosL5rM/u7N2OR48TlCI/s+juheJi759/KHXNvIhgL8ejuvxPQwii6hVMrzmBrx5fcNL0Qi6Thieh0+SVerU1U8nr2QDeHhwz8fOlPqUzJ4ftzysmy2cl3wOK8VNSYilG1UGotI1lPYU7OJKZlpjApzY4kuCl26pxemkZRciYHeuvItds5szyFs8qycAgaDd5GXjjwFo/veoY52TozMhNqgmybiSybiUyLEYsUZWVpBrkGE3fcv4EfPbifJ19vZmQohKhIOPUUBE3CoGrcMr2YDIMRTdMJSj4UTaUqfSY/X/pzNnSE2dXrY2buidw45xZk3Z5Yh4pGgcWEiI6qeTi7Iplch4nCpAgj4S6ccpSLJmaTaTWSYhqgPDmdk0uXcvbEs4jh4okDbXiicT5q7qdpJMgtM0uZnFrCE6838NALTRRYHFxUkcurHxzBF4xR3zGCMCqRU1WdSSkVLCyYTXX6BCakluKPBnh814v8cdtTaLqOw+Dky+19zK1KKG1++8QO3B1eTk5zMSXdwY3Tiqgb8iEKAsnmo/5drR4v83KSMWkCwWiYofAIKZYMlpaez7uNGu5QjP5gjBcODnBJVT6pliQMooxFtnBi8QJ+tfgHnJi/BH8sQO/QANmaRLrVxCnFGVjiQsJrRRbZ4/ahSiJ2yc6cvOmsb93K8pJF3Dz3Nnb2RnFZ7OwbUBmOxNneo3PtrJtYXno6M7NmUGwv49k1zazb2EaBxUaSnowDgf9+dDe7thq4/d6t3HX/Dhq6fUiajKbp7O87zOH+Q1w9pYjhYBd2o42h0AjLS1fycfMwOhn0B+GrzjCXT7uaVw93o5NJmi2d3258iPdq3yTTZsBujHJeZSoFSWbQGtnbvZv7Nj5KkjHKBRNSeHDzX1F1lc292xmJerhv86P8btPDnHdaOpa8Th7Z8VcKkmLsONjD3DQnybKE2WhnTX03zx7sAMAdjnHf9kaiqpFfLPk+ihrl4R1/Z0XpYrq8PQwEh5iUOZeZuQt4qWYNzf4WjKrKRRNyOaM0GykqICEixR0kISMLIWLxIOmWAGeUJQNQPxSgLNnMHbNKOdDv4cCAn3VtI8zKO5vrZl2LQTNjjIlUJdu5cVoRogBXTS4gwyRiVgRsushP51fi0EWGw0Pct/EhXq15j8umnoNZNvGX7c9w+dTzMElGCpwVRPV8tnb72do9wk63j5Cuj1VnHMc4xjGOcYxjHOMYx/89/i0IHkXVcY+EjznmcpiYOSED7RvpO7qikazB3TNKE2a/gsBVFflsXdfCLfeuo7Z3gI+bvmRzxy7avV00DR3ihDwD0zJsHO7fikyQKruF1ZPySTYZOLMkG13VafeFuWF6MT3+CB+MlnsdDMd5pdbPgqJlXDtjNTn2HPoHo8QVFUEQmDOvgL1uLy8d6SLJaMQkCZxSbCPbbubU4gwktZmQR+WtdW1Ul6bxX3/bwS8f2wP95ZyQfAa79vRiEwyk2yfyQWM/ZWXpfLaxhbc+refSMwp5aMfTKLpKriMXRZPGDH/jqoYnqDA9ayrnTzwdo2xlfcs2vnfCXbx82M0HTf2cXZ6NLyaxoWOE52q6qU5PpdxlJ6528OL+v+MP7RzzKbm0PIcj27v4y/O7KS2y0uZv4ppZ17CuPczbdQMUuyZQlFKGIAqYFTualiB3emLdPLL7WaJSkJgU5tXaNUyZqVGSZ+fXj2+lY28/FxZnA3B+ZQ4XluWQJErccFYVLquMIAgoOsRUHVE6PgBQhBjrWzcTjkdYNeEUUswu2j3d2AwyzxzoGCt//VrtADOzXeQ5UkixuLCIMrLg5Il9rfQGVOJeJ1/t7mfXwWFeeL+Oh57ZhRpR6A2EuHl6DrIosCDXRr+/jvJkne/PKcUoCpxUmM5lkzJxCSIuMQWnJZ/Xm3p5t7EXVdd58bCXFeVXc+Ps61nXupmtHbtJkpwU2czYdAGnbGFeXiqP7W2hwxfmiX3tzM1JY1KqnZjSidVgpSK1lLeOrMUiK8xMc9IXiLC8MI2mET+vHu7klJIMTivN5PLqAt6u6yGqanzQ5OWK6dfzedMWJqVP4IbZN5BmcfHS/hfRxRhDcYUMm5k/727CHYrS6o3w0mEPjT4f/UEPX7ZtIBoPYFBM3DnnWq6ZfhFWYy4WOY/zK1dxdsGFPPF6PfsHPWzrdmMx2JBEnQ9b47jDMawGCZOcSFMxSgITU52kmlNIldKIBaLYtWQKrWlY1aNzmTAxFsgz5WGISlwzpRADUTKMVvIcVlwmJ0tLT8FCMvkWB1NTk4hrCmm2LBxGG9dNv5LC5DyKk/y4zAYur87DpuiIUY1MYzqTkxz85fndROMqcUWjpmmQXz+3k7Ci8/X2oetg00BQNEJigD9sfhR32E9A0Xh0bzeto8qZkaiJZw904I4rR0s663FOLklmY+s6onE3108tom2kib9ufxpZksmyGLh5RjFTMoqJ+W0c3mVmZs5shsNxwqMKNR1o9oSIxBREzYwoCXgCUX758A66moZp7kqQZgb52C3doFq4ZMI5OEhmZcWpTMmcSFyNo+kaK0tOoWaPxP6GYerbR7hs5QREUeCxNw7wycZWLq0q4I26bj5uGeDvNe1UpDgodlqZnZ3MzAwFWVHR4pBpyOLXy35IdXolZllmTnaCiBRIpCL1+gd54/A7hBWJW+fdglk2sa+vhpXlJ/L9Bd/HYU6nJM3OPfPKsYymmImiwIiq8kZdN72RGMGgxJkVpzAnbzYxLY2XD3u4ckoRmzoH2dQ5DEAgDgcGfHzVPczijFPZtVWgpmEEXdOwCiJxFR594wB9wyF2HnKj64m/HX9+dR+BqIpdd/KzRXfwvfk3ogTizM+eyW3zbqEzYOW1Oj8n5KeRZHbQH4wzKS2Jvx3oIabpvFbbw54++NWyX3Fx1VlUpVl4atfTOIwxVlUk0zBYx4mlp3PX/NvZ0bmNLk8dfYEBPLEY9UNt1PTVsaJ0EcF4iKCq4o66CStRwqEop80tRYsqDHsihAMxzqvM5bpRw/4Mq4l75lbgEkRkRaJxuIWB4CBTMitJMadx5fTL+ag5QF/QweLChbSOtBPTYxTazNg0kGQRzAb+/NpeWobb+PG6e+ny9/Jly+d0jWxjbk4y51RkEVU8jERifNWZWGOqrrOhM4gnCurochPiBlyixC0zSvh4fTO33PsVt9+/nr++sR89oqIqGslGJwXOPK6ZcQkFjjwqU0uYlTOL/X2NZNpzcIdUPmjqH6tH93FrP13BCKr0b/GYMo5xjGMc4xjHOMbx/wmEb/uX/E/D7fb/b/9BVYffvbib1h4fkihw2cqJKIrGkbYhCjKTWDo9l2SbjP4NpbdXgJ3dw+z5qp2G9hEAfnZTFU8degJREPnFkjtZW/85gXiMlRWn8ODmP/PzxXeSKqYTEwV8qkYqQsL/RRbZOejFF1Moc9l5an8bBUkWrqouwKBoBJUQtR1DPPl6I7++eQH7/AG29Y6MtcUsCfxoXiVmNJqHwwwPhWjtGGTDrl7yMx0U5zj5bEf72PnpLguXr6qmS4uzqWsInYRx9NLsFKwRnQ++aOTiVZkEBDdTM2fjHgkSlFReONzPlWW5fLq+iRvOqgaLwGt1veTbOgjGfFSmT0fDQVjReKe+m6/tPJwmmZ8tqOSrti3Y9GRMRpEmXysOy0xKTTK/enQXAFecMYmSCam8eKiT4Khvw+qqfNY29XL7zFLM8dFi0oYYfz/4Ont7DlLozMNpdlDTX0uuI5tTMi/g0VcaADhpXgGOsmSW56dh/caqiWs6h9tGeOvLRsJRhZNm53PijDzys5243f6j50lRuoPd5FvzMWBgSBukx98Poo2t3QbafSGumZJJ8+BeluTPxSib8cUF3mvqpXYogFWWOL8ih+42D2s+ayAcTZBCf75nISE9yhsHX2F+0SU4jQEe2vZXTi9fxhmlp3BgOEJ5shWzkmi0IAhEJYHakQDvNCSCwlyHieumFiPqMf68/RFumHEZLiENXdfRBYGQquHVVN5u6B3ziTm1JJ0lBWk8s/vvzC9ahd2g8IeN9zEjp5qrJ19CSDcgCHHCisgje1r56bxSVCReOtxBiyc0Ni6zspJYkGsgrom8eHiESyZYEESJ3b0anqjK4oI0DvR72NefCOjm5dgpccZYW/8ut8y6HCep6KNv1uMGkYf2tiKisyovneZOL6nZDta09aED10/JwWk282lrH/v6gySbDFw8KZcn97XxvTmlRBWdQExhgu3YalTfRlwWUYCYP4Y3ECUl2YhFNpCV4aDLE+D+nc3cPqMEm6qj6WAxS2zq9zAr285AQOPQoI+TCmwIkhVZ0WGUOImoGt9/aPPY3H4Tv75+Hnmp1uOOa4Y4XSE/O3ojyKKR6vQkvuoYZG6OC3cowrq2QVLMRq6ZXIBLlhAUDU1W6A33kmXOxIgJjzaCpmskC6NjKQloms7r61uoLE9lfzBIVyjCLdOLeWJ/G3OyklmRl4oe1xCERErq/S/vRvmG544kCjxw+wkkWwzogC+s0DscxCCJZOcm8WpdNwX2Ft6tfR+AJJODu2bdyX1P1eALxvjlNXPIcFkIR1VsZhmrzYhfjfJJaz97+oIszrcyJSMVf3SEx3c+wo8X3kq2MQddA0EU6I7HeWRvK3fMzGFLtx9JgFLnMPt7axgKeVhQfCm6Dts7XiPDmsKFE87iwHCciKIxP92JoqiIgoBmEKkbCbKmIUFKyqLAKUXppFh8vLT/eeblz6fINZlPWoOckJ+OOLonpJgNvFHXTUzVOK8im1K7FWIqDrMBSYBATOWOP331nevrV9fOpTDdhiQJx1RqUo0C3aEgjSMxJqQ6eO5AG0sK03EYZT5rGcATjSMAywvTmZ/jwkycbX27eLnmHa6edgHVmROJqCJP7Ovn3MpsChwKJtHImrpPQZpJVZqALAQpSS7irdq1mE1zqXCBhB9HvIDfPLtzbG1WFrj4wWUzkUR4r22A+TkpZIhHyQ9NVOiOdJPtKGIoovJ2fTdd/sjoPZzMssJ07BoJwzogKAm8eKSTCapManqY52qfJapEuWr6BbjMTmQphWx7CroW4kD/EVJt+bxRF8ZhlDixQEMmSmVSGcJoRURFh82H+3hh7ZFjxnZqeRq3nz8VUdeJyxFEBAwmMz//4ndcPOVaQOBvu/7KWZUns6BgCY/uayOu6tw1swSzqo/tC+npjmP29/9dSE93/MsSof+J55dv43+qn///gPG+/+f1/T+13zDe9/G+/2fhP7Xf8D/b93/0DPNv8WpMFuH6s6sxyCLnLytn84FuXv60jn31bt7b2Mw9j25mKBA/5juB4TC5ojxG7gA88lIj10y6ll8uuYutHbv5qn0HLSMt7OnaTkSJ8rtND+PHj6BopMmJMtjeiEIorDA13UmG1Uyx1cS8HBcXTcjFENNYs6GFXz62FzWcSPX63TM7MA3HOLMgA4AUs4G7ZpVh1nQkTaCteZi3Pq7nky1dRGIqxTlJ1LUPH9P2UETBH4iSbTdjGn1jbzdIOGWZ/qEgvcMhXnuvn+lpM2jxhTFYzaSKZlaVZSPHNa4/qxrZIrO7z0/DcBCLsRSDZOLpXQ+TYtY4OODle3NKsBskkk0Gzq+00uvtIs+aw7trhxGDaZyQP5XlBWnk2B386c5F/PnORSyZnE2W2cRpJZnk2M1cXl1A3ZAfb1ThnfoemkdCPP9JHbVNQa6YfAHVGRW0e7uo6a8l25HJTTOu4ak3msb6+eWODpbnpWEdlUKIooAoCuyo7eehN/bTMxhkxB/lzS+beGzNQXzB6DHjZFBNlNpKkTQDmgYpQjqTkispS07nggk5rCjMIN9mYnH+HIyqBR0DBwd9NAwnquiEFJVN3UOUFbkoGFUlALzwXi3B8CArShYxJzOFkqRUFubPYlnRItS4yASXHVnRkaSvvYZ0jIrGdKeNy6sKsMgSN04r4uCAl5gqc+fsm9DDSUQUjZim8/Jn9dx+/3p++9AWlrqcuMwGTipMZ2l2KiPBfs6vvpB36gfY0RPjx4u/x1XTL0CIy9g1sKtGUiSZu2eXYVIEjJrONZPyWVWeUEOdV5RFkSYjiw4+aQkQiCns6RNIt6QzyelgJBLj7zXtFCfbmJjqYF5OMtHYbh7f+Sid3m5q3U2oQhxNFmmPxXlgZ0Lp0x+K4ZMFMkuSeaOll7imo2g6T+zvptkTZEGOzIxMJ5k2E/5IO9dPy8dmkHmttos367sJiAKC+N3bkSgKNPqCrO8Y5KXP6/ivZ3Zwxx838eX+blpHArxV30tYUXn2YDuNvhA7GvrpCETpDkTwROHV2i42dw3RFRCQNUDRECUBYTT1IxpXv/N3lX/g/SHLVhpGBPb3B9nVO8KrRzq5dmohjcMB1rUNAjAcifHYvlZCAoiyiKjI5JsKkFQjqqqTRDLJQsqYQbim6miiwKpTyvlgYIgGb8Lc9pmadlaVZ7MwP22MlNJ1nYKiZH587VxMo6a9aclmfnvjfFLsRhCgtsPD9x/ayNPvHsIdivFFh5tmTxCToZT7VvyGy6ovYnr2NFSDidWnlZCbbiMzxYrVIOGyGwlFFVo97fzii1+xON9Jjt1MksFNMNqNoAeIq3HW1H2MKsWIyiJbh3w8sb8NgMf39bI4P5OTirM50n+E86pWcf7ka/iwaYAPmwc4b9JVXFB1AX0Rkfcbe/m4pZ+Dg34+39fNn17bRyiqYJSEMQNpURAwyyKhWJBCRwGzUmfS5z3EwlwrvkiUOVnJ5NjNvDlK7gC809hLTASXy8LXAj9JELCYvrsSk8koocoioW+lA0kxnTyjkUU5Kbxb383ts8poGArwSXM/t8wswSAKXDIxj+XZKVgUHUGRmZs5i98s+yEzM2cRVe2safDgiym8cqSbJo+IN65SmTGPPf1BtnYrWIwpNI10UJW5gB09AbZ2K0Q1maA+gtkojbWlvmOEN79oRNB0Ti/NJO1bVaVETabIUkwwrjMUiRH/BmEaUwFdQCexh0Zlkc9aB+jwhdGcRrwjdm6YfC0A79d9zsM7/k6uzYY5LiLqErWDjbx1+HXOn5DNBROzeWHf32n1dKCMskVxXcftjRxH7gAcah4iHFfxR1UiQQOKYOK5mh7umn8XGzqirG+PcN2saxAFEUmNcdGEPC6amItJ0f8p6TuOcYxjHOMYxzjGMY7j8W+h4IGESsITitMzHOSBF/cc9/mCydlcd+YkGH1gPNzu4Y+v7j3uvIIsOz+/ajYRwcsTe1/i5lmXE/DJ7OzfhiiIDLZkEgrqXLi8gifWHKS524tRFll9ygQWzsxFjKloZhlBURn2RPnhI5sBWDojj7wMO+9vasEXjHH+SeVEMszMznaxY1sHzV1eFkzJorIwhZ89vhV1tJ0zKjMwGSS2Heo9pp23XziNdTs7OPuMCbxY18WlRdk8/vJeAuEEkXXbBVOYUJnOH3c14zTJ3DytGKssosdUVKPEQ7tbxpQhAEVOC5dOSmNd85ecUn4GJiFKo0cjElGw6yHW7+yjpt5DRoqV718yHatBHEtficoiOmAeDUAlg4hmlHlkTzPd/qO/kWYx8r3ZZWzZ3YXDpbF1+FMODiQCgrykbO6eewM+j8ym/d2EIwqLp+eSk2JNlImXRVQBtLDCDx/ZTChyvOLij3cuxmX5F0vpyiKaJCJ+S7khSCIeXeP+HY2cVJTO0txURkbCPD461xaTzAXLy1k4JQNJAFEfDcAMKv4AvPhJLXvqBnBYjVyyooIZFekYvhE0KrKIV1UxSyJ/2NHIpBQHhYrIKx/WkpvhYNG0HJ55/6ifVJLNyLWrp1OUasMqi7QFIrxe101gNMWswGFhdXUBdl1H+IbyQJRFtG8YUAcF+LhtAJdXYc6UHP52uB13KHZ0/pMsXD4hj/bhIC839/LjueWEtSj9gX6e3/cM106/iCf3vEJUifKrpXeTZcglJMCOvhE+bR0AYFGWiwlJVlQEXm/tRdPhzpklWCUFX2wEkyEDVdMxSTF6QwJ/P9gxFpBLgsBFE3OZnOJA/8acaLLIQCzO0wfaiSgqZxdm4u0P8vHGFu65Zg6b3CPsHVUaGUSBKycX0h+MEIgrVKY6eHJvK9/ccE4sTGN5XjpPvV2DPxjjvGVlfLW3i037e45ZB0ZZ5ME7FmH/RoA91iZJodHXiiYk89JhD3Oyk5mbYyDZnEKnJ8hzh7soc1qZZrGRYTWSn2blX9lmBVlk96CPQqeV12q76AlGWZTlotrlwC4KuKwJg2Ykkfc7BpiTk4JTSaRdBsIKB5rc2C0GqkvT+PGjmynIdHDXFbN45EDrmGmyzSBxXmUuRckWhkJBntrfze1Ti7HpAhaDiCAI7Kgf4OVP6rjhkkJeqH+Oc8tXsahsNnXuI2xs3c7Fk1fRE+gn15aNWbMSk0SafCHeqk94m9kMEpdXFZBrNSHLGoeHwrx8uHNsHlZVZOMwGnjpUMfYMQE4uzQbbSjC39bU8OCdi9HMEg/uauKikmzWr2/mtOVpDA4pvPdFDz+/fhqSyYCIEauqY7QZ8UXiPHmgneFIjHvmltMbilJoMSGO3geiKPDZni5e+bT+mHEvznHy08tn0hWPs7vfw3lFmccZ+4qiQEc8TpbZSFDR2NPv4aTcFOr9YYrsFgzfMnsXBFANEjVDft5t7B1b5z9dUMn69gG2dR99sXD37DL29I2wsXNo7JjVIHHTtHwOHx7g+Q+OtleWRB763mIssnRc9UBVFukMRXmltgtF07hqciGv13YxNcPJKaPqL0kSUE0G7ttWP5amClCSbOXaKTk8vONpbpx9Db9Y91vOnbiSORkzETWZuBwhrscwiS5EdCK6F4NuQlaNRFWdv31wmJkTM3nqnYPHtEmWBG4+bypba3qpaxvi3JMrySpIAknk4+Y+BkerBaZZjFw6KZd0gwFBENDhOAP9cQXPvz/G+/6f1/f/1H7DeN/H+/6fhf/UfsP/GQXPvw3BAwmSZ+uRfp5+79Bxn00uS+X6s6rxBWNYTAkPlx88tJFvvyC87JRKTpqZh67rqHKMYEDk7r9sZOGMdHQdNu91c91Z1by+rh5/6FhV0NVnTGLp1Bw0TUPXobnPz71/3zX2eXaajWUz87GYZWZUpKObJNZtb+OddUdVK3MmZXLesnI+2NRCZ7+feVVZzJyYyU8f34qiamSn2bj05Eqau728+1Uzq5aVUT01i+6mYd77qgWzQeLH186hKRjm7foe1NH5Ncsi10wuJN9iAk3Hp+u8Xt9FiydEZYqJ5YVJHO7fw/v1n3Ja+XJOLTkRXTej6TotHV5au72U5DopzLSPmUxDghDZPOAhrunMS03CZjfhHQkh2xPB6N5+D2ub+5mT7mRuhovn1tQwdaKTqmozf972GOnWVJJMduqHmilOzufOOddhwQYIKKNG2KIoUB+K0DQSZGmmi1vvX/+d8/+bGxeQ6zL/6wvmH0CQBDYNeJmVmYxZ0RCERPpBKKIgyyI2k4T2rXLUYUXjF09tZ9gXOeb4redPZXZF2tE30SaZXQMePmjqG/NFSrcaObswC3ePj4+2tNHZf+wmcOqiYqoLkqkqTsWv66xt7qPG7UMUYGVJJlNTkzAoOmaDiP4P3nj3eSPIJpmfPLQJs0nmvJMriCcbWN81xMm5qQR6gnywoZm5k7NZsbSEdFlGNCrs7N3F9OwqUm2Z9Hq72NNbw9K8E5C1xPwKBok1Lf2oikqo2cuG3V2kuyysWjUJh83IlCRrwndJAF0U0HWQ0ImJIq2BMC8e7kTVdC6emMeEZBtGVU9Ex+iIskRrKMLT+1v55nCfUpROSlTgLy/v4YIVFVRWZ/L0gTZOyHJRbDKhSAJf9g2RYjWxIDeFd+p7GYnEuHl6McaYzs8e2TxGoFpNEvdcOZtnPzhMe29i3M1GiR+snklJlh2+YzhjhiD3rPsd07Onkuk8iYkp8ODm+7lw4jnEh/IZtEpUOWz88ZmdFGQ6+NmVs/naE1wQEvvUccoEWWQgpvDXPc0UOy2cUZrNW/XdlMdlWttHuP7MKgAUSaAzFOHZgx2kmA3cMLWIznYPf3z5KFl9/dnVY3vglIp0ViwqZtPgCO5InJumFdHqDeMwSbzf2Is3qpBnN3PxpDzSjAZ8vijff3gTcUXDaTdy2+oKvtjex+BgnB9eNQVNiGFSbEiSiDpKWmijaht3TOFPu5v54ZxyUr/Rx69J04f3tqDrcMfMEpJlEb+q89DeFlRN4/zCLDZsbWfXoYSH2UlzCjjnxDLqfUGaDg3w0aZWTEYJs1Hij99fSl+/n3U7O4gpOvOqsqjMd2IQBQY0jcFwlCKnjfu213PTtGLyjYaxtsQ0nR1H+nl7fROhSJwl0/M4f0U5AV3j6QPt+GIKl03Kp8JpxaBqxxBzglGCuIouieiyiBBRwCghxLXjyJax74gCARF+v72REwvTOCk3Db8WYW9/gI9b3LhMMldPycMsS+zu9fJZ2yBOk8zl1TkM9gZ46OWaY9aKzWLgwdtOwDJKsH/9u6IkEBQFXq/tpmEkAECSSeaCCblk28xY40fJEkESCAKv13fTOBJkfpaL2bkmntj1GJdMuZxPW1VmZQ7x8oFXuO+kH+MSUtF1IUFafZv4kkT2Ng3y0Ov7Oe/EMrYf6qPbHRj7/NR5hbT2+hj2RvivWxbw1ME2TLLE0sJ0agf97BpNVT4hN5WlBanYNP7hHjZO8Pz7Y7zv/3l9/0/tN4z3fbzv/1n4T+03/J8heP4luUNlZeWfgXkkwp076+vrd33jMzPwJFBVX18/639DW/9fQ9d1ctNtxx2vKHCxZHoe9zy6ZczP4LwTy/jB6pk8/OaBsWPzqrNYOCVn7IFajBvpHfKh6bBpj3vserIsHkfuALyzoZm5kzIxjio2HF+/cR9F72CQlz+tIy/DzryJmbzxeQNf7u485pydR/pZMaeAa0+fiKLpGEa9OX5/60I27e+mOMfJoZZBGkcNL9d+1YwkCOw50s9Zi0qoKHSxbls7JcUuTivK4IPWfgyiwKUT88gyG0FR0XVwAJdMzOPPu5o5qchBptFCZsFCfFEf8/NnYtLNKKNvUCfmJVFV4ETTjprOCgLEpUSQ/knrADo6Zck23q/t4oS0ZCLdPiwmmSkpSRxw+ygyGKltcNPU5aWqLJXBSDIXVJ2LI5ZFisPKx/J7zMubiawZUbSjQYQui/THFd6o6yYUVylLtnHjhVN5/t1DRGJHU2tkSSQt+X+d3AHQVZ3FeakQTSQgJEgJcJgTt8u3yR1JEuh3h48jdwBeX1fP5JIUTJJAOK7j8QYotlmYlZXM9p4RTJLIgnQXHZ0eRobCyN9hGP3JplbKL5gGqoZdh4sqchgMx6hOdbB/UwfP1A5gNcvcfO4UJhUk8113us1s4PsPbULVdILhOC+8d5jf3bWIzkCEqDvCmnWNAGze182yWfns6B7k421tLJyeSSjZxvOHm7ihuoAT8xchqUerKelxlZOL0okpGg+ua0uMhygwIdWB3SyjKRqiOBrsqzoCCQsQWdOotJo5vSSTkUicKck24jGNZneAtZtbSXGaOGl2IQ6jxD1zK3hifyv+mMLFJdls2dHF1v3dADR3eFgyI5+p6UmkqSIPPLsLs1Hitstm8HpnP8vy0rh0Ui6HB/1kGQ387G8JdZwgwHknlpPsMLF5fw9Xn16FLCdIixSHGbvpeIUEgC4IRANGfrjgVoySTKY9i5gS5Oppl9DTYuPtz+u49/YTePOzekwGiZiioWo6BlnEH1Vo7vYx6AkzodBFZrIZWRSQrUY+au1nQ0civavFG2ZH7zA3zSzBNxxiaXU2LX1+HEkm9nj8bOlJpGwOR+Lcv7ORG6cUcfL8Qj7blvDpkr9BwNY0uDnU6OY3dy1iRFX5uKWPE4sy2djhxju673UHIuzoGmZ6ShKxUJz46H3vDcS498mjZHnADy5rYn/9ZqA/rKgYRJFUg8zVkwtwSQn1mAZ4Q3F8wRgpSWbOr8xB18GFgBbTcBkkzijMwB9VeOntQ/QOBceuqSgaMgLmsManWxLrKhpTuf6CqTy0t4UTU5xs2JtYA1trejhtfiHnLS0l1WwgrKk8uq8FVYe/1bRzTkU2E112TKqOEVgyJZs5EzPR0bFZDPTFFB7e0zJGuL50pJNlhWmcWpSJ8g2Vmz6630g6iKpGWIegL4pBEkfXC8etGV3TsSNwdnk21akO9LiKUzIyLzOFgwN+FqQn89RLB+l2BzjrxFIKHBZOKcogQzDywDu7jiMCbz53Cp5gjK2tQzhtJiYWu0gyG1AUFYuqc+WEXLa7vXzQ1Md1UwpJNchIOnijKpGYgtNuJB7REAW4cEIuT+5vo0A00Nzo4bqZN7KlK0pfMIhCEb9a+jMMqpU121pp7PQwc0ImcyZlYDcm+hpRdY40udl0IKF++3hbGzedM4XXPq+nZzAxl5WFLj7ZnliXf315L2csL2O3x88LBzu4eGIuqqaj6zqnF6ajx9Xv4lPHMY5xjGMc4xjHOMbx/wD/twRPZWXlEqC8vr5+fmVl5UTgWWD+N055ANgPVP2PtPD/IbJcViaXpnKw+ajc/ZR5hTz65v5j1Dpvr2/itgum8uBtJzDsj5JkNyCJInFVwyBJY+ZEhu+o4PGPfAGicfWY30hxGJlXncX20bfSkCBGbr9gKsOBKDVNg8eYpH6N3sEQ5TlJGESBUEzFE4ghSyInzS7gnkc3U5aXTE66jZZuL4qq8/YXjQgCuJLM/NdT24gpGmyCxTPzmFrmpNRlo8JmRlO0Yx6g7XoiZUCIh5E0A55QnInGhbz2bh/5WUGWTs8jySwn1EzfbqdBotUX4sXDnWi6zvy8FLqCEfYPeClxWmlrdPPpljauPGMiN0wt5Om3a7CaDeRl2KmoSOfFhh6uqa7m3Q/qmFaeziXTLsLn1egfjpPqFDFJInFRoDcS48lvKDieO9TBypIM7r58Jvc9s3NsTB+4ezFmo0T3QABN10l1mtFUHVkSsRjEf93LQRDwRxSG3UEsJpkUhxFZ+McveOOazq4G93FKsK+RlmwhHFPxazoPvLibgdFqbz+/YR7tthCzUp18uLaOroEAyXYTZy8ppbXnWB8LWRIpzU0aI9fEuMb55Tl09/jYU5tIjwpFFP706l4euO0EUmyjxKIoEI6pCAI4rQauPXMST757NGB/59N6br14Ojfeu27s2KJpOWzY3cnGfd0k202kpjjZ3D1Mlz/Mjn4PczKTkYWE0e/XKg6nJIIk8V/XziWmqBhlCaMkEImqNA0EaOv1UZDloCDTgfkbBJam6UxNT0IDBE1nV8MAT797iBmVGeSmO/j1M9uJxFRcDiO3XzeHlqEgb31QS2uPb+wa5ywtw6jrnF6QwW+e2g4k7sODtQNcu6CQdLMRWYD0vFRiIQW3JzH+Zy8upaFjhJqmBKny+c4O7BYDv71xPjaj+J3kTlTVefHTWrbW9JKWbCbJauKaMx3kploos1Xx8OcbAfjzi7s5d2k508vTicY1PMEYZqPEL5/adgwxfOq8Qs5dXIIYibM0NxWnUea9pj6SjDLzc1Mx62CwGmkbCHLf87uQJYHTFpVwXmkWa9r6SLcauWJSPs+vOcTBxsGx63YNBKgscFHfkVBHaDocONzPvFl5aLrAE3tbmJuTwqqKbN5t6OWyilw+XdfMm40HuPm8KQm11be6bzXLY34/cU1nyBclpmpkZNh543AnZkni8lEVlhpRiGs6H2xpY+2W1rFr/OyGeeRl2MdSB+NxlTybmSPu4TFyR5YETp5bRFVJCj99YgsXr6hkSnka7b1+zj+1kiGDzkAoykFjiNsvn8E7nzbQNRDg4+3trJhTgDVJxBuOExr1VYqpGl3eMDZFQAnGKMpKwgSYJAEQUGMqGaLIT+ZW8LeaNvpDUW6bUUKm0XAMuQOJfWY4GOdI6zBZqTZe+LgWfyjGJSdXIokCsbhGaW4SKXbTmO+PqsOIN0qFw0LEH+Vgp5dBb5g5kzK4pDKPr3Z20NTlAWDNukZ+fssCUs1GDILAr66ZyxPvHKSh00Numo2bzp/CkeYhHnx5D+nJFi4+uZLPd3Qy5IswZ1ImpblOrKLO9PQkQnGVVElGiap8uqeLD7e0cf2qal77vIH9jW4MksjVZ1fx/TnlEI2DOZ3fbT2atvVJi5sjSRaurUrhsx0dhKMKR1qH+WRbG7+6di4Wo8SzHxwiFFVIT7YAiT3oiXdqOHV+EWnJFtKTLTisR8nghvYR/vTsLu66chY94SjFDislzlHCMK4RUzSMspj4myuAqny3B9Y4xjGOcYxjHOMYxzj+Mf4VBc9y4F2A+vr62srKSldlZWVSfX3911HWT4FUYPX/TBP/n8EoCXzv0pkcah5kV20/JdlJCdXAdwTgb37RyK+vm0t6spktB/vGqjJVlaRy3VlVJFsMZKZYsVsMY942kAhCZEk4jpxZPjs/IZ0f/TFZELhy5UTmV2fzxZ5OUhxmzlpUwvo9nbT3+akscNE3FOLbKMxKGPr2eiLc/+JuRvwJ8+DbL5hGKKJwsHmQuy6ewc5DfQkyB5hUnMre+v6xfwNs3NPFD6fnkGYxH1NB7Gvoqo4hrqIqMp5InJ88vnVMzbS7boAvdnXy2xvmYzcd70Oix1QqbGZ+Pr+SgKLyYVMfW7sSyoI1jb2UpVv5w/eWMNDnp63LS3ufn9tWz6DIH+KNtgTh9cKRLq5ZNQmX0civHtmCJ5Do58r5hUwtT+eJNQfJybBx6fJyPuodxBuNc/uMEtKNMsFgnJ9cOZtYTKUoL4nmcITa9mHe+6KJS06u5Lm1R2jt8eG0G7li5USmlKQg/ROiBhLytP1NQzy+5gCqpnPizHymVaSTkmQixW7CapSOIYpEUeBI6zCPrznIredPRRSOXWfl+cksm5nPc2sPk5JkGSN3Tp1fRCQQ46LKXOqahugaSKQ0eAJR3J4Ql5xcyZr1TUTjKukuC7dfMBWnRR4LujVgx+4uttcc68uk63CkbZjFk7MJxFTWrG/iq33dGA0SqxaXsHhaLn+4dSEHGgcxGSWqS1JRwnF+ff08DjYPYZBFJhal8KNHNpOVauVXNy3g0QOtYz4ZH7b0s2/Ay92zy9iyp4tAOE5+poPth3oRBIETZ+SRNWpqG46r/Om1fTSNlu8GKMxK4keXzcDyDYWJVUuMeyCq8vIndQgCLJyaw8Nv7B87Z8Qfo7PVw6zKdDaMrm+Xw8TVZ1SRm26jfyhEXNMIRZWEZ9FZ1ew41MvB/X2saR/h4pMqcDqMdAwEKMxy0DUQIDvVxrtfNR8zfoFwnLVbWlm9ouK4NBFRFPh8RwdbR8d80BNh0BPhN8/tHE2ZkbjopAre/KKBy1dO4pn3D+ELJsZt9qRMZEk4TvW36UAPJ88tpK/Xz4gvTFVFOrUuO8sL08kUJZSIgibA618kqsopqs77G5qZ5Q4wa0o6s7JdEFKOIXcAPtzSyq3nTWVicQpf7u5kekU6k4tT0QNxVk/I48mDbZglkSmpSQzmRNm9p5uaxoRCcW/dACfOyOfLPccqC1efOgG7WSIc03jyvUPk5yQxa3oOTx1so2/U3Pzpg+2cV5FDuslAW6f3GHIH4IFnd/LjK2ZRlGEfO2aXRLpH18i86ixmTsgkyWbk9y/sQtfh8TU1nDQ7n7tWz+ShvS10DyXuoSOeAN3hKD+/YR73Pr2Dzn4//nCcZKuBacl2CmeVcv+ORs4qzGD7lg7eqk/0b9msPC49qWKMwJckAVUHm65z0cQ8Dg/6yTbI6N/hqdPrifDLp7Zx/dmTefCVPaiqxh0XTeepdw4e8/fhslMnsHRaQq20bk8Xb69v5I4Lp/P4mpqx/fXNLxq575YFHGo4qgxVVQ3/UIhcqxFd10m2Gvjh6hmEYyrN3T7cI2Fe/bwBUYDLV04cu57FJJNkM2K3GvAGYqzd3Mqlp0/ksbdrWDQtlze+aOTC5RW8+UXjWPpUTNF48u2DRCIqS6dmQzjO3TNLeK+pjwNuHytLMsiTjNzz143HVJiLxlV8oRgDHpXddQOIApx80XQ27e9GG01jXbO+CYMscv+tJ2A1SWSn2egdPKrOeufTen583VwMqo6EwHAoyp/fO0JWqpVJxansONSLqumcOq+IggzbMR5m4xjHOMYxjnGMYxzj+Of4VwieLOCbrsXu0WM+gPr6en9lZWXqv/qDLpcVWT6eMPjfjaUz81k6Mx+Ajfu6vvMcgyyS5DCzYW8XL35cO3b8cMsQ//23HfzpzsWYTQK/um4eT793iIaOESwmGVEQuOfyWfzp1X1jD79VJamcvbiUtNTjU8TyspJYPCMPURBo6/XyweZE4HPXxdPZWz9wTOA3a0IGRblO4nGVe5/beUzg8HVVH12H1z6r59YLprG3rp+ewSAr5xfx3sZjA1aA19fWcsKUHC45ZcI/Ha9PPq49rlS0LxjjUOswZy4q+c7vqKqGJIkc6BlheWE6wZhChz9MltXE0pxUevv9PPz6PnLS7Fx0UgV2swFLWMIgCkRVcBhlVB0aPQHSXZYxgqcs38UfXtyNridIj/bevVy7ehoBQSfHasIXiGG1Gpmf40QQBNo9Qd7Y182ZBRlce3YVf3x5L9HRdApvIMbDbx7gF9fOZc6krH86Bi09Xh5+cz8A151dzZ66fv70SsLbJMlm5EeXz6K6NG2suo/HH+GN0dSmL3Z3cPlpk3jp41pUTaeqJJVLTq7kl09t49ylZXyxqwOAE6blEI0pPPjKXu64aBq9PQkvnbRkC2cvLiUr1Uq6y8oJU3MS1ZbsRlKdlmPaGYrEqW0Zpn/4eHJQliRkk4G/vriHxk4PAOGowqufNxCNq1y+chKTStKO+U5mumPsWG1rQvnWNxTiwed3cdaKCvb6/NR7gkxPS2JJXiq/f3Yn0ZjKzAkZ3Pf8UY+pL3d3cvN5UzhlXhEb93UdQ+4AtPf5qG0f4ZR5Rce129/jJRRRyM900DTa7m/i+fcPs3BKNr+9acFYUCuJIs+tPcyXuztJSTJz6cmVFGYncf+Lu8fIFYBZEzP5cHMLgXCc686ezCuf1o0peb6Ng81DyKfLJDvMxBQV90iYuKIRjsT4eGvbcedHYypDvigzJ2ZyzlILJ0zL4ZVP64/5/dJcJx9+i+zISrFywzmT+c2zO8YIXEkUuO/7i0m3m0mzJ9INewcDePxHq8NVl6Qyb1IWxXkuYhEFu83Eoqk5Y2kykFBGWcwyV50+iZXzi/hsRzv/9fR2VE3H5TDxgxvnkWoz4R0KUWW18utdB8a+u+NwH+csLeXuS6bzybb2BDm4pITKwhQcViNf7u5kf4ObE2fnEwzGcBkNYwSPy2RAQmBP3QD76o4SF18jpmgcbh0mJ8OBPxjDYTWQmWrnyjOqOP2EEo60DvHB5haqilOPkpmazmc7Oth1pJ8bLppGb6qDz9oGqHLZmWS28OsnttEzGCQvw4bDauRgu4doTKWqNJXTSzLx9wQ5UH+0LV/u7uKsxWWU5jrpHQyy6UAPW2t6Kcx2cN5JFSwrSifNajqu7f5gjGde2IMoCETjKtGYyqJpuazb1XHMHg3w0id1zK7KQlN1Xl/XwMIpOazf03nc/vrLp7bz4B2LCEUUQlGFDJeV7FQbpm8Ze28/2MtfX9/H9WdXAzC9MoOtB3sJjxKa151VzcfbWsnPdPDEmhoAfv3kNpbPzh9bdylO8zHeOF/j1U/rOGFqDlmjf7fOnZBLXyjK4vw0fv+3nWNrTxIF5k/J5tR5Rfz+hd1cdFJFYn70BKF424XTWLu5lY4+H+UFLq49s4rivGQkUeDHV8zmt8/uGLvnIjEVIa6RmeGgtcfLPQ9toSg7idQkyzHE7r76Aa46YxJnnFCCYfSZIT3dwf9J/H/1/PJ/up//JzHe9/88/Kf2G8b7/p+K/9S+/6f2G/6/7/u/WHLoGPwvvU4bGTk+KP3fja/NjESDiBbXyE23YZDFMW+Jr3H24lK8/givr2s45niy3cRvblvItsO9PL/2CKIosGpJKTecXY3VLGE1JDwIHrjtBIZ9EcxGmWS7EUnTxkyUBCFR1Tiu6Vjkoykf7pGjgeVzaw9z2akTGQlEGfSEmTMpk/x0O2o0Ts9Q6LjAwe0JU5DloKPPT+9QkL+8tpeq4lRWzi9iWmkKPe7AWFD/NTr6/BSenPRPzZ1kOZHaZLMYCH7rNxs6RhgZCY0ZHgsC+KMqO4/0U9M8yOSSVGZPzWZ3bT/nVmTxaE0bK7JS8PaHxsiStl4fD72xn1SnmZ9fPZfC6kLeaenj4ol5PL2/jWBc4eLTJvD5xha6+wN09PmPSREJhuN43SGmVKTzo4c30zsYJNlh5J5r5jKsq7xd34OmwwcdAyzOTeWmi6fxygdHxsa6JNfJ7iN9FGbYkBAIxVX6hkNEoirZaVacFgMC0DqaKlFZ4KKjz8++bwSGvmCMX/9t+zGVlaKqjn80jaOubQRNgxvPmUxasoWDTYO09/rQNB1vIEqq08KIP8rUsnQefSsRUD/0+n7mVmVx58XTsZoM/PX1fWNzPqHQxe0XTEWLKcfNnSAInHVCMQ++MnLMcVGAivxkuvr9x60DgA82t3LizDxshn8coFhNMjazTDCi0Nzl5c/P7eK/b19IXzjGBLOFHXt6ONwyxHVnV/PiR7XHff+5Dw4za0IGOw/3HfdZhstCXeswcydkEP9WaXKDKJCSZEbX9bHy5d+EpukEQgqoKiYBtJhC+2BozMNq2Bfhlc/qOe/EsmPIla+D5f7RtbBmQxOXnFI5RtJ9G8U5ScSjCl1BH2u3tiKJAp39AapL0/hHAjBV08fmSBYE9jccS24MeSNkpdrwhzyIAlx5+iRsZpkNe7vGyJ3y/GRWzCmgr8tH0BYhlmJl2B/l9XUNzJiQyUdbWqkscDG9MoNH3zqAw2okEI5jM8v89sYFTK1IH0szO3tRCdmpVkZGQjR2jPD2+qMm7iP+KB990cQFS0sxySI/eWzLcelYX+3t5tSbCplcnJLY7HWdSDCKEo2Pjbc/EOPZV/Zy8coJxJKsWGSJKSYLf3+rBlXVyUm38238X+3dZ3gkV5n//W+Fzq2cw0iTa3L2ZGfjHHHC2BgbAwZM2CU8sOEPLHmBXXbJS3AgGhOMwRjbOOeZ8Xhy6MkajcIoS61Wq1PV86KqW92SJtieYFn357q48By11FVdvz5VffrUfVbOq8LvdfHxbz9NPGniclYfXDmnEhX4xSM7qCoJ5MxCzN7ux5/fx4dvXMCm9l7mBPz873329w55fhe3XzGHz37/hczvvv+qOXh9Ln7tDMDm/K3eKAdV+Op962hujzClpoCZE0t46Ok9KAosm1XJhPIgijW0THc0abG3qRevW8sMtE+bUMi9fxu5LDjA4c4IcWeQeWJ1Pn/KOgZpiaTJobZ+ZtYWAPagUl9v7vkxZcFvHt8J2F9IANSWB3l5iz2T7Oqzp3DPw9tYML2Mp4fNugIlZ6BsNPGkSXQwkcmvW1X49NJpmNE4C6aXETrYjVtX+fC18wk1dPLSlhb6InHiSZM8v4vwQILdjT00PbSVsxbWctHyehZMLcGlKHR1pos9q3zpA8vpCsdQgOJ8Dx4VuroiPLfhEMmUyTmLavnlo3Z/oij2flWWBOjuG2RjqJ3qEj81lUc/j71Rr+ei61Rev4xHsu/jb9/H636D7Lvs+/gyXvcbTnqR5VHbRxaYGakZe8ZOWjXQcoTHvmWoqkJrPElKVynwuvjCHcuoKPYD9oXyjRdMY+6kYkzLIuosua0q9q0IH75+Hq8c7iFQ6CWeNBmMp7j/H7v4wk9fBiCWNIkmUvjdGrUlfsoLPCRSJn2DSVKWfQvNnpYwX75vHZ/53vPc+1iI/phdCyU/q/Byb3+cH/1pM4+9fIDecIyJ5XlObQj7Q/xwf3luL+88ZyrL51SiKuB2acyYWMTM+iLi8RQr5lZRVpQ722POlBLqKkZ+2MpmmiaXnz+Vmy6bOeJnC6aV5RRU7Y+l+PxPX+FXj+5k8+4Ofv1YiN8/GqIi6GPTllb+eclUNm9tY9v+zhF/q7N3kN88tpOqfC/vmFTOf63dTddgnFjK5Bd7mliwso73XDFr1A8j+W6dL/7gxcxU/75Igg2hNtyKitupk6QqCgGXTiyeIpEwmVpbyCduXMi0CYWEowkOHO6nO5rgX3/8El++ey3f+vV6fv7X7TR2DmCq4HHb451LZ1fyvFPEN1s8aWZus1IU8LlUzl5Um/n5LufD9K6D3Tz47F40Z7te3NzMRcvrAfsWh2xrtrUSiSb59m/W5wzo7WxwPpiPMhBhWRbTagu48YLpmQ99+QE3n33PEoqDLuKJ0WtXJJLmyFpKwwQ8Gh+/cQFq1vP2dw/yT4sms3n7YQ60DM3KGb4vANedN41XtrVSnpXDGROL+NgNC1g1v5qiAi+t3VG77o5i3x4TTZo0dw5w2+WzaG7vZ0pNwYi/G/S5uOqsyZkC17qusu1A54jHZM92AfvDf3d4qPh14+Ew3/3dRsIDcSZU5HaKuqZw7blTURV4ZkMTj7x0gNryPDbsauflLS2ZGYHZfB6d8qzi3rqqUOn0M2kvbGrm4hUTURS46uwpvLS5hdauaKb+z7QJhayeX82PH9zCf/92A//xszVs3tfJl+9Zy8bdHdRX5FFfmcd5Z0zgN4/txLLsAUfTtAgPJPjZX7ayaFoZn715ER+9di61JX40wFLgr8NmDgG8uKGJ10LtFPhdvMuZiZGmKPYqXB7dvt8wkTJp64uxt7WfvmiSimKf81qpWMDvHg2xorSQBQVBIk59ml2N3cybmjsgpqkKC6eX88u/78gMwiSSJvf+bTvNnRGisSQDg0n2t/Qxo75oxDYDXLi0HnfS5NNLpzG9PJ/3XDyD686bxn98cAV3/2VbzsBQTzjGH/4RGjFrRlUVivM9NB7up7k9Qp7fxaWrJvG932/k0ZcPUBD0sK+lj7v/tp2nNjYTTVlYbg2XplBbHmQwnqIg6EFR7NmF6fozaRXFfs5eWENJgZegU3+msydKdenImZ2Qez4YTcqy6HdmeB5q62fmxGKaOyLUV+YD4Pe66A7H8Hn0EYPz63ceZuW8KsCZ1eUZ+j7H59G5YGkdH7luHoGsdsu0SA3ESaUsVs2rojjfyyUrJ/GX5/fSN5DgQLP9/v/7S/t572WzcDv9z8Bgkuc3HGJiVX5mkYHM37TsmkdVhV4qC724ndX0VFUZukVZITPr8obzp7P7YA8/+uNm7v/HLr509xq+88AG2kaZsSiEEEIIIXIdzwyex4H/AP7PMIxFQHMoFHrLD8ENagr/t/4At8+towSNoM/FF96/jOhgEreuEvTqWKaFotof0h9f08BVZ0+hpz/GjMIyntp8gIWlBdxyxSz+8FiIwXiKJTMr2NHQw+/+EaKrb5Clsyt51wXTWb+zjQeetOv3zJpUzNVnT+VrWcujP/vaITbvbucrd66gMOhm9fxqXsi6paKnP8blqyeRsiw6emK4dJXiAg8lBV46e4c+nMaTJqGGLu68ag63XDQDRSFnye6gW+VrH17Fjv1dNB4OM72ukNqyYGbQSHWKNneFYyiKQkm+B4+mYCkKu/oH0PJd1JQFM1P5J1fnM21CQWb2kaIqrN/VPuJD9IubW1gwvYwz59egWlBV7MusojKcS1dREikmBX18YN5E7t7SQDxlclldObH2KD/6xy7ed0Vuve7ifC+Hu6I5t7KZpsUDj4ZYfqiPj10zm6+9vIur6srJS8A37t9Int/FxSvq+d4DGzJ1cTRFoac/Tm9/HJ9H5wNXz2HLnk6+//uNlBf6uP2KOfi9OqZl5QxwpAV9LvKDbva0hglHEkyoCHLJ8nq27evkQItdkmrlvKrMLIdoLJk5hi9taeau6+bjdo0yppr14SbbsxuauPbcqZmaNYqioKoKqZSJS1W4eOkEVs2rImVauHWVgFMjqDjfg8+jj/hwO6O+iKD36G95y7SYVpXPf33sTBrbwqiqQmHQw9d+uoZk0mT53KrMzCaPS8sZ5Fk2u5IDrX28sLGZj14/n4BXJy/g5qyFtXz/9xszswl+/+RuvvTBFXT1RhlMpHh8zUH2NfUyva6Iu65fQDye4qPXz+feh7dTmOfh6rOnEE+kaO7oJ+hzEfDqbNjXjseVuy8dPVFqynMHM7v7YlQWj/xwfe/DO/jcrUto7ojw8pYWJpQHuXB5PcUBF4NJk788vw+fR6e3354NtOdQD6vmV7NqXjUvb2nG69G5fPUkFs+oQFWVzEphugq3XDKDL9+9NvNc0ViSzbs7+MqdK+nsG+TBZ/ZSW5FHeZGfnnCMdyyt48cPbskZ2EykLAacgeefPrSFa8+dRtDnyizvnm3L3k4ig0m7OPSwnx2pfImqKCjAOQtrMOqLeHGTvU+r5lVRmufBNC1iKYv7/r4jUyReUeDfb1/GE+sa2bynnRVzq3hpcwtPvrCf6GCSs+bX2Bmy4B9rG/jQNfP449O70VSV9181O1O/aLgn1jXy7guNTK2zTbvbue68afz52T0kUxaqAlecOZnJVXn2azQQp64yn4BLRVEUuiLxEbcfPbH2ILdcMoMf/XFzzmt280UG+T4X653+6bwldTz4zB5M0+K686bxWqiNnQfsmXHPb2ymrDKIO9/NjICPO66YzZfuXsMTaw9y++WzefiFfVx51hR+9tBWNFXhtstn0dsfZ8ueDh558QBXnjWFqhI/z21s4o4r5+S8ByqK/Zy9qIbKEh/ZB03X7YLw6Sx4dZVzFtXw+6f28PAL+3jvZbPojyaYXF3Apt3tmM4f3LS7g6WzKznUNjRTqCcco7c/zpVnTuaRl/Zxx5Wz+flftlFflceFy+p59OUG1mxtYdO0Dq47dyqFPhdW1qylPI/Gf3xgOe09UR56bi+WBbMml7B9fxdt3VH+/Oxe3nflHEzLoijoYUJ5kKBHO+6C9slkilXz7HNhMmUScPqmgM/F1n25g7ehhh427W5n0dSS4y+YL4QQQggxDh1zgCcUCr1kGMZ6wzBewp6ccpdhGLcBvaFQ6EHDMH4PTAAMwzCeAX4SCoV+czI3+mgsXWFvdz/3b28kmkxxz5aDXFBdQqxrkDUbmnn/VXMIevRMEVXLtLjqzEnsa+rh3GX1PN/UyY+2HMACXuvopTLg4bN3LuexZ/YxpbYwp0bAroPdvLqzjV84t6qUFtpFlH/3RGjEdnWHYzS1R5halcfNFxosnVXJk682UpTn4bJVE0kkTf7lRy9l6tAsnlHOv773DH7wx03sa7LrtJy1sIYrVk/GSpn4nYGC7CW7LQsqSwPolsn8yUU5szUUReFw7yBfv+/VzHPUlgf5lzuW0j4Y4/H9h9FVlQ/cspD+ziiaaTG5Oh+P84EjkjB5Yt1BWkYpCg328u7LZ1aQSKQ4e341rT2DPL7m4IjHXbS8nmTCRMGkzuPi6mlVtPQP0n2wl4ee2ceE8iC1ZQE+ev18fvrQVmLxFB63lvkgM1xHTxSfCe+dW4caSfDk2gZuOH868WSKPz+7N7focV0RP3vIXkXqXe+Yzm8fC9HeEyXg1TljdhVN7f38221LeXxNA+ctmcBfn9+X+V1VgTvfOY+v3buOnnAMVVVYNruSi1fU85mbF9PTHyMaS1Je7ONZZ/nmPzy5izuvmcdT6+26JU1t/XzypsUsnVXB2u2Hs/726J/Cdd3+AKsoCuFYktDBbg619TNncok9cAcE3Vpm6p9pWqQsiCdT/PNNi/j2r17NzGooyvNw59Vzj2vKHkCBT6fAmUkRT1nEEykOdw1QWeKnON/Ls68d4qqzp/BA1u2NC6aX8dM/bwHg14/u5ANXz0XXFH7y5605twHNnFjMqzsO8+SrjVx//jT2NdmzAnYd7GbXwW4qS/zcevEMvv3x1bR2RfnK3WtzbotZaJTzwBO7+PA752VuEwH7VqkDzX2ct6SWp149lGnri8RHrGaX53dRXuRjalUeZ86tRFXsgbOBhElX3yCJpIlpmuQFhmZY3Pe37SyfU8XHblhAaaGPu/+6jQee2E1JgZf3XzmH+so8/C6V+rIg//GB5TzwxG66+gZZPb+asxfV4NfVzCytlzbbfdGug93Oc+XmOzsRSaeWy4evnTfqscoPuNG1kRlSLIvLV01ix4HcW/kUxa7lY5oWugITSvzccqE9kyfp5EVRFHYe7M55zdy6xrrtrXzxA8v51d93snxOJbVlQZ5efwhVVaguDVBVEqClM8L2/V20dg5w+epJ1Ffm8+AzeygdNtslTVUV8n06H7hqDt+5fwMvbGpm1qRi7rhyDoVBD5UlfvJ9Osqw243s/7cHN4cPaPb0x3jkpQN8/SOr2LK3E49LZXp9MdHBBF3hOBOr7RkwZUU+DrX1o2sKpYW+zOCOpipcfd5Udg5E2dHczmeXTqO2LMA3PrKKR19p4FBbmE+8ayGaqvCvty2lszfK42sa2N/cx8LpZcycVMy9D2/j3RfPYNu+TtZua+FT717MC5uaOGNWBb39cV7e0kJja5grz5xCUZ6b5o4BXt15mNICHwunl1EYcGGaFucsqmXDrnb2HOrlnoe3U10aYO7kEr5x12q6woP4PDpN7f0U5XmYObGYHQfsYveqYr/vV8+t5LzFE0ikUnzjI6voG4jz+Z+8nHlPvripmY272vn6h1dmbj8F+3wScKn0Obd0Hmjp44ozJ5MfcNMXiXOorZ8f/2kz1SUB/vW2M/CPslqhib2SmVtXUYd14ZYFkyrzWDG3kifWHuSGC6azZlsruw7m5jXtuY1NLJlehmmOHAwXQgghhBC246rBEwqFPjesaVPWz64/oVv0JpmqSqi9j0PObRnRZIpQX4Qzq4t4bl0jX757DV//0Ep8WTMpfLrKp9+9iEMd/dR5PHQX57G1M0zApbGqrJCdezqpKvHz2CsNOc+1al41/1hrD2JUlQa47rxpNLT00d2XO8MlrS8SR1Hs6epzJxYxf0oxAOFoki/+9AUig0MfUNbvbKM438u/vGcJ4YEEmqaQ53WNXL94FJbFiFtxBpMm//nL9ZnBHYArz53K5s4wD+21P8SlUib/t/kAt82to97vY82WZlRFYd60Un74h8109EY5f0ndqPVVsm/lskyLsnwPn3r3In76kL2akN+rc+ulM6nOun3FMi1mFgWZXhTEU1XM+Qsn4NIUdBXKCzwYH11N34BdZ2QwnuIPT42sp3HR8jpUy2J6no/CqiKq8nyg2LOdsldJKi30Ul0SoCDoJhJNomsq7T1RVFXhg9fM476/bXfqKWmcs6iWcxbVEkskeWJtI6ZpccHSel7e0kxPOEbA5+KDV8/luQ2H+I+fraEoz8PNF81gzsQi3LrKxcvr+c3jISKDSb77wAZWzK3m/VfOYc7kEgp8OrdfNosVc6t46tVDFBd4mT6hkMI8z4iZUVesnoTfpdIbTfL/fvJyprbMQ8/tY5FRzgevnI0764O9vYz3Tl7a3EJteZDbr5hNnt9N0OeivNCHz6XkxEfVFFKmhaYqmCm79s1APEU0lsLv0TKrhnl0hU/fvIiv3buOX/xtO7deOovO3ihuXeVf3nsGLzs5qS0PZgbUusMx/uf+DXz8xgU5NXHAft/c98h2Jlbl5yx5ntbaOcDfXm7g49fP58d/2pwZ3AE4c0ENv37Mrkny28dDvP+quby8pYWdB7qoKQ+yen41pQUeLjijjqb2fkryfVSW+Dhzvl0gNtTQRVVpgMnVBQTcQx9IU9gzVr71q9coCLpZNb+aZ187RFffIJNrCjKDUK9sbWH+tFK+du86orEkS2dXstgo50/P7KEnHGP1/GrOP2MCE0r8fPJdC0imTDwuNTMQW5xv11qJxpI8vb6Rj92wYNQBvkTSHLF6X1vXAFNqCtjblFu8+qYLDfxuLfP+UxQF1auTiiaYWlPATe+Yzu+f2kMyZddN+fA751EcdOXMHEkOq3ujqkpmJhrA+WfUMaW2gI272nn61UbuvGYOXpeG36Nz3uJaFMWebfIpJyddfYN09Q2iqSo//OMmusMxPnLtPJ55bWTB+wuWTCAeTzF7YhFf//Aqnt/URCJpUlMWpKrIa69+Z9m3nPUNJOmNxAjHTfxuFQ17FuNNF07n7r/m1sMpK/JRFHRzzoIq1u1s519/+EJm5cOP37iABdPL6AnHqCj2k0iatDv1VeZMLeHS86byYkcPe9vt1/rb6/ZwYU0pZjjO5asnUZLnwUpZWJZFRb4Hj0tlf3Mf+QE3y+dU8f3f26fIDbvamTWpmGWzK5lWW8C02gK+c/8GdjbYgxi7G8Hr0dFUhSfWDb3e9/8jxJfvXEFZngefrvKZdy+ioy9GLJGiKOghz6ejAmX5+fzbbWfwzV+t596Ht3HZ6slcvKKefL9dnH0glqB3IEFBwI1qaSiqwq8fD404jUSidi2dRVNLMzM2Nc3uL4ryPJn+6b6/bec9l8ykuSPCocNhFs0oZ+7kkswXDhkKHO6N8cu/72B/cx/TJhRwy8UzKcv35KxQ59YUbrt0Fp3OoOqsSSWsyxr8zmavLimzd4QQQgghjuaNFFl+S9PiKS6aXMG0wgDfWrubc6pL6NrXw9f/9HLmw2d7b5S6YTUR3KqC36XzlR+/xAeum0ez18WFtWX88v5NdPYOcsvFM+jtz/0A7tK1zK01V5w5mZ88uIUptQUsNMp4ct3wgpdQV5mXubC2LItU0v5HR+9gzuBO2pOvNnLVmZMpdGo5HM/gzpF0h2N09Q3mtP3wdxtZuaCGT140je9v2I9HU/nookn0tEf58P8+kXm6D71zXuYDSUHQQ0WxP2cFp/IiH/OmluYuIQ7Mm1TE1z+8koFBe9Wj0abve1L2t/AW4NWVod20IODWCDjfKAe9Ou+/cg73PLwtc8vFWQtqmDPJmbIfT6FpambgTlOVzGyCiVX5XLZqEr9/ajeXr57MQ8/uJex8cF42u5LnNhzKvDaD8RSPvtLA42sa+O6nzuGyFRNJJEx8Xp1Pfvd5AG44f1pmQAjs2kLffWAj/3zTQuZPKubM+dXsb+nj5S0tJFMW63ceZvX8avK8zoCJprBgcgmLppWiYA/Gff59y/jBHzaxt6kXXVO4cFk95y+egKIqPLamIWeQpKTAS2Geh3A0QUnQnmFiKQqb9rZnboM51NbP/z1oz6b52odX4tWHBncUBXoGkjy2poE9h3pZOL2UsxfVsm1/F/f9bTsDg0kKgm7uvHouRm0BWFAa9PDVO1fQGY6hAgunl+J3aySTJrPqCgGIZN2SljYQtW+JzCmcq9gDGJ29gyyeWTEyrMDUCQUMxJJDNTocmqpk3nM9/TH+9/7XWGiUc8HSOpbPrqQ4YL9XKgu8VBV6QbEHrRIpkwllASaWB7AsC8sa+XZq7ozQ0GoPOH342nm0dw/wx6d2c+ulM1k2u5ItezqoLQ9QGPQQjdmv0YLpZfzIWbkI4MFn97J+Zxv/+t4luFW7eHT2LLtCv5urzprMQ8/tY+veTnY39vDxGxZQWeynNes99edn9/KZWxbzwz9u5nDXAIpiF1n/p3ct5Il1B3l6/SECPhc3nD+NWfVFOXWy4rrCq81drCjLx5WEC5dMYMWcKqKxJEG/K3Mr39EoChQ5g1FzppQQ8Or8xMkTwNPrD/HR6+azZHpppuZKKmVREnDz1TtX2O8NBTRVzeRhzbZW3nPJTP7w1O7MSmi3XjqTKmfQVwUqCjy867ypQO6gU9KyeG5jC795bGemH3/H0jquPXsKbmD5zAqK87z88Zk9xOIpLlpez9KZFWhAe1+MH2dtO8D3HtjIF9+/HNOymFAR5HsPbMqsVtfRHSUaTVDj97K/bwDTglKvG5+i8sKOdn70u018+YMrqHHqEVkWmb7g7EW1/PWFfTnPtX1/F9v3dzG5pgAFMn1p2qxJJZnC65ljmDS575EdfPLGBajYOaoq9I4o1JdImNSW+Pn6h1fS0x/DpakU53vpCsf46r1rM/304hnl3HG5XTOn/QiFgtu7o6gqJFLQ0Rdj4+52fG6d+dNL+dx7lvC1+9bRF4nzgz9sYu6UUj56/Xw86ugFnLsiCf79xy9l+urNezr5tx+/xH/etZpCX+5lh0ux369pK+dV8Zfn9zKYdduqS1c5/4y6EQORQgghhBAi19tugAfsD4EBS+H8CaUEBi1+++KBnJ+bR7hGLCnwsHR2Bfc/soNPfWAZkd4YN14wnbIiH1XFAdp7ojmzeDaE2lg+t4pHnEKmsUSK7fu7OP+MOrbt68z5cHrjBdMpCoxeUPNIdTKOtNLP8VBUuyByR88gmqrgPsLKSQ2HevAnLa6YXEHQraMNmnzjvnU5H36trH/84pHt3HLJTAYGExxsDTNnSilzJhWP/AYX+wOfT1fxOYMQo30QsI5z0EoFVs4uZ87kYnr6YwR9LgoCbo60HpRHU/nAVXP48j1ruGzVJH78J7sWR3VZkGvPm0ZRnv3hddakYu7567YRv29a0NIRYUplHnggaUFpgY+m9n48bn3EYBnA/Y/vYsYdS/FoCndcNpNrz51KLJakIOgh4NFyvrnOHuADKPTpfO6WxfQPJtE1haBXJxpPseNgD5t2d2Qed/NFMzAti3XbD/PLR3dy3blT6Y+bvLCpiQ27Ri5NDbDjQDcVC6qJJ008ukLPQJLP/ejFzEDJwdY+KkoC/OiPQwMVvf1xvvXr9fznXaspz/egqgo+NGqyiienVwlK3zLh1VX++V0L+fLdazO1eV7e0sz150/j14/Zty2evaiW+sq8zEBQYdAzYvaSz6NzzsJaXNrIW29aOweYWJWfqXlkWvZst637Ojl7QXXOfsdSFv9Yd5CHX9hPPGkv637rJTNzbkNJUxQlU0Ab4P8e3MJFy+o5e2EtKHDGrAouXmoXWd6y374F5uyFtfzthZFFjA8eDtPWE6V2WLFlAE2By5bXs2RmBVv3dlCc76W2PMC/3X4Gv/3HLl7Z2krQ5+L686ZSVeznS+9fRu9AApemUuDXwYJrzpzExcvryQt4SMYSue8rXSXUHeHhPa3MLM6jSFOwUhZBj0bQoznH69jvuWTS5JLlE3luQxOr5lVnbm3Mds/D25h51+qc2ZCWZQ9gVjk56RtMotr1mlm3/TBtXQPcdKGBqirMnlRMkd81YntG+xDf1jPIrx7dmdP2j7UHmTullLkTC9FVhdn1Rcy4dQmmBR5dIZWya2ltd45XNsuyV+3611uXoJbDV+5cQVtPNJOt7/3yNZbOruCSFRNY09rNAreX7/x8bWbA4v4ndvHPN87P3HaULuBv1wsbfQClfyDhDGXnGq1YOUCooZt40sSrH/3GStNZqdHn3AIXTaT4yj1rcwaF1+9soyDo4daLDVbPrxl15tzsKcWkLHhlR1vO8Vb/rvClDyznGx9eRWffIKpq129zK9ao51JdV3nq1cYR9aISSZM121q5dFldzoDkcAVeja9+aCV/fGYPOw90M7W2gOvPn0ZdZX5mZS4hhBBCCDG6t+UAD4Bbhdn5Qf7rz+ty2r1ujbKsVW+yuRSF9106iwOHw+zf24WZNFlklFMY0LFMuGLVJLbs6cgUEN7X3MvtV8ymqS2cUzPjJ3/ewg3nTyfocxFLpJhRX0RRwM0oZTIAKC3wUpTnySyZnHbRsvrXVbQyTVGgsSPK1+5dm/kW9IYLpuXc3lFTFuTyVZMoL/bzqe++wHuvmUPjQJgeXRtRnLe1cyCzPPtgPMXPHtpKUZ6HhdPLWWKUob6JmUW6roICySOs/JTDgnyvTv4xCgWD/UGzviLANz96JqGG7syHjSfXHaQ438vNF8/g4uX1RKIJCoIjX3sAr3voeVyqwi0Xz+Bbv15PIjn6B7K+SCwzu0AFiv0ucGZfWcdxDDXFrn0DkEiZ/OBPW/B7dKrLAjS19/OOpXXsbOhi/c62zO/MmVLCE2sPMnVCYc4qOWlGXRH1lXn856/W09jWz0XL6ognzZyiznOnlrJm68jb7rxunf5oggMtfew62M2sSSUYdYWZos/DmaZFTYmPb31sNYe7BuyaUMV+vG6N2vI82roH2NfUy3d+u4F3X2Tw4z9t5ld/38HtV8xmT2MPew71ZJYLL/TpKIrCu94xnXseHrr15slXD/LPNy3iO799LVOEWFXgEzcsIOjRhmYpqQpPrD2Ys0T4qzvaaG6L8Pk7lo6y0o9FbVaBZtO0+PvLBwA4d3EtZxhlpJyBh+rSIIoChXkeOnqijCYSHTkjL01XFWqKfNQtq8M0hwY533/ZLG650EBRFPxu1b7NUlEodQZI02MDZsrCoyoUBD20R+OZ/R1QFR470MbaFnuGyHde3cPlUypZWFaA7gwiqKpCwrRQFQUV66iTAssLPPy/9y2lo3dw1OLOkcEkA7EkPpcbC+iNJghHEuQH3HbNHCDf5+KcxRMyt3s1tIa5+6/bOGdRLStnlR9X36ZpKq/uHP22ncfXNjBvUjGWZWJZFip2HtK3qFpW7vs4m8etoSj2e7M830N1sY9pNYvZss9eDnxidT5T8/yUuHR+cO/6nNegrWuAZMrK5Kg0z8NZC2vYe6iH2ZNL2DjKYGtpoXfU/fUcYfC9riIPl3a8VbOGdPQOjrgtEuxi/+88ewrLZ1XwwsYm9rcMDfLceME0dE1j+8Ee7n04d8DbNC2++8BGvvT+5ZlZS3CUCaWKwuEj1GqzZ6PZr5mpKPQ59bPynVvO0n+3yO/i/ZfNIp4ycWkqimW9qS88hBBCCCHGi7ftAI9lWuS7NapLg3T02LMt8gNuPnPzYoJeDesI4wluTcGoyWdWXZE9yyJlZh7rd6n8v9uX0t4bZTCWorTQR75P5653zqN/MEnAqxMZTBKLp/jl3+3Cyze9YzrlBZ6c2zSG87k0/t/7lvG9329kf3MfqqpwzqJaLl058Q2tGDKQMPnmL1/NmeL+4DN7+eS7F/HkuoNoqsqMicUkUibffWADsUSKX/x5KynT4n1XzM6sCJT2+JoGPnztPH73j12Z1WoCPhdXnjXpDQ/umEBLV5TH1jQQS6R4xxl11FcEcZ3Ai3jFgtKgiwZP7georr5BvvfARq4+ewpLZlSQH/Dwkz/n3sJRUxbIGQi0LIup1Xn8y61LGDzCYNSq+TV4XepxDeYcS2c4xrZ9naiqwj/duJANoXamTSjkh1mzbADy/G7auqP0RuK874rZmaW3wZ4BdsnKiXz13rWZD2MdvYN09OYOSqiqMuqsidsum8UP/7gp8/55Yl2jXZj71iVHHOSxTLvwc7AydwnyGbX5uF1qZrDmr8/v485r5tHbH2MwluSSlfUE3FPQVHsAw76FymLFrApKC3z86dk9JBImFy+vp748yH9+ZBWtXQOkLKgo8lHg03M+cEZiKf76/MjZNc2dETp6B6kuGlnwt7zAy4q5lby8ZWiwK+hzcdWZk8mu1l3g0/nkTYtYs7WFOVNKcgbc0oYvnz2aEUvWW1ZmtsaxlrMfwbLQUTCKg2xp7yWaNCn2uanL96M5L0wsZbEx1M5jrzTgdWtcc85UJlXmoR/hLacAkyvs2Va6pubUQgK7ULXfq5MwLR55pYG/PL/PXv5agevOm84Fi2vQVbj+3KlUFvt52JnpeOnKiZy9oOZ1lFOx8Htdo/4k4NVzK1KPeFksZtQXoWtKpv5O2tVnTUGxhubUJJMmHk1hqVHG8pkVgMXh3kHWrDs0YgnyZbMr8ehD73VdVXj3O6bbszZVhd2NPTm/885zp1LotwfCLl4xkUedwUOA5o4IC6eX5czAUxS47fJZ6OrrvzP3SC9HutSTz6Xy2fcsprUrSnd4kMqSAJqq8LkfvsgdV8we8ToBtHVHGYgncftGPw7ZUkmTMxfWsD6U+75QFLvI/qHOCJqm8qu/72DLXnu1rLlTSrjz6rm5M0EtZwDtTXyBMBYl0rW0dAWcvlDVVcykiaLZ0+HeeJv9nlBdKmbCBE1Bcdo0l0oqYYKqoGIP7B29zT7HWhbHaFNQsLDMoTZFUcAZXM1+XHoQNfM41am/lbV9igoW9v4N/T27Rhc5zzGyTVUVTMj53dHaFEXBUoHU0GulKAqoYKWsoddUAVTljbdpClbSbktL/zz9/9ltpzoTmbbXkQkV5ThyMpSJRFbtuNEywfBjozq3m79lM3H8OUnv+5EyMfz4v6UyoSmo1hvPRKbWW3ZOIKefQFEyX8Jkt6G8NTKhqgqm8vozYef9jfUTx5OJk5OTN5+JdN5Hy4Slgno855PjzATOuSM3E6Pk5AiZMBVQTlAmTpe37QAP2MWTP3btPHoH4sQSJkVBd6Zw7NFYlr2E62g8mjLi1gtVgeKAi8/fsZz//d0GmjsiqKrCBUsmcNaCmqMO7tjPZ1Hk1+2CytEEuqaS59NzPlS+Ht3hWE5xVrCnx3/7V+v530+eTUfvIF/86St84Ko5mWWg04NBa7e3cv6SCZni0WAXhG3rGuDz71tKdziGAhQGPbi1N3btraoKG/d08N0HhupOrNt+mGvPncqly+syq+WcCJZlL/eevk0kW2Wxn9I8N/lGKd4bFnD/P0L0ReKsnl/NVWdNGTHLQ1MUplblkbTgQ9fM5f/+vCWz/zVlAa5cPemEDO4ARJ3ZKaZp8cCTu/jYDQtIjXI/RPrZYvEUG0Lt3Hb5LP78zF56+mNccMYE1m5vzTlGB1r6WDyjPLNaEMDWvZ3cfNGMnA+YVaUBWrsGMoM7aYfa+tnZ0J1TjPV4aJqasyJTQ2uYH/xhEwGfiwXTSjlzbiXJpMnwBXJ0VWFWXSHGLYsxLQu3ZhdG1t0aUyrzhmqSjBgrsYgf4T08fKAizaUqvPfimVxwRh1b9tqF1WfWF5Pn1XP2VQFm1xcysTKPaCLFnkM9mfcRwE0XTqcgcOwPwieSZYEraTI76CN/3kR+snE/d86fiC9pYiVNTODXj4d4YVNz5ne+ft867rxmLitmHnkmjWVZ5Htd3HLxDO79W24R4/dfNYeAW2NXcx8PPTdUd8a04IEndzFzUhH1pQE8msJFZ9Ry5vxquxhzVtHp45FKWSw2yrn/H7tGbOdlqyZhHuV2H4BCv84X7ljOD/+4mZbOCAGfvT8Ts2qiZbOXKbezU+BzkefJPZblRT4uWl4/4r3uVhXqygLousY3PrKSvU199IRjTK8rpDTfm5nBec2Zk1g5p5LNezooKfQxc2IRFy6dwPb93Ty9vpHSQh+XrJhIaZ77DfWvpQVeCoLunEwCnLt4QuZWUbeqUFfqp67Uj6qq3P33HZimhesIA7cBn+uIM42GsywLY0IhC40yNoSG+pSP37CA3z+5m/IiH/tb+ghl1SLasreT7/9hM5+6acERb7sdD1K6yqFwlHwVei3waSoqELYs8hWFPrLaGKXNsihQFXoBr6aiA71ktynoKPRZFvmq/btuTcGFQq9lka9Cn2LPZnYrCr0W9uOcNo/zd/JUhX7F7p89lkWf0xZWQFPBa9l/O6gpRLBXivQp2G2qQsS5HvdrCmEgoCkMKHA4Moh7WJtlQSDr70Wdc3lAs9sCmkpUsVeQzFNx2hQGFYWEZZGnQi8Q1FWiQMLZ914r/bvpNui1LAK6ShyIp18jpy0BDGZeX4vg8DbncSmnLV9R6LHsx5lA1GlLPy7dVqBCj2XhiiVI6mqmrdey8Dvvxz7LolCFHgv8zrHusywKRjn+6Ux4NbsI/fBMaE520m0e5/iPlolMm2LXynIr6qiZSB/XsAK6ouB1jnV2JnxZx7Af0BQVn2LR3D9IIJ0JBfzK0PGPOH1mIKttALBUCJjqyJzkZAJSlkWe5mRCV4iikLIsgulMONlJOPvUaw3PSToTCnGUEZnIzkmvdeRMmMCAZVKg2NlJtzWFowSPkInRjn92WzjzOPuzjmKlM8ERM3GkfmJ4JtL9RK91jJyo6UxYR8xEv2LPTvc625DOhBmJoWnqsEyM0k/kZEIl4nxAyMmE81k+YNmZ8GdnQh3KxIBiYVqMyEQyu59wHpe07G0dmQklk4koSqZt1EyQ2yek+w5PPElcUzP9xGh9R/pYW8P6iYCuYikQNXPbcjNh4XMNZaIwKyeqdeRMZPcdo507NJRMdkbtJ7Cvg1zONgzPRHN/lECmnwCvombOJxHF/lLai5WbCVXBa43MhG9YJhRy+47M8WeUTFgj+4mgk4ngEc4n0cz5xPndI2RicJR+QjlNtQNf//zvMUZToDjgpqrQi1cfuYzriWKaFuX5br7wvmV8+6Or+c4nzuSm86fhOdJ9WcNYlh34Ir+LPI/2hgd3ANxHuEhXFLtY5eNOHSF9lOn/G0LtBP0uPn7DAqbWFjJtQiGffvcizpxXhUuB8nwPZfkeXG/gm+W0SDw1YsUbgAef2UPfUW5teaMK/S7+v/csIeB8+6wq9jfJC5zC0LqisGhqCV/+wHL++xNnccs7phMYpaYQOCPJwBlGGf/98bP419vO4EsfXMG/37Z01DpEb1Rxvjfz5dWhtn7+5/7XcOvaiHpNsXiKfKe20ytbW/j7Swe4dNVEPn3zYq47dxrt3bmzdQ619VNTFqQsawZLNJYklkjyznOnojpPUF+Zx96mnlG3beu+TrTXeeuIZdn7NFwkmhj11rLc37VvvdEV5bjfv36PzuIZ5SPavW6Nkvwjz65xawqTyoNcs3oSS41y57avUZ7TsouAlwU9fPXOlXz2PUv4yLXz+OZdqzlvYe1p+5BqmhZVHhd3LpiE3xy6BasnEs8Z3En71aM7icSPsey0ZbFqTgVf+uAKLlxax2WrJvL1j6xidl0Rmqbw1CgF5QGe39iMrtuvRCpl1+Zxq8rrGtxJKwq4+Pz7lmZq3RQGPfzzTQszBZqPsfnUlvj5wh1L+c4nzuSbd61ixczyI85cyqarCleumsg3PrKKj1w7j3+7bSlfvGMZQfeR859Mpgi4NOZPKuKc+VVUFnhznsulKtSW+Lli5URWzCwn36PjURUWTyvhUzct5PZLZlCW5z7axKSj8rk0/v32pVRlLSSwbHYl15w9ZdQB6JRl0txu33a8aXcHZy6oGfGY91wyI1Pw/nh4NIUPXTWHr35oJZ++eRH/edcqdE3ltVAb9VX5OYM7aTsbuugd5day8UJVFZqjcX782n7iLo17tjTQHI3RMhjnxxv3k3Rr3Lf1II0DgxyOJfjha3bbr7c1ciASpSOR5Puv7SPuUvntjkb29w/QkUjyvVf3EnepPLDzEHv6BuhKpvifdXuJuzT+EGom1BOhO5XiO+v2EHdp/HlPC9u7+ukxU/zX2t3EXRp/3dvK1s4wvabJf63ZTcKl8si+w2zq6KMP+NYru4i7VB490MZrbX2EsfjmK7uI6yr/aGhnbWsPYQW++couYrrC042dvNzSRb8C33hlF3FN5dlDnTx7sJ2IovCNV3YR01RebOri2UOdDGgK33xlF4OawistPTx5sJ0BVeFbr+xiUIN1h3t5/EAbA5rTpiqsb+vl7/taiWoK/7VmN1FgU0cfD+9tJaor/Nfa3QwoFlu7wjy0p4VBXeU76/YQsUy2d/fzx1Azg7rK/7y6l7CZYmdPhAd2HmJQV/neq3vpS6XY3RvhNzsaGdRVvv/aPnpTJvvCA/xqWyNxt8qPNuynO5lif3+U+7YeJOHW+PHG/XQkkjREBrlnSwNxl8ZPNx3gUN8ATQMxfr75AHGXzs83H+DwYJymaIyfbjqQyUSLk4n/y8rEoXQmNthtv9rWyMFIlPZ4wsmExm+cTHQmknxv/T4STib29Q3QmUzyP68OZWJXJhN2dh7c3cKOrgg9Zor/Xmdn4i97WjKZ+Paa3SRdKo/sa2VzOhNrdmcysaGtjz4sOydaOhPdhIH/fDlEXFd5qrGDl1u67LZXdhHTVZ5r7OTFps7cTDTbmYho9uPSmXiq0c7EN9OZaO3mHwfahnKiKLzW1svf9x0mqil8e81uoipsbA/nZgKLrZ1h/rKnhaiuOZmw2NYV5k+7nEysG8rE73Y22ZlYP5SJ3+5oJJaViT3hAX6z7RBxt8oPX9uXycS9mxuIu1V+vHE/nYkkDf2D3Otk4v82HqA9nqBxIMbdmxuIu3R+uukAh2O5mbh7SwOtA3YmfrJxPwm3zr1bDtI0MEhrLMGPNuwn6Vb55baDNESitMUT/CArEwf67b7je+v3kXCr/G7nIfY6mfhfp+/4faiJ3T0RupN2JhIulT/tamZHd4RuM8V/r9tD3K3xkJOJnpSdiYRL5eF9rWzpCNNnDWXi7/vbWNfSPSIT6w53D/UdLpUnD7azpqU7k4m4rvBsYycvNQ31HTFN5YWmLp4/1ElEcbKjKbzc3M3Tje1ZfQesa+0ZkYn1bT08tj8rEwpsau/jb3tbGczKxJbOPicTaiYT27vCPJiViX4rxc6efh4I2Zn47qt76U+l2NUb4f4ddt/x/fX7aIvE2Ns3wK+32/3ED9KZCEf55daDmUx0JVMc6I9mMvGTjQfoiCdp7B/MZOJnTiYOZWdicwOt0fhQJlw6925poCkSozWW4Mcb95Nwq/xy60EORgYzmUi61Uwm2hNJvr/ePp/cv+MQ+8IDdCWSfDd9Pgk1sbt3KBPxTCb66UmZzvlE5aE9LWxzMvGtV5xM7G1la0eYXmsoJ3/f38bG9l7CFplMPH6gjVcPd9M/Sib605nQ4NnGTl4clonnD3XxfNNQJuLq6JlY09rNEw3tRJ1MRFVYf7iXx/Y755M1u4kqChvaezOZ+Paa3QwAmzuGMvHf6/YQwT6fPLir2cnJXrqSyczs6VNNeT3fwp8I7e3hk/6Ew1caGU/KyvJoaQvzX7/dQOhg7kX0JSsmctMF0/jOAxvZEGrn/DMm0NU7OKI474XL6nj3+dNJ2XPZUFFe12yNY+keSPApZ0Wq4bJXp3m9jnbcVVWhP5aiLxLH59Ep8B/fkvOniwW8srONn/55qNjpkhnlzJxUkrn9D6C8yM8nblzAt3+9PlNHaFptIZ+40a5J88LWVn72l9yaGj6Pzpc+uILm9n4OtPRh1BdRX5GHW1foiyaJRBMU53t5dkMTv3ti14htO9asjyPpjib47PdfyLkFRFXg6x9ZTVne6AXIj+Vox7w/nuIbv3g1UzPL69b47HuWMLEieMJmWmVTlFMbqaPtu+LSsLKK9zZ2DvCFn74y6mP/55/OOq66VuDUzGKoELLLpXH3Izt4ev3I5c+vWD2Z68+ZfMJWPlIUhXjKJBpPkR/0opqpkzZgP/rzn/4u43jPbYoC8ZSVKdCdl1XjZjhVVXhqQzO/cPqV686bhs+js3Z7K163xpVnTmZCWQD9TVyluFwa3//TFtZsa+WD18zNWZEt27c+ujqzMuBwJ+u8XlaWd9w7drKuX1IulUMDMZ492M6ymhJ2doQp9Lkp8rrY2NrDsppidnX2k+fRKfG5ea21h+U1xezp6sfv1inzuVnf2s2ymhL2dvfj1TUq/B7Wt3SztKaEht4IuqpSFfSyrqWLpdXFHOwdQFUVaoI+1jV3s7SmiEN9USxgQr6PtU1dnFFdTEt/lIRpMbHAz7rmLhZVFdMWGWQwaTKpMOC0FdExEKM/kWRqYZC1LV0srCikMxonHE8yrTjI2qZuFlYW0DWYoGcwwYySIGuau5hfXkhfLEFnNM7M0jzWNncxr7yQcDxJ20CM2aV5rGvpZk5ZPgPxFC2RQeaWF7C2uZNZpQXEkimawlHmVxSyrrmLGaX5xFMmB3sHWFhZyLqWLozifJKmSUNvhIWVRbza0s204iCmabG/N8KiyiJebelialEeCrC7O8ySqmLWt3QzuSiAisKu7n7OqCpiQ2sP9QV+dFVhZ2eYpdXFbDjcQ12+H7emsqOjj6XVxWw63ENNng+vrrG9vZczakrYcriXyjwvAV1jS3svy2pK2NbWS1nAS9CtsaXNbtve3keJ302+W2fT4R6W1ZQQcjJR6HWxwTn+6UwU+9yZtmNl4tUWO08HeiO4nEy82mIf68a+AVRFpTro5dXmLs6oKc7NRLOdnaZwlJQJ9QV2TpZUF9PaP0gsZTKp0M+65m4WVRXRHhlkIGkypTAwaibWNXWxoLKQrsE4PYNJZpQEWdvcxfyKQnoHR8tEgraBeE4mIvEUrU4m1jV1Massn8FkiubwIHMrCnjVyUQsmeJQX5QFrzcTxXlgwZ5RMrG7K8yS6uJMJjRVYVdnmDOyMuFSFXZ0hFlaU8zmYZlYWlPCpsM9VOX58OsaW9v7WFZTzNa2XsqzMrG0upgdHX2U+j3kuXU2He5lWU0xOzvCFDmZ2Hi4h2XVxYQ6+8l3MpHuO3Z39RNIZ6Klm2W1diZ8uk65353JxP7eftyqlsnE0uoSGvoiaKNkAqA2OxN9UVLWkTOxtqmbxdVHz8TUoiCvNg9loncwiZGViZ7BBF2DcWaW5LG2qYt5FcMy0dzNnPJ8IokUrf25mYg6mZhXUcC65k5mOn3HoXCUBRXDMtE3wMJMWx6prEysa+limpOJvd39LK4q4rWWLiYV5aFCTiYmFvpRFYVQup9o7aGuwM5Euu/Y1NpDTYEfj6ayvaOXpdUlbD7cQ3WeD5+TieU1xWzJzsThXpbVlrC9vXdkJtrDFPlHZqLA6xpxPgl6dEp9bl5zMrGnux+/k4n1rT0srbYz4dE0KgNe1jV3sazGzoSuOOeT5i6W1hTT2GvX16vJGzqfNPVFMZ2+Y11WJuKmycQCP2ubu1h8tPNJPMmUoiDrmrtYWGnnpC82MhPdg3FmlAz1E33xBB0DcWaV5rG2uZu55fn0x1O0RQaZU17A2qYu5pTnM5BI0ZLOyREyMaMkn0TKpCHnfJKbiXQ/YVkW+7ojLK4q4sVDHezqilDsdXHzrAlMKg4w2DtycZ4T4UjXMG/7GTzjka7Ax2+YzzmLa9FUBY9b453nTuXK1ZNIJVNcuLQegKdfbWTJzAouXFaH160R8OrceMF0rjlrCqZpoliWc//jib2m9bk1CoOekdutKZnZKCeaaVr4XSqVhV67kPHp/qR2DAqwbEY53/rYaj50zVw+9e5F3HrpTM6eX8XXP7yKd19o8MGr5/Avty5h9pRSvvqhFXz1Qyv55l2r+Mwti/C77NlqC6eXMd1Zxjxt5dwq8n068yYVcfXqSRg1+Xg0BcWCAq9OdZEPr6awcm4Vef7c21OK873MmVT8hj5YF/tdfOmDK5hSWwDYRWS/cMfyNzy4cyxBt8bn37eUr965ki++fxnf/tiZJ21wB95akbKGrcxUGPSgjzKbsLo0gO8IRYhHk0yaOQM2iUSKdyytG/E4RYHV86tO6LLWlmXhUhXyvTplRb5TOrhjP/8pfbo3xbLsmUKlQTcFRxncAbtvXDqrggnldt2sPzy1m78+v49Vc6v46HXzmFQefFODO/b2WFSW2rOtWjsi1A+r0QX2rMGCk9T/v5WpmsKgZfHQ7hZWTyjjUDhK92CcaUVBnmloZ2VtCc39g7QPxDBK8nj2YAfLa4ppjcRo6R9kRkkezzZ2sLS6hPaBGM3hQWaX5vNcYyeLq4vpisY52DfA3PJ8nmvsYFFlEb2DCRp6B5hfXsDzjR0sqCygL5Zkb3c/CysKeaGxk7nlBUQSKXZ39bO4sogXD3Uyw7kA3tkZZklVES8d6mR6SR7xlGl/OK0u5qWmTqYUBUlZFlvae1leU8wrTV1MKvJjAZsP97Cy1m6ry7c/FL92uIdVE0pY29xNTZ4fl6awvqWbMyeUsK6lm8qAF4+msbali7PqSnm1pZsyvxe/S2NNUxdn15exvrWHIp+boFvnpaZOzqkv47XWHvI9LvI9Oi8e6uSc+nI2tfUScOkUel280NjBOfVlbG7rxefSKfG7ebaxg/MmlrO1vQ+3plLm9/BcYwfn1ZexvSOMqipUBr08c7Cd8yaWs7MzjGVBddDL0wfaOae+jF1d/SRMi5p8H880tHN2fTl7u/sZTJnU5/t5+mA7Z9eXsb8nQn8yxcQCP880dHBWXRkNvQP0xRNMLgzwzMEOVteV0dgXpXswwVQnE6ucTHREhzKxoraElv5BWiN2Jp45aGeizclJOhNLqovoisZp7BtgTlk+zx3sYGFlET2DCfb3DDCvPJ/nGzuYX1k4MhNlhfTHU+zp7GdRpd02q6yAaDJFqKvfyURXJhPbO8IsrS7KyUT6A+vLh7qYVBTAtGDz4d6hTBQEUIANTibWOJnQVYX1LT1Hz0TAg8+lsaa5izPrSnmttZsin5uAS+PlZjsnr7X2UOBx52Ri4+Fegm4nE4c6Obe+fCgTXrd9/NOZ0DXK/B6ePdjBuRPL2d5h182sCHh59mA75zqZAKgKenn2oP27u7rCJC07E083tHPOxHJ2d/UTNy3q8v12m5OJiJOJp9OZ6BugL55kkpOJM+tKaeyL0hMbysTK2hKawoN0jpKJw9mZqBnKxKzSPJ5t7OSM6iI6o3EO9UUzmVhUWUT3YJwDo2RiX3c/CyoKeb6xk3nlhfTHk+zpyspEeW4mXjzUhVHqZKLTzsSLTZ1MHZYJu5+wM7GlrZcVtcW8nJWJjYd7WFVrZ6K2YJRMBL24NZV1zd05mfDqdibOrrczUezzEHBpvNLczdl1diYKszNRV8bGw73kuV0UZGUi3XeUeN0839jOuRPL2NLeh1vXKfO7M5nY5mSi3G9nIt1PKEo6E+2cW19OqCtMEqgJenmmwW7b42RiQr6fZ5xM7O2OMJDJRDtn1ZdxoDdCOJ5iUmGApxuyMhG3M/F0QzurakszmZheHOSZhqFMtA/E7HPHwQ6W1dqZaA0Pz0SMpr4os0vzefZgB4ur7Ew09Njnk+cb7b6jL5Zkf0+EBRWFvHCok3kVBZlMpPuOWeUFDDiZsM8n9uBJLGmyI30+aepkWnGQpGlmBjtfaepkclHQzkT7UCbqszKxsraENc1d1KbPJy09rJ5QwtqWbqrz7Ey82tLNmXWlrGvupjzosfuOZrvvWN/STYnPm8lE+txR6HGT59Z56ZB9Ptl4uId8t4sCT24m/C4XxV43LzR22Jlo62VXl/3Fctdggr/sbaE/nkI9zjt6Tti1xSl9NnHK+HSV915k8L//fDbf+fiZXLmyHo9mF5iaVJXHFWdOxgJ++tBWDh0O87lbz+BbHzuTS5ZNOO7byt4ov1vjg1fPGdH+7gtnkOcdzxUYcqlAScDNshnlzK4rJOjWUIGKAg8XLqll5awKCny6fY+qplJV6KU0z5NTWMunq3zyxoV8+YMr+PS7F/GNj6zixvOn4nKKjaVS5hE/uOZ7db5y50puvGA6c6eUcsvFM/ji+5dlltt+vSwLqgq9fO7mxfzw0+fy77ctoa7s2LfYvBluVaGqyEtdaQD/CSqAPRbleTXef2Xue07XVD5y7Tzcb/L9Xp7v5TM3L6Yozx60LSnw8rlbz6A0b+Qgrnhr8rtU/uW9i/l/71vKB6+2B5SXzapAO0Fvl2TS5KwFNeiayuNrGrj23GnUlA2tWldTFuSf37WQE3iX65hhpiyCKYu75k9ke0cfDb0DXDW9mrs37efSKZXs6Y6wrzvCO41qfr7pAO+YVM7B3gF2dYa5fmYtP990gPPqymjpj7KjI8wNM2v5+cb9nF1XQudAjC3tvdw4cwI/3XiAVbUl9A4m2NjWy02zJ/DzTQdYXl1MNJFifWsPN8+p4+cbD7C4spCkabG2uctu23SA+eUFKMBLTV28Z04dd28+wOyyPNyawguNHdw6t467Nx1gRkkeQV3j2YMdvHduPfdubmBKYYBCj4snD7Tz3rn13Le5gfoCP2V+D4/vO8xtc+v55ZaD1OR5qQp6eHTvYW6bV89vth6kMuBhQr6Pv+1p5bZ59dy/rZESn5vJhQEe3t3CbfPqeWD7IfLdOkZxkId2NXP73Hr+uLOJgEtlTmk+fwo1c9vcOh7c1YRbVVhQUcAfdjRx67x6/rq7FU1RWFJZxO+2H+LWORN4ZE8rpmmyvKaY+7cf4pY5dTy+7zDxVIpVNSX8eutBbpldx5MH2ojEk5xTV8ovtx7k3bMn8PzBDnpjcc6fWM4vNh/khpm1vNzUSVc0zkWTy7l3cwPXGjW82txNW2SQSydXcO/mA7zTqGZjaw/N4SiXT63ins0HuHJqFdvb+zjYN8CV06u4e9N+LsvKxDVGDT/beICLJpVzoCfCnu5+rp1hZ+KCiWU090fZ2Rnm+hlDmehIZ2KWffxXT7Azsamtl3fPnsDPNh5geU0xkXiK11p7uGVOHT/fuJ8llYUkUinWtXRx81w7Ewsq7S9rXm7q4j1zJnD3pv3MKcvHpSq80NjJe7IyEXAycevcOu7dfIBpRQEKPC6ebrAz8YstDUws8FPic/HEgbZMJibk+6gKeHhsn52JX289SFXAw4Q8OxO3z6vnt04mJqUzMdfORIHHxfTiIH/Z3cLtc+v5w85DBN0as0rz7EzMq+fBXU14dYV55fn8cWcT751bx192N6MpCosrC/ndjkPcOqeOR/a0Ylkmy6qKuH/7Id4zt47H9h0mkTJZVVPCb7YNZWIgnuSsCaX8autBbpo1gWcPthOOJTivvpxfbDnIjbNqefFQJz2Dcd4xsZz7Njdw/cwa1jZ15WTiWqOaDa09tIQHuXzKUCa2tvXR2DfAldOGMrG7s5/9vRGumV7Nz51M7B8tE+GhTPxs437OqbM/3G8dlomeYZlYUVOSycS7nUwsrSwinkyxrqWbW+bafceCygIsy+IVJxP3bDrAvOxMzLEzMbMkD386E3PsTEwvCpDvtjNx6xw7E5MLApR4hzLxi812Jir9Q5n41ZaDVAW8TMjz8Xen7/jt1kZKfW4mFgT42x77+P9um5OJIjsTt82t4w877EzMKMnjQScTfwqNzMRDu5pxKQoLK9KZqOfh3a1gWSzNZGICj+49TDKdie2Ndib225k408nEu2fX8WxDm5OJUn6x9SDvmlXLi41DmfiFk4k1TZ10DMS4ZHJFpu94rbWblvAgl02p5J7NB7h6+lAmrphWxc837efyKZWEOsM5mbhkcjn7eiLs6Y7wzhk1TibKaewbsDMx087EuXUlHO4fZFtHmBtm2pk4q66E7sE4m9t6eVdWJvrjCTY4mfhZTiZ6MplYVGFnYk2mnzjAvPJ8NFXhxUOd3Dqnjns2H2B2SR7erH7ink0HmF4cJM+t88zBdt47xz53TC4IUOx18cSBdicTDUzI91ORPp84magOeKkJ2pm4fV49v9naSHnAzcR8P3/bY/cTv9vWSLHXxdSiQCYTv99+iDy3zkwnE++dV8+fdjbh1VXmlOXzx1A6E01OJgr4fVYmFOCuRZMBuHRyBR+YXUdV0PuGyhO8GW/rIsvjneXMWgFyguVWFa5eNYlzF9XSH42T73eT59NRLE5JAE3Twqgt4D/vWsVLW1qIJVKsmltNRZH3daysM36MNoPq9cxecGsKNcW+133rm2VZ5Hk0Ll1Wx6XL7FkaRxsQOr6/adfF0pyiJGNpVsSYZsESo4xvfnQ1O/Z34fVoTJ9QRKHf9aZn6KmKXXT6qx9aSSyewuvW8LlOXr0zcXJ4NZVJ5UEmV+Sd8FmbYNeX++qHVvCrR3dy3yPbuf68adRW5KGrCkVBN27nC4jxyLJAS5icV1fKusO9lGgq59aXUeX3UBPw8FJzN8Waxjvqy6kJeKkP2vXMClWFiyaVMyHPx6R8H/GUSZGmcsmUSuqCfqbmB4gkUhSoCldMqWRing9PQYCeWIICReGKKVXU5fnwairtAzEKFIWrplVSFbBvI2rpH6RAVXnn9CrKfB7yXBqHwlHyFJVrp1dT5HFR4NLZ3zNAvqJynVFDnkunyK2zp6effEXheqMGr65S6nERyg8TVBVumFGDrqpUeF1sz/dl2jRNodztYmu+j6CicP2MWpKmSY3fw8RCH3mKyvUzahhMmtT5vUwqDBBUVa43aggnkkwKeJlcGCBPVbneqKYrlqDe77U/JOga10+voS0ao87nZkZJHvmaxrXTqmiJDFLrdTG7NI98XeeaadU0hqPUeFzMLcunQNe4eloV+3sHqPK4WFBRSKFL56opVezq7qfSrbO4spAit8blUyrZ0RWmwqWxrLqIEo/OJZMq2NYRplzXWVFTTJnXxUUTy9nY3kuprrF6QilVQS+l9WWsP9xLqa5ydm0ZFT43FXWlrG3tyclEtZOJIlXlHRPLqA54qQt6eR6FIk3hoonl1AZ9TMzzkXQycfHkSury/EzJDzCQSFGoqFw2pZL6PB/TC/z0pTMxtYp6JxNd0Rj5isJV06qoCvoIaCqHB2IUqCrXTKui3O8hTx/KxDuNGoq9Lgp0nQO9Tiam19i3kbl09vb0k6+oXG/U4tNVSjwudjmZuM6owa2qlHtd7MgbygRAlc9tZ0JVuGFGLSnTosbnHsqEUUM8ZTIh4GVioZ88TeWGGTX0D8vEDUYN3bEEE/1ephXZbddNr6EjGqPe58EoziNP07h2WjUtA4NM8HqcTGhcM62aQ+EoNV4Xc7IycSArEwUunSunVLKnJ0JVViauyM5EVRElbheXTqpge1c/5S47E6UeFxdPKmdTey9lusbq2hJKvS4urC/jtbZeSl0qZ9WWUeF3U1FvZ6J4WCZeae6mSNM4f2IZNQEvE4JeXlQUilSFCyeWUxv0MjHPT9K0KFJVLplckcnEYDJFoapy6eQKJxMB+mIJ8tOZyPfhVe1MFCgKV06rojorE/mqytXTq6jwewjqGk3hQfIVlWumV1PsszPR4GTi2unVFPs95Kkqe3si5DvHwe/SKfHo7Oo+ciZunFmDAlR6nUxoCjfOdDLhd1OX7yNPUbh+xrBMqFmZCGb1EzNq6IklmBQYysT1RjUd0XhuJqZXc3jA7jtmleaRr9v7kZsJnWumV9HQO0CVR2d+eQGFLp0rp9qZqHTrLKoopNzv4fKpVYS6wlS4dM6oLKLY7eLSyRVs7wxTrmssqymmxOPikkkVbG7vo1TXWVXr9B315TmZKPe5Ob++lHXpfqIuKxMtTibq7X6iNujlRaV7WCZ8mCYUqioXT65gQp6fyfl+BpMmhZqdibqgj2n5AcKxlHPuqHQyEaArGrczMbWK2jwf/iNkojk8SL6q8s7p1ZT4XOTrOgd7BzLnkwKPi0KXzr6eCHnO+STo0il26+zuDpOn2ucTt5bORJigZvcJqgKVPjfbnEzcMLMW07SodjKR7k/ipskE/1Amrp9Rw0AiRf2wTPTGEkwMeJma7idmVNMVTTDR72F6JhM1mUzMdPqJa6dX09RvZ2JFdRFnVBSinqaVtKQGz9vMWNv34TU93oyxtu8nynjdb5B9fyP7rjqzt051338ijdfj/nbYb1OBeNLCrdtLqh6vt3MNnjRFU3AHPMT6BsGroyRS9qqSHh0zmsDy6KjJFFigel2kBuKZNsVpSw7EMd0aaspCtSxUn4tkJN1molqg+VwkIrmPS7elXCqqCZplofvdxPtjdpsFasrCFThyW9Kl2n8rZeEKeOzH6SoKoKVMe9+cNgB9WJvf7ybWN4gn6CEeiZHS7JWF9KSZ02YBWtLEHfSQiMRIaQqmoqAn0m1xUqq9rLWW1WZqYCoqWiKFO+ghORAnpSiYzuNcATepaAJTUTA1BTWeymoDU1NR4yn0gBszGsdU1MzjdL8bczCBpYCpayixJJrfhTmYBAVMl4YymET1uSCWxFLAcmkwmETxuSjye+jujoBbwxpMonh1lHgKSwHFbR//Y2dCJzWQyMmE4uRk6FibqD73UCZM0z7e6ePv1tCOmgkX8f44KZdm/60UOZlQTNDMrJzoKgp2JtLHOqnbK/doKRNfvo+B3mhO2/CcaFnHP6mNbMvORKZNVTFVcjJhavYSxtmZSGlgHUcmUqqdMS1xtEzkZic7EyldRY2l0Jw2FND9bhLh2KiZUH0urHjSXsPZrdqZcB4H9vG3sjMBkM6JR0cZJRNKVj/xejIxWt+RcmloloVqHj0TSZeKNrzv0FXygh6ivdFMP3Gk43+kvuOYx/84+w5TU0dkYnhO7EyAqaq5x19VSI2SiZSmouVkIisnfjeFfjed3QOkdGVEJjJ9h8+F5WQi3ZbJBAq4jpUJE7CG+o7sTHh0UtHRM2F5NJSkc+7IOZ8MO/5uDe0omchuS+fJm+8l2hsd/dyh26u5qSnzmOeOY2Ui1h/D1EfPxNFyMnQ+Gd42et9hqkOZcAfdJAeOkAnTOqnXbke6hpEBnrcZ2ffxt+/jdb9B9l32fXwZr/sN42OAB+QYy76PL+N1v0H2XfZ9fBmv+w0nd9+lyLIQQgghhBBCCCHE25QM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcTLAI4QQQgghhBBCCDHGyQCPEEIIIYQQQgghxBgnAzxCCCGEEEIIIYQQY5wM8AghhBBCCCGEEEKMcfrp3gAhhBBCiPFMVRUURQFA10FVNQAsC+f/UyPaTNNE09RjtqVSJro+vM1C15Vhv2uhaYrzbwtQjtGmAOaINssyURQFy7JQVRXLYkRbeluHt+m6mmlTFBVFyX1cui2VMlHV7DaLVMpCVZXMdtqPO3pb+jUfagOniWTS3qfctqHXN91mb8vxtA0dw3SbaaZQFLvN7dac12rksT7etpOVCbvteDIxek7Sx99uG8pE+pi/3py8sUwcX05OZSY0jaNmYnibopzqTBwrJ7nH+nhzkj7uo2XijfYdo2ViZNvQ8X89fceJyER2m9utva6cHCsT6ePz1shE+u8NP/6gaeob6idObibe2PnkeDJhmpbzfjj1jmuAxzCM7wDLsffyE6FQaF3Wzy4AvgakgEdCodCXT8aGCiGEEEK83aS0BI3RFqI9AQoH29H0FIrpoj/VR8AVQEUlRQLVchFJhvE7bUkSaHEXkVSYgMuPgk7CiqEn3ESS/fhdfjRFI27GUBMuoqkIAZcfTdEZNKPoCQ8DqX6CLj+qojOYGkDHSzTVT8AdQEUjmhpAx81gaoCg24+Ci2iqHxceomaUgMuHhotIqh+30xZ0+VHR6U/241Y8xMxBAm4fiqUTSYZxK95Mm2rp9CfDuBUP+yOxTFs40YdH9RI34/jd3tw2K4Hf5UVJafQ7bQkzgc/tQUnqhJO9eDUfSTOBz+WFlEY4kW5L4nN5htpUPykricflRklp9CV68ak+UqTw6C6UuE5fogef5sfExK3rENcJJ3oI6AGSlolb1yBp/z2/7se0LHRNRUlohJN9+HU/FqCpCiTtbfbrAQAU1UI1dfY19eF3+cFSwGnrT9ptCioWdiYiqb7M8U9noj8ZJui0JUigJeycBNz2cYibQ5kIuP2olkbciqEl3Ayk+odlws1AKjIsE55MdlTFzpEr3eY8RzQ1gEvxEE0NEHD5UNEZcB43mJWT/mQ/HsXNoBnD7/bR1d5NfzKMR/EyODwTqodYKpbJTvpxced3FWvo+Ns58aGmNMKJPrxOTnwuD2pKp885/gnTbkvnxKf6SFhJvC4PSiYTPpJWCp/LDaNmwmlzMuHSdVSnza8HSFkpXLqOkp0J7EyQ0OlP2m3Ng9gDA04mfLofUFBVy97fhJ0dcDKR1aagYilDmfA5x98kieq8z3L6iYSbSLIPv9uPhk7CjDltYfzuAKqlkbBiaAkXA1n9RMyMOjnJzkQUPeFyjnUAVbH7iXQmgi4/iqJntQ3YxxUXA6l+3HjZFxkg4PajWbqTCc/I44+XmHUCMmFpmb4j4WRCSemZPiHh9BPp45/OhM/lsd/XyaFMeF0uyMrOaP1EChOPrmdykpOJuMa+pn1D/YSu5eTEwh7YUJL29g1lAicTvZlMKKqFku4ndD+ggpJCtdx2xlwBlEwmXPbxdwXQnEyoTiYCznFNmDG0uJtIKuw8Lt1PDGVCdc4nw3Mysu9wMZiK5PQdHe26cz7xMJjVdwykIrjxEjUH7OdAd3Jy5Ez4XT40hs4dMTPr3JGTiaFzh1v1khhxPvGRsOL4XF5U573uVX2ZnKhJnb7M8R9+7rDbvE5O+p1MJJ1M9HaaYGpo/n78iSmn/LpCOdbIkmEYZwOfCYVClxuGMRO4OxQKrcj6+XbgIqAJeBa4MxQKbT/S32tvD5/0oayysjza28Mn+2nekmTfx9++j9f9Btl32ffxZbzuN5y8fS8ry1OO97En5fpFM3mh5RWCA0nmeWsxNQUtGkdRVDS/Dys6iOL3kezvR1VU1Ky2RH8/2httC4fRVC3Tpvp9xMNhNE1D9Q1v01F93kxbLBzGpekoPi9mdBBtRFsUze/PbRuIEldMVI8bVyyVaUsoJnjcuN9Am2mZ6IEgVjSK4vOSGohijWgbwLIs9EDA3vfX2YZloY1oAy3gd9p8pCIRUEDzZ7f1g6LktCUj/SjHanOO9ehtx87Em8pJuB9NVUdmYtSc5GYiHg6jO8f6uHMyECWOieo9eZk4ek7GSCaOmpNTm4mj9x0nIBPRKHHLRPV6cMWSOcdaeYN9x1sjE15SkYFRMnEy+o6RmXgrnU/eSCZGO5+cuky8/vNJvL8fl6YTx6R5oJ2yqnr8BbU4kxZPqCNdwxzPDJ7zgT8DhEKhHYZhFBmGkR8KhfoMw5gMdIVCoUYAwzAecR5/xAEeIYQQQggBlqlS7Z2Ep6+BPf/+JSbdcTu7f34PAJPuuJ39P78n8/9jvS393ztH+fmbaXur7ae0SSakTTIhbW/9nJzsbU1zfekLKIUKFqfudq3jKbJcCbRn/bvdaRvtZ21A1YnZNCGEEEKIt6940uK3DzVR6is53ZsihBBCiBOssydOInlqa/G8kSLLR5vOfMypzkVFfnRdewNP+/qUleWd9Od4q5J9H3/G636D7Pt4NV73fbzuN5z+fT8Z1y8DgwluuqqGjraGE/p3hRBCCHH6lRS6KS0J2HW4TpHjGeBpZmjGDkA10HKEn9U4bUfU3T3werbvDZE6BbLv48l43W+QfZd9H1/G637DSa3Bc9yPPSnXL5pJ8+B+6szTs9KGEEIIIU6eFAl6eiInqwbPqO3HU2R5JfAfoVDoHYZhLAK+GwqFVmf9fBtwGXAIeBm4ORQK7TrS35MiyyeX7Pv42/fxut8g+y77Pr6M1/2Gt3GRZexVtMxwJ3QN4g94MCMRALRAgFQkgh4IkIhEUN5EG4B+mn8XTUf1uklFBk5Mm/N8Sef5TnVbKhLJ/P+x2nTnb5zItjebiVPRdqzspI+rGRkY0fZmMjHacTjeY3i6MpGMRHC9wUykf/etdvzfSNvp7ifeLpl4qx3Xt9T55AQc12Mda8sCNJ24miK/rJIBzV458UR7w0WWQ6HQS4ZhrDcM4yXABO4yDOM2oDcUCj0IfBj4rfPw3x1tcEcIIYQQQgzRUi5cwSqUPIXC4gDd3WFU1b4VTLXsCy/VSo1oU0wTzZnyfbQ2Uia6PrzNQtOVYb9roWkKlgUqFibKMdsUy8JUstsUFMvEVBRUy0JVVedxJoqi2KuNVIzeVlDgo7s7kmnTylVQ7H0a3kbKRFUVzEybBSkLVbULWWoozuOO3qYrzrVxpg2clwUr6exTTpv9+lqAlr6sTpn2fh6lzQJI2ccwu00xUyiKRkGhn97eAUwLlNGO9ShtbzYT2knKxMi2oUzYbUPHv6goQHd3BO0ImYDc4z9a22iZUIdlws7JyOOvnqRMHE9O8gv8dHWFM5nQh2VitJw4K6aPyIR20jJxrJy8sUwUFPjp7o6Mmolj9ROvJxPpttH6idOVifR7fbRMWMPajicTFnZB3VPXT7yxviO/MEBXV+R1nE+Gjv+xzidvLhMMO5+80XOHhea0pTNhmhZuyyJQEmTgFH85d1w1eEKh0OeGNW3K+tlzwAqEEEIIIcTrZpoWzuU9ySRAapRHjWxLpY6vLR4frW2UZxjlad9Mm3P5f9xtyaR5XI/Lfb7R2o6+XcfbZo6yCab5xo/DaG3p45p7jI7v+I/FTKRSuS+qfcxfX06O1PZWysTx5CSVOnomTlTbm8vEyclJ9nt9eCZsJ6/tdGci+zV9vf3EiWo7HZlIpcw33E/YxnYmTqVTV+1HCCGEEEIIIYQQQpwUMsAjhBBCCCGEEEIIMcbJAI8QQgghhBBCCCHEGCcDPEIIIYQQQgghhBBjnAzwCCGEEEIIIYQQQoxxMsAjhBBCCCGEEEIIMcbJAI8QQgghhBBCCCHEGCcDPEIIIYQQQgghhBBjnAzwCCGEEEIIIYQQQoxxMsAjhBBCCCGEEEIIMcYplmWd7m0QQgghhBBCCCGEEG+CzOARQgghhBBCCCGEGONkgEcIIYQQQgghhBBijJMBHiGEEEIIIYQQQogxTgZ4hBBCCCGEEEIIIcY4GeARQgghhBBCCCGEGONkgEcIIYQQQgghhBBijJMBHiGEEEIIIYQQQogxTj/dG3CiGYbxHWA5YAGfCIVC607zJp1UhmF8EzgT+1h+HbgSWAx0Og/5VigU+ttp2ryTwjCMc4DfA9ucpi3AN4FfAhrQArwnFArFTssGnkSGYdwBvCeraQnwKhAAIk7bp0Kh0PpTvW0ni2EYc4CHgO+EQqHvG4YxgVGOtWEYNwP/BJjAT0Kh0M9P1zafKEfY93sAF5AAbgmFQq2GYSSAF7N+9fxQKJQ69Vt84oyy7/cySt82To7774Ey58fFwCvA17D7vvR7vT0UCl1/yjf2BBrlfLaOcfJeB7l+YRxcv8D4vYYZj9cvMH6vYeT6Ra5f5Prl9L3P31YDPIZhnA1MC4VCKwzDmAncDaw4zZt10hiGcS4wx9nfEmAD8BTwL6FQ6OHTu3Un3bOhUOi69D8Mw7gH+EEoFPq9YRhfA94H/Oi0bd1J4nQEP4dM3m8AZgO3h0Khradz204GwzACwPeAJ7Oav8SwY20Yxi+AzwNLgTiwzjCMB0OhUNcp3+gT5Aj7/hXsE8IDhmHcBXwS+P+A3lAodM6p38qT4wj7DsP6Nudxb/vjnn3hYxjG3cDPhn709jjuRzifPck4eK+DXL8wvq5fYBxew4y36xcYv9cwcv0i1y/pNrl+OT3v87fbLVrnA38GCIVCO4AiwzDyT+sWnVzPAek3Tg/2tyDaadua0+sc4C/Of/8VuOD0bcop83ngy6d7I06yGHAp0JzVdg4jj/UyYF0oFOoNhUJR7G+DVp3C7TwZRtv3jwB/dP67HSg51Rt1ioy276MZL8cdAMMwDKAwFAqtPeVbdfKNdj47h/HxXge5fhnP1y8w/q5hxsP1C4zfaxi5fpHrlxxy/XJq3+dvqxk8QCVD073A7kAqgb7TszknlzOFMT2t9Q7gESAFfNQwjE8CbcBHQ6FQx2naxJNplmEYf8Ge7vcfQCBrOnMbUHXatuwUMAzjDKDRmd4K8CXDMEqBHcA/OR3HmBcKhZJA0tnHtNGOdSX2+51h7WPWaPseCoUiAIZhaMBd2N8EAngNw/gNUA/8MRQK/fcp3twT6gjHHYb1bYyT457lE9jfjqVVGobxB6Aa+5uiX5+CTTwpjnA+u2g8vNcdcv0yfq5fYBxfw4yX6xcYv9cwcv0i1y+jkOuXU3jM324zeIZTTvcGnAqGYVyFHaiPYt/v97lQKHQesBH44unbspNmN/YF0VXAe7Gn/GYPVo6H4/5+4F7nv/8X+EwoFDoL+57Ou07XRp0GRzrWb9sMOBdHvwSeCoVC6WmwnwY+CFwI3GwYxpLTtX0n0fH0bW/n4+4GVodCoaedpk7g/wE3Ydcu+bJhGGP64hBGnM+yjbf3+tt1v3KMw+sXkGsYuX4ZMq76Nbl+kesXp0muX47e/qa93WbwNGOPjqVVYxc2etsyDOMi4N+Ai0OhUC+593z+hbfZPdwAoVCoCfid88+9hmG0AmcYhuFzvvmp4dhTI8e6c4CPAYRCoQez2v8K3Hg6NugU6h/lWA9/79dgF3J7O7oH2B0Khf4j3RAKhX6c/m/DMJ4E5mIXr3zbyLoYhKG+7Q+Mn+N+NpCZ2hwKhcLYWQDoMAzjVWAGY/icN/x8ZhjGeHqvy/XLOLh+AbmGYXxfv8D4voaR6xe5fpHrlyEn7Zi/3WbwPA5cB2AYxiKg2QnR25JhGAXAt4DL0wWaDMP4o2EYk52HnAO87QrXGYZxs2EYn3b+uxKowO4ornUeci3w6GnavJPOMIxqoD8UCsUNw1AMw3jCMIxC58fn8DY85sM8wchjvQb7ArnQMIwg9j2tz5+m7TtpnOr78VAo9IWsNsMwjN84WdCx933bEf/IGHWEvm1cHHfHGcCm9D8MwzjXMIz/dv47ACwAdp2eTXvzRjufMb7e63L9Mg6uX2B8X8PI9Qswvvq1DLl+keuX9D/k+uXkH3PFsqyT8XdPG8MwvgFkpnqGQqFNx/iVMcswjA9iT/PLflPcgz01bADox16doO3Ub93JYxhGHvAboBBwY0913gD8AvACDdj7nThd23gyGYaxGPhKKBS6xPn3DcBnse//bALuCIVCA6dxE08YZ1//C5iIvaxmE3Az9vTunGNtGMZ1wGewlxj+3li+nxeOuO/lwCBDdTm2h0KhjxiG8Z/Aedj93l9CodBXT/0WnzhH2PfvAZ9jWN82To77O7H7uRdCodDvnMfp2KtRGNjFaX8UCoXuGe1vjgVHOJ+9F3sf39bv9TS5fnn7X7/A+L6GGU/XLzB+r2Hk+kWuX5Drl9N6/fK2G+ARQgghhBBCCCGEGG/ebrdoCSGEEEIIIYQQQow7MsAjhBBCCCGEEEIIMcbJAI8QQgghhBBCCCHEGCcDPEIIIYQQQgghhBBjnAzwCCGEEEIIIYQQQoxxMsAjhDjtDMOwnGUTj/fxXzEM44sncZOEEEIIIY5JrmGEEG8lMsAjhBBCCCGEEEIIMcYd92izEEKcbIZhnAN8DjgEzAYSwMWhUGjAMIyvApcDjUAE2OH8zrnAFwDFefwHABN4EjgjFAp1G4bxFPDfoVDo4VO7R0IIIYQYD+QaRgjxViAzeIQQbzUrgH8NhUIrgBRwkWEY04GbgaXA1cA0AMMw/MCPgXeGQqGzge8B3w6FQg3AN4FvGIZxG7BfLoyEEEIIcZLJNYwQ4rSSGTxCiLeaHaFQqM357wagGJgLrA+FQjEAwzCec34+B6gC/mQYBoAGWAChUOgnhmH8HVgJrDp1my+EEEKIcUquYYQQp5UM8Agh3mqSw/6tOP8zs9o05/9jwMFQKHTO8D/iFDwsdH63AOg70RsqhBBCCJFFrmGEEKeV3KIlhBgLdgCLDMNwG4bhAs522ncBpYZhzAEwDOMswzA+6Pzs34BHgU8DdxuGoZzqjRZCCCHEuCfXMEKIU0YGeIQQb3mhUGgb8GdgDfB7YKPTHgVuAX5uGMazwJeBZw3DmA+8E/h6KBR6FGgD7jr1Wy6EEEKI8UyuYYQQp5JiWdbp3gYhhBBCCCGEEEII8SbIDB4hhBBCCCGEEEKIMU4GeIQQQgghhBBCCCHGOBngEUIIIYQQQgghhBjjZIBHCCGEEEIIIYQQYoyTAR4hhBBCCCGEEEKIMU4GeIQQQgghhBBCCCHGOBngEUIIIYQQQgghhBjj/n/LYLHDzk+yEgAAAABJRU5ErkJggg==\n", "text/plain": [ "
    " ] @@ -924,25 +923,28 @@ "fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(16, 6), sharey=True)\n", "training_stacking_weights = trace[\"w\"].mean(axis=0)\n", "sns.scatterplot(data=pd.DataFrame(training_stacking_weights), ax=ax[0])\n", - "fixed_weights = pd.DataFrame(\n", + "fixed_weights = (\n", + " az.compare({idx: fit for idx, fit in enumerate(fit_list)}, method=\"stacking\")\n", + " .sort_index()[\"weight\"]\n", + " .to_numpy()\n", + ")\n", + "fixed_weights_df = pd.DataFrame(\n", " np.repeat(\n", - " scipy.special.softmax(lpd_point.sum(axis=0))[:, np.newaxis].T,\n", + " fixed_weights[jnp.newaxis, :],\n", " len(X_stacking_train),\n", " axis=0,\n", " )\n", ")\n", - "sns.scatterplot(\n", - " data=fixed_weights,\n", - " ax=ax[1],\n", - ")\n", + "sns.scatterplot(data=fixed_weights_df, ax=ax[1])\n", "ax[0].set_title(\"Training weights from Bayesian Hierarchical stacking\")\n", - "ax[1].set_title(\"Fixed weights derived from lpd_point\")\n", + "ax[1].set_title(\"Fixed weights stacking\")\n", "ax[0].set_xlabel(\"Index\")\n", "ax[1].set_xlabel(\"Index\")\n", "fig.suptitle(\n", " \"Bayesian Hierarchical Stacking weights can vary according to the input\",\n", " fontsize=18,\n", - ");" + ")\n", + "fig.tight_layout();" ] }, { @@ -968,7 +970,7 @@ "We decided we'd do this in three ways:\n", "- Bayesian Hierarchical Stacking (`bhs_pred`);\n", "- choosing the model with the best training set LOO score (`model_selection_preds`);\n", - "- fixed-weights stacking based on LOO scores (`fixed_weights_preds`)." + "- fixed-weights stacking (`fixed_weights_preds`)." ] }, { @@ -1038,9 +1040,7 @@ "# get predictions using only the model with the best LOO score\n", "model_selection_preds = test_preds[:, lpd_point.sum(axis=0).argmax()]\n", "# get predictions using fixed stacking weights, dependent on the LOO score\n", - "fixed_weights_preds = (scipy.special.softmax(lpd_point.sum(axis=0)) * test_preds).sum(\n", - " axis=1\n", - ")" + "fixed_weights_preds = (fixed_weights * test_preds).sum(axis=1)" ] }, { @@ -1094,7 +1094,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
    " ] From c7984a7dac72a5cc7fb391beabac129d900583a1 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Sat, 13 Nov 2021 16:42:31 +0000 Subject: [PATCH 207/222] color divergences (#1225) --- docs/source/_static/img/examples/funnel.png | Bin 158575 -> 121902 bytes examples/funnel.py | 43 +++++++++++++++++--- 2 files changed, 37 insertions(+), 6 deletions(-) diff --git a/docs/source/_static/img/examples/funnel.png b/docs/source/_static/img/examples/funnel.png index eecd6d664c70ee29bccebb2110e46e5324ccb2ee..6a3fe6e0e84b63637c904ddd98831e76e6be9315 100644 GIT binary patch literal 121902 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

    U!nUd;nP|(Ir9xLL6t;-v#>UyX05_Rwz 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 Pg6rEoUhY-9k7WK0GX`9N literal 158575 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

    i4f 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 Tkdk1b{!>aq?qPx0bKn0DWs_gq diff --git a/examples/funnel.py b/examples/funnel.py index 5ef996cf6..b350964c9 100644 --- a/examples/funnel.py +++ b/examples/funnel.py @@ -60,7 +60,7 @@ def run_inference(model, args, rng_key): ) mcmc.run(rng_key) mcmc.print_summary(exclude_deterministic=False) - return mcmc.get_samples() + return mcmc def main(args): @@ -70,13 +70,17 @@ def main(args): print( "============================= Centered Parameterization ==============================" ) - samples = run_inference(model, args, rng_key) + mcmc = run_inference(model, args, rng_key) + samples = mcmc.get_samples() + diverging = mcmc.get_extra_fields()["diverging"] # do inference with non-centered parameterization print( "\n=========================== Non-centered Parameterization ============================" ) - reparam_samples = run_inference(reparam_model, args, rng_key) + reparam_mcmc = run_inference(reparam_model, args, rng_key) + reparam_samples = reparam_mcmc.get_samples() + reparam_diverging = reparam_mcmc.get_extra_fields()["diverging"] # collect deterministic sites reparam_samples = Predictive( reparam_model, reparam_samples, return_sites=["x", "y"] @@ -87,15 +91,42 @@ def main(args): 2, 1, sharex=True, figsize=(8, 8), constrained_layout=True ) - ax1.plot(samples["x"][:, 0], samples["y"], "go", alpha=0.3) + ax1.plot( + samples["x"][~diverging, 0], + samples["y"][~diverging], + "o", + color="darkred", + alpha=0.3, + label="Non-diverging", + ) + ax1.plot( + samples["x"][diverging, 0], + samples["y"][diverging], + "o", + color="lime", + label="Diverging", + ) ax1.set( xlim=(-20, 20), ylim=(-9, 9), ylabel="y", title="Funnel samples with centered parameterization", ) - - ax2.plot(reparam_samples["x"][:, 0], reparam_samples["y"], "go", alpha=0.3) + ax1.legend() + + ax2.plot( + reparam_samples["x"][~reparam_diverging, 0], + reparam_samples["y"][~reparam_diverging], + "o", + color="darkred", + alpha=0.3, + ) + ax2.plot( + reparam_samples["x"][reparam_diverging, 0], + reparam_samples["y"][reparam_diverging], + "o", + color="lime", + ) ax2.set( xlim=(-20, 20), ylim=(-9, 9), From 9724b6aa61be0d1cc98bd2674ea3220eb2c05f0b Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Thu, 18 Nov 2021 20:35:50 +0000 Subject: [PATCH 208/222] fix example from bayesian imputation notebook (#1229) --- notebooks/source/bayesian_imputation.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/source/bayesian_imputation.ipynb b/notebooks/source/bayesian_imputation.ipynb index 72d0e0b6d..718b2749a 100644 --- a/notebooks/source/bayesian_imputation.ipynb +++ b/notebooks/source/bayesian_imputation.ipynb @@ -452,12 +452,12 @@ "First, we want to note that in NumPyro, the following models\n", "```python\n", "def model1a():\n", - " x = numpyro.sample(\"x\", dist.Normal(0, 1).expand([10])\n", + " x = numpyro.sample(\"x\", dist.Normal(0, 1).expand([10]))\n", "```\n", "and\n", "```python\n", "def model1b():\n", - " x = numpyro.sample(\"x\", dist.Normal(0, 1).expand([10].mask(False))\n", + " x = numpyro.sample(\"x\", dist.Normal(0, 1).expand([10]).mask(False))\n", " numpyro.sample(\"x_obs\", dist.Normal(0, 1).expand([10]), obs=x)\n", "```\n", "are equivalent in the sense that both of them have\n", From 576d07a12bb7bf316cb3d16ed065ef1e31c7bd4d Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Sun, 21 Nov 2021 08:30:29 -0500 Subject: [PATCH 209/222] update readme (#1232) --- README.md | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index cd94f33ec..9b4d41782 100644 --- a/README.md +++ b/README.md @@ -11,13 +11,13 @@ Probabilistic programming with NumPy powered by [JAX](https://github.com/google/ ## What is NumPyro? -NumPyro is a small probabilistic programming library that provides a NumPy backend for [Pyro](https://github.com/pyro-ppl/pyro). We rely on [JAX](https://github.com/google/jax) for automatic differentiation and JIT compilation to GPU / CPU. This is an alpha release under active development, so beware of brittleness, bugs, and changes to the API as the design evolves. +NumPyro is a lightweight probabilistic programming library that provides a NumPy backend for [Pyro](https://github.com/pyro-ppl/pyro). We rely on [JAX](https://github.com/google/jax) for automatic differentiation and JIT compilation to GPU / CPU. NumPyro is under active development, so beware of brittleness, bugs, and changes to the API as the design evolves. NumPyro is designed to be *lightweight* and focuses on providing a flexible substrate that users can build on: - **Pyro Primitives:** NumPyro programs can contain regular Python and NumPy code, in addition to [Pyro primitives](http://pyro.ai/examples/intro_part_i.html) like `sample` and `param`. The model code should look very similar to Pyro except for some minor differences between PyTorch and Numpy's API. See the [example](https://github.com/pyro-ppl/numpyro#a-simple-example---8-schools) below. - - **Inference algorithms:** NumPyro currently supports Hamiltonian Monte Carlo, including an implementation of the No U-Turn Sampler. One of the motivations for NumPyro was to speed up Hamiltonian Monte Carlo by JIT compiling the verlet integrator that includes multiple gradient computations. With JAX, we can compose `jit` and `grad` to compile the entire integration step into an XLA optimized kernel. We also eliminate Python overhead by JIT compiling the entire tree building stage in NUTS (this is possible using [Iterative NUTS](https://github.com/pyro-ppl/numpyro/wiki/Iterative-NUTS)). There is also a basic Variational Inference implementation for reparameterized distributions together with many flexible (auto)guides for Automatic Differentiation Variational Inference (ADVI). - - **Distributions:** The [numpyro.distributions](https://numpyro.readthedocs.io/en/latest/distributions.html) module provides distribution classes, constraints and bijective transforms. The distribution classes wrap over samplers implemented to work with JAX's [functional pseudo-random number generator](https://github.com/google/jax#random-numbers-are-different). The design of the distributions module largely follows from [PyTorch](https://pytorch.org/docs/stable/distributions.html). A major subset of the API is implemented, and it contains most of the common distributions that exist in PyTorch. As a result, Pyro and PyTorch users can rely on the same API and batching semantics as in `torch.distributions`. In addition to distributions, `constraints` and `transforms` are very useful when operating on distribution classes with bounded support. + - **Inference algorithms:** NumPyro supports a number of inference algorithms, with a particular focus on MCMC algorithms like Hamiltonian Monte Carlo, including an implementation of the No U-Turn Sampler. Additional MCMC algorithms include [MixedHMC](http://num.pyro.ai/en/latest/mcmc.html#numpyro.infer.mixed_hmc.MixedHMC) (which can accommodate discrete latent variables) as well as [HMCECS](http://num.pyro.ai/en/latest/mcmc.html#hmcecs) (which only computes the likelihood for subsets of the data in each iteration). One of the motivations for NumPyro was to speed up Hamiltonian Monte Carlo by JIT compiling the verlet integrator that includes multiple gradient computations. With JAX, we can compose `jit` and `grad` to compile the entire integration step into an XLA optimized kernel. We also eliminate Python overhead by JIT compiling the entire tree building stage in NUTS (this is possible using [Iterative NUTS](https://github.com/pyro-ppl/numpyro/wiki/Iterative-NUTS)). There is also a basic Variational Inference implementation together with many flexible (auto)guides for Automatic Differentiation Variational Inference (ADVI). The variational inference implementation supports a number of features, including support for models with discrete latent variables (see [TraceGraph_ELBO](http://num.pyro.ai/en/latest/svi.html#tracegraph-elbo)). + - **Distributions:** The [numpyro.distributions](https://numpyro.readthedocs.io/en/latest/distributions.html) module provides distribution classes, constraints and bijective transforms. The distribution classes wrap over samplers implemented to work with JAX's [functional pseudo-random number generator](https://github.com/google/jax#random-numbers-are-different). The design of the distributions module largely follows from [PyTorch](https://pytorch.org/docs/stable/distributions.html). A major subset of the API is implemented, and it contains most of the common distributions that exist in PyTorch. As a result, Pyro and PyTorch users can rely on the same API and batching semantics as in `torch.distributions`. In addition to distributions, `constraints` and `transforms` are very useful when operating on distribution classes with bounded support. Finally, distributions from TensorFlow Probability ([TFP](http://num.pyro.ai/en/latest/distributions.html?highlight=tfp#numpyro.contrib.tfp.distributions.TFPDistribution)) can directly be used in NumPyro models. - **Effect handlers:** Like Pyro, primitives like `sample` and `param` can be provided nonstandard interpretations using effect-handlers from the [numpyro.handlers](https://numpyro.readthedocs.io/en/latest/handlers.html) module, and these can be easily extended to implement custom inference algorithms and inference utilities. ## A Simple Example - 8 Schools @@ -174,6 +174,7 @@ For some more examples on specifying models and doing inference in NumPyro: - [Hidden Markov Model](https://github.com/pyro-ppl/numpyro/blob/master/examples/hmm.py) in NumPyro as compared to [Stan](https://mc-stan.org/docs/2_19/stan-users-guide/hmms-section.html). - [Variational Autoencoder](https://github.com/pyro-ppl/numpyro/blob/master/examples/vae.py) - As a simple example that uses Variational Inference with neural networks. [Pyro implementation](https://github.com/pyro-ppl/pyro/blob/dev/examples/vae/vae.py) for comparison. - [Gaussian Process](https://github.com/pyro-ppl/numpyro/blob/master/examples/gp.py) - Provides a simple example to use NUTS to sample from the posterior over the hyper-parameters of a Gaussian Process. + - [Horseshoe Regression](https://github.com/pyro-ppl/numpyro/blob/master/examples/horseshoe_regression.py) - Shows how to implemement generalized linear models equipped with a Horseshoe prior for both binary-valued and real-valued outputs. - [Statistical Rethinking with NumPyro](https://github.com/fehiepsi/rethinking-numpyro) - [Notebooks](https://nbviewer.jupyter.org/github/fehiepsi/rethinking-numpyro/tree/master/notebooks/) containing translation of the code in Richard McElreath's [Statistical Rethinking](https://xcelab.net/rm/statistical-rethinking/) book second version, to NumPyro. - Other model examples can be found in the [examples](https://github.com/pyro-ppl/numpyro/tree/master/examples) folder. From d155669c36247bf0055105d036869eff09a9651f Mon Sep 17 00:00:00 2001 From: martinjankowiak Date: Mon, 22 Nov 2021 14:53:47 -0500 Subject: [PATCH 210/222] clarify tensorflow_probability.substrates.jax.distributions usage in docs (#1234) * reduce variance in autodais * remove extra test code * tweak docstring * make format * clarify tensorflow_probability.substrates.jax.distributions usage * remove unintentional commit --- docs/source/mcmc.rst | 2 +- numpyro/contrib/tfp/distributions.py | 7 +++++++ 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/docs/source/mcmc.rst b/docs/source/mcmc.rst index 10b477931..58f61a74c 100644 --- a/docs/source/mcmc.rst +++ b/docs/source/mcmc.rst @@ -102,7 +102,7 @@ SA TensorFlow Kernels ------------------ -Thin wrappers around TensorFlow Probability (TFP) distributions. For details on the TFP distribution interface, +Thin wrappers around TensorFlow Probability (TFP) MCMC kernels. For details on the TFP MCMC kernel interface, see `its TransitionKernel docs `_. .. automodule:: numpyro.contrib.tfp.mcmc diff --git a/numpyro/contrib/tfp/distributions.py b/numpyro/contrib/tfp/distributions.py index d7834da45..2c8d3c40f 100644 --- a/numpyro/contrib/tfp/distributions.py +++ b/numpyro/contrib/tfp/distributions.py @@ -182,6 +182,13 @@ class TFPDistribution(NumPyroDistribution, metaclass=_TFPDistributionMeta): d = TFPDistribution[tfd.Normal](0, 1) + Note that typical use cases do not require explicitly invoking this wrapper, since + NumPyro wraps TFP distributions automatically under the hood in model code, e.g.:: + + from tensorflow_probability.substrates.jax import distributions as tfd + + def model(): + numpyro.sample("x", tfd.Normal(0, 1)) """ def __getattr__(self, name): From 9d06ea58d5f24b2ce0abce18da31a532071bbd3f Mon Sep 17 00:00:00 2001 From: Du Phan Date: Tue, 23 Nov 2021 11:07:11 -0500 Subject: [PATCH 211/222] Make init to sample work with scalar value (#1226) --- numpyro/infer/autoguide.py | 2 +- test/infer/test_autoguide.py | 10 ++++++++++ 2 files changed, 11 insertions(+), 1 deletion(-) diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 798021fe5..40cbda8a7 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -485,7 +485,7 @@ def _ravel_dict(x): x_flat = [] for name, value in x.items(): shape_dict[name] = jnp.shape(value) - x_flat.append(value.reshape(-1)) + x_flat.append(jnp.reshape(value, -1)) x_flat = jnp.concatenate(x_flat) if x_flat else jnp.zeros((0,)) return x_flat, shape_dict diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 0833764d0..facd8591d 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -43,6 +43,7 @@ init_to_median, init_to_sample, init_to_uniform, + init_to_value, ) from numpyro.infer.reparam import TransformReparam from numpyro.infer.util import Predictive @@ -644,3 +645,12 @@ def model(): svi = SVI(model, guide, optim.Adam(1.0), Trace_ELBO()) with pytest.raises(ValueError, match="local latent variables"): svi.init(random.PRNGKey(0)) + + +def test_init_to_scalar_value(): + def model(): + numpyro.sample("x", dist.Normal(0, 1)) + + guide = AutoDiagonalNormal(model, init_loc_fn=init_to_value(values={"x": 1.0})) + svi = SVI(model, guide, optim.Adam(1.0), Trace_ELBO()) + svi.init(random.PRNGKey(0)) From e7216323988ae8bc68025b5628e42f8ebbc7c539 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Mon, 29 Nov 2021 23:57:33 +0000 Subject: [PATCH 212/222] Bug: Dirichlet distribution got invalid concentration parameter for BetaDistribution (#1237) * check that mean param of betaproportion is in 0-1 open interval * inherit from _Interval, only overwrite __call__ * register transform_to_open_interval * fix domain of transform_to_open_interval * noop * deduplicate _transform_to_interval * register list of constraints * return factory from biject_to.register --- numpyro/distributions/constraints.py | 6 ++++++ numpyro/distributions/continuous.py | 4 ++-- numpyro/distributions/transforms.py | 2 ++ test/test_distributions.py | 13 +++++++++++++ 4 files changed, 23 insertions(+), 2 deletions(-) diff --git a/numpyro/distributions/constraints.py b/numpyro/distributions/constraints.py index acf099918..98ba8c7de 100644 --- a/numpyro/distributions/constraints.py +++ b/numpyro/distributions/constraints.py @@ -319,6 +319,11 @@ def feasible_like(self, prototype): ) +class _OpenInterval(_Interval): + def __call__(self, x): + return (x > self.lower_bound) & (x < self.upper_bound) + + class _LowerCholesky(Constraint): event_dim = 2 @@ -507,3 +512,4 @@ def feasible_like(self, prototype): softplus_positive = _SoftplusPositive() sphere = _Sphere() unit_interval = _Interval(0.0, 1.0) +open_interval = _OpenInterval diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index af2a9b452..337b7efe4 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -72,10 +72,10 @@ def __init__(self, concentration1, concentration0, validate_args=None): ) concentration1 = jnp.broadcast_to(concentration1, batch_shape) concentration0 = jnp.broadcast_to(concentration0, batch_shape) + super(Beta, self).__init__(batch_shape=batch_shape, validate_args=validate_args) self._dirichlet = Dirichlet( jnp.stack([concentration1, concentration0], axis=-1) ) - super(Beta, self).__init__(batch_shape=batch_shape, validate_args=validate_args) def sample(self, key, sample_shape=()): assert is_prng_key(key) @@ -1659,7 +1659,7 @@ class BetaProportion(Beta): """ arg_constraints = { - "mean": constraints.unit_interval, + "mean": constraints.open_interval(0.0, 1.0), "concentration": constraints.positive, } reparametrized_params = ["mean", "concentration"] diff --git a/numpyro/distributions/transforms.py b/numpyro/distributions/transforms.py index 9cc4b5fd4..e468b9b8c 100644 --- a/numpyro/distributions/transforms.py +++ b/numpyro/distributions/transforms.py @@ -1052,6 +1052,7 @@ def register(self, constraint, factory=None): constraint = type(constraint) self._registry[constraint] = factory + return factory def __call__(self, constraint): try: @@ -1106,6 +1107,7 @@ def _biject_to_independent(constraint): ) +@biject_to.register(constraints.open_interval) @biject_to.register(constraints.interval) def _transform_to_interval(constraint): if constraint is constraints.unit_interval: diff --git a/test/test_distributions.py b/test/test_distributions.py index 1e36aaf88..88605b6f5 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1593,6 +1593,13 @@ def g(x): assert_allclose(grad_fx, grad_gx, atol=1e-4) +def test_beta_proportion_invalid_mean(): + with dist.distribution.validation_enabled(), pytest.raises( + ValueError, match=r"^BetaProportion distribution got invalid mean parameter\.$" + ): + dist.BetaProportion(1.0, 1.0) + + ######################################## # Tests for constraints and transforms # ######################################## @@ -1713,6 +1720,11 @@ def g(x): jnp.array([[1, 0, 0], [0.5, 0.5, 0]]), jnp.array([True, False]), ), + ( + constraints.open_interval(0.0, 1.0), + jnp.array([-5, 0, 0.5, 1, 7]), + jnp.array([False, False, True, False, False]), + ), ], ) def test_constraints(constraint, x, expected): @@ -1754,6 +1766,7 @@ def test_constraints(constraint, x, expected): constraints.softplus_positive, constraints.softplus_lower_cholesky, constraints.unit_interval, + constraints.open_interval(0.0, 1.0), ], ids=lambda x: x.__class__, ) From b1497690ceefd8aae988774f421ce8eb40ddb0d1 Mon Sep 17 00:00:00 2001 From: Marco Edward Gorelli Date: Sun, 5 Dec 2021 21:21:28 +0000 Subject: [PATCH 213/222] DiscreteUniform distribution (#1243) * add discreteuniform distributions * fixup mean and variance * fixup variance * revert accidental change * add sphinx entry, used closed definition * update annotation.py example * fixup enumerate support --- docs/source/distributions.rst | 8 +++++ examples/annotation.py | 4 +-- numpyro/distributions/__init__.py | 2 ++ numpyro/distributions/discrete.py | 59 +++++++++++++++++++++++++++++++ test/test_distributions.py | 2 ++ 5 files changed, 72 insertions(+), 3 deletions(-) diff --git a/docs/source/distributions.rst b/docs/source/distributions.rst index f65e4d3c7..79d0aa632 100644 --- a/docs/source/distributions.rst +++ b/docs/source/distributions.rst @@ -369,6 +369,14 @@ DirichletMultinomial :show-inheritance: :member-order: bysource +DiscreteUniform +^^^^^^^^^^^^^^^ +.. autoclass:: numpyro.distributions.discrete.DiscreteUniform + :members: + :undoc-members: + :show-inheritance: + :member-order: bysource + GammaPoisson ^^^^^^^^^^^^ .. autoclass:: numpyro.distributions.conjugate.GammaPoisson diff --git a/examples/annotation.py b/examples/annotation.py index 49adfa764..801ead5a8 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -167,9 +167,7 @@ def mace(positions, annotations): theta = numpyro.sample("theta", dist.Beta(0.5, 0.5)) with numpyro.plate("item", num_items, dim=-2): - # NB: using constant logits for discrete uniform prior - # (NumPyro does not have DiscreteUniform distribution yet) - c = numpyro.sample("c", dist.Categorical(logits=jnp.zeros(num_classes))) + c = numpyro.sample("c", dist.DiscreteUniform(0, num_classes - 1)) with numpyro.plate("position", num_positions): s = numpyro.sample("s", dist.Bernoulli(1 - theta[positions])) diff --git a/numpyro/distributions/__init__.py b/numpyro/distributions/__init__.py index 4ab02fba6..4aa93fade 100644 --- a/numpyro/distributions/__init__.py +++ b/numpyro/distributions/__init__.py @@ -54,6 +54,7 @@ Categorical, CategoricalLogits, CategoricalProbs, + DiscreteUniform, Geometric, GeometricLogits, GeometricProbs, @@ -114,6 +115,7 @@ "Delta", "Dirichlet", "DirichletMultinomial", + "DiscreteUniform", "Distribution", "Exponential", "ExpandedDistribution", diff --git a/numpyro/distributions/discrete.py b/numpyro/distributions/discrete.py index 2c597abc5..dd70ba590 100644 --- a/numpyro/distributions/discrete.py +++ b/numpyro/distributions/discrete.py @@ -405,6 +405,65 @@ def Categorical(probs=None, logits=None, validate_args=None): raise ValueError("One of `probs` or `logits` must be specified.") +class DiscreteUniform(Distribution): + arg_constraints = {"low": constraints.dependent, "high": constraints.dependent} + has_enumerate_support = True + + def __init__(self, low=0, high=1, validate_args=None): + self.low, self.high = promote_shapes(low, high) + batch_shape = lax.broadcast_shapes(jnp.shape(low), jnp.shape(high)) + self._support = constraints.integer_interval(low, high) + super().__init__(batch_shape, validate_args=validate_args) + + @constraints.dependent_property(is_discrete=True, event_dim=0) + def support(self): + return self._support + + def sample(self, key, sample_shape=()): + shape = sample_shape + self.batch_shape + return random.randint(key, shape=shape, minval=self.low, maxval=self.high + 1) + + @validate_sample + def log_prob(self, value): + shape = lax.broadcast_shapes(jnp.shape(value), self.batch_shape) + return -jnp.broadcast_to(jnp.log(self.high + 1 - self.low), shape) + + def cdf(self, value): + cdf = (jnp.floor(value) + 1 - self.low) / (self.high - self.low + 1) + return jnp.clip(cdf, a_min=0.0, a_max=1.0) + + def icdf(self, value): + return self.low + value * (self.high - self.low + 1) - 1 + + @property + def mean(self): + return self.low + (self.high - self.low) / 2.0 + + @property + def variance(self): + return ((self.high - self.low + 1) ** 2 - 1) / 12.0 + + def enumerate_support(self, expand=True): + if not not_jax_tracer(self.high) or not not_jax_tracer(self.low): + raise NotImplementedError("Both `low` and `high` must not be a JAX Tracer.") + if np.any(np.amax(self.low) != self.low): + # NB: the error can't be raised if inhomogeneous issue happens when tracing + raise NotImplementedError( + "Inhomogeneous `low` not supported by `enumerate_support`." + ) + if np.any(np.amax(self.high) != self.high): + # NB: the error can't be raised if inhomogeneous issue happens when tracing + raise NotImplementedError( + "Inhomogeneous `high` not supported by `enumerate_support`." + ) + values = (self.low + jnp.arange(np.amax(self.high - self.low) + 1)).reshape( + (-1,) + (1,) * len(self.batch_shape) + ) + if expand: + values = jnp.broadcast_to(values, values.shape[:1] + self.batch_shape) + return values + + class OrderedLogistic(CategoricalProbs): """ A categorical distribution with ordered outcomes. diff --git a/test/test_distributions.py b/test/test_distributions.py index 88605b6f5..f39b6f127 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -614,6 +614,8 @@ def get_sp_dist(jax_dist): T(dist.NegativeBinomial2, jnp.array([10.2, 7, 31]), jnp.array([10.2, 20.7, 2.1])), T(dist.OrderedLogistic, -2, jnp.array([-10.0, 4.0, 9.0])), T(dist.OrderedLogistic, jnp.array([-4, 3, 4, 5]), jnp.array([-1.5])), + T(dist.DiscreteUniform, -2, jnp.array([-1.0, 4.0, 9.0])), + T(dist.DiscreteUniform, jnp.array([-4, 3, 4, 5]), jnp.array([6])), T(dist.Poisson, 2.0), T(dist.Poisson, jnp.array([2.0, 3.0, 5.0])), T(SparsePoisson, 2.0), From 9987eb737e4b6da5d83da961e636d51a5ae36dde Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 6 Dec 2021 09:49:06 -0500 Subject: [PATCH 214/222] Raise warning for the automatic enumerate behavior (#1244) * Raise Future Warning for sites without enumerated support * fix typo on enumerate key * add test to capture the warning * Run black * Fix all failing test due to the new future warning --- examples/annotation.py | 22 ++++-- notebooks/source/discrete_imputation.ipynb | 12 ++- notebooks/source/model_rendering.ipynb | 6 +- numpyro/infer/util.py | 21 ++++- test/contrib/test_funsor.py | 90 +++------------------- test/contrib/test_infer_discrete.py | 2 +- test/infer/test_autoguide.py | 1 + test/infer/test_hmc_gibbs.py | 2 +- test/infer/test_mcmc.py | 9 +++ 9 files changed, 70 insertions(+), 95 deletions(-) diff --git a/examples/annotation.py b/examples/annotation.py index 801ead5a8..e46cf189f 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -123,7 +123,7 @@ def multinomial(annotations): pi = numpyro.sample("pi", dist.Dirichlet(jnp.ones(num_classes))) with numpyro.plate("item", num_items, dim=-2): - c = numpyro.sample("c", dist.Categorical(pi)) + c = numpyro.sample("c", dist.Categorical(pi), infer={"enumerate": "parallel"}) with numpyro.plate("position", num_positions): numpyro.sample("y", dist.Categorical(zeta[c]), obs=annotations) @@ -144,7 +144,7 @@ def dawid_skene(positions, annotations): pi = numpyro.sample("pi", dist.Dirichlet(jnp.ones(num_classes))) with numpyro.plate("item", num_items, dim=-2): - c = numpyro.sample("c", dist.Categorical(pi)) + c = numpyro.sample("c", dist.Categorical(pi), infer={"enumerate": "parallel"}) # here we use Vindex to allow broadcasting for the second index `c` # ref: http://num.pyro.ai/en/latest/utilities.html#numpyro.contrib.indexing.vindex @@ -167,10 +167,18 @@ def mace(positions, annotations): theta = numpyro.sample("theta", dist.Beta(0.5, 0.5)) with numpyro.plate("item", num_items, dim=-2): - c = numpyro.sample("c", dist.DiscreteUniform(0, num_classes - 1)) + c = numpyro.sample( + "c", + dist.DiscreteUniform(0, num_classes - 1), + infer={"enumerate": "parallel"}, + ) with numpyro.plate("position", num_positions): - s = numpyro.sample("s", dist.Bernoulli(1 - theta[positions])) + s = numpyro.sample( + "s", + dist.Bernoulli(1 - theta[positions]), + infer={"enumerate": "parallel"}, + ) probs = jnp.where( s[..., None] == 0, nn.one_hot(c, num_classes), epsilon[positions] ) @@ -207,7 +215,7 @@ def hierarchical_dawid_skene(positions, annotations): pi = numpyro.sample("pi", dist.Dirichlet(jnp.ones(num_classes))) with numpyro.plate("item", num_items, dim=-2): - c = numpyro.sample("c", dist.Categorical(pi)) + c = numpyro.sample("c", dist.Categorical(pi), infer={"enumerate": "parallel"}) with numpyro.plate("position", num_positions): logits = Vindex(beta)[positions, c, :] @@ -232,7 +240,7 @@ def item_difficulty(annotations): pi = numpyro.sample("pi", dist.Dirichlet(jnp.ones(num_classes))) with numpyro.plate("item", num_items, dim=-2): - c = numpyro.sample("c", dist.Categorical(pi)) + c = numpyro.sample("c", dist.Categorical(pi), infer={"enumerate": "parallel"}) with handlers.reparam(config={"theta": LocScaleReparam(0)}): theta = numpyro.sample("theta", dist.Normal(eta[c], chi[c]).to_event(1)) @@ -270,7 +278,7 @@ def logistic_random_effects(positions, annotations): pi = numpyro.sample("pi", dist.Dirichlet(jnp.ones(num_classes))) with numpyro.plate("item", num_items, dim=-2): - c = numpyro.sample("c", dist.Categorical(pi)) + c = numpyro.sample("c", dist.Categorical(pi), infer={"enumerate": "parallel"}) with handlers.reparam(config={"theta": LocScaleReparam(0)}): theta = numpyro.sample("theta", dist.Normal(0, chi[c]).to_event(1)) diff --git a/notebooks/source/discrete_imputation.ipynb b/notebooks/source/discrete_imputation.ipynb index dc67bd8d8..3ca471b1f 100644 --- a/notebooks/source/discrete_imputation.ipynb +++ b/notebooks/source/discrete_imputation.ipynb @@ -401,7 +401,11 @@ "\n", " # sample imputation values for A\n", " # mask out to not add log_prob to total likelihood right now\n", - " Aimp = sample(\"A\", dist.Bernoulli(logits=eta_A).mask(False))\n", + " Aimp = sample(\n", + " \"A\",\n", + " dist.Bernoulli(logits=eta_A).mask(False),\n", + " infer={\"enumerate\": \"parallel\"},\n", + " )\n", "\n", " # 'manually' calculate the log_prob\n", " log_prob = dist.Bernoulli(logits=eta_A).log_prob(Aimp)\n", @@ -712,7 +716,11 @@ "\n", " # sample imputation values for A\n", " # mask out to not add log_prob to total likelihood right now\n", - " Aimp = sample(\"A\", dist.Bernoulli(logits=eta_A).mask(False))\n", + " Aimp = sample(\n", + " \"A\",\n", + " dist.Bernoulli(logits=eta_A).mask(False),\n", + " infer={\"enumerate\": \"parallel\"},\n", + " )\n", "\n", " # 'manually' calculate the log_prob\n", " log_prob = dist.Bernoulli(logits=eta_A).log_prob(Aimp)\n", diff --git a/notebooks/source/model_rendering.ipynb b/notebooks/source/model_rendering.ipynb index cdd8266c2..5bf4abeb5 100644 --- a/notebooks/source/model_rendering.ipynb +++ b/notebooks/source/model_rendering.ipynb @@ -187,9 +187,7 @@ " theta = numpyro.sample(\"theta\", dist.Beta(0.5, 0.5))\n", "\n", " with numpyro.plate(\"item\", num_items, dim=-2):\n", - " # NB: using constant logits for discrete uniform prior\n", - " # (NumPyro does not have DiscreteUniform distribution yet)\n", - " c = numpyro.sample(\"c\", dist.Categorical(logits=jnp.zeros(num_classes)))\n", + " c = numpyro.sample(\"c\", dist.DiscreteUniform(0, num_classes - 1))\n", "\n", " with numpyro.plate(\"position\", num_positions):\n", " s = numpyro.sample(\"s\", dist.Bernoulli(1 - theta[positions]))\n", @@ -568,7 +566,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.8.8" } }, "nbformat": 4, diff --git a/numpyro/infer/util.py b/numpyro/infer/util.py index 427d765d8..3b320d337 100644 --- a/numpyro/infer/util.py +++ b/numpyro/infer/util.py @@ -402,11 +402,28 @@ def _get_model_transforms(model, model_args=(), model_kwargs=None): for k, v in model_trace.items(): if v["type"] == "sample" and not v["is_observed"]: if v["fn"].support.is_discrete: + enum_type = v["infer"].get("enumerate") + if enum_type is not None and (enum_type != "parallel"): + raise RuntimeError( + "This algorithm might only work for discrete sites with" + f" enumerate marked 'parallel'. But the site {k} is marked" + f" as '{enum_type}'." + ) has_enumerate_support = True if not v["fn"].has_enumerate_support: + dist_name = type(v["fn"]).__name__ raise RuntimeError( - "MCMC only supports continuous sites or discrete sites " - f"with enumerate support, but got {type(v['fn']).__name__}." + "This algorithm might only work for discrete sites with" + f" enumerate support. But the {dist_name} distribution at" + f" site {k} does not have enumerate support." + ) + if enum_type is None: + warnings.warn( + "Some algorithms will automatically enumerate the discrete" + f" latent site {k} of your model. In the future," + " enumerated sites need to be marked with" + " `infer={'enumerate': 'parallel'}`.", + FutureWarning, ) else: support = v["fn"].support diff --git a/test/contrib/test_funsor.py b/test/contrib/test_funsor.py index 85520bafb..9e8095592 100644 --- a/test/contrib/test_funsor.py +++ b/test/contrib/test_funsor.py @@ -26,6 +26,7 @@ def test_gaussian_mixture_model(): K, N = 3, 1000 + @config_enumerate def gmm(data): mix_proportions = numpyro.sample("phi", dist.Dirichlet(jnp.ones(K))) with numpyro.plate("num_clusters", K, dim=-1): @@ -60,6 +61,7 @@ def gmm(data): def test_bernoulli_latent_model(): + @config_enumerate def model(data): y_prob = numpyro.sample("y_prob", dist.Beta(1.0, 1.0)) with numpyro.plate("data", data.shape[0]): @@ -81,6 +83,7 @@ def model(data): def test_change_point(): + @config_enumerate def model(count_data): n_count_data = count_data.shape[0] alpha = 1 / jnp.mean(count_data.astype(np.float32)) @@ -93,84 +96,13 @@ def model(count_data): with numpyro.plate("data", n_count_data): numpyro.sample("obs", dist.Poisson(lambda_), obs=count_data) - count_data = jnp.array( - [ - 13, - 24, - 8, - 24, - 7, - 35, - 14, - 11, - 15, - 11, - 22, - 22, - 11, - 57, - 11, - 19, - 29, - 6, - 19, - 12, - 22, - 12, - 18, - 72, - 32, - 9, - 7, - 13, - 19, - 23, - 27, - 20, - 6, - 17, - 13, - 10, - 14, - 6, - 16, - 15, - 7, - 2, - 15, - 15, - 19, - 70, - 49, - 7, - 53, - 22, - 21, - 31, - 19, - 11, - 1, - 20, - 12, - 35, - 17, - 23, - 17, - 4, - 2, - 31, - 30, - 13, - 27, - 0, - 39, - 37, - 5, - 14, - 13, - 22, - ] - ) + # fmt: off + count_data = jnp.array([ + 13, 24, 8, 24, 7, 35, 14, 11, 15, 11, 22, 22, 11, 57, 11, 19, 29, 6, 19, 12, 22, + 12, 18, 72, 32, 9, 7, 13, 19, 23, 27, 20, 6, 17, 13, 10, 14, 6, 16, 15, 7, 2, + 15, 15, 19, 70, 49, 7, 53, 22, 21, 31, 19, 11, 1, 20, 12, 35, 17, 23, 17, 4, 2, + 31, 30, 13, 27, 0, 39, 37, 5, 14, 13, 22]) + # fmt: on kernel = NUTS(model) mcmc = MCMC(kernel, num_warmup=500, num_samples=500) @@ -184,6 +116,7 @@ def test_gaussian_hmm(): dim = 4 num_steps = 10 + @config_enumerate def model(data): with numpyro.plate("states", dim): transition = numpyro.sample("transition", dist.Dirichlet(jnp.ones(dim))) @@ -586,6 +519,7 @@ def transition_fn(carry, y): def test_missing_plate(monkeypatch): K, N = 3, 1000 + @config_enumerate def gmm(data): mix_proportions = numpyro.sample("phi", dist.Dirichlet(jnp.ones(K))) # plate/to_event is missing here diff --git a/test/contrib/test_infer_discrete.py b/test/contrib/test_infer_discrete.py index dd364531e..157f042ba 100644 --- a/test/contrib/test_infer_discrete.py +++ b/test/contrib/test_infer_discrete.py @@ -405,7 +405,7 @@ def model2(): @pytest.mark.parametrize("model", [model_zzxx, model2]) @pytest.mark.parametrize("temperature", [0, 1]) def test_mcmc_model_side_enumeration(model, temperature): - mcmc = infer.MCMC(infer.NUTS(model), num_warmup=0, num_samples=1) + mcmc = infer.MCMC(infer.NUTS(config_enumerate(model)), num_warmup=0, num_samples=1) mcmc.run(random.PRNGKey(0)) mcmc_data = { k: v[0] for k, v in mcmc.get_samples().items() if k in ["loc", "scale"] diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index facd8591d..8116f0844 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -562,6 +562,7 @@ def model(): init_to_uniform, ], ) +@pytest.mark.filterwarnings("ignore:.*enumerate.*:FutureWarning") def test_discrete_helpful_error(auto_class, init_loc_fn): def model(): p = numpyro.sample("p", dist.Beta(2.0, 2.0)) diff --git a/test/infer/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py index 3ab0e8663..330eef939 100644 --- a/test/infer/test_hmc_gibbs.py +++ b/test/infer/test_hmc_gibbs.py @@ -281,7 +281,7 @@ def test_block_update_partitioning(num_blocks): def test_enum_subsample_smoke(): def model(data): - x = numpyro.sample("x", dist.Bernoulli(0.5)) + x = numpyro.sample("x", dist.Bernoulli(0.5), infer={"enumerate": "parallel"}) with numpyro.plate("N", data.shape[0], subsample_size=100, dim=-1): batch = numpyro.subsample(data, event_dim=0) numpyro.sample("obs", dist.Normal(x, 1), obs=batch) diff --git a/test/infer/test_mcmc.py b/test/infer/test_mcmc.py index d41efe72d..129d76fae 100644 --- a/test/infer/test_mcmc.py +++ b/test/infer/test_mcmc.py @@ -1060,3 +1060,12 @@ def model(): mcmc = MCMC(NUTS(subs_model), num_warmup=10, num_samples=10) with pytest.warns(UserWarning, match="skipping initialization"): mcmc.run(random.PRNGKey(1)) + + +def test_discrete_site_without_infer_enumerate(): + def model(): + numpyro.sample("x", dist.Bernoulli(0.5)) + + mcmc = MCMC(NUTS(model), num_warmup=10, num_samples=10) + with pytest.warns(FutureWarning, match="enumerated sites"): + mcmc.run(random.PRNGKey(0)) From c74033ed0f771ec8bc78bce45824fe36a5269056 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 11 Dec 2021 11:52:17 -0500 Subject: [PATCH 215/222] Fix failing tests in jax 0.2.26 (#1251) * Fix failing tests in jax 0.2.26 * Also pump tfp version to a stable version --- docs/requirements.txt | 3 +-- numpyro/infer/hmc_util.py | 2 +- setup.py | 3 +-- test/contrib/test_control_flow.py | 2 +- test/infer/test_hmc_gibbs.py | 3 +-- test/test_distributions.py | 2 +- test/test_handlers.py | 2 +- test/test_model_rendering.py | 12 +++++++----- 8 files changed, 14 insertions(+), 15 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 9369a0260..999bb0c42 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -11,6 +11,5 @@ readthedocs-sphinx-search==0.1.0 sphinx==4.0.3 sphinx-gallery sphinx_rtd_theme==0.5.2 -# TODO: change to tensorflow_probability when it is stable -tfp-nightly +tensorflow_probability>=0.15.0 tqdm diff --git a/numpyro/infer/hmc_util.py b/numpyro/infer/hmc_util.py index d860a557a..6e5836e03 100644 --- a/numpyro/infer/hmc_util.py +++ b/numpyro/infer/hmc_util.py @@ -166,7 +166,7 @@ def init_fn(size): mean = jnp.zeros(shape[-1]) m2 = jnp.zeros(shape) - n = 0 + n = jnp.array(0, dtype=jnp.result_type(int)) return mean, m2, n def update_fn(sample, state): diff --git a/setup.py b/setup.py index 4b944278b..eba486cb6 100644 --- a/setup.py +++ b/setup.py @@ -61,8 +61,7 @@ "graphviz", "jaxns==0.0.7", "optax>=0.0.6", - # TODO: change to tensorflow_probability when it is stable - "tfp-nightly", + "tensorflow_probability>=0.15.0", ], "examples": [ "arviz", diff --git a/test/contrib/test_control_flow.py b/test/contrib/test_control_flow.py index 520ebfa7e..61eca0025 100644 --- a/test/contrib/test_control_flow.py +++ b/test/contrib/test_control_flow.py @@ -111,7 +111,7 @@ def transition(state, i): fun_params = {"x": jnp.arange(1, T + 1) / 10, "y": -jnp.arange(T) / 5} actual_log_joint = potential_energy(fun_model, (T,), {}, fun_params) expected_log_joint = potential_energy(model, (T,), {}, params) - assert_allclose(actual_log_joint, expected_log_joint) + assert_allclose(actual_log_joint, expected_log_joint, rtol=1e-6) def test_scan_without_stack(): diff --git a/test/infer/test_hmc_gibbs.py b/test/infer/test_hmc_gibbs.py index 330eef939..96b6859e7 100644 --- a/test/infer/test_hmc_gibbs.py +++ b/test/infer/test_hmc_gibbs.py @@ -399,11 +399,10 @@ def taylor_expand_2nd_order_sum(pos): @pytest.mark.filterwarnings("ignore::UserWarning") @pytest.mark.parametrize("kernel_cls", [HMC, NUTS]) def test_estimate_likelihood(kernel_cls): - data_key, tr_key, sub_key, rng_key = random.split(random.PRNGKey(0), 4) ref_params = jnp.array([0.1, 0.5, -0.2]) sigma = 0.1 data = ref_params + dist.Normal(jnp.zeros(3), jnp.ones(3)).sample( - data_key, (10_000,) + random.PRNGKey(0), (2000,) ) n, _ = data.shape num_warmup = 200 diff --git a/test/test_distributions.py b/test/test_distributions.py index f39b6f127..c73e6b9b1 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -1591,7 +1591,7 @@ def g(x): x = 0.5 fx, grad_fx = jax.value_and_grad(f)(x) gx, grad_gx = jax.value_and_grad(g)(x) - assert_allclose(fx, gx) + assert_allclose(fx, gx, rtol=1e-6) assert_allclose(grad_fx, grad_gx, atol=1e-4) diff --git a/test/test_handlers.py b/test/test_handlers.py index 557a09686..745781549 100644 --- a/test/test_handlers.py +++ b/test/test_handlers.py @@ -777,4 +777,4 @@ def subsample_fn(rng_key): ) # test that values are not duplicated - assert len(set(subsamples[k])) == subsample_size + assert len(set(subsamples[k].copy())) == subsample_size diff --git a/test/test_model_rendering.py b/test/test_model_rendering.py index 9db9f2ef2..095d0e657 100644 --- a/test/test_model_rendering.py +++ b/test/test_model_rendering.py @@ -1,6 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 +import numpy as np import pytest import jax.numpy as jnp @@ -36,7 +37,10 @@ def nested_plates(): def discrete_to_continuous(probs, locs): c = numpyro.sample("c", dist.Categorical(probs)) - numpyro.sample("x", dist.Normal(locs[c], 0.5)) + # We need to make sure that locs is a jax ndarray + # because indexing a numpy ndarray with an abstract + # index does not work in JAX. + numpyro.sample("x", dist.Normal(jnp.asarray(locs)[c], 0.5)) def discrete(prob): @@ -48,7 +52,7 @@ def discrete(prob): [ ( simple, - dict(data=jnp.ones(10)), + dict(data=np.ones(10)), { "plate_groups": {"N": ["obs"], None: ["x", "sd"]}, "plate_data": {"N": {"parent": None}}, @@ -95,9 +99,7 @@ def discrete(prob): ), ( discrete_to_continuous, - dict( - probs=jnp.array([0.15, 0.3, 0.3, 0.25]), locs=jnp.array([-2, 0, 2, 4]) - ), + dict(probs=np.array([0.15, 0.3, 0.3, 0.25]), locs=np.array([-2, 0, 2, 4])), { "plate_groups": {None: ["c", "x"]}, "plate_data": {}, From de94469f19388ff09b705754f407461163030fbe Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sat, 11 Dec 2021 17:27:41 -0500 Subject: [PATCH 216/222] Move contrib.indexing to numpyro.ops (#1254) * Move contrib.indexing to ops.indexing * make format --- docs/source/utilities.rst | 2 +- examples/annotation.py | 2 +- examples/hmm_enum.py | 2 +- numpyro/contrib/indexing.py | 149 ++----------------------- numpyro/ops/__init__.py | 0 numpyro/ops/indexing.py | 147 ++++++++++++++++++++++++ test/contrib/test_funsor.py | 2 +- test/{contrib => ops}/test_indexing.py | 2 +- 8 files changed, 159 insertions(+), 147 deletions(-) create mode 100644 numpyro/ops/__init__.py create mode 100644 numpyro/ops/indexing.py rename test/{contrib => ops}/test_indexing.py (99%) diff --git a/docs/source/utilities.rst b/docs/source/utilities.rst index 9a531c8b3..865d2853f 100644 --- a/docs/source/utilities.rst +++ b/docs/source/utilities.rst @@ -88,7 +88,7 @@ init_to_value Tensor Indexing --------------- -.. automodule:: numpyro.contrib.indexing +.. automodule:: numpyro.ops.indexing :members: :undoc-members: :show-inheritance: diff --git a/examples/annotation.py b/examples/annotation.py index e46cf189f..5ddf6a8ef 100644 --- a/examples/annotation.py +++ b/examples/annotation.py @@ -42,10 +42,10 @@ import numpyro from numpyro import handlers -from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist from numpyro.infer import MCMC, NUTS, Predictive from numpyro.infer.reparam import LocScaleReparam +from numpyro.ops.indexing import Vindex def get_data(): diff --git a/examples/hmm_enum.py b/examples/hmm_enum.py index ae577492d..62c6f39bb 100644 --- a/examples/hmm_enum.py +++ b/examples/hmm_enum.py @@ -58,11 +58,11 @@ import numpyro from numpyro.contrib.control_flow import scan -from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist from numpyro.examples.datasets import JSB_CHORALES, load_dataset from numpyro.handlers import mask from numpyro.infer import HMC, MCMC, NUTS +from numpyro.ops.indexing import Vindex logger = logging.getLogger(__name__) logger.setLevel(logging.INFO) diff --git a/numpyro/contrib/indexing.py b/numpyro/contrib/indexing.py index 3dfc4efd8..91a4505f0 100644 --- a/numpyro/contrib/indexing.py +++ b/numpyro/contrib/indexing.py @@ -1,147 +1,12 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 -import jax.numpy as jnp +import warnings +from numpyro.ops import Vindex, vindex # noqa: F401 -def _is_batched(arg): - return jnp.ndim(arg) > 0 - - -def vindex(tensor, args): - """ - Vectorized advanced indexing with broadcasting semantics. - - See also the convenience wrapper :class:`Vindex`. - - This is useful for writing indexing code that is compatible with batching - and enumeration, especially for selecting mixture components with discrete - random variables. - - For example suppose ``x`` is a parameter with ``len(x.shape) == 3`` and we wish - to generalize the expression ``x[i, :, j]`` from integer ``i,j`` to tensors - ``i,j`` with batch dims and enum dims (but no event dims). Then we can - write the generalize version using :class:`Vindex` :: - - xij = Vindex(x)[i, :, j] - - batch_shape = broadcast_shape(i.shape, j.shape) - event_shape = (x.size(1),) - assert xij.shape == batch_shape + event_shape - - To handle the case when ``x`` may also contain batch dimensions (e.g. if - ``x`` was sampled in a plated context as when using vectorized particles), - :func:`vindex` uses the special convention that ``Ellipsis`` denotes batch - dimensions (hence ``...`` can appear only on the left, never in the middle - or in the right). Suppose ``x`` has event dim 3. Then we can write:: - - old_batch_shape = x.shape[:-3] - old_event_shape = x.shape[-3:] - - xij = Vindex(x)[..., i, :, j] # The ... denotes unknown batch shape. - - new_batch_shape = broadcast_shape(old_batch_shape, i.shape, j.shape) - new_event_shape = (x.size(1),) - assert xij.shape = new_batch_shape + new_event_shape - - Note that this special handling of ``Ellipsis`` differs from the NEP [1]. - - Formally, this function assumes: - - 1. Each arg is either ``Ellipsis``, ``slice(None)``, an integer, or a - batched integer tensor (i.e. with empty event shape). This - function does not support Nontrivial slices or boolean tensor - masks. ``Ellipsis`` can only appear on the left as ``args[0]``. - 2. If ``args[0] is not Ellipsis`` then ``tensor`` is not - batched, and its event dim is equal to ``len(args)``. - 3. If ``args[0] is Ellipsis`` then ``tensor`` is batched and - its event dim is equal to ``len(args[1:])``. Dims of ``tensor`` - to the left of the event dims are considered batch dims and will be - broadcasted with dims of tensor args. - - Note that if none of the args is a tensor with ``len(shape) > 0``, then this - function behaves like standard indexing:: - - if not any(isinstance(a, jnp.ndarray) and len(a.shape) > 0 for a in args): - assert Vindex(x)[args] == x[args] - - **References** - - [1] https://www.numpy.org/neps/nep-0021-advanced-indexing.html - introduces ``vindex`` as a helper for vectorized indexing. - This implementation is similar to the proposed notation - ``x.vindex[]`` except for slightly different handling of ``Ellipsis``. - - :param jnp.ndarray tensor: A tensor to be indexed. - :param tuple args: An index, as args to ``__getitem__``. - :returns: A nonstandard interpretation of ``tensor[args]``. - :rtype: jnp.ndarray - """ - if not isinstance(args, tuple): - return tensor[args] - if not args: - return tensor - - assert jnp.ndim(tensor) > 0 - # Compute event dim before and after indexing. - if args[0] is Ellipsis: - args = args[1:] - if not args: - return tensor - old_event_dim = len(args) - args = (slice(None),) * (jnp.ndim(tensor) - len(args)) + args - else: - args = args + (slice(None),) * (jnp.ndim(tensor) - len(args)) - old_event_dim = len(args) - assert len(args) == jnp.ndim(tensor) - if any(a is Ellipsis for a in args): - raise NotImplementedError("Non-leading Ellipsis is not supported") - - # In simple cases, standard advanced indexing broadcasts correctly. - is_standard = True - if jnp.ndim(tensor) > old_event_dim and _is_batched(args[0]): - is_standard = False - elif any(_is_batched(a) for a in args[1:]): - is_standard = False - if is_standard: - return tensor[args] - - # Convert args to use broadcasting semantics. - new_event_dim = sum(isinstance(a, slice) for a in args[-old_event_dim:]) - new_dim = 0 - args = list(args) - for i, arg in reversed(list(enumerate(args))): - if isinstance(arg, slice): - # Convert slices to arange()s. - if arg != slice(None): - raise NotImplementedError("Nontrivial slices are not supported") - arg = jnp.arange(tensor.shape[i], dtype=jnp.int32) - arg = arg.reshape((-1,) + (1,) * new_dim) - new_dim += 1 - elif _is_batched(arg): - # Reshape nontrivial tensors. - arg = arg.reshape(arg.shape + (1,) * new_event_dim) - args[i] = arg - args = tuple(args) - - return tensor[args] - - -class Vindex: - """ - Convenience wrapper around :func:`vindex`. - - The following are equivalent:: - - Vindex(x)[..., i, j, :] - vindex(x, (Ellipsis, i, j, slice(None))) - - :param jnp.ndarray tensor: A tensor to be indexed. - :return: An object with a special :meth:`__getitem__` method. - """ - - def __init__(self, tensor): - self._tensor = tensor - - def __getitem__(self, args): - return vindex(self._tensor, args) +warnings.warn( + "`indexing` module has been moved from `numpyro.contrib` to `numpyro.ops`." + " Please import Vindex or vindex functions from `numpyro.ops.indexing`.", + FutureWarning, +) diff --git a/numpyro/ops/__init__.py b/numpyro/ops/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/numpyro/ops/indexing.py b/numpyro/ops/indexing.py new file mode 100644 index 000000000..3dfc4efd8 --- /dev/null +++ b/numpyro/ops/indexing.py @@ -0,0 +1,147 @@ +# Copyright Contributors to the Pyro project. +# SPDX-License-Identifier: Apache-2.0 + +import jax.numpy as jnp + + +def _is_batched(arg): + return jnp.ndim(arg) > 0 + + +def vindex(tensor, args): + """ + Vectorized advanced indexing with broadcasting semantics. + + See also the convenience wrapper :class:`Vindex`. + + This is useful for writing indexing code that is compatible with batching + and enumeration, especially for selecting mixture components with discrete + random variables. + + For example suppose ``x`` is a parameter with ``len(x.shape) == 3`` and we wish + to generalize the expression ``x[i, :, j]`` from integer ``i,j`` to tensors + ``i,j`` with batch dims and enum dims (but no event dims). Then we can + write the generalize version using :class:`Vindex` :: + + xij = Vindex(x)[i, :, j] + + batch_shape = broadcast_shape(i.shape, j.shape) + event_shape = (x.size(1),) + assert xij.shape == batch_shape + event_shape + + To handle the case when ``x`` may also contain batch dimensions (e.g. if + ``x`` was sampled in a plated context as when using vectorized particles), + :func:`vindex` uses the special convention that ``Ellipsis`` denotes batch + dimensions (hence ``...`` can appear only on the left, never in the middle + or in the right). Suppose ``x`` has event dim 3. Then we can write:: + + old_batch_shape = x.shape[:-3] + old_event_shape = x.shape[-3:] + + xij = Vindex(x)[..., i, :, j] # The ... denotes unknown batch shape. + + new_batch_shape = broadcast_shape(old_batch_shape, i.shape, j.shape) + new_event_shape = (x.size(1),) + assert xij.shape = new_batch_shape + new_event_shape + + Note that this special handling of ``Ellipsis`` differs from the NEP [1]. + + Formally, this function assumes: + + 1. Each arg is either ``Ellipsis``, ``slice(None)``, an integer, or a + batched integer tensor (i.e. with empty event shape). This + function does not support Nontrivial slices or boolean tensor + masks. ``Ellipsis`` can only appear on the left as ``args[0]``. + 2. If ``args[0] is not Ellipsis`` then ``tensor`` is not + batched, and its event dim is equal to ``len(args)``. + 3. If ``args[0] is Ellipsis`` then ``tensor`` is batched and + its event dim is equal to ``len(args[1:])``. Dims of ``tensor`` + to the left of the event dims are considered batch dims and will be + broadcasted with dims of tensor args. + + Note that if none of the args is a tensor with ``len(shape) > 0``, then this + function behaves like standard indexing:: + + if not any(isinstance(a, jnp.ndarray) and len(a.shape) > 0 for a in args): + assert Vindex(x)[args] == x[args] + + **References** + + [1] https://www.numpy.org/neps/nep-0021-advanced-indexing.html + introduces ``vindex`` as a helper for vectorized indexing. + This implementation is similar to the proposed notation + ``x.vindex[]`` except for slightly different handling of ``Ellipsis``. + + :param jnp.ndarray tensor: A tensor to be indexed. + :param tuple args: An index, as args to ``__getitem__``. + :returns: A nonstandard interpretation of ``tensor[args]``. + :rtype: jnp.ndarray + """ + if not isinstance(args, tuple): + return tensor[args] + if not args: + return tensor + + assert jnp.ndim(tensor) > 0 + # Compute event dim before and after indexing. + if args[0] is Ellipsis: + args = args[1:] + if not args: + return tensor + old_event_dim = len(args) + args = (slice(None),) * (jnp.ndim(tensor) - len(args)) + args + else: + args = args + (slice(None),) * (jnp.ndim(tensor) - len(args)) + old_event_dim = len(args) + assert len(args) == jnp.ndim(tensor) + if any(a is Ellipsis for a in args): + raise NotImplementedError("Non-leading Ellipsis is not supported") + + # In simple cases, standard advanced indexing broadcasts correctly. + is_standard = True + if jnp.ndim(tensor) > old_event_dim and _is_batched(args[0]): + is_standard = False + elif any(_is_batched(a) for a in args[1:]): + is_standard = False + if is_standard: + return tensor[args] + + # Convert args to use broadcasting semantics. + new_event_dim = sum(isinstance(a, slice) for a in args[-old_event_dim:]) + new_dim = 0 + args = list(args) + for i, arg in reversed(list(enumerate(args))): + if isinstance(arg, slice): + # Convert slices to arange()s. + if arg != slice(None): + raise NotImplementedError("Nontrivial slices are not supported") + arg = jnp.arange(tensor.shape[i], dtype=jnp.int32) + arg = arg.reshape((-1,) + (1,) * new_dim) + new_dim += 1 + elif _is_batched(arg): + # Reshape nontrivial tensors. + arg = arg.reshape(arg.shape + (1,) * new_event_dim) + args[i] = arg + args = tuple(args) + + return tensor[args] + + +class Vindex: + """ + Convenience wrapper around :func:`vindex`. + + The following are equivalent:: + + Vindex(x)[..., i, j, :] + vindex(x, (Ellipsis, i, j, slice(None))) + + :param jnp.ndarray tensor: A tensor to be indexed. + :return: An object with a special :meth:`__getitem__` method. + """ + + def __init__(self, tensor): + self._tensor = tensor + + def __getitem__(self, args): + return vindex(self._tensor, args) diff --git a/test/contrib/test_funsor.py b/test/contrib/test_funsor.py index 9e8095592..467af436f 100644 --- a/test/contrib/test_funsor.py +++ b/test/contrib/test_funsor.py @@ -17,9 +17,9 @@ from numpyro.contrib.funsor import config_enumerate, enum, markov, to_data, to_funsor from numpyro.contrib.funsor.enum_messenger import NamedMessenger, plate as enum_plate from numpyro.contrib.funsor.infer_util import log_density -from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist from numpyro.infer import MCMC, NUTS, init_to_median +from numpyro.ops.indexing import Vindex from numpyro.primitives import _PYRO_STACK diff --git a/test/contrib/test_indexing.py b/test/ops/test_indexing.py similarity index 99% rename from test/contrib/test_indexing.py rename to test/ops/test_indexing.py index 568bda865..cf8b65f9a 100644 --- a/test/contrib/test_indexing.py +++ b/test/ops/test_indexing.py @@ -10,8 +10,8 @@ import jax.numpy as jnp import jax.random as random -from numpyro.contrib.indexing import Vindex import numpyro.distributions as dist +from numpyro.ops.indexing import Vindex def z(*shape): From 9592fd1873cc63a11aaa2f6fe9110ad7d44e8004 Mon Sep 17 00:00:00 2001 From: Du Phan Date: Sun, 12 Dec 2021 18:30:21 -0500 Subject: [PATCH 217/222] Fix CI freezing (#1256) * jnp.array to np.array to avoid global settings for jax * further jnp.array to np.array * Fix lint * Skip sinebariatevonmises tests on CI * Fix failing hmc_util test * try dense mass * change Travis to CI * reduce the number of sample in SineBivariateVonMises mean_var test --- .github/workflows/ci.yml | 2 +- .../contrib/einstein/test_einstein_kernels.py | 19 +- test/contrib/test_tfp.py | 5 + test/infer/test_hmc_util.py | 10 +- test/infer/test_reparam.py | 4 +- test/test_distributions.py | 531 +++++++++--------- test/test_distributions_util.py | 12 +- test/test_util.py | 38 +- 8 files changed, 303 insertions(+), 318 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e65ad17c8..4f1ace453 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -71,7 +71,7 @@ jobs: pip freeze - name: Test with pytest run: | - pytest -vs -k "not test_example" --durations=100 --ignore=test/infer/ + CI=1 pytest -vs -k "not test_example" --durations=100 --ignore=test/infer/ test-inference: diff --git a/test/contrib/einstein/test_einstein_kernels.py b/test/contrib/einstein/test_einstein_kernels.py index 556080c5a..0050162b6 100644 --- a/test/contrib/einstein/test_einstein_kernels.py +++ b/test/contrib/einstein/test_einstein_kernels.py @@ -3,6 +3,7 @@ from collections import namedtuple +import numpy as np from numpy.testing import assert_allclose import pytest @@ -22,9 +23,9 @@ jnp.set_printoptions(precision=100) T = namedtuple("TestSteinKernel", ["kernel", "particle_info", "loss_fn", "kval"]) -PARTICLES_2D = jnp.array([[1.0, 2.0], [-10.0, 10.0], [7.0, 3.0], [2.0, -1]]) +PARTICLES_2D = np.array([[1.0, 2.0], [-10.0, 10.0], [7.0, 3.0], [2.0, -1]]) -TPARTICLES_2D = (jnp.array([1.0, 2.0]), jnp.array([10.0, 5.0])) # transformed particles +TPARTICLES_2D = (np.array([1.0, 2.0]), np.array([10.0, 5.0])) # transformed particles TEST_CASES = [ T( @@ -33,8 +34,8 @@ lambda x: x, { "norm": 0.040711474, - "vector": jnp.array([0.056071877, 0.7260586]), - "matrix": jnp.array([[0.040711474, 0.0], [0.0, 0.040711474]]), + "vector": np.array([0.056071877, 0.7260586]), + "matrix": np.array([[0.040711474, 0.0], [0.0, 0.040711474]]), }, ), T(RandomFeatureKernel, lambda d: {}, lambda x: x, {"norm": 12.190277}), @@ -42,18 +43,18 @@ IMQKernel, lambda d: {}, lambda x: x, - {"norm": 0.104828484, "vector": jnp.array([0.11043153, 0.31622776])}, + {"norm": 0.104828484, "vector": np.array([0.11043153, 0.31622776])}, ), T(LinearKernel, lambda d: {}, lambda x: x, {"norm": 21.0}), T( lambda mode: MixtureKernel( mode=mode, - ws=jnp.array([0.2, 0.8]), + ws=np.array([0.2, 0.8]), kernel_fns=[RBFKernel(mode), RBFKernel(mode)], ), lambda d: {}, lambda x: x, - {"matrix": jnp.array([[0.040711474, 0.0], [0.0, 0.040711474]])}, + {"matrix": np.array([[0.040711474, 0.0], [0.0, 0.040711474]])}, ), T( lambda mode: GraphicalKernel( @@ -61,7 +62,7 @@ ), lambda d: {"p1": (0, d)}, lambda x: x, - {"matrix": jnp.array([[0.040711474, 0.0], [0.0, 0.040711474]])}, + {"matrix": np.array([[0.040711474, 0.0], [0.0, 0.040711474]])}, ), T( lambda mode: PrecondMatrixKernel( @@ -70,7 +71,7 @@ lambda d: {}, lambda x: -0.02 / 12 * x[0] ** 4 - 0.5 / 12 * x[1] ** 4 - x[0] * x[1], { - "matrix": jnp.array( + "matrix": np.array( [[2.3780507e-04, -1.6688075e-05], [-1.6688075e-05, 1.2849815e-05]] ) }, diff --git a/test/contrib/test_tfp.py b/test/contrib/test_tfp.py index 1a323dcc0..5ff2507b7 100644 --- a/test/contrib/test_tfp.py +++ b/test/contrib/test_tfp.py @@ -132,6 +132,11 @@ def make_kernel_fn(target_log_prob_fn): def test_mcmc_kernels(kernel, kwargs): from numpyro.contrib.tfp import mcmc + if ("CI" in os.environ) and kernel == "SliceSampler": + # TODO: Look into this issue if some users are using SliceSampler + # with NumPyro model. + pytest.skip("SliceSampler freezes CI for unknown reason.") + kernel_class = getattr(mcmc, kernel) true_coef = 0.9 diff --git a/test/infer/test_hmc_util.py b/test/infer/test_hmc_util.py index 8849028d4..a507287a1 100644 --- a/test/infer/test_hmc_util.py +++ b/test/infer/test_hmc_util.py @@ -125,7 +125,7 @@ def register_fn(model): p_i={"x": 1.0}, q_f={"x": jnp.sin(1.0)}, p_f={"x": jnp.cos(1.0)}, - m_inv=jnp.array([1.0]), + m_inv=np.array([1.0]), prec=1e-4, ) ] @@ -149,7 +149,7 @@ def potential_fn(q): p_i={"x": 0.0, "y": 1.0}, q_f={"x": 1.0, "y": 0.0}, p_f={"x": 0.0, "y": 1.0}, - m_inv=jnp.array([1.0, 1.0]), + m_inv=np.array([1.0, 1.0]), prec=5.0e-3, ) ] @@ -174,7 +174,7 @@ def potential_fn(q): p_i={"x": 0.0}, q_f={"x": -0.02}, p_f={"x": 0.0}, - m_inv=jnp.array([1.0]), + m_inv=np.array([1.0]), prec=1.0e-4, ) ] @@ -238,7 +238,7 @@ def potential_fn(q): p_generator = lambda prototype, m_inv, rng_key: 1.0 # noqa: E731 q = 0.0 - m_inv = jnp.array([1.0]) + m_inv = np.array([1.0]) fn = ( jit(find_reasonable_step_size, static_argnums=(0, 1, 2)) @@ -411,7 +411,7 @@ def potential_fn(q): vv_init, vv_update = velocity_verlet(potential_fn, kinetic_fn) vv_state = vv_init(0.0, 1.0) - inverse_mass_matrix = jnp.array([1.0]) + inverse_mass_matrix = np.array([1.0]) rng_key = random.PRNGKey(0) @jit diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index 454243ce7..144e62182 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -55,7 +55,7 @@ def circular_moment(x, n): def get_circular_moments(x): - return jnp.stack([circular_moment(x, i) for i in range(1, 5)]) + return jnp.stack([circular_moment(x, i) for i in range(1, 3)]) def test_syntax(): @@ -314,7 +314,7 @@ def get_expected_probe(loc, concentration): return get_circular_moments(trace["x"]["value"]) def get_actual_probe(loc, concentration): - kernel = NUTS(model_act) + kernel = NUTS(model_act, dense_mass=True) mcmc = MCMC(kernel, num_warmup=1000, num_samples=10000, num_chains=1) mcmc.run(random.PRNGKey(0), loc, concentration) samples = mcmc.get_samples() diff --git a/test/test_distributions.py b/test/test_distributions.py index c73e6b9b1..4cbe77f43 100644 --- a/test/test_distributions.py +++ b/test/test_distributions.py @@ -21,7 +21,6 @@ import numpyro.distributions as dist from numpyro.distributions import constraints, kl_divergence, transforms -from numpyro.distributions.directional import SineBivariateVonMises from numpyro.distributions.discrete import _to_probs_bernoulli, _to_probs_multinom from numpyro.distributions.flows import InverseAutoregressiveTransform from numpyro.distributions.gof import InvalidTest, auto_goodness_of_fit @@ -109,21 +108,21 @@ def _TruncatedNormal(loc, scale, low, high): class SineSkewedUniform(dist.SineSkewed): def __init__(self, skewness, **kwargs): - lower, upper = (jnp.array([-math.pi, -math.pi]), jnp.array([math.pi, math.pi])) + lower, upper = (np.array([-math.pi, -math.pi]), np.array([math.pi, math.pi])) base_dist = dist.Uniform(lower, upper, **kwargs).to_event(lower.ndim) super().__init__(base_dist, skewness, **kwargs) class SineSkewedVonMises(dist.SineSkewed): def __init__(self, skewness, **kwargs): - von_loc, von_conc = (jnp.array([0.0]), jnp.array([1.0])) + von_loc, von_conc = (np.array([0.0]), np.array([1.0])) base_dist = dist.VonMises(von_loc, von_conc, **kwargs).to_event(von_loc.ndim) super().__init__(base_dist, skewness, **kwargs) class SineSkewedVonMisesBatched(dist.SineSkewed): def __init__(self, skewness, **kwargs): - von_loc, von_conc = (jnp.array([0.0, -1.234]), jnp.array([1.0, 10.0])) + von_loc, von_conc = (np.array([0.0, -1.234]), np.array([1.0, 10.0])) base_dist = dist.VonMises(von_loc, von_conc, **kwargs).to_event(von_loc.ndim) super().__init__(base_dist, skewness, **kwargs) @@ -251,251 +250,218 @@ def get_sp_dist(jax_dist): CONTINUOUS = [ T(dist.Beta, 0.2, 1.1), - T(dist.Beta, 1.0, jnp.array([2.0, 2.0])), - T(dist.Beta, 1.0, jnp.array([[1.0, 1.0], [2.0, 2.0]])), + T(dist.Beta, 1.0, np.array([2.0, 2.0])), + T(dist.Beta, 1.0, np.array([[1.0, 1.0], [2.0, 2.0]])), T(dist.BetaProportion, 0.2, 10.0), - T(dist.BetaProportion, 0.51, jnp.array([2.0, 1.0])), - T(dist.BetaProportion, 0.5, jnp.array([[4.0, 4.0], [2.0, 2.0]])), + T(dist.BetaProportion, 0.51, np.array([2.0, 1.0])), + T(dist.BetaProportion, 0.5, np.array([[4.0, 4.0], [2.0, 2.0]])), T(dist.Chi2, 2.0), - T(dist.Chi2, jnp.array([0.3, 1.3])), + T(dist.Chi2, np.array([0.3, 1.3])), T(dist.Cauchy, 0.0, 1.0), - T(dist.Cauchy, 0.0, jnp.array([1.0, 2.0])), - T(dist.Cauchy, jnp.array([0.0, 1.0]), jnp.array([[1.0], [2.0]])), - T(dist.Dirichlet, jnp.array([1.7])), - T(dist.Dirichlet, jnp.array([0.2, 1.1])), - T(dist.Dirichlet, jnp.array([[0.2, 1.1], [2.0, 2.0]])), + T(dist.Cauchy, 0.0, np.array([1.0, 2.0])), + T(dist.Cauchy, np.array([0.0, 1.0]), np.array([[1.0], [2.0]])), + T(dist.Dirichlet, np.array([1.7])), + T(dist.Dirichlet, np.array([0.2, 1.1])), + T(dist.Dirichlet, np.array([[0.2, 1.1], [2.0, 2.0]])), T(dist.Exponential, 2.0), - T(dist.Exponential, jnp.array([4.0, 2.0])), - T(dist.Gamma, jnp.array([1.7]), jnp.array([[2.0], [3.0]])), - T(dist.Gamma, jnp.array([0.5, 1.3]), jnp.array([[1.0], [3.0]])), + T(dist.Exponential, np.array([4.0, 2.0])), + T(dist.Gamma, np.array([1.7]), np.array([[2.0], [3.0]])), + T(dist.Gamma, np.array([0.5, 1.3]), np.array([[1.0], [3.0]])), T(dist.GaussianRandomWalk, 0.1, 10), - T(dist.GaussianRandomWalk, jnp.array([0.1, 0.3, 0.25]), 10), + T(dist.GaussianRandomWalk, np.array([0.1, 0.3, 0.25]), 10), T(dist.Gumbel, 0.0, 1.0), T(dist.Gumbel, 0.5, 2.0), - T(dist.Gumbel, jnp.array([0.0, 0.5]), jnp.array([1.0, 2.0])), + T(dist.Gumbel, np.array([0.0, 0.5]), np.array([1.0, 2.0])), T(FoldedNormal, 2.0, 4.0), - T(FoldedNormal, jnp.array([2.0, 50.0]), jnp.array([4.0, 100.0])), + T(FoldedNormal, np.array([2.0, 50.0]), np.array([4.0, 100.0])), T(dist.HalfCauchy, 1.0), - T(dist.HalfCauchy, jnp.array([1.0, 2.0])), + T(dist.HalfCauchy, np.array([1.0, 2.0])), T(dist.HalfNormal, 1.0), - T(dist.HalfNormal, jnp.array([1.0, 2.0])), + T(dist.HalfNormal, np.array([1.0, 2.0])), T(_ImproperWrapper, constraints.positive, (), (3,)), - T(dist.InverseGamma, jnp.array([1.7]), jnp.array([[2.0], [3.0]])), - T(dist.InverseGamma, jnp.array([0.5, 1.3]), jnp.array([[1.0], [3.0]])), + T(dist.InverseGamma, np.array([1.7]), np.array([[2.0], [3.0]])), + T(dist.InverseGamma, np.array([0.5, 1.3]), np.array([[1.0], [3.0]])), T(dist.Laplace, 0.0, 1.0), - T(dist.Laplace, 0.5, jnp.array([1.0, 2.5])), - T(dist.Laplace, jnp.array([1.0, -0.5]), jnp.array([2.3, 3.0])), + T(dist.Laplace, 0.5, np.array([1.0, 2.5])), + T(dist.Laplace, np.array([1.0, -0.5]), np.array([2.3, 3.0])), T(dist.LKJ, 2, 0.5, "onion"), - T(dist.LKJ, 5, jnp.array([0.5, 1.0, 2.0]), "cvine"), + T(dist.LKJ, 5, np.array([0.5, 1.0, 2.0]), "cvine"), T(dist.LKJCholesky, 2, 0.5, "onion"), T(dist.LKJCholesky, 2, 0.5, "cvine"), - T(dist.LKJCholesky, 5, jnp.array([0.5, 1.0, 2.0]), "onion"), + T(dist.LKJCholesky, 5, np.array([0.5, 1.0, 2.0]), "onion"), pytest.param( - *T(dist.LKJCholesky, 5, jnp.array([0.5, 1.0, 2.0]), "cvine"), - marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for Travis"), + *T(dist.LKJCholesky, 5, np.array([0.5, 1.0, 2.0]), "cvine"), + marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for CI"), ), pytest.param( - *T(dist.LKJCholesky, 3, jnp.array([[3.0, 0.6], [0.2, 5.0]]), "onion"), - marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for Travis"), + *T(dist.LKJCholesky, 3, np.array([[3.0, 0.6], [0.2, 5.0]]), "onion"), + marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for CI"), ), - T(dist.LKJCholesky, 3, jnp.array([[3.0, 0.6], [0.2, 5.0]]), "cvine"), + T(dist.LKJCholesky, 3, np.array([[3.0, 0.6], [0.2, 5.0]]), "cvine"), T(dist.Logistic, 0.0, 1.0), - T(dist.Logistic, 1.0, jnp.array([1.0, 2.0])), - T(dist.Logistic, jnp.array([0.0, 1.0]), jnp.array([[1.0], [2.0]])), + T(dist.Logistic, 1.0, np.array([1.0, 2.0])), + T(dist.Logistic, np.array([0.0, 1.0]), np.array([[1.0], [2.0]])), T(dist.LogNormal, 1.0, 0.2), - T(dist.LogNormal, -1.0, jnp.array([0.5, 1.3])), - T(dist.LogNormal, jnp.array([0.5, -0.7]), jnp.array([[0.1, 0.4], [0.5, 0.1]])), - T(dist.MultivariateNormal, 0.0, jnp.array([[1.0, 0.5], [0.5, 1.0]]), None, None), + T(dist.LogNormal, -1.0, np.array([0.5, 1.3])), + T(dist.LogNormal, np.array([0.5, -0.7]), np.array([[0.1, 0.4], [0.5, 0.1]])), + T(dist.MultivariateNormal, 0.0, np.array([[1.0, 0.5], [0.5, 1.0]]), None, None), T( dist.MultivariateNormal, - jnp.array([1.0, 3.0]), + np.array([1.0, 3.0]), None, - jnp.array([[1.0, 0.5], [0.5, 1.0]]), + np.array([[1.0, 0.5], [0.5, 1.0]]), None, ), T( dist.MultivariateNormal, - jnp.array([1.0, 3.0]), + np.array([1.0, 3.0]), None, - jnp.array([[[1.0, 0.5], [0.5, 1.0]]]), + np.array([[[1.0, 0.5], [0.5, 1.0]]]), None, ), T( dist.MultivariateNormal, - jnp.array([2.0]), + np.array([2.0]), None, None, - jnp.array([[1.0, 0.0], [0.5, 1.0]]), + np.array([[1.0, 0.0], [0.5, 1.0]]), ), T( dist.MultivariateNormal, - jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), + np.arange(6, dtype=np.float32).reshape((3, 2)), None, None, - jnp.array([[1.0, 0.0], [0.0, 1.0]]), + np.array([[1.0, 0.0], [0.0, 1.0]]), ), T( dist.MultivariateNormal, 0.0, None, - jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), + np.broadcast_to(np.identity(3), (2, 3, 3)), None, ), T( dist.MultivariateStudentT, 15.0, 0.0, - jnp.array([[1.0, 0.0], [0.5, 1.0]]), + np.array([[1.0, 0.0], [0.5, 1.0]]), ), T( dist.MultivariateStudentT, 15.0, - jnp.array([1.0, 3.0]), - jnp.array([[1.0, 0.0], [0.5, 1.0]]), + np.array([1.0, 3.0]), + np.array([[1.0, 0.0], [0.5, 1.0]]), ), T( dist.MultivariateStudentT, 15.0, - jnp.array([1.0, 3.0]), - jnp.array([[[1.0, 0.0], [0.5, 1.0]]]), + np.array([1.0, 3.0]), + np.array([[[1.0, 0.0], [0.5, 1.0]]]), ), T( dist.MultivariateStudentT, 15.0, - jnp.array([3.0]), - jnp.array([[1.0, 0.0], [0.5, 1.0]]), + np.array([3.0]), + np.array([[1.0, 0.0], [0.5, 1.0]]), ), T( dist.MultivariateStudentT, 15.0, - jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), - jnp.array([[1.0, 0.0], [0.5, 1.0]]), + np.arange(6, dtype=np.float32).reshape((3, 2)), + np.array([[1.0, 0.0], [0.5, 1.0]]), ), T( dist.MultivariateStudentT, 15.0, - jnp.ones(3), - jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), + np.ones(3), + np.broadcast_to(np.identity(3), (2, 3, 3)), ), T( dist.MultivariateStudentT, - jnp.array(7.0), - jnp.array([1.0, 3.0]), - jnp.array([[1.0, 0.0], [0.5, 1.0]]), + np.array(7.0), + np.array([1.0, 3.0]), + np.array([[1.0, 0.0], [0.5, 1.0]]), ), T( dist.MultivariateStudentT, - jnp.arange(20, 22, dtype=jnp.float32), - jnp.ones(3), - jnp.broadcast_to(jnp.identity(3), (2, 3, 3)), + np.arange(20, 22, dtype=jnp.float32), + np.ones(3), + np.broadcast_to(jnp.identity(3), (2, 3, 3)), ), T( dist.MultivariateStudentT, - jnp.arange(20, 26, dtype=jnp.float32).reshape((3, 2)), - jnp.ones(2), - jnp.array([[1.0, 0.0], [0.5, 1.0]]), + np.arange(20, 26, dtype=jnp.float32).reshape((3, 2)), + np.ones(2), + np.array([[1.0, 0.0], [0.5, 1.0]]), ), T( dist.LowRankMultivariateNormal, - jnp.zeros(2), - jnp.array([[1.0], [0.0]]), - jnp.array([1.0, 1.0]), + np.zeros(2), + np.array([[1.0], [0.0]]), + np.array([1.0, 1.0]), ), T( dist.LowRankMultivariateNormal, - jnp.arange(6, dtype=jnp.float32).reshape((2, 3)), - jnp.arange(6, dtype=jnp.float32).reshape((3, 2)), - jnp.array([1.0, 2.0, 3.0]), + np.arange(6, dtype=jnp.float32).reshape((2, 3)), + np.arange(6, dtype=jnp.float32).reshape((3, 2)), + np.array([1.0, 2.0, 3.0]), ), T(dist.Normal, 0.0, 1.0), - T(dist.Normal, 1.0, jnp.array([1.0, 2.0])), - T(dist.Normal, jnp.array([0.0, 1.0]), jnp.array([[1.0], [2.0]])), + T(dist.Normal, 1.0, np.array([1.0, 2.0])), + T(dist.Normal, np.array([0.0, 1.0]), np.array([[1.0], [2.0]])), T(dist.Pareto, 1.0, 2.0), - T(dist.Pareto, jnp.array([1.0, 0.5]), jnp.array([0.3, 2.0])), - T(dist.Pareto, jnp.array([[1.0], [3.0]]), jnp.array([1.0, 0.5])), - T( - dist.SineBivariateVonMises, - jnp.array([0.0]), - jnp.array([0.0]), - jnp.array([5.0]), - jnp.array([6.0]), - jnp.array([2.0]), - ), - T( - dist.SineBivariateVonMises, - jnp.array([3.003]), - jnp.array([-1.343]), # check test_gof, test_mean_var, - jnp.array([5.0]), - jnp.array([6.0]), - jnp.array([2.0]), - ), # check test_distribution_constraints - T( - dist.SineBivariateVonMises, - jnp.array([-math.pi / 3]), - jnp.array(-1), - jnp.array(0.4), - jnp.array(10.0), - jnp.array(0.9), - ), - T( - dist.SineBivariateVonMises, - jnp.array([math.pi - 0.2, 1.0]), - jnp.array([0.0, 1.0]), - jnp.array([5.0, 5.0]), - jnp.array([7.0, 0.5]), - None, - jnp.array([0.5, 0.1]), - ), + T(dist.Pareto, np.array([1.0, 0.5]), np.array([0.3, 2.0])), + T(dist.Pareto, np.array([[1.0], [3.0]]), np.array([1.0, 0.5])), T(dist.SoftLaplace, 1.0, 1.0), - T(dist.SoftLaplace, jnp.array([-1.0, 50.0]), jnp.array([4.0, 100.0])), + T(dist.SoftLaplace, np.array([-1.0, 50.0]), np.array([4.0, 100.0])), T(dist.StudentT, 1.0, 1.0, 0.5), - T(dist.StudentT, 2.0, jnp.array([1.0, 2.0]), 2.0), - T(dist.StudentT, jnp.array([3.0, 5.0]), jnp.array([[1.0], [2.0]]), 2.0), + T(dist.StudentT, 2.0, np.array([1.0, 2.0]), 2.0), + T(dist.StudentT, np.array([3.0, 5.0]), np.array([[1.0], [2.0]]), 2.0), T(dist.TruncatedCauchy, -1.0, 0.0, 1.0), - T(dist.TruncatedCauchy, 1.0, 0.0, jnp.array([1.0, 2.0])), + T(dist.TruncatedCauchy, 1.0, 0.0, np.array([1.0, 2.0])), T( dist.TruncatedCauchy, - jnp.array([-2.0, 2.0]), - jnp.array([0.0, 1.0]), - jnp.array([[1.0], [2.0]]), + np.array([-2.0, 2.0]), + np.array([0.0, 1.0]), + np.array([[1.0], [2.0]]), ), T(dist.TruncatedNormal, -1.0, 0.0, 1.0), - T(dist.TruncatedNormal, 1.0, -1.0, jnp.array([1.0, 2.0])), + T(dist.TruncatedNormal, 1.0, -1.0, np.array([1.0, 2.0])), T( dist.TruncatedNormal, - jnp.array([-2.0, 2.0]), - jnp.array([0.0, 1.0]), - jnp.array([[1.0], [2.0]]), + np.array([-2.0, 2.0]), + np.array([0.0, 1.0]), + np.array([[1.0], [2.0]]), ), T(_TruncatedNormal, -1.0, 2.0, 1.0, 5.0), - T(_TruncatedNormal, jnp.array([-1.0, 4.0]), 2.0, None, 5.0), - T(_TruncatedNormal, -1.0, jnp.array([2.0, 3.0]), 1.0, None), - T(_TruncatedNormal, -1.0, 2.0, jnp.array([-6.0, 4.0]), jnp.array([-4.0, 6.0])), + T(_TruncatedNormal, np.array([-1.0, 4.0]), 2.0, None, 5.0), + T(_TruncatedNormal, -1.0, np.array([2.0, 3.0]), 1.0, None), + T(_TruncatedNormal, -1.0, 2.0, np.array([-6.0, 4.0]), np.array([-4.0, 6.0])), T( _TruncatedNormal, - jnp.array([0.0, 1.0]), - jnp.array([[1.0], [2.0]]), + np.array([0.0, 1.0]), + np.array([[1.0], [2.0]]), None, - jnp.array([-2.0, 2.0]), + np.array([-2.0, 2.0]), ), T(dist.TwoSidedTruncatedDistribution, dist.Laplace(0.0, 1.0), -2.0, 3.0), T(dist.Uniform, 0.0, 2.0), - T(dist.Uniform, 1.0, jnp.array([2.0, 3.0])), - T(dist.Uniform, jnp.array([0.0, 0.0]), jnp.array([[2.0], [3.0]])), + T(dist.Uniform, 1.0, np.array([2.0, 3.0])), + T(dist.Uniform, np.array([0.0, 0.0]), np.array([[2.0], [3.0]])), T(dist.Weibull, 0.2, 1.1), - T(dist.Weibull, 2.8, jnp.array([2.0, 2.0])), - T(dist.Weibull, 1.8, jnp.array([[1.0, 1.0], [2.0, 2.0]])), + T(dist.Weibull, 2.8, np.array([2.0, 2.0])), + T(dist.Weibull, 1.8, np.array([[1.0, 1.0], [2.0, 2.0]])), T( _GaussianMixture, - jnp.ones(3) / 3.0, - jnp.array([0.0, 7.7, 2.1]), - jnp.array([4.2, 7.7, 2.1]), + np.ones(3) / 3.0, + np.array([0.0, 7.7, 2.1]), + np.array([4.2, 7.7, 2.1]), ), T( _Gaussian2DMixture, - jnp.array([0.2, 0.5, 0.3]), - jnp.array([[-1.2, 1.5], [2.0, 2.0], [-1, 4.0]]), # Mean - jnp.array( + np.array([0.2, 0.5, 0.3]), + np.array([[-1.2, 1.5], [2.0, 2.0], [-1, 4.0]]), # Mean + np.array( [ [ [0.1, -0.2], @@ -516,117 +482,126 @@ def get_sp_dist(jax_dist): DIRECTIONAL = [ T(dist.VonMises, 2.0, 10.0), - T(dist.VonMises, 2.0, jnp.array([150.0, 10.0])), - T(dist.VonMises, jnp.array([1 / 3 * jnp.pi, -1.0]), jnp.array([20.0, 30.0])), - T( - SineBivariateVonMises, - jnp.array([0.0]), - jnp.array([0.0]), - jnp.array([5.0]), - jnp.array([6.0]), - jnp.array([2.0]), + T(dist.VonMises, 2.0, np.array([150.0, 10.0])), + T(dist.VonMises, np.array([1 / 3 * np.pi, -1.0]), np.array([20.0, 30.0])), + pytest.param( + *T( + dist.SineBivariateVonMises, + 0.0, + 0.0, + 5.0, + 6.0, + 2.0, + ), + marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for CI"), ), T( - SineBivariateVonMises, - jnp.array([3.003]), - jnp.array([-1.3430]), - jnp.array(5.0), - jnp.array([6.0]), - jnp.array([2.0]), + dist.SineBivariateVonMises, + 3.003, + -1.343, + 5.0, + 6.0, + 2.0, ), - T( - SineBivariateVonMises, - jnp.array(-1.232), - jnp.array(-1.3430), - jnp.array(3.4), - jnp.array(2.0), - jnp.array(1.0), + pytest.param( + *T( + dist.SineBivariateVonMises, + -1.232, + -1.3430, + 3.4, + 2.0, + 1.0, + ), + marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for CI"), ), - T( - SineBivariateVonMises, - jnp.array([math.pi - 0.2, 1.0]), - jnp.array([0.0, 1.0]), - jnp.array([2.123, 20.0]), - jnp.array([7.0, 0.5]), - None, - jnp.array([0.2, 0.5]), + pytest.param( + *T( + dist.SineBivariateVonMises, + np.array([math.pi - 0.2, 1.0]), + np.array([0.0, 1.0]), + np.array([5.0, 5.0]), + np.array([7.0, 0.5]), + None, + np.array([0.5, 0.1]), + ), + marks=pytest.mark.skipif("CI" in os.environ, reason="reduce time for CI"), ), - T(dist.ProjectedNormal, jnp.array([0.0, 0.0])), - T(dist.ProjectedNormal, jnp.array([[2.0, 3.0]])), - T(dist.ProjectedNormal, jnp.array([0.0, 0.0, 0.0])), - T(dist.ProjectedNormal, jnp.array([[-1.0, 2.0, 3.0]])), - T(SineSkewedUniform, jnp.array([-math.pi / 4, 0.1])), - T(SineSkewedVonMises, jnp.array([0.342355])), - T(SineSkewedVonMisesBatched, jnp.array([[0.342355, -0.0001], [0.91, 0.09]])), + T(dist.ProjectedNormal, np.array([0.0, 0.0])), + T(dist.ProjectedNormal, np.array([[2.0, 3.0]])), + T(dist.ProjectedNormal, np.array([0.0, 0.0, 0.0])), + T(dist.ProjectedNormal, np.array([[-1.0, 2.0, 3.0]])), + T(SineSkewedUniform, np.array([-math.pi / 4, 0.1])), + T(SineSkewedVonMises, np.array([0.342355])), + T(SineSkewedVonMisesBatched, np.array([[0.342355, -0.0001], [0.91, 0.09]])), ] DISCRETE = [ T(dist.BetaBinomial, 2.0, 5.0, 10), T( dist.BetaBinomial, - jnp.array([2.0, 4.0]), - jnp.array([5.0, 3.0]), - jnp.array([10, 12]), + np.array([2.0, 4.0]), + np.array([5.0, 3.0]), + np.array([10, 12]), ), T(dist.BernoulliProbs, 0.2), - T(dist.BernoulliProbs, jnp.array([0.2, 0.7])), - T(dist.BernoulliLogits, jnp.array([-1.0, 3.0])), - T(dist.BinomialProbs, jnp.array([0.2, 0.7]), jnp.array([10, 2])), - T(dist.BinomialProbs, jnp.array([0.2, 0.7]), jnp.array([5, 8])), - T(dist.BinomialLogits, jnp.array([-1.0, 3.0]), jnp.array([5, 8])), - T(dist.CategoricalProbs, jnp.array([1.0])), - T(dist.CategoricalProbs, jnp.array([0.1, 0.5, 0.4])), - T(dist.CategoricalProbs, jnp.array([[0.1, 0.5, 0.4], [0.4, 0.4, 0.2]])), - T(dist.CategoricalLogits, jnp.array([-5.0])), - T(dist.CategoricalLogits, jnp.array([1.0, 2.0, -2.0])), - T(dist.CategoricalLogits, jnp.array([[-1, 2.0, 3.0], [3.0, -4.0, -2.0]])), + T(dist.BernoulliProbs, np.array([0.2, 0.7])), + T(dist.BernoulliLogits, np.array([-1.0, 3.0])), + T(dist.BinomialProbs, np.array([0.2, 0.7]), np.array([10, 2])), + T(dist.BinomialProbs, np.array([0.2, 0.7]), np.array([5, 8])), + T(dist.BinomialLogits, np.array([-1.0, 3.0]), np.array([5, 8])), + T(dist.CategoricalProbs, np.array([1.0])), + T(dist.CategoricalProbs, np.array([0.1, 0.5, 0.4])), + T(dist.CategoricalProbs, np.array([[0.1, 0.5, 0.4], [0.4, 0.4, 0.2]])), + T(dist.CategoricalLogits, np.array([-5.0])), + T(dist.CategoricalLogits, np.array([1.0, 2.0, -2.0])), + T(dist.CategoricalLogits, np.array([[-1, 2.0, 3.0], [3.0, -4.0, -2.0]])), T(dist.Delta, 1), - T(dist.Delta, jnp.array([0.0, 2.0])), - T(dist.Delta, jnp.array([0.0, 2.0]), jnp.array([-2.0, -4.0])), - T(dist.DirichletMultinomial, jnp.array([1.0, 2.0, 3.9]), 10), - T(dist.DirichletMultinomial, jnp.array([0.2, 0.7, 1.1]), jnp.array([5, 5])), + T(dist.Delta, np.array([0.0, 2.0])), + T(dist.Delta, np.array([0.0, 2.0]), np.array([-2.0, -4.0])), + T(dist.DirichletMultinomial, np.array([1.0, 2.0, 3.9]), 10), + T(dist.DirichletMultinomial, np.array([0.2, 0.7, 1.1]), np.array([5, 5])), T(dist.GammaPoisson, 2.0, 2.0), - T(dist.GammaPoisson, jnp.array([6.0, 2]), jnp.array([2.0, 8.0])), + T(dist.GammaPoisson, np.array([6.0, 2]), np.array([2.0, 8.0])), T(dist.GeometricProbs, 0.2), - T(dist.GeometricProbs, jnp.array([0.2, 0.7])), - T(dist.GeometricLogits, jnp.array([-1.0, 3.0])), - T(dist.MultinomialProbs, jnp.array([0.2, 0.7, 0.1]), 10), - T(dist.MultinomialProbs, jnp.array([0.2, 0.7, 0.1]), jnp.array([5, 8])), - T(dist.MultinomialLogits, jnp.array([-1.0, 3.0]), jnp.array([[5], [8]])), + T(dist.GeometricProbs, np.array([0.2, 0.7])), + T(dist.GeometricLogits, np.array([-1.0, 3.0])), + T(dist.MultinomialProbs, np.array([0.2, 0.7, 0.1]), 10), + T(dist.MultinomialProbs, np.array([0.2, 0.7, 0.1]), np.array([5, 8])), + T(dist.MultinomialLogits, np.array([-1.0, 3.0]), np.array([[5], [8]])), T(dist.NegativeBinomialProbs, 10, 0.2), - T(dist.NegativeBinomialProbs, 10, jnp.array([0.2, 0.6])), - T(dist.NegativeBinomialProbs, jnp.array([4.2, 10.7, 2.1]), 0.2), + T(dist.NegativeBinomialProbs, 10, np.array([0.2, 0.6])), + T(dist.NegativeBinomialProbs, np.array([4.2, 10.7, 2.1]), 0.2), T( dist.NegativeBinomialProbs, - jnp.array([4.2, 10.7, 2.1]), - jnp.array([0.2, 0.6, 0.5]), + np.array([4.2, 10.7, 2.1]), + np.array([0.2, 0.6, 0.5]), ), T(dist.NegativeBinomialLogits, 10, -2.1), - T(dist.NegativeBinomialLogits, 10, jnp.array([-5.2, 2.1])), - T(dist.NegativeBinomialLogits, jnp.array([4.2, 10.7, 2.1]), -5.2), + T(dist.NegativeBinomialLogits, 10, np.array([-5.2, 2.1])), + T(dist.NegativeBinomialLogits, np.array([4.2, 10.7, 2.1]), -5.2), T( dist.NegativeBinomialLogits, - jnp.array([4.2, 7.7, 2.1]), - jnp.array([4.2, 0.7, 2.1]), + np.array([4.2, 7.7, 2.1]), + np.array([4.2, 0.7, 2.1]), ), T(dist.NegativeBinomial2, 0.3, 10), - T(dist.NegativeBinomial2, jnp.array([10.2, 7, 31]), 10), - T(dist.NegativeBinomial2, jnp.array([10.2, 7, 31]), jnp.array([10.2, 20.7, 2.1])), - T(dist.OrderedLogistic, -2, jnp.array([-10.0, 4.0, 9.0])), - T(dist.OrderedLogistic, jnp.array([-4, 3, 4, 5]), jnp.array([-1.5])), - T(dist.DiscreteUniform, -2, jnp.array([-1.0, 4.0, 9.0])), - T(dist.DiscreteUniform, jnp.array([-4, 3, 4, 5]), jnp.array([6])), + T(dist.NegativeBinomial2, np.array([10.2, 7, 31]), 10), + T(dist.NegativeBinomial2, np.array([10.2, 7, 31]), np.array([10.2, 20.7, 2.1])), + T(dist.OrderedLogistic, -2, np.array([-10.0, 4.0, 9.0])), + T(dist.OrderedLogistic, np.array([-4, 3, 4, 5]), np.array([-1.5])), + T(dist.DiscreteUniform, -2, np.array([-1.0, 4.0, 9.0])), + T(dist.DiscreteUniform, np.array([-4, 3, 4, 5]), np.array([6])), T(dist.Poisson, 2.0), - T(dist.Poisson, jnp.array([2.0, 3.0, 5.0])), + T(dist.Poisson, np.array([2.0, 3.0, 5.0])), T(SparsePoisson, 2.0), - T(SparsePoisson, jnp.array([2.0, 3.0, 5.0])), + T(SparsePoisson, np.array([2.0, 3.0, 5.0])), T(dist.ZeroInflatedPoisson, 0.6, 2.0), - T(dist.ZeroInflatedPoisson, jnp.array([0.2, 0.7, 0.3]), jnp.array([2.0, 3.0, 5.0])), + T(dist.ZeroInflatedPoisson, np.array([0.2, 0.7, 0.3]), np.array([2.0, 3.0, 5.0])), T(ZeroInflatedPoissonLogits, 2.0, 3.0), T( ZeroInflatedPoissonLogits, - jnp.array([0.2, 4.0, 0.3]), - jnp.array([2.0, -3.0, 5.0]), + np.array([0.2, 4.0, 0.3]), + np.array([2.0, -3.0, 5.0]), ), ] @@ -711,7 +686,7 @@ def gen_values_outside_bounds(constraint, size, key=random.PRNGKey(11)): upper_bound = jnp.broadcast_to(constraint.upper_bound, size) return random.uniform(key, size, minval=upper_bound, maxval=upper_bound + 1.0) elif constraint in [constraints.real, constraints.real_vector]: - return lax.full(size, jnp.nan) + return lax.full(size, np.nan) elif constraint is constraints.simplex: return osp.dirichlet.rvs(alpha=jnp.ones((size[-1],)), size=size[:-1]) + 1e-2 elif isinstance(constraint, constraints.multinomial): @@ -1015,7 +990,7 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): else: # old api low, loc, scale = params - high = jnp.inf + high = np.inf sp_dist = get_sp_dist(type(jax_dist.base_dist))(loc, scale) expected = sp_dist.logpdf(samples) - jnp.log( sp_dist.cdf(high) - sp_dist.cdf(low) @@ -1050,7 +1025,7 @@ def test_log_prob(jax_dist, sp_dist, params, prepend_shape, jit): @pytest.mark.parametrize( "jax_dist, sp_dist, params", # TODO: add more complete pattern for Discrete.cdf - CONTINUOUS + [T(dist.Poisson, 2.0), T(dist.Poisson, jnp.array([2.0, 3.0, 5.0]))], + CONTINUOUS + [T(dist.Poisson, 2.0), T(dist.Poisson, np.array([2.0, 3.0, 5.0]))], ) def test_cdf_and_icdf(jax_dist, sp_dist, params): d = jax_dist(*params) @@ -1165,7 +1140,7 @@ def test_log_prob_LKJCholesky_uniform(dimension): )[1] corr_log_prob.append(log_prob - cholesky_to_corr_jac) - corr_log_prob = jnp.array(corr_log_prob) + corr_log_prob = np.array(corr_log_prob) # test if they are constant assert_allclose( corr_log_prob, @@ -1247,7 +1222,7 @@ def test_ZIP_log_prob(rate): # if gate is 1 ZIP is Delta(0) zip_ = dist.ZeroInflatedPoisson(1.0, rate) delta = dist.Delta(0.0) - s = jnp.array([0.0, 1.0]) + s = np.array([0.0, 1.0]) zip_prob = zip_.log_prob(s) delta_prob = delta.log_prob(s) assert_allclose(zip_prob, delta_prob, rtol=1e-6) @@ -1364,7 +1339,11 @@ def test_mean_var(jax_dist, sp_dist, params): if jax_dist is dist.ProjectedNormal: pytest.skip("Mean is defined in submanifold") - n = 20000 if jax_dist in [dist.LKJ, dist.LKJCholesky] else 200000 + n = ( + 20000 + if jax_dist in [dist.LKJ, dist.LKJCholesky, dist.SineBivariateVonMises] + else 200000 + ) d_jax = jax_dist(*params) k = random.PRNGKey(0) samples = d_jax.sample(k, sample_shape=(n,)).astype(np.float32) @@ -1610,122 +1589,122 @@ def test_beta_proportion_invalid_mean(): @pytest.mark.parametrize( "constraint, x, expected", [ - (constraints.boolean, jnp.array([True, False]), jnp.array([True, True])), - (constraints.boolean, jnp.array([1, 1]), jnp.array([True, True])), - (constraints.boolean, jnp.array([-1, 1]), jnp.array([False, True])), + (constraints.boolean, np.array([True, False]), np.array([True, True])), + (constraints.boolean, np.array([1, 1]), np.array([True, True])), + (constraints.boolean, np.array([-1, 1]), np.array([False, True])), ( constraints.corr_cholesky, - jnp.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), - jnp.array([True, False]), + np.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), + np.array([True, False]), ), # NB: not lower_triangular ( constraints.corr_cholesky, - jnp.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), - jnp.array([False, False]), + np.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), + np.array([False, False]), ), # NB: not positive_diagonal & not unit_norm_row ( constraints.corr_matrix, - jnp.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), - jnp.array([True, False]), + np.array([[[1, 0], [0, 1]], [[1, 0.1], [0, 1]]]), + np.array([True, False]), ), # NB: not lower_triangular ( constraints.corr_matrix, - jnp.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), - jnp.array([False, False]), + np.array([[[1, 0], [1, 0]], [[1, 0], [0.5, 0.5]]]), + np.array([False, False]), ), # NB: not unit diagonal (constraints.greater_than(1), 3, True), ( constraints.greater_than(1), - jnp.array([-1, 1, 5]), - jnp.array([False, False, True]), + np.array([-1, 1, 5]), + np.array([False, False, True]), ), (constraints.integer_interval(-3, 5), 0, True), ( constraints.integer_interval(-3, 5), - jnp.array([-5, -3, 0, 1.1, 5, 7]), - jnp.array([False, True, True, False, True, False]), + np.array([-5, -3, 0, 1.1, 5, 7]), + np.array([False, True, True, False, True, False]), ), (constraints.interval(-3, 5), 0, True), ( constraints.interval(-3, 5), - jnp.array([-5, -3, 0, 5, 7]), - jnp.array([False, True, True, True, False]), + np.array([-5, -3, 0, 5, 7]), + np.array([False, True, True, True, False]), ), (constraints.less_than(1), -2, True), ( constraints.less_than(1), - jnp.array([-1, 1, 5]), - jnp.array([True, False, False]), + np.array([-1, 1, 5]), + np.array([True, False, False]), ), - (constraints.lower_cholesky, jnp.array([[1.0, 0.0], [-2.0, 0.1]]), True), + (constraints.lower_cholesky, np.array([[1.0, 0.0], [-2.0, 0.1]]), True), ( constraints.lower_cholesky, - jnp.array([[[1.0, 0.0], [-2.0, -0.1]], [[1.0, 0.1], [2.0, 0.2]]]), - jnp.array([False, False]), + np.array([[[1.0, 0.0], [-2.0, -0.1]], [[1.0, 0.1], [2.0, 0.2]]]), + np.array([False, False]), ), (constraints.nonnegative_integer, 3, True), ( constraints.nonnegative_integer, - jnp.array([-1.0, 0.0, 5.0]), - jnp.array([False, True, True]), + np.array([-1.0, 0.0, 5.0]), + np.array([False, True, True]), ), (constraints.positive, 3, True), - (constraints.positive, jnp.array([-1, 0, 5]), jnp.array([False, False, True])), - (constraints.positive_definite, jnp.array([[1.0, 0.3], [0.3, 1.0]]), True), + (constraints.positive, np.array([-1, 0, 5]), np.array([False, False, True])), + (constraints.positive_definite, np.array([[1.0, 0.3], [0.3, 1.0]]), True), ( constraints.positive_definite, - jnp.array([[[2.0, 0.4], [0.3, 2.0]], [[1.0, 0.1], [0.1, 0.0]]]), - jnp.array([False, False]), + np.array([[[2.0, 0.4], [0.3, 2.0]], [[1.0, 0.1], [0.1, 0.0]]]), + np.array([False, False]), ), (constraints.positive_integer, 3, True), ( constraints.positive_integer, - jnp.array([-1.0, 0.0, 5.0]), - jnp.array([False, False, True]), + np.array([-1.0, 0.0, 5.0]), + np.array([False, False, True]), ), (constraints.real, -1, True), ( constraints.real, - jnp.array([jnp.inf, jnp.NINF, jnp.nan, jnp.pi]), - jnp.array([False, False, False, True]), + np.array([np.inf, np.NINF, np.nan, np.pi]), + np.array([False, False, False, True]), ), - (constraints.simplex, jnp.array([0.1, 0.3, 0.6]), True), + (constraints.simplex, np.array([0.1, 0.3, 0.6]), True), ( constraints.simplex, - jnp.array([[0.1, 0.3, 0.6], [-0.1, 0.6, 0.5], [0.1, 0.6, 0.5]]), - jnp.array([True, False, False]), + np.array([[0.1, 0.3, 0.6], [-0.1, 0.6, 0.5], [0.1, 0.6, 0.5]]), + np.array([True, False, False]), ), (constraints.softplus_positive, 3, True), ( constraints.softplus_positive, - jnp.array([-1, 0, 5]), - jnp.array([False, False, True]), + np.array([-1, 0, 5]), + np.array([False, False, True]), ), ( constraints.softplus_lower_cholesky, - jnp.array([[1.0, 0.0], [-2.0, 0.1]]), + np.array([[1.0, 0.0], [-2.0, 0.1]]), True, ), ( constraints.softplus_lower_cholesky, - jnp.array([[[1.0, 0.0], [-2.0, -0.1]], [[1.0, 0.1], [2.0, 0.2]]]), - jnp.array([False, False]), + np.array([[[1.0, 0.0], [-2.0, -0.1]], [[1.0, 0.1], [2.0, 0.2]]]), + np.array([False, False]), ), (constraints.unit_interval, 0.1, True), ( constraints.unit_interval, - jnp.array([-5, 0, 0.5, 1, 7]), - jnp.array([False, True, True, True, False]), + np.array([-5, 0, 0.5, 1, 7]), + np.array([False, True, True, True, False]), ), ( constraints.sphere, - jnp.array([[1, 0, 0], [0.5, 0.5, 0]]), - jnp.array([True, False]), + np.array([[1, 0, 0], [0.5, 0.5, 0]]), + np.array([True, False]), ), ( constraints.open_interval(0.0, 1.0), - jnp.array([-5, 0, 0.5, 1, 7]), - jnp.array([False, False, True, False, False]), + np.array([-5, 0, 0.5, 1, 7]), + np.array([False, False, True, False, False]), ), ], ) @@ -1793,7 +1772,7 @@ def test_biject_to(constraint, shape): assert transform.inverse_shape(y.shape) == x.shape # test inv work for NaN arrays: - x_nan = transform.inv(jnp.full(jnp.shape(y), jnp.nan)) + x_nan = transform.inv(jnp.full(jnp.shape(y), np.nan)) assert x_nan.shape == x.shape # test codomain @@ -1875,12 +1854,12 @@ def inv_vec_transform(y): @pytest.mark.parametrize( "transform, event_shape", [ - (PermuteTransform(jnp.array([3, 0, 4, 1, 2])), (5,)), + (PermuteTransform(np.array([3, 0, 4, 1, 2])), (5,)), (PowerTransform(2.0), ()), (SoftplusTransform(), ()), ( LowerCholeskyAffine( - jnp.array([1.0, 2.0]), jnp.array([[0.6, 0.0], [1.5, 0.4]]) + np.array([1.0, 2.0]), np.array([[0.6, 0.0], [1.5, 0.4]]) ), (2,), ), @@ -2014,7 +1993,7 @@ def test_transformed_distribution(batch_shape, prepend_event_shape, sample_shape "transformed_dist", [ dist.TransformedDistribution( - dist.Normal(jnp.array([2.0, 3.0]), 1.0), transforms.ExpTransform() + dist.Normal(np.array([2.0, 3.0]), 1.0), transforms.ExpTransform() ), dist.TransformedDistribution( dist.Exponential(jnp.ones(2)), @@ -2131,8 +2110,8 @@ def test_generated_sample_distribution( (dist.BinomialLogits, (4.5, 10), jnp.arange(11)), (dist.BinomialProbs, (0.5, 11), jnp.arange(12)), (dist.BetaBinomial, (2.0, 0.5, 12), jnp.arange(13)), - (dist.CategoricalLogits, (jnp.array([3.0, 4.0, 5.0]),), jnp.arange(3)), - (dist.CategoricalProbs, (jnp.array([0.1, 0.5, 0.4]),), jnp.arange(3)), + (dist.CategoricalLogits, (np.array([3.0, 4.0, 5.0]),), jnp.arange(3)), + (dist.CategoricalProbs, (np.array([0.1, 0.5, 0.4]),), jnp.arange(3)), ], ) @pytest.mark.parametrize("batch_shape", [(5,), ()]) @@ -2266,7 +2245,7 @@ def f(x, data): assert log_prob.shape == data.shape[: len(data.shape) - len(event_shape)] return log_prob.sum() - data = jnp.array([[0.4, jnp.nan, 0.2, jnp.nan], [0.5, 0.5, 0.5, 0.5]]) + data = np.array([[0.4, np.nan, 0.2, np.nan], [0.5, 0.5, 0.5, 0.5]]) log_prob, grad = jax.value_and_grad(f)(1.0, data) assert jnp.isfinite(grad) and jnp.isfinite(log_prob) diff --git a/test/test_distributions_util.py b/test/test_distributions_util.py index 830725e5e..d97d1d5ac 100644 --- a/test/test_distributions_util.py +++ b/test/test_distributions_util.py @@ -33,10 +33,10 @@ def test_binary_cross_entropy_with_logits(x, y): @pytest.mark.parametrize("prim", [xlogy, xlog1py]) def test_binop_batch_rule(prim): - bx = jnp.array([1.0, 2.0, 3.0]) - by = jnp.array([2.0, 3.0, 4.0]) - x = jnp.array(1.0) - y = jnp.array(2.0) + bx = np.array([1.0, 2.0, 3.0]) + by = np.array([2.0, 3.0, 4.0]) + x = np.array(1.0) + y = np.array(2.0) actual_bx_by = vmap(lambda x, y: prim(x, y))(bx, by) for i in range(3): @@ -66,7 +66,7 @@ def test_categorical_shape(p, shape): assert jnp.shape(categorical(rng_key, p, shape)) == expected_shape -@pytest.mark.parametrize("p", [jnp.array([0.2, 0.3, 0.5]), jnp.array([0.8, 0.1, 0.1])]) +@pytest.mark.parametrize("p", [np.array([0.2, 0.3, 0.5]), np.array([0.8, 0.1, 0.1])]) def test_categorical_stats(p): rng_key = random.PRNGKey(0) n = 10000 @@ -97,7 +97,7 @@ def test_multinomial_inhomogeneous(n, device_array): if device_array: n = jnp.asarray(n) - p = jnp.array([0.5, 0.5]) + p = np.array([0.5, 0.5]) x = multinomial(random.PRNGKey(0), p, n) assert x.shape == jnp.shape(n) + jnp.shape(p) assert_allclose(x.sum(-1), n) diff --git a/test/test_util.py b/test/test_util.py index 99963810d..5a0b05207 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -1,7 +1,7 @@ # Copyright Contributors to the Pyro project. # SPDX-License-Identifier: Apache-2.0 - +import numpy as np from numpy.testing import assert_allclose import pytest @@ -20,20 +20,20 @@ def test_fori_collect_thinning(): def f(x): return x + 1.0 - actual2 = fori_collect(0, 9, f, jnp.array([-1]), thinning=2) - expected2 = jnp.array([[2], [4], [6], [8]]) + actual2 = fori_collect(0, 9, f, np.array([-1]), thinning=2) + expected2 = np.array([[2], [4], [6], [8]]) check_eq(actual2, expected2) - actual3 = fori_collect(0, 9, f, jnp.array([-1]), thinning=3) - expected3 = jnp.array([[2], [5], [8]]) + actual3 = fori_collect(0, 9, f, np.array([-1]), thinning=3) + expected3 = np.array([[2], [5], [8]]) check_eq(actual3, expected3) - actual4 = fori_collect(0, 9, f, jnp.array([-1]), thinning=4) - expected4 = jnp.array([[4], [8]]) + actual4 = fori_collect(0, 9, f, np.array([-1]), thinning=4) + expected4 = np.array([[4], [8]]) check_eq(actual4, expected4) - actual5 = fori_collect(12, 37, f, jnp.array([-1]), thinning=5) - expected5 = jnp.array([[16], [21], [26], [31], [36]]) + actual5 = fori_collect(12, 37, f, np.array([-1]), thinning=5) + expected5 = np.array([[16], [21], [26], [31], [36]]) check_eq(actual5, expected5) @@ -41,8 +41,8 @@ def test_fori_collect(): def f(x): return {"i": x["i"] + x["j"], "j": x["i"] - x["j"]} - a = {"i": jnp.array([0.0]), "j": jnp.array([1.0])} - expected_tree = {"i": jnp.array([[0.0], [2.0]])} + a = {"i": np.array([0.0]), "j": np.array([1.0])} + expected_tree = {"i": np.array([[0.0], [2.0]])} actual_tree = fori_collect(1, 3, f, a, transform=lambda a: {"i": a["i"]}) check_eq(actual_tree, expected_tree) @@ -62,8 +62,8 @@ def f(x): return_last_val=True, progbar=progbar, ) - expected_tree = {"i": jnp.array([3, 4])} - expected_last_state = {"i": jnp.array(4)} + expected_tree = {"i": np.array([3, 4])} + expected_last_state = {"i": np.array(4)} check_eq(init_state, expected_last_state) check_eq(tree, expected_tree) @@ -71,12 +71,12 @@ def f(x): @pytest.mark.parametrize( "pytree", [ - {"a": jnp.array(0.0), "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, - {"a": jnp.array(0), "b": jnp.array([[1, 2], [3, 4]])}, - {"a": jnp.array(0), "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, - {"a": 0.0, "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, - {"a": False, "b": jnp.array([[1.0, 2.0], [3.0, 4.0]])}, - [False, True, 0.0, jnp.array([[1.0, 2.0], [3.0, 4.0]])], + {"a": np.array(0.0), "b": np.array([[1.0, 2.0], [3.0, 4.0]])}, + {"a": np.array(0), "b": np.array([[1, 2], [3, 4]])}, + {"a": np.array(0), "b": np.array([[1.0, 2.0], [3.0, 4.0]])}, + {"a": 0.0, "b": np.array([[1.0, 2.0], [3.0, 4.0]])}, + {"a": False, "b": np.array([[1.0, 2.0], [3.0, 4.0]])}, + [False, True, 0.0, np.array([[1.0, 2.0], [3.0, 4.0]])], ], ) def test_ravel_pytree(pytree): From 7c8dd4eabcef5ade52cc49d26da7da7a58e768fe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Omar=20Sosa=20Rodr=C3=ADguez?= <32113591+omarfsosa@users.noreply.github.com> Date: Mon, 13 Dec 2021 12:49:48 +0000 Subject: [PATCH 218/222] WIP: Added CDF for gamma, inverse gamma and log normal densities (#1250) * Added CDF for gamma, inverse gamma and log normal densities * Added CDF for gamma, inverse gamma and log normal densities * simplify cdf expressions * Simplify CDF functions --- numpyro/distributions/continuous.py | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/numpyro/distributions/continuous.py b/numpyro/distributions/continuous.py index 337b7efe4..669076f8b 100644 --- a/numpyro/distributions/continuous.py +++ b/numpyro/distributions/continuous.py @@ -27,6 +27,7 @@ from jax import lax +from jax._src.scipy.special import gammainc import jax.nn as nn import jax.numpy as jnp import jax.random as random @@ -282,6 +283,9 @@ def mean(self): def variance(self): return self.concentration / jnp.power(self.rate, 2) + def cdf(self, x): + return gammainc(self.concentration, self.rate * x) + class Chi2(Gamma): arg_constraints = {"df": constraints.positive} @@ -447,6 +451,9 @@ def variance(self): def tree_flatten(self): return super(TransformedDistribution, self).tree_flatten() + def cdf(self, x): + return 1 - self.base_dist.cdf(1 / x) + class Gumbel(Distribution): arg_constraints = {"loc": constraints.real, "scale": constraints.positive} @@ -845,6 +852,9 @@ def variance(self): def tree_flatten(self): return super(TransformedDistribution, self).tree_flatten() + def cdf(self, x): + return self.base_dist.cdf(jnp.log(x)) + class Logistic(Distribution): arg_constraints = {"loc": constraints.real, "scale": constraints.positive} From 545db3fccc9f284f984acc55cad4b204cdb91ecd Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 13 Dec 2021 08:19:43 -0500 Subject: [PATCH 219/222] Use multipledispatch for kl_registry (#1252) --- docs/requirements.txt | 4 +- numpyro/distributions/kl.py | 119 +++++++----------------------------- setup.cfg | 2 + setup.py | 2 + 4 files changed, 30 insertions(+), 97 deletions(-) diff --git a/docs/requirements.txt b/docs/requirements.txt index 999bb0c42..0788411e2 100644 --- a/docs/requirements.txt +++ b/docs/requirements.txt @@ -5,8 +5,10 @@ ipython jax>=0.2.11 jaxlib>=0.1.62 jaxns>=0.0.7 -optax>=0.0.6 +multipledispatch nbsphinx==0.8.6 +numpy +optax>=0.0.6 readthedocs-sphinx-search==0.1.0 sphinx==4.0.3 sphinx-gallery diff --git a/numpyro/distributions/kl.py b/numpyro/distributions/kl.py index ba30068f2..358c91cc9 100644 --- a/numpyro/distributions/kl.py +++ b/numpyro/distributions/kl.py @@ -25,8 +25,7 @@ # ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. -from functools import total_ordering -import warnings +from multipledispatch import dispatch from jax import lax import jax.numpy as jnp @@ -42,89 +41,12 @@ ) from numpyro.distributions.util import scale_and_mask, sum_rightmost -_KL_REGISTRY = ( - {} -) # Source of truth mapping a few general (type, type) pairs to functions. -_KL_MEMOIZE = ( - {} -) # Memoized version mapping many specific (type, type) pairs to functions. - - -def register_kl(type_p, type_q): - if not isinstance(type_p, type) and issubclass(type_p, Distribution): - raise TypeError( - "Expected type_p to be a Distribution subclass but got {}".format(type_p) - ) - if not isinstance(type_q, type) and issubclass(type_q, Distribution): - raise TypeError( - "Expected type_q to be a Distribution subclass but got {}".format(type_q) - ) - - def decorator(fun): - _KL_REGISTRY[type_p, type_q] = fun - _KL_MEMOIZE.clear() # reset since lookup order may have changed - return fun - - return decorator - - -@total_ordering -class _Match(object): - __slots__ = ["types"] - - def __init__(self, *types): - self.types = types - - def __eq__(self, other): - return self.types == other.types - - def __le__(self, other): - for x, y in zip(self.types, other.types): - if not issubclass(x, y): - return False - if x is not y: - break - return True - - -def _dispatch_kl(type_p, type_q): - """ - Find the most specific approximate match, assuming single inheritance. - """ - matches = [ - (super_p, super_q) - for super_p, super_q in _KL_REGISTRY - if issubclass(type_p, super_p) and issubclass(type_q, super_q) - ] - if not matches: - return NotImplemented - # Check that the left- and right- lexicographic orders agree. - left_p, left_q = min(_Match(*m) for m in matches).types - right_q, right_p = min(_Match(*reversed(m)) for m in matches).types - left_fun = _KL_REGISTRY[left_p, left_q] - right_fun = _KL_REGISTRY[right_p, right_q] - if left_fun is not right_fun: - warnings.warn( - "Ambiguous kl_divergence({}, {}). Please register_kl({}, {})".format( - type_p.__name__, type_q.__name__, left_p.__name__, right_q.__name__ - ), - RuntimeWarning, - ) - return left_fun - def kl_divergence(p, q): r""" Compute Kullback-Leibler divergence :math:`KL(p \| q)` between two distributions. """ - try: - fun = _KL_MEMOIZE[type(p), type(q)] - except KeyError: - fun = _dispatch_kl(type(p), type(q)) - _KL_MEMOIZE[type(p), type(q)] = fun - if fun is NotImplemented: - raise NotImplementedError - return fun(p, q) + raise NotImplementedError ################################################################################ @@ -132,34 +54,39 @@ def kl_divergence(p, q): ################################################################################ -@register_kl(Distribution, ExpandedDistribution) -def _kl_dist_expanded(p, q): +@dispatch(Distribution, ExpandedDistribution) +def kl_divergence(p, q): kl = kl_divergence(p, q.base_dist) shape = lax.broadcast_shapes(p.batch_shape, q.batch_shape) return jnp.broadcast_to(kl, shape) -@register_kl(ExpandedDistribution, Distribution) -def _kl_expanded(p, q): +@dispatch(ExpandedDistribution, Distribution) +def kl_divergence(p, q): kl = kl_divergence(p.base_dist, q) shape = lax.broadcast_shapes(p.batch_shape, q.batch_shape) return jnp.broadcast_to(kl, shape) -@register_kl(ExpandedDistribution, ExpandedDistribution) -def _kl_expanded_expanded(p, q): +@dispatch(ExpandedDistribution, ExpandedDistribution) +def kl_divergence(p, q): kl = kl_divergence(p.base_dist, q.base_dist) shape = lax.broadcast_shapes(p.batch_shape, q.batch_shape) return jnp.broadcast_to(kl, shape) -@register_kl(Delta, Distribution) -def _kl_delta(p, q): +@dispatch(Delta, Distribution) +def kl_divergence(p, q): return -q.log_prob(p.v) -@register_kl(Independent, Independent) -def _kl_independent_independent(p, q): +@dispatch(Delta, ExpandedDistribution) +def kl_divergence(p, q): + return -q.log_prob(p.v) + + +@dispatch(Independent, Independent) +def kl_divergence(p, q): shared_ndims = min(p.reinterpreted_batch_ndims, q.reinterpreted_batch_ndims) p_ndims = p.reinterpreted_batch_ndims - shared_ndims q_ndims = q.reinterpreted_batch_ndims - shared_ndims @@ -171,8 +98,8 @@ def _kl_independent_independent(p, q): return kl -@register_kl(MaskedDistribution, MaskedDistribution) -def _kl_masked_masked(p, q): +@dispatch(MaskedDistribution, MaskedDistribution) +def kl_divergence(p, q): if p._mask is False or q._mask is False: mask = False elif p._mask is True: @@ -192,15 +119,15 @@ def _kl_masked_masked(p, q): return scale_and_mask(kl, mask=mask) -@register_kl(Normal, Normal) -def _kl_normal_normal(p, q): +@dispatch(Normal, Normal) +def kl_divergence(p, q): var_ratio = jnp.square(p.scale / q.scale) t1 = jnp.square((p.loc - q.loc) / q.scale) return 0.5 * (var_ratio + t1 - 1 - jnp.log(var_ratio)) -@register_kl(Dirichlet, Dirichlet) -def _kl_dirichlet_dirichlet(p, q): +@dispatch(Dirichlet, Dirichlet) +def kl_divergence(p, q): # From http://bariskurt.com/kullback-leibler-divergence-between-two-dirichlet-and-beta-distributions/ sum_p_concentration = p.concentration.sum(-1) sum_q_concentration = q.concentration.sum(-1) diff --git a/setup.cfg b/setup.cfg index 2a47de391..51df4d534 100644 --- a/setup.cfg +++ b/setup.cfg @@ -2,6 +2,8 @@ max-line-length = 120 exclude = docs/src, build, dist, .ipynb_checkpoints ignore = W503,E203 +per-file-ignores = + numpyro/distributions/kl.py:F811 [isort] profile = black diff --git a/setup.py b/setup.py index eba486cb6..21bc8bb07 100644 --- a/setup.py +++ b/setup.py @@ -35,6 +35,8 @@ install_requires=[ f"jax{_jax_version_constraints}", f"jaxlib{_jaxlib_version_constraints}", + "multipledispatch", + "numpy", "tqdm", ], extras_require={ From fa75d6d383878c09ebb4ebc66acab032cd18ffca Mon Sep 17 00:00:00 2001 From: Du Phan Date: Mon, 13 Dec 2021 12:11:57 -0500 Subject: [PATCH 220/222] NeuTra - only reparam unobserved sites in the prototype trace (#1255) * Fix neutra reparam * attempt to make circula reparam test less flaky * revert unnecessary change --- numpyro/infer/reparam.py | 10 ++++++---- test/infer/test_reparam.py | 17 +++++++++++++++-- 2 files changed, 21 insertions(+), 6 deletions(-) diff --git a/numpyro/infer/reparam.py b/numpyro/infer/reparam.py index 290997465..107a5195d 100644 --- a/numpyro/infer/reparam.py +++ b/numpyro/infer/reparam.py @@ -235,10 +235,12 @@ def __init__(self, guide, params): self._x_unconstrained = {} def _reparam_config(self, site): - if site["name"] in self.guide.prototype_trace and not site.get( - "is_observed", False - ): - return self + if site["name"] in self.guide.prototype_trace: + # We only reparam if this is an unobserved site in the guide + # prototype trace. + guide_site = self.guide.prototype_trace[site["name"]] + if not guide_site.get("is_observed", False): + return self def reparam(self, fn=None): return numpyro.handlers.reparam(fn, config=self._reparam_config) diff --git a/test/infer/test_reparam.py b/test/infer/test_reparam.py index 144e62182..2a061b2c4 100644 --- a/test/infer/test_reparam.py +++ b/test/infer/test_reparam.py @@ -156,7 +156,7 @@ def neals_funnel(dim): def dirichlet_categorical(data): concentration = jnp.array([1.0, 1.0, 1.0]) p_latent = numpyro.sample("p", dist.Dirichlet(concentration)) - with numpyro.plate("N", data.shape[0]): + with numpyro.plate("N", data.shape[0] if data is not None else 10): numpyro.sample("obs", dist.Categorical(p_latent), obs=data) return p_latent @@ -190,7 +190,7 @@ def body_fn(i, val): "model, kwargs", [ (neals_funnel, {"dim": 10}), - (dirichlet_categorical, {"data": jnp.ones(10, dtype=jnp.int32)}), + (dirichlet_categorical, {"data": np.ones(10, dtype=np.int32)}), ], ) def test_reparam_log_joint(model, kwargs): @@ -212,6 +212,19 @@ def test_reparam_log_joint(model, kwargs): assert_allclose(pe_transformed, pe - log_det_jacobian, rtol=2e-7) +def test_neutra_reparam_unobserved_model(): + model = dirichlet_categorical + data = jnp.ones(10, dtype=jnp.int32) + guide = AutoIAFNormal(model) + svi = SVI(model, guide, Adam(1e-3), Trace_ELBO()) + svi_state = svi.init(random.PRNGKey(0), data) + params = svi.get_params(svi_state) + neutra = NeuTraReparam(guide, params) + reparam_model = neutra.reparam(model) + with handlers.seed(rng_seed=0): + reparam_model(data=None) + + @pytest.mark.parametrize("shape", [(), (4,), (3, 2)], ids=str) @pytest.mark.parametrize("centered", [0.0, 0.6, 1.0, None]) @pytest.mark.parametrize("dist_type", ["Normal", "StudentT"]) From a35e9254bfbf2a1a84138670f48bdc45c94f829e Mon Sep 17 00:00:00 2001 From: Du Phan Date: Wed, 15 Dec 2021 12:58:14 -0500 Subject: [PATCH 221/222] Add a warning for missing plate statements in the model (#1245) * Fix missing plate statement in the model * Point users to format_shapes utility * Fix failing tests * Fix remaining failing tests * Fix further tests * Fix a bug at AutoNormal that makes TraceMeanField test fail --- notebooks/source/bad_posterior_geometry.ipynb | 4 ++ numpyro/infer/autoguide.py | 2 +- numpyro/util.py | 30 +++++++++- test/contrib/test_optim.py | 6 +- test/infer/test_autoguide.py | 41 ++++++++----- test/infer/test_svi.py | 9 ++- test/test_util.py | 57 ++++++++++++------- 7 files changed, 103 insertions(+), 46 deletions(-) diff --git a/notebooks/source/bad_posterior_geometry.ipynb b/notebooks/source/bad_posterior_geometry.ipynb index 50a15ce95..4c970988b 100644 --- a/notebooks/source/bad_posterior_geometry.ipynb +++ b/notebooks/source/bad_posterior_geometry.ipynb @@ -141,9 +141,13 @@ "Instead of \n", "\n", "$$ \\beta \\sim {\\rm Normal}(0, \\lambda \\tau) $$\n", + "\n", "we write\n", + "\n", "$$ \\beta^\\prime \\sim {\\rm Normal}(0, 1) $$\n", + "\n", "and\n", + "\n", "$$ \\beta \\equiv \\lambda \\tau \\beta^\\prime $$\n", "\n", "where $\\beta$ is now defined *deterministically* in terms of $\\lambda$, $\\tau$,\n", diff --git a/numpyro/infer/autoguide.py b/numpyro/infer/autoguide.py index 40cbda8a7..57acf824a 100644 --- a/numpyro/infer/autoguide.py +++ b/numpyro/infer/autoguide.py @@ -306,7 +306,7 @@ def __call__(self, *args, **kwargs): site_fn = dist.Normal(site_loc, site_scale).to_event(event_dim) if site["fn"].support is constraints.real or ( isinstance(site["fn"].support, constraints.independent) - and site["fn"].support is constraints.real + and site["fn"].support.base_constraint is constraints.real ): result[name] = numpyro.sample(name, site_fn) else: diff --git a/numpyro/util.py b/numpyro/util.py index 33e638837..472fb3289 100644 --- a/numpyro/util.py +++ b/numpyro/util.py @@ -510,10 +510,8 @@ def model(*args, **kwargs): def check_model_guide_match(model_trace, guide_trace): """ - :param dict model_trace: The model trace to check. - :param dict guide_trace: The guide trace to check. - :raises: RuntimeWarning, ValueError Checks the following assumptions: + 1. Each sample site in the model also appears in the guide and is not marked auxiliary. 2. Each sample site in the guide either appears in the model or is marked, @@ -522,6 +520,10 @@ def check_model_guide_match(model_trace, guide_trace): appears in the model. 4. At each sample site that appears in both the model and guide, the model and guide agree on sample shape. + + :param dict model_trace: The model trace to check. + :param dict guide_trace: The guide trace to check. + :raises: RuntimeWarning, ValueError """ # Check ordinary sample sites. guide_vars = set( @@ -606,6 +608,28 @@ def check_model_guide_match(model_trace, guide_trace): ) ) + # Check if plate is missing in the model. + for name, site in model_trace.items(): + if site["type"] == "sample": + value_ndim = jnp.ndim(site["value"]) + batch_shape = lax.broadcast_shapes( + site["fn"].batch_shape, + jnp.shape(site["value"])[: value_ndim - len(site["fn"].event_shape)], + ) + plate_dims = set(f.dim for f in site["cond_indep_stack"]) + batch_ndim = len(batch_shape) + for i in range(batch_ndim): + dim = -i - 1 + if batch_shape[dim] > 1 and (dim not in plate_dims): + # Skip checking if it is the `scan` dimension. + if dim == -batch_ndim and site.get("_control_flow_done", False): + continue + warnings.warn( + f"Missing a plate statement for batch dimension {dim}" + f" at site '{name}'. You can use `numpyro.util.format_shapes`" + " utility to check shapes at all sites of your model." + ) + def _format_table(rows): """ diff --git a/test/contrib/test_optim.py b/test/contrib/test_optim.py index 294236b4b..7fb094dcd 100644 --- a/test/contrib/test_optim.py +++ b/test/contrib/test_optim.py @@ -69,7 +69,8 @@ def test_beta_bernoulli(elbo): def model(data): f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) - numpyro.sample("obs", dist.Bernoulli(f), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) @@ -100,7 +101,8 @@ def test_jitted_update_fn(): def model(data): f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) - numpyro.sample("obs", dist.Bernoulli(f), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) diff --git a/test/infer/test_autoguide.py b/test/infer/test_autoguide.py index 8116f0844..64425ee3d 100644 --- a/test/infer/test_autoguide.py +++ b/test/infer/test_autoguide.py @@ -69,10 +69,12 @@ ) def test_beta_bernoulli(auto_class): data = jnp.array([[1.0] * 8 + [0.0] * 2, [1.0] * 4 + [0.0] * 6]).T + N = len(data) def model(data): - f = numpyro.sample("beta", dist.Beta(jnp.ones(2), jnp.ones(2))) - numpyro.sample("obs", dist.Bernoulli(f), obs=data) + f = numpyro.sample("beta", dist.Beta(jnp.ones(2), jnp.ones(2)).to_event()) + with numpyro.plate("N", N): + numpyro.sample("obs", dist.Bernoulli(f).to_event(1), obs=data) adam = optim.Adam(0.01) if auto_class == AutoDAIS: @@ -104,12 +106,12 @@ def body_fn(i, val): # Predictive can be instantiated from posterior samples... predictive = Predictive(model, posterior_samples=posterior_samples) predictive_samples = predictive(random.PRNGKey(1), None) - assert predictive_samples["obs"].shape == (1000, 2) + assert predictive_samples["obs"].shape == (1000, N, 2) # ... or from the guide + params predictive = Predictive(model, guide=guide, params=params, num_samples=1000) predictive_samples = predictive(random.PRNGKey(1), None) - assert predictive_samples["obs"].shape == (1000, 2) + assert predictive_samples["obs"].shape == (1000, N, 2) @pytest.mark.parametrize( @@ -135,9 +137,10 @@ def test_logistic_regression(auto_class, Elbo): labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) def model(data, labels): - coefs = numpyro.sample("coefs", dist.Normal(jnp.zeros(dim), jnp.ones(dim))) + coefs = numpyro.sample("coefs", dist.Normal(0, 1).expand([dim]).to_event()) logits = numpyro.deterministic("logits", jnp.sum(coefs * data, axis=-1)) - return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) + with numpyro.plate("N", len(data)): + return numpyro.sample("obs", dist.Bernoulli(logits=logits), obs=labels) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -242,7 +245,8 @@ def model(data): dist.Uniform(0, 1), transforms.AffineTransform(0, alpha) ), ) - numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -317,12 +321,14 @@ def actual_model(data): dist.Uniform(0, 1), transforms.AffineTransform(0, alpha) ), ) - numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) def expected_model(data): alpha = numpyro.sample("alpha", dist.Uniform(0, 1)) loc = numpyro.sample("loc", dist.Uniform(0, 1)) * alpha - numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Normal(loc, 0.1), obs=data) adam = optim.Adam(0.01) rng_key_init = random.PRNGKey(1) @@ -355,9 +361,10 @@ def expected_model(data): def test_laplace_approximation_warning(): def model(x, y): a = numpyro.sample("a", dist.Normal(0, 10)) - b = numpyro.sample("b", dist.Normal(0, 10), sample_shape=(3,)) + b = numpyro.sample("b", dist.Normal(0, 10).expand([3]).to_event()) mu = a + b[0] * x + b[1] * x ** 2 + b[2] * x ** 3 - numpyro.sample("y", dist.Normal(mu, 0.001), obs=y) + with numpyro.plate("N", len(x)): + numpyro.sample("y", dist.Normal(mu, 0.001), obs=y) x = random.normal(random.PRNGKey(0), (3,)) y = 1 + 2 * x + 3 * x ** 2 + 4 * x ** 3 @@ -375,7 +382,8 @@ def model(x, y): a = numpyro.sample("a", dist.Normal(0, 10)) b = numpyro.sample("b", dist.Normal(0, 10)) mu = a + b * x - numpyro.sample("y", dist.Normal(mu, 1), obs=y) + with numpyro.plate("N", len(x)): + numpyro.sample("y", dist.Normal(mu, 1), obs=y) x = random.normal(random.PRNGKey(0), (100,)) y = 1 + 2 * x @@ -401,7 +409,8 @@ def model(y): "sigma", dist.ImproperUniform(dist.constraints.positive, (), ()) ) mu = numpyro.deterministic("mu", lambda1 + lambda2) - numpyro.sample("y", dist.Normal(mu, sigma), obs=y) + with numpyro.plate("N", len(y)): + numpyro.sample("y", dist.Normal(mu, sigma), obs=y) guide = AutoDiagonalNormal(model) svi = SVI(model, guide, optim.Adam(0.003), Trace_ELBO(), y=y) @@ -417,7 +426,8 @@ def model(x, y): nn = numpyro.module("nn", Dense(1), (10,)) mu = nn(x).squeeze(-1) sigma = numpyro.sample("sigma", dist.HalfNormal(1)) - numpyro.sample("y", dist.Normal(mu, sigma), obs=y) + with numpyro.plate("N", len(y)): + numpyro.sample("y", dist.Normal(mu, sigma), obs=y) guide = AutoDiagonalNormal(model) svi = SVI(model, guide, optim.Adam(0.003), Trace_ELBO(), x=x, y=y) @@ -497,7 +507,8 @@ def model(y=None): mu = numpyro.sample("mu", dist.Normal(0, 5)) sigma = numpyro.param("sigma", 1, constraint=constraints.positive) - y = numpyro.sample("y", dist.Normal(mu, sigma).expand((n,)), obs=y) + with numpyro.plate("N", len(y)): + y = numpyro.sample("y", dist.Normal(mu, sigma).expand((n,)), obs=y) numpyro.deterministic("z", (y - mu) / sigma) mu, sigma = 2, 3 diff --git a/test/infer/test_svi.py b/test/infer/test_svi.py index 202fa90a2..add240db3 100644 --- a/test/infer/test_svi.py +++ b/test/infer/test_svi.py @@ -63,7 +63,8 @@ def test_beta_bernoulli(elbo, optimizer): def model(data): f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) - numpyro.sample("obs", dist.Bernoulli(f), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) @@ -94,7 +95,8 @@ def test_run(progress_bar): def model(data): f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) - numpyro.sample("obs", dist.Bernoulli(f), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): alpha_q = numpyro.param( @@ -124,7 +126,8 @@ def test_jitted_update_fn(): def model(data): f = numpyro.sample("beta", dist.Beta(1.0, 1.0)) - numpyro.sample("obs", dist.Bernoulli(f), obs=data) + with numpyro.plate("N", len(data)): + numpyro.sample("obs", dist.Bernoulli(f), obs=data) def guide(data): alpha_q = numpyro.param("alpha_q", 1.0, constraint=constraints.positive) diff --git a/test/test_util.py b/test/test_util.py index 5a0b05207..b257ef26e 100644 --- a/test/test_util.py +++ b/test/test_util.py @@ -170,28 +170,27 @@ def model_test(): ) -def test_check_model_guide_match(): - def _run_svi(model, guide): +def _run_svi_check_warnings(model, guide, expected_string): + with pytest.warns(UserWarning, match=expected_string) as ws: adam = numpyro.optim.Adam(1e-3) svi = numpyro.infer.SVI(model, guide, adam, numpyro.infer.Trace_ELBO()) - svi.run(random.PRNGKey(42), num_steps=50) - - def _run_svi_check_warnings(model, guide, expected_string): - with pytest.warns(UserWarning, match=expected_string) as ws: - _run_svi(model, guide) - assert len(ws) == 1 - assert expected_string in str(ws[0].message) - - def _create_traces_check_error_string(model, guide, expected_string): - model_trace = numpyro.handlers.trace( - numpyro.handlers.seed(model, rng_seed=42) - ).get_trace() - guide_trace = numpyro.handlers.trace( - numpyro.handlers.seed(guide, rng_seed=42) - ).get_trace() - with pytest.raises(ValueError, match=expected_string): - check_model_guide_match(model_trace, guide_trace) + svi.run(random.PRNGKey(42), num_steps=5) + assert len(ws) == 1 + assert expected_string in str(ws[0].message) + + +def _create_traces_check_error_string(model, guide, expected_string): + model_trace = numpyro.handlers.trace( + numpyro.handlers.seed(model, rng_seed=42) + ).get_trace() + guide_trace = numpyro.handlers.trace( + numpyro.handlers.seed(guide, rng_seed=42) + ).get_trace() + with pytest.raises(ValueError, match=expected_string): + check_model_guide_match(model_trace, guide_trace) + +def test_check_model_guide_match(): # 1. Auxiliary vars in the model def model(): numpyro.sample("x", dist.Normal()) @@ -236,7 +235,9 @@ def guide(): # 5. Check shapes agree def model(): - numpyro.sample("x", dist.Normal().expand((3, 2))) + with numpyro.plate("a", 3, dim=-2): + with numpyro.plate("b", 2, dim=-1): + numpyro.sample("x", dist.Normal().expand((3, 2))) def guide(): numpyro.sample("x", dist.Normal().expand((3, 5))) @@ -245,12 +246,24 @@ def guide(): # 6. Check subsample sites introduced by plate def model(): - numpyro.sample("x", dist.Normal().expand((10,))) + with numpyro.plate("a", 10): + numpyro.sample("x", dist.Normal().expand((10,))) def guide(): - with numpyro.handlers.plate("data", 100, subsample_size=10): + with numpyro.plate("data", 100, subsample_size=10): numpyro.sample("x", dist.Normal()) _run_svi_check_warnings( model, guide, "Found plate statements in guide but not model" ) + + +def test_missing_plate_in_model(): + def model(): + x = numpyro.sample("x", dist.Normal(0, 1)) + numpyro.sample("obs", dist.Normal(x, 1), obs=jnp.ones(10)) + + def guide(): + numpyro.sample("x", dist.Normal(0, 1)) + + _run_svi_check_warnings(model, guide, "Missing a plate statement") From de22e7143c9792fe14e6c6d6647a9cb66d71f956 Mon Sep 17 00:00:00 2001 From: Carlosbogo <84228424+Carlosbogo@users.noreply.github.com> Date: Thu, 16 Dec 2021 07:15:37 +0100 Subject: [PATCH 222/222] Allow prior to be a callable in random module (#1227) * Solves #1224 Allows prior to be a user defined function in random module * Changes to #1227 Fixed a mistake in #1227 and added the new funcionality to the docstrings. * Changes to #1227 Added the requested changes to #1227 and a test for the new functionality, namely `test_random_module_mcmc_callable`. * Allow prior to be a callable in random module. Fixes PR #1227 Added the changes mentioned by @fehiepsi to PR #1227 in `test_module`. * Update to PR #1227 Added the changes proposed by @fehiepsi to PR #1227 in order to fix the errors present in it. * Allow prior to be a callable. Changes to PR #1227 Fixes the errors spotted by @fehiepsi in my previous commits for PR #1227. * Run black * Make sure that callable prior is not a distribution Co-authored-by: Du Phan --- numpyro/contrib/module.py | 22 +++++++++++++++++++--- test/contrib/test_module.py | 17 ++++++++++------- 2 files changed, 29 insertions(+), 10 deletions(-) diff --git a/numpyro/contrib/module.py b/numpyro/contrib/module.py index b6f5114bc..17b7c8ad5 100644 --- a/numpyro/contrib/module.py +++ b/numpyro/contrib/module.py @@ -10,6 +10,7 @@ from jax.tree_util import register_pytree_node, tree_flatten, tree_unflatten import numpyro +import numpyro.distributions as dist from numpyro.primitives import mutable as numpyro_mutable __all__ = [ @@ -223,12 +224,17 @@ def _update_params(params, new_params, prior, prefix=""): new_item = new_params[name] _update_params(item, new_item, prior, prefix=flatten_name) elif (not isinstance(prior, dict)) or flatten_name in prior: - d = prior[flatten_name] if isinstance(prior, dict) else prior if isinstance(params[name], ParamShape): param_shape = params[name].shape else: param_shape = jnp.shape(params[name]) params[name] = ParamShape(param_shape) + if isinstance(prior, dict): + d = prior[flatten_name] + elif callable(prior) and not isinstance(prior, dist.Distribution): + d = prior(flatten_name, param_shape) + else: + d = prior param_batch_shape = param_shape[: len(param_shape) - d.event_dim] # XXX: here we set all dimensions of prior to event dimensions. new_params[name] = numpyro.sample( @@ -270,7 +276,12 @@ def __call__(self, x): prior={"bias": dist.Cauchy(), "kernel": dist.Normal()}, input_shape=(4,)) - :type prior: dict or ~numpyro.distributions.Distribution + Alternatively, we can use a callable. For example the following are equivalent:: + + prior=(lambda name, shape: dist.Cauchy() if name == "bias" else dist.Normal()) + prior={"bias": dist.Cauchy(), "kernel": dist.Normal()} + + :type prior: dict, ~numpyro.distributions.Distribution or callable :param tuple input_shape: shape of the input taken by the neural network. :param list apply_rng: A list to indicate which extra rng _kinds_ are needed for ``nn_module``. For example, when ``nn_module`` includes dropout layers, we @@ -374,7 +385,12 @@ def random_haiku_module( prior={"linear.b": dist.Cauchy(), "linear.w": dist.Normal()}, input_shape=(4,)) - :type prior: dict or ~numpyro.distributions.Distribution + Alternatively, we can use a callable. For example the following are equivalent:: + + prior=(lambda name, shape: dist.Cauchy() if name.startswith("b") else dist.Normal()) + prior={"bias": dist.Cauchy(), "kernel": dist.Normal()} + + :type prior: dict, ~numpyro.distributions.Distribution or callable :param tuple input_shape: shape of the input taken by the neural network. :param bool apply_rng: A flag to indicate if the returned callable requires an rng argument (e.g. when ``nn_module`` includes dropout layers). Defaults diff --git a/test/contrib/test_module.py b/test/contrib/test_module.py index 62ef56869..140e59994 100644 --- a/test/contrib/test_module.py +++ b/test/contrib/test_module.py @@ -148,7 +148,8 @@ def test_update_params(): @pytest.mark.parametrize("backend", ["flax", "haiku"]) @pytest.mark.parametrize("init", ["shape", "kwargs"]) -def test_random_module_mcmc(backend, init): +@pytest.mark.parametrize("callable_prior", [True, False]) +def test_random_module_mcmc(backend, init, callable_prior): if backend == "flax": import flax @@ -179,13 +180,15 @@ def test_random_module_mcmc(backend, init): elif init == "kwargs": kwargs = {kwargs_name: data} - def model(data, labels): - nn = random_module( - "nn", - linear_module, - {bias_name: dist.Cauchy(), weight_name: dist.Normal()}, - **kwargs + if callable_prior: + prior = ( + lambda name, shape: dist.Cauchy() if name == bias_name else dist.Normal() ) + else: + prior = {bias_name: dist.Cauchy(), weight_name: dist.Normal()} + + def model(data, labels): + nn = random_module("nn", linear_module, prior=prior, **kwargs) logits = nn(data).squeeze(-1) numpyro.sample("y", dist.Bernoulli(logits=logits), obs=labels)

    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 L+9yOHZx8+dj{y;XQ%N zplA7pP7OU9iU9#n5b1homUR>ni(xtWvt2k8=ca{*XMzIikGF%;WP3v1NbSN~5B)J# zI(RfmQOizI#8b(>O4VdusU9G$Y{||8u~7T~BV>R_`1i z!xBPIs!-B5QsVMAyGvQ(rtUQRjT~VkiqeXBd03F;A?$u95v}%vB54~skxtd{6$9tO_WSg z&q|EwjO1febvvnodx>K6AP8tU*QA975TU8564S}fWn-Do!=uEP_wPGMYL4yE*M;X+ zTm`}wIhbEAJ;@^(idlA!z)!0YijSr=m$t_87~K!e52H?G zB11ocWr)e|#`19X%Ip=TiKo|jhYAFZm~HmeE|g!$_!==8Od5m%-h$L#zLOUr89?Qm zkYZaViK~}|o62z_^UZg|BeA4qUz&!1=Ex@~x)BXv3xD3eNBd+ztrdzE*BP90O&RUw<15jYrfnAcrW=|Zf1PoRj)pQ3DHvv+sx(pi4Nc|E_dC1 ztGzM5BAer5<3lXaFq-JFCr|C(xO_NZT4l#xq4g+dur+I*=mQBE3sm%q9&ILKud0!= zGsDWW$e==@c8{#3y0aYI7fn)y0jB|yWt@SG>CTyViJD3P9teRGw74f{F(80Dl9MI> zT*P~JHPul%`=?8}Jhs|V57js@r7dRZjUHAV4m4ONu;nzNtqSTOblJ2&lwC?I+7U#F zqhQ$c`8wF8LqvXC%Ev(R<8EE7_x>v`JhrXyylt)dk%qqbWvYMBj}!kH^rV)2rg{>c z1g1%L0H=GlO-5pMP#Mw<0hHAbf)kHyzv<2HrhOl3wx!&YE)6U$hxe)q zRngU!{&;18zHQuno+PeQKHW1R5LLrLr0n`QoOFJXGQYM&6Sj#DT!@;TW%$j`%sUV*+c07;*XNSeUVka z;D5R)y7g-ZrG39%V0%P%tt0ece6-Csi5<{shWWMjMZYO1QKMDpFt-NM`Mo@vuz%5_ zwG`u(cXm$)tOL2T z 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≫UTW#aVY5=*(9SZW4gI@&PP24&8LF!B z{_a!UX?R^dyKx6k-n$A(lGwJtg09{H*50&;!`*YQ&X z!T$bi{Qj}$@F~t-yn@4K<>?27FWt_ACpmrLG7g)SXCB|c^BcF()i+2^MhXQv8Jw=F z!)i8TvDxSy9403-nG+Z44K|CHcw8ktC4p#6B{j)MEUw~pJ5f~~mtov4%c8?zFsdP& z6k@85*=#VfkdbADh$j56G#xA^!2~oJK3H)KDWPFGkSN6oNhYRfeVjIn=0SJ09OPG1 z?k1|3nca1PCoA7#f8GNA`|@wl<4huBw1fWVR8mYw*=8`VN$&V3=Sn?8ce1? z3Kj)MVlfpE#}Gw9&9D}XL6AaqFeI?;8FX+@dz_G{Sm za%wJF028{dqDB))u`l541r=R)QIu6eLu(90%OF2(Aunv~B0M^cMYHCzZEqvZZ7L3H zD$D21LseDw9NCGgCh*YuyT+OD{R4j9-YS@mUwHV_*;hY*=^gs|{Y)sx?>38HL-vVFTce#0{_(tY$+JYj`h> z)oaFncC1(u(!}*988je8icl?y7=Dq~!+WwI1l%fh5>_mHf9l=DWQBP>m$^u3|*tbPq8ngk>D^f6xK*~SqMbp zWF$F>YeG_}>-xAvx2ZRT+iu}Bb*){LmlU8VGTRTGrDQ@bi9R=t zt=)Wd;51L)FY=G)-`GYZ665pt--g3(<9v19xFpo+uyfCC!lq!1<^GBB8Gv||%8UiX@FRacC~a}~fkdgda!t~0qf7q8oieeIj2Xma zg_1xIkGCD?7Z={-do}O#NLvL@v>xN>mLojVc!2L$zsnP?$8g0XG&z#^`;uGPm^lk` zVgi$tAh()?Y3}PWalhu71Z%3oZ=%2euzF%L0TrAE_5D*BSQd$a5wUS3d2FJ0f{VNM!~EMEn%4F9X@Isvkj6<_tgs;U+DwtQm2wcqE(T6A5fC@%}2 z$Mxy#tD^#toIiUCR_mWfN4BYx{xARwVA2>{tM*#9R&l<#=XH%&0j#225v0@`-&203 z0I(WbyD7@e9tW^;3;?UCdzkDb0a~^71;{Z>%Ol3T=nce4bcn-2GN|JrgCG>s1z;r( z6d^xV& zl%AN090!;rIN2FxR+a?~kQ5mixY(Sw2T3A8+qC!A%QAcf!}V9^&!4gq-8&uWe()s>OKS4jNm#*ngsu8yC+c zKPMgkNPu^?32?+@Quy5cqEhngYwusfsQ7Gr`nYtZi6Q?8MS0oWxb*s+Yv0>(h_=pN zk`ujbFua2R4xBho)#WA}HY*RU6O4uz-w{&JnPn50JFS$L-`z_f6lU^-T;@%k$m?4~ zW&QEHR`ALe;ft|ydM^9Uw-b!UDbG)$u4{x~B+kTiH?_TCf>DiO! zA5;o3>+TsTynfU$Z(ml->w7N~j;c&4NTxW`$L2%gynXz(Ib5jg;^c)Zm`n-}uU$bP z80H1TNdGS$y#ra6>FFQh)lCBA`ok>EQguT6SE=hXTN1xADjZqk8({rfYz%rysl>Ns{MAq!KHl?+BIVQ7ACMXB=XhEsvaC?kHcWb= zi@u>zW=s<2dQDR&30^1lZQV>S6EV`;+mEtg)k0)hX6KQ!NRrIlX%kUZjo04Wi^XE* z{yT)6_SbKIH2%FmcF(OylEjYvC+O_y`^232Op5;dhpy}V==rxqTz~f(k`leBn#TWn zR+w3T?%p*>lEm|G2$1j_Pu;^$UlTy_hBb?LbDJoDWT&MP3`dz*kj2INc1$J{-GigZ zicG&h2(rvjAcDzcVl=E`v6zUd+Eu_xmqAvDsbDdg&?PV_GDs3JT|yr3ItWo+!es&# zi8PB&Kvzg3LXYgkqemE#9Yj%>6Kr8;>MVvWE=mR(`P#`BcxB36{B-u?L=`i0JI?X% zd%jEF@F%5ZE1E>{|48l}qW~h)XGnpQ!hXV$I4!b}9EUIw8upMxfJU1WbcxZZn0p>u z0NEPE>i3|>%p_O=S;emCpo2xy0G*i8DSJ#A(qs50^$&-znPnQgM?~SZcL-UM=pPCY z3ufW8Bp_RRn2>9yzO4&%GjVm4c-+pcNqIE1)dCu`rlwO-d7eNpPHI9r#kpC0u=@g< z>S4k3Wdwo__8mJ%cYiNlmz!H}xGEp~^&49WN1{wGo5=i`W!IfYt?gaBVtAc?`!65= zqsm>V2Q z1PtJ6>@jBKAQNml)d1}*@@z-hgWbn_YU*fiwWJ#jS zAH!l+=<-MKxGePeBV;7I2}R;e%n{)6#l|iib}LnN?cB6Tc!U4u!^5mM8oK=8#rLnO zLSEg<9XHM=GcAeU0YC5UIzoci#eH{(xcK8NtVix%EsFBT&(UDylmBV3^#7Seq^=1N zlBw&p!S3!GpuMXXMUk00`Kpi7@iWx|+?Xj606am%zRBa~s)@%{iu1F`%}iyV(I$2E zve_Izf0?d<5qwT7swOco5+*&-$xtXpG_EqED1|*|M8$aRlw>}r64mk>N_|}D9K~e< zr%7QbCQ*6xd>L`ScCPZTs(_f+%Ki*Ivt?-mWtk)y5aUB+KIl-AE*@0b8Z|zEsOz|%%AyZ zGvB9{6_3yR-zOOxW2c?2ynM~;rG~t)v9)uY$x~|3c*nkni3T&SrmmIT%w+6VGoeTv z2_2h7ArOvXHBN=v_91c&Hr9x7sC4+FqVfgAj9|Pgri?TC#u!*3g90AXuWnfy5Hhwf zhZ?2VDh`s|zyMXgTr^2$%1|pM!&f)QjRi}&;>pAn3-P7P+xWrBU-S2sZ}3db7Vc|0 zggX|Z(VfOOXFbL{d5bXb+riJ>O=J+F5hwp5mGSpnLI&RI^RPa76h+cG;CFI+ikQ<4 zgW$2rGz@CY%(kKHIvzuZU)K}FZZT2c9iTMZMt*3^U9akllC>5od}Dp78?`gtvq zLlXT4?tR;S4^Oz2$Eti*K* zpQMuMv2&z5VgOhg2Mqb(@>JN}(2J@I`Cx5NfZov0zLS@jTb6I!-w28#)7&#kNtP&vsG7(o+WJM8 zuPp!aZ4$tEC~$q4qb zxT}(8cRD|rem|Ndv9h&-XZQXq|91E%Y^d8q-bg1!!)@Hry_*}_PO+|jKWi&bVAkUF z+I)O}(S58Qz!BPTC#v98^did7yUr?DknXSb)BI_CtRc+=Q$9{o59=h&*DeV{MUAHUISj#dEJ`v|< z270N`JZM0UI?Mqn7cFKcR~ckfH{sTyDJnis+pq^MZlN!1M^{bs2Q(yEr9UXTMfV0& zEGCK3P#l+4Askala+*<94UbI$U8gX`L0r{H_Sn&NjTsZOXlxB*CW)@0227?f4qKRL zD3kQ$1iA*=u-g1gE-K($?RiY5AWuG!$VW$C#^Siby4AVVwOydQ{|YW=l-0{8BgV=~J(}VbN@4S>{4bJ>7i+_-`}c}Ncp@RbYi@STe1 z`R2LT_;S@|9=NiLwBP^(HV@BDUdvxD{wfnkI(XvpN65OyuIyRJvP9u%7eiPGNmjB6 z(vOu~S;SHUaRs}q(;GMAHN#+BA=w6@xK66eLR8gBb&IZqDIP1ju9N7tUsF^c3dRA6 zbB%-KrF$6~2~s{m z@%o3Tn#SkvzfIT{oU5VgvdA5Cv(mU>(JXXbXXACec|QZNJ`P|R33utI$p?*Yb(1FK zU1QdI%mA@-L)d|U6-Zvez#aqcV()4)C~%-#2Vz?XaX|uZCeN53*|B@nJ5kP z@a_6N{33rbTT{!?C5e@Nm-$ikCKe6~P^Z)8V|VIgeo}NJ|6F=I8?)zf&YMF>xteIX z;}M=}Il_wmS~N-GCweAvB#PuPMRJIkE^#R4p~SHFXbvd^Rf#mKp}UQla2QB$FshGt z02s^8qd=b9OG?j3o=uvGyJb6mllHxL>YC1l<2$)8UtfMX^ zW5H7XcE-bmE35dqQb__)YVfjC%HUB++|yrnr?5Ur%-_>NCk3`R17VHwRI$FA{5n=e z;>tjr!el$as7kSskc~CZy3{^`*I}WdV}Lnj;{Fbfgi&Ofqvz{by;xK|b{wf>=A;55 zu^8{|so>5VjgF{W5AewPn+#8r8ZKUGX8r1=B>3F4w0E=X;3*@qv9jLi6!pe?yFbe$ z{(un*M@UaiX6>qF*M0xw`5Nk)+HkuZJhc9n@z?8HIyiQw8by(L;$FdG`C#{PhDQSw zzm-DW&CGwuE;Np=$xoI0n6WGu4IWBD;&Zy#gv4iMF4Hbq5(@OgVL{dMhx zba*FC1dI1|p2P85jX3_0F$NQ;9}6kEEh3@LlEv?blrYiB>N)wmxlf$KkKQ_qw!R=A z9XyRBNj!1)%>=`d@y>%^e&h}mS*ESCmp8VEW-DKR>fUS4gC9I6ylEc0_g0b(CeUw> zpS}1tef@rl^0Iko!9qc@p=6pFJ7C3JpG_BVtxC= z{qzp_ktB%+4Iur+cXlF45*t>Dmhf+HKg=zQr=ut`XKNa9+N>n`+zbao=(>i}Zl$Z= zPi~rEs2;7XXL5l!^Ie9+a<5+`zKz`h(u_`oi7pW@nGNk=T)o!2Bx=abWnfS>AzLC$ zEchizd_NN+V#lk=s7VEiK1L3l0!gth_w=Rt5_c)>z-eUf9TmiFR%_iGp0K>?K8y z(RO7fT6+PKDTc+@hsE26YK{`_Dx%}ke9+8{#Dt;ta6~d55#B}-BmNqWBFhpj{UIzC zg@*1?GLpOu3U=Ksxi4JmxlIU9CjORJwqrag^vDVWLd!Ni+0GG|joo;8~R z4wwa)H9y|Q0dtPQgb|-F-5f*(l9U*ch!tl{_{X`;pz0cK&4n6r;8o0kWB}eesuo8A zMnmF^8V*JhW69k)v%wR z9R4v+)@;ES8Kujf$PcF8OT90LuUEZ;MU8VNc_J2FCp|nwo8-hTOIXlolw9OXVZyqE z*8t_j*(Wien#CLr3Ds9mP{U%9=^oXvnN4*0BX}KF`i3K9B)SMj;^d`!P&Eyo;aObW z*d+?-E#1tUD)Q;KcAQ|{jiMO%`iF;jY`sv0{N$Anxc9bYB>FtGw0E=pz)8}Q6IioC zNY-E3eDy53|4vaf*}QH4Cp?%x1F$|e#*+Aw33=Cj|4fx&pUfz~3SxBk4bs%wg(Az$ zGJLU4oEO*4n^sCgOBZcj{aDRrrj+KfNZ+1D+by#B?=H;*e0-mt-uu0FPM^ng*`1xkT zK7LxTjMLs+tXiCJ)$Qbq&4bQGaivLo&fThyl)`+{t*YpP5Ku@rx({~S({UPj zSRkqqGpe~JMIsP20!dXv*L4(GCKM59gvViFG#DiqiJ{0cnJEe509J8c2A#cw1Va%_ zCWV}gWP+i{IG{Dz_#Q9Sw-AlSNbtGIOiQ}vJH2pOfQZv3P59J#aiy^p|8M|@-A2iT zfkl!aGoISM^tHnZRPaiF9UDv!f!vO!zUKGD0J3X27kV?qA9YBOK0*@7z`rp}YeKc_6kq1gGMeijoNJERN>bL>{b(vJwb}nJ%nQ_6LUoH*3vzMBFh}FYGB@! z2}b2q$6>Q@{&F)*<_IAD)h!3vutp?@+Yg;VlBDsjYA?LC1H0A2LwAY;<(I#?+HLIq zbvKEC;_%69s$HLrPahj@UwMtM)yK!?Z3jfrV&$T147}gkA`*}l3ucVB#eVxEA?LjJ zw&lpO%%&ZpyX`%zmoVTTrJ}M9Ns_pI*>v98Evk<9ubjlDBVw+uUsS~VCj@}MwmgB& z=f(H8ZdxL5pBMA|t}K-|+C>0!Yr00=s6tCf!Y!$+vW)P4%*TkXkSj--<#Q9Nz08Lx zlkuBuWJHF!p}+3`=pIE3>7Y%&n$UJQ#2U;o0IZ8KqhfE0a6TfV>X7HqQ4G*p2BsEg zaH2^7!Yd|vI9MzGuA3(%vZX>4W!5ez;=^O&p4>jakTX}hY3}mlvYWZ><`ulSc{i%6 zv1ImSN(-}j?cF^L42_VNoyzSuh#=}GFK!|hi?eu6IrC>+HNM@l>j;UhbBqv zP%@aQjGzI%gSo_eGKjeYxNQOAMq(|Q!?=8Xga+Rm#p1lV z^$-u;DP)5$yuA}$*Lm{3+YE24<8*Y31a#%1*`%i=(m&v5*TIvY9T5MCQQOeUp%dp( z6nR{pyM2EJwGFMfoemyacN4E{-pxoLNNG_Hqv0qu_2RvO;SjNy%KWJ%96l$CuKgpT z_?@02;)eu}TgYv_E`$-g1W1HqIJpM9 zGoqQW$uO*$a4O(e6%vWkpd=!pqe~{@lFSXk22P|;L6c+_x1XY{ua@VhJ;0F7L-ued z_tb3pz4xZqF4kXKP)Jh;tv=e_=_tC&EN7G>CIK*8bd`t#*`@(5sp4n)GzqiEkI6ZN zY!9Nw6(m_hl?-5N#EKg9(9xMdY$%hyPA{fdB7tEmZi|&jEN-x`H1d<}#NsN+UI&`4 zF{LPj*6w~>4l~{TeiTV!Xh=cRprlA;Bz6+BStl(qk=Cv@Jl;mW^hg13Y!mG2zj^u| z_8k9!kzfyro?>oUJfDv4ezxv8j;8v!@3xznRH|XI=zO^QDEp6{!D2D<4}bNZ&s*V|x1%P$FrjgPjF*hzXwozt0?;R8%WJli+IYwb*jB({KfGd+B9W;-5 z>>ABK#-xN}g^@9Dt+6h*V*r*K6Z0#T2sMVhwOAkKeMRJwH+P((+mXmSMWS&0VC_zx zx$rh-?UTTN&}2iCC04f_=Vyn$&;50~QFM*{nKRg(J(s^Z|2mF%m`lD~@&bK0v=}v# zmkE*~o0OfnC6%tIOu9`cq{(F1bTl1&Rta6#aT`hy`Je`bXIQF%PuQ0Ic5{V-mvB3HjFtunY#)jE~99 zD$WUsLV0Nc9+#7$;Q*H#+K?oPxzkEGWU#O1Oq;-|%FB!dBV;GL>GMa3##JWeCUN?T zV1TTgmdmztLdsN{=A>sNPKMXanGS&x-;t@auTMddpu_{0Ms$3VN*EKP$V^j$_+*{q zQ9Cv*&R;j~=jEJvoc88m)#Ch3-7aSNTd8-Z^4H~evpubh0gDrprcxRo=AO2bJl%AV zWqq}zg@@53iF#)W|5~z|7KfJKXld_eU~m|V#mvOQoKKw>r;TnpGp3aO|Jr`` z|BEpuBRqTI^6$LPYPB%EOn@avPhZ=WYQ_}tJ5Cw_6TozXC3Ld#GA5Hk`9uL)ovNy1 zssUh~uIpoNi8xqKTKb5Li8v_C2KE2LL+7}C`7BXk zs&6MJJ&A##5o+q&nORmuJg%~7`%#{_M+C%M_nlzSKf=T7Z^3FYQ(03#&Ri_Y%VN&7 zNvNvEd)p6wmQnlxvVT)1a zzOU>2b)|!PMh*i7Wwh8+&XUxc-#C!HtiRC(`^eU zpdAY?KW{v)@}pk~ADX8hzVlOk z6aV!mFA|N$SU6|epM2Na2iC75H#>vwz5!l&bIYez$nUvbcv$@GrE6JOpEo)Xy}EfP z!B7~N!_Hd68{_3oJIPK@V&1fgXqv{R9Y?wER^f~F_KsuRyl{$0;18c;xdE;mJ9mX? z6SC2D9V55kO2;rZi^5PaMnQ@wdWlM@SA0(&(VT+S|e>?Zo?qJbq zJ&9TmW?e;%*l2U7@lnAdLS{SPKm0@TMmia=c{rb1%8Jf2=t!I;fqX^@3?*X*WK)y? zX0)J(kr5we86uK~Sy374Ps468F%l8duHmSTtSIyah1Y0bAciDMv=2s6WQFFwAXc-P zrk+u9(-Ig7hR3^fHFpoxZ)mDlcH3Ev#ukcYb@QN*6E_0g<&aS~%< z-D#?mCSX@1JW};8$FgQ|BxeqauJX*u7ci@FbXi6%E~m|#NpJQ<@c6E|H|=h5KT<;i zz`B?$V$b5iW*WVj49YfqdW6%8VdU;;Bd*INsXBwI38x%qKnIhgGZM1kaE%htBRH*b zbc-L4GXj!|(;}m*7PN?+crbzCzEq;a+4T4N&|?YIw`%CR!oc7Nk|fd9E39795+#tL zOv)?aQe6;5kx->pOx8~BTI1t2U(V5a0dDO8|WNvAZb9{Uk7@>s|S%q5uFO07*na zR65`K&QA#hL(H31&V%b$|IyF+2aP5}Z@jnbQ>E%F4Iiwdr!I`!l>jU?SXc)uL_u%N z$o*vHWs37NaoTMJLSZ722tK!iSWG3!C#(x+Ek>}Z-!X0p$i%aV~p828ioJY&p2 zSs62FA7fzY*StRlV2w!#jbn#o!qiG4CzT`^kgOz0QD*hl@?q{mR7qh*Z!PN^MZq&B zE9}jl!>=db$v@3~il3uE_4Or`XN?$|f*%QW4Q;jJH4BKfbrzdxrqJHoo_tKTG~- zGxpKZQ5qT=2m}KE<=-_j8lcmt9+eb*l7SVEt5nxE8VlrVfPUHlwPsHhtgMRjm(Vng z3AvdhC3rY|N&r}kXO@k7%B-A~&!G##pm61kT(+DLzqcU8%}^*#n%hEkw^*PnihWde z1Tjl6qMFckSedHwdWQ(~H`x5_jrov(&)ItUSxm5{9_ctmg)g7|NyW%$e4~ChWg{JI zOP|8G%hu6jb(0wM^T7V!@ZUClj}7nqh;^+;uIDPS&*B8wm zlg`!963#VIOvv;EC<)HTz0{yc4m4pVusf;LYEdS1~d?nzd#pKn&ZgIQBKnmmyo45sn8 z)W{_K_%ZXcRLCQSlyK*;mj&(+5naM&l941h*{M>JY$g=bnP_w(j2k{KwLKy17KNtX zAUVk{MnZ8W=L$e?%z*evWgVpj8H6G+JT51aB(eWw4eM?eH2q(_vxobQ4m`^af}2mGWa`BdZ-!sTz?9 zYcR>Jk!9D}-7Ajxb=Dyc#yqrX7JQP*LN$OI2=GB_8Ka7o-0%}RG(hAWIm)oE(4tz9fNA;Zoa`58$D9O}qlU6z zabXhst_a5OvSK%TYQ^&v6BF20Dfa%GX6A7CLL0$IoPu-@g&96RGMHH#Ze7mCt%n#5 zhA1h>V$rNp-q^CA{=s2#vr<`mqv)LX;}LGg^Y>r>{Ga^#Fq=(0^Q4eaKKtq>hWsPfz3%CU@5F32apYtrXFg`g zd()Cx6y#bpnA0e_EScBLBLn!%`H#4N%FhQgZhs2V`l#{euN z=@>Pt=XrUxm>i?HVj90`z8PJUnG^4(V#*CPyVG$+gRHCH$MKA*{MGVrP?cPaEgt2O z>JRw0LqB9gyonoL`Uh^Tc!7l#?=!pl0Ew|t;0-d zD>?*-)v0)~MioM`j7Nv)Knn2@AMp_%nr?s!vW^zB3&UVZLN_|UIShJ$&nf&B$2v$Q zdPLlq;=KKKn+`bZ7mN|N=ik9~7|0lqw|LR%dA0Fic133TOeYYENYCV-T z^;j)t9=+=p-u~zSJp)7JWTarT*|^fwfyd<_u7Rp)ESOfpo)Z_Zi4#&1y<#31MO}}_ zX#kCe(SKA!QA`A*Di*UabJmeTmI%baY?9G+Fq_1CAyq<_B|^G_%LGAPA;}acsL3Sj z5n5y~Rz1#;B4V`LT8^@*M0nn;ySxLFrt#d&2SxGc(nk~xH4`hDN`1`Ag`NB8J9nP; zLr3T_VzTj=Jx#=sr3O3xbh3y&=XRW9vn=wqIk9#w$w^pHX>-V!69q<3wP5!Q5@is#Ge%5};xwDkV-`}ZDTGIpaB33> zk7SddIGN5a8LuOe=FT>3&OX}OTxhD5$%Q`Jds}hZZOD28Jwt7zqy$+wqlAwRoJNsl zzV*}wzWeiygd$NE&B@`*kL3{4j#Ah9As%lvKmN{qvNGaG68zw~H|XjeAU`LAr#^-K z`}*eX96MEs!)E1s|NSf1_2v9y8@DW9NOF>w?%sZOAFR0UHO2Wk6y{|TiALFX;m+z0D?P2;$IiDrOOmm52nR3P#~r{N12HO`GO$*4bIbWb+y zOUC?S$856A#uM{zdGe0=Jdc^VD?k9T-;Nr7S(Btu6kVgjC=jl0z1l40`Lgx=Z0bF1 z%U?ugaxwi@v3A3Xh4&N6d3wn=_{HMSlO62kpH9AjCmNv6o5SnHw{TaZX!Nrub0*9C zL=M&^x$qLF4JY|h7*&@@F;pxTWvoN5@!=%_NDEn{U|)_E{s96JqcO-p5R)QvrDK?k zBrpEa5Hk!P-b>9rBzT;(boMcAQo(ppYW>X%u~z_7&wQ18P%F4>{`Fs==6|rN-f88kZQe6|eu9KObjK}@S zs%q8cdcu(?Nr_%^v(vAF8%9^cnMROXVaNyPPA@@KHBOutf!yL*lQ?unJYQIz&5?`k zMj+v!dnkm@X{EVSR25d1`Z(GsBof0$aJ4d3XGf0+N|LM+LouBRN|ah%IQ*%MQDkbne2+9NIJ(x9L#Y?QFR@+K~=sypyDt~G!3fc zCc6klRVHQ$P|t1X%rAA0Vpe3T>N_bf$|fGyNKY1^)`y4BGq*)C5ylTY)%w`i8Ya6IN6!hC#>$1)GzQsuK!8zq+`Mp{)w$!K@OD^tivUq}8$Y{t~rAy4W4OuE5 z^w@}Ng7Gv#iSm}=eYMsdC35@-ev^$4Q^daaK<8QHkF9$>BbzJr?ev^FebvbnhztzS zDLX&W;y7Sv3^^Zl7Psw&QgK!cht`5|}=@m^X~Bo1fcoBa$TXw(;-J z-zPfW3=9pk{eX}?J@fcggWPZ=%747{4ggP4 zu3E! zmVMl^bOv6xgVxSIj-07s!z#hhdTaX;)+`YoRJ)E=GNUw4wDQ))K2=fONNHZ00A~!d z_Ml-u&}DQCYv~oSM6c0FtT!NjcEIq74#stUn^-+2|Ij=x97S~`m`7;|r4VY$r(7H0 zSgJ^zZ*4w;Nssfh>Gu(nP0Z-2;fDvl$J+XRC{8C0H4UKaxDfG@V`PBxGdn5otHTuw z(dfIHTjdam(^HP~w%H+XjBFH!#A@qoqp1y2MQ41;(Hd`1~0*49IxEZ%= zl(-H)yNRd@4y%dLsE);~Fc?xXDJHu85iDjCy(3W+MWJ;dgvD&4q0>)pMiQf;$hfSg zYhVPc+02=mMpi8qG33S%5Aony;qmv<=G}bm?pu&$nLS6((bC?-^7+%q&q-%^G{Ck! zA_>dRNMXs`X=s|pn;-mn`zik4I!m_iJ5D4TW!BVEW*F@FR}Jay?KdvO<8kt9qf_cr z_pjmkx5WQ*|82|pV6RC0-5w|5Xq4i-Oqx6UuvyI1we_ILGChLt`sjA6w!8{pJWJ_b_4S5EjoM z0YaE%2y0PXW>NU`*%c%?j@=f*WFJDZbz$+e6E`(uaSYHG=s}XB_(y}Fo9OP25sxHd zR&$923Meluq|e`oS+UdA6GDxquw>d2b{{{A#Zk}K9$(InUV0B**STlS|7P#KqvJZS zv)|u2XXZ@B40;C$5Fi19B*5NDks_%^b(xlI$#xVca@@WoE1#1u&drzH^xQbfN^xR2 z#kMTTl2xc)NwN0=Hh=)p0iu@yFuj~}?jP?vLqeir`>x!zKFdC9aiI-}IWzD3?!BM= zJkQ=lC>-JK1E9GyeREb)qy{n(6UKC8>KmEq9-*lqj zwc#=T`k#IP2xjZF0)emscZhDM&!G}Gq0wjZ z{-j8pcQ}I_PWsTWSZRxLFzLf?nS62ZBu~!Uhy~m|dYPT$ZG5--7Eb0?W5eQ(vv2dz z(HC(f<8wRYv$Kq9o;lz1regfB_P22x30i%n{J3lt&VoF4*(OkdQ-+^$>@3#ACchlk zDU&j;p_mxa4iHV4sFH$ZSQaVC5=|t;bMQDcrerHLH_O3zT0&TmLogDTMZA;I2~m_4 zOS)&8fi=HEfKvm*62L0C4#cIqfAc;BU|nt#Mb6SiH6Ob!CMIVX7#u-WRhkype&P}@ zms6*4kyz6we*z0@`QnAR96A$IGj#UN1$b^*E0T-@Cq&U*RbE78X(7pEic=TbS+cN_ z{M;-;ktk+!DZwNB}FSi?yG)bpEFIp9}_h zKH%U`!>yU5Eq!esYvJKu0SJ97R?ejA=8K5+_4i60pHsv+@xo*-_v8o=EujcG@YxZQ z1$lynRafY^A@o82R2)rJxH1@`Fx$mcD9$3u!tzV`(%H5?^0U1RjZf1c%_(2`;4Hgk z5%|>W2YEnBcAk0dAop%xhpyYW)Ye0L_cgYyUrtVT7NZk^3;^lR^00B0=xn|9!SPRI z(ed9EN6Lx|KK5rP&WSy>adl(ndxmLp;G|e%JEZ|@NADp0Lt{8~oy}{O5|{~b`D#Ck zqOfJn5?=e@43=fFuBnb|gZ+$6NAS6I7FFhPp=$y~QE05rr@3nqRfQ#`9#H*b=^03yF*-@=JAm(X=PU;WkHpP0R(sw#i{yHB7f3O{~zFXu1cTyp-KzxHXI z4xQs?E^+M4b*cG-cWkCGFI)J!$n)e2veWvb*Y;ys!hjm!sXhDo^qm_}RfQvG+cMJ# z-#vDb?Q5ir@M0&`W%(qMDXL1uc_?ST&@niRs=&ZR1gBkPGL#_KYsa*NtT1UP@uOuAz0|dWMVUliPKPZ=8FYtwYV2io$bscd}{t z0u{kgCY{-gW)+eX3o~W9u|=Jj2?r@u6u@vs#l*Lm8=GceWRIe$3eyP%MbU^EvU{!y zmX^yYfC-;$g5*gSR$;bVcHKoR>m3PTw`-hf?P24}I+UC55;gIxQXj zj0a}fylOF~Y4X%7`%qPtPwx`o<&UNG1B3}Vz>9C}CzT$B_sdvv)625pUFjG0Yo8J9 ztH4Z%H}=WF9S`i}t^KFyyEaCCu8(=;#hh#D#Hs7#<@lHmMkp)J=kQr^-uYyHP*jkM zXWFfGt+VqHayx!zY%Q=`zH zV%AW}A;Fm9A?S0tLC4dYjFr=naaScHW_{bV=C7i`1?)+GlxstQI;&=NUhxh;%hPf(RN zf<1SfV)rbn9wplw0aM5c6)itwnjAs5X^f1`U~`VLvMI@Aa2TIgN3(?p#s-*Invchk#o5c9xLppu z{`q_PGd=?I)$n#42{p=cG`$0Quy6EDMOGi zg3@PkDiqIB5nSQrFYW<1hUgpWpLW%pbUnp{P8$_#uvzt>7_-Igq7^wJE@w`n%+<(}z$^9+ZyfH(@z%&Gu2CAjZ zK5kf8C=3RoD2hURe*nMN#kH{jtCon@JQxv^f{$P5;P%ZzY4Fsm2Y5ue(2arm^L@orqvz~NJ(U|F%S zh|}#N>EE=ZoTDv*K~(9t6HS_w`5iP52r#Iw*i9&5Q0a!V(^{q*JrRdIHN`ci}|W3N_wIi1rkh{N~yTrVxvZq7MkqHo2Ei4O|LZM zBsqsIGl9_OwiA$tL~d>&;plY$YghtUB@)0I9Txy#nKWk~kP^bm(i;IR0cus270$V@ z?mp=^R#W-0>!Q0~yq}fjMPzwBpUC7ZEe$+*?$S@}lB|?d7(XmI+`3+L$@d?-4*qPC z(!wKWT2NJ$EvrNVa`4n;Hm?)_){*9`tX(RK#N#bPY-|uxtkFOihh1fCCQ7}W$d{Ia zTp5c|;IWY~Eav5jqSvmZWvdE`0{y0gg^K9BC**34l5VWd;$WvVJTEXgFfO|1t8)xy4UH?a26kYF9^}PDE*7xSoxt0Ao=Llh z_wvN^du*sV1FBjj6?F8B5FHu$FJG5%JUQp(HHYcwNz-r^-681Ltl1!O2ROaHatDI>U zLslNRV>2(jBi8q>t*ddn9PD{lNMv_xT#iqk?=MK1+auD`3B)AZ?>_sg1Zf`rSjqW6 z{+sZ}+I`OsiVO2UQTt_O<02loYb&N{@<)I3B!=-(K%%%HH>1B zXlq)@X#PCLbIa+dUdh?U9kdSzd7$HcKHVdRIXt^)7u$x;Q5G6wTrD8dQHL?>#qfu4 zVvtHWu~`ae24>ig5%JqE~S!(mfFfh?Caa(4>3y<67^#ta;G8xx@fcDs$S*#xR& zVL9wJdPir-%gJJDHq3G<^$16kD2l?n$1ic)CQ&T!*>{@zcZz%c{>%ILmEFR(=J_`c z5Q;?k)LmP#*)+~vY^S4F?8lv3)=-q6%lOpv9P{O0#*&X-@kD}PC`?6ZAv-n;!|E5_ z+)q4_Wbwjk8W+{@gO}gWfWI%iE#mS+cWmV4y@HWaUtLZlmY}Y>l=JQVfWpAowD4&P zgg{Z44#&{#cBVry?79uhvT#X*=D1;js**A-+>+sADWafF7z!@CiUnlb#5&g`{lrwo z@B8J>*_ayQs+Nn(N?|ApF`JVGfnGKap5^^&VSXQpZvX%w07*naR8O$0V;_a3g;fk7#rdagF zB*Q)~&VaF?s7Zo^QPGGd3_QAlVVdN)RIn`E64*{l&4ST5ilQ(yDH;5M5Q+k0fe|!) zhTNQKbk{W&*XA=c9w5gLgX3-3^a<|WQN_L!Col~U58nD9fBKJSNJJNK|F%bX{k?83 zwoc%6`}pl&eTd<)NuGRKOqBeCuRWGw`9A;J2Q;^IkmYsr2fz7+o4!u}_QO3H>EK`e zoJa@f)R`rP+_HWpmSyqm%WvKEF^vtilosU^iN-i``eNq$X&*R+6fX)nl#P-*o^pC!grp z*hgNAc|&bH`r5a+<Xkeh|YndG!9BXsXKbvn?50pv`NWs4N#O-*@+)`1u8}{{Of#2JQ>0Zu;}|1j1#D zuQRaHtgN(Y+^Gv!F-(*Bl_eDAWpm`Lke+Q?(ZJDW@%tN>lyg{ihZ}1O=pLCxQx#@r zMZ&&fo|lWmQB+_mqDasRy22_B6$X=H6WpqY*_#rZY`GSt&2Zr`Q`|Orl{bn6An~c; z^CVOo->njz&2?9fQ89jvm?$5{o76b3#rk$j=cVNB@TySi(mmjG`!%-@wX>#}kZC zi2|tNL(Hrjul{Rk`C-W?cI~fOArAZFXMVB|*7}w5u^;lmTEB8J4&Bbc@K{FHxoK6p z3nB{cTh{XY#(9Sd~p~$Wp}(|JciGy zF&i_e&C}=nY+53sS3(-|oGDBoR}t%J(z2ldqn3kG*>xUtWm6avYiHakIwOje?no#f z-T(C)*}qzN4!GhG#_eAIz3xtaW8-hJr)ndnqM%^$rK|5y7@J|x)cL+v%O6>n(XiM{ z5f3tmqFB5h@NrwV2qx2(1DgVu#!M=+h4f>QoJi=CV|>$IEiKoAc$_x+$0IB#^^-`Y zsFduV(Le~hUE}PPUbaYZ@V#S~Sl3jCX<8h=*vb0k^_Zr~kKa1XgK~8J%kLh+Fih^d zT}~@JaEe$WA-i2`aXNH5d#^Dz5#X2C&vvERS51p*aos@oKX6+<;=xh$UZ<|U=Pc|!PI?OIpEO9$JqEQ`%67vl4}GCpFv z@7#c4n!LVOBtj3!^?&O86*~I{@wlDbvtxbcxxaJp1d~%UloaOkz#Us|o+Dgr0#(L^V z26DJKvWUq;>nQB7G3w5vJ+}(YGT3%atgVx!O+2+kNKY4aoMi2}H`#jWN7VFPpnBjE z_Eem(JDX?j|0drp+s3NcAoq6d$3o%hMR&8hy`T8S`HUt@DNat2z49E6`F+^!2~sL( z2_3@`qom;idi51NHj9X%;#3u86T(0}m;@AsxTS!iWW26CE|EXxW(i=gyg>MdxtwC} zjR(SLn#!q`9-8XrVHhT=VnbCG4xYZu9a~nSC<^Z#X{L5wDK(WPgd;Ite&?w0Q{1pZ z0xtpt)-;s|?-J6(=U(0W%b@UIT{0(r_}(38nu=vvJoows0Q%tFf6WHVvHOV8t3HJ$|whVS=iQ7#a=6 z1jjW226#;oQ)=}XaZ91tmLOq4o}prx3Vx@7YK!5NCqqj5p-zXBsEWdDG=WoB#cSr& zFb#tezhL7OWqUD9gZZVo1S2tubA9v;jbpb;=;;ffs3|tDaWNgeLRD1&Q*FgidRgA! zVR*cc@u_L@b8^_Wb|e4zpT|fh%DL~>#~B+xs#DFUi>qA&losZYNTkS@A5* z64KoqFBbQ*`|A5*il^;*vuvPbAzkyDNZPLFlUq)|%Dwyk9o010Td|fOF1m*=wY-9Y z#oLwZ*fw$r1&bD2E(^3M5p3j3BliS?aXD`2pg>ae>mJJT|NnxxgMdNJ>!@J}n1>Jo_`4x&Pb)Sl|2J_t?2}XXfA6zy5U+iR2A& z!^%hqZ#IE&bYhCZk#RIlrKzFz22e`?Sm~*RC*?%Kb<66R2}ZcoE((oxORG61L911D zC7kaXm)#5T<~LU5b4GT|op#X?X)5z@ymv-+K*ZwNoNsVwQYL1qm~yZ{i_vU}1+pp7 z!;#$i%-Wok#AetS=;ntN>zUHM<1-NTeAl|Pg1>0${B8u=<(?i9)BH888@JJt`*_4XgBbHAzX{H&7 z8TQqU0G7vL%V>*T4qJwJH zbWg-tQX-3Bhu9M{lAYHU)F{+N7oozDl7N(0XziAp5+#NOIOMdQL02yMQcgH7%@Nbn z)vOQ61KZ~<EE)4mRdUhM^o^+dFNcslxZm>$EXA6{EH!i$uy~ zez8v$9O6E%^o^n0ZCvgeWYhBWnE6!3%zgWM0XV+&?r|QyM-&pzzj>G~tCy0W>tkYS zmLq3dSh;i|m8FG*!cq1e76zFfw~MW^AV~xKzv$QFk3T*qmc01liy!;gZX5;(5aVgyW$ zQPYMBEX_B$7!-SOna|`*KN zYTi99Ue^b9uIKRS7Q)dO6(#wsTwKeMGcAlwO_P`7V~gzAKKGhn!`!=b!yIPavy#gG z@O|4qb`tHsd{3-}hjwkJv^f70x&HI>{QUNB2=nD{{mWAXre{C$n7mv+zb*}i|MH)o zA|~nnKCg$z9uVxTzxwvG7>3F2yEfx>yJ+hgVE>5=eBpsxC1`b&wM`4i%gJJFYKB~& z8<)dQd+#vI(-Uo5d&tlBG98Svs7k~Sr$frYBjRsP1;rZA$Ufwtn3VY;*@x^|qz!n} z-Sdg@VuGzp2!!&`yg{7hgLu3%STP43mv83-o4B94sb2i?AQlSG)eHI8+KY$S^u`-3 zIe3QEC*P%J_#BmkZLB{34rL>qsFp=b-A4X!;b&OrGP$ky7?HseerWz0HIu{GJP~56 z$7s-7NuiKi+DFcsV-&7AM)t}hP$C*4aVh;k5t2ctF5-yaWy6qi{BYdBsoR;3q|j^{ z6Tt+EqS7-K#-?dp8=JxHbkH+2!ODheEXyL>C%~;Y51(gk(*jJ>;^f5+)-SKeFif6# z?I2%xXlDk1G)phaK9U`6SjJD5m0Bn~T_V8j zZM{eFCL+9CcN>ZVTLwjr!UKK70RdA9;O(p)mjBn}0(xnPS(@O+0k>tv|Q>;+FL*sVFUC zHW=cqy*Fq6-@a9VAo~uV$(VfC&MTv$q>y+b$;swca{O5|EU3h?ERLORVcR+Z3hh66 zku^(2o;*1{OP0q)U?xO$iKuCH3CKicT@jS;eVTQZj{I4&^Wk-NxzYs0@70M_c&t9jyyCo=!;zyE$QeM4S- z10#gO5gfWs^@k?a0W{0QsJ^Bulhj(4b%TNXbp{r|nx;BVTxi2EO%_y@GBq*EbU2RB z;~*GIkupqbO0sDi5Uu6qm0sFL1xsi=BsR*zVh^)%lR^hvniUC2r5mD#MU|G|TuO8} z?zK;|KP3u*ofB7iFJEYZ9~!y9gzjZ;Q9TN9_o+9qOKH?pRvxdfdjLyOsUGQKd-Hod zy6^k^&lmoJ`%dn`X(qXtUBQdxbLr6QCxxd^m*pXf%0g8f=-rl!VxNJc2yn`jQx_tJ zf^L(jbIQs{P*OKET+)*r+zwkNx%4>g1mlJTtsI1IU|>y53#M9ru8+x?Af_q0ME)!{ zV^cF2rinwhlbbD)ui-H%c^#XPWJTK% zo_Ol_c|33)1&h}zH}GtYNF3HoTxIn{2PsS857p)TD&06SX(opiiBTLXoC&$PC0p#D ziIg2pQD~hoDfNmVv8YhTvMfq+#XTqzOzxi)RQAgQGZbXIn4AgIAkBB(PLZ4)IMdEb zY34pP8^P;#GB7fU-{+w)*UxxhmSfFVxO>~$OtGOT3inDg_g8L^4Bop_1eGftePI2v z@Ob#)hv&qS#>U2vee9{`);XXr2%m~e?E+LuoAkE#TqBl9knQtOSyn)M&mdz{Gq_z2 zRxPRJ*m((fEwAU8^e9_iTfpVMNoFI`R5OyqFimO;Ty%^@u`G+mGB@W2#Ts9mYjJ!^ zOpt9K=<@gv?2a=hT@JKd;lG8TQpYdx~UejQ)s_0+%@rx+B6T z%i~a(jTvM)G-jeH4AY{zz{}OaF$~jUVR;U115>07lLh5DU|Doro5E((xMlTX-aRaU z_1iYBKv5K4en+hHd$+H{X43>U{h%;HzEM8d)i=ng^H0`e1x%(+EDPUk|jPE}4YUcZ2`P_ZvX8Y*s zAL7;bk4R8Uyw?Bx)N5>6y_iKc6@(&DUVisD4@t?|tNTuI+Xk`MM#iUvF?IhaYZr_7 zl4f!AkBE5RJsLz+U}!3arYKBEAZvJ9e4L2LNmH^to|0$3B_-i03oupsyB1+3?RflC zD4Oud@#l@BdZMHZCvOaY4orpekZAmzDs7}cs}#DknL4$S*Z3n|=YR7Of5i|DBynI* zC8+If=JP-PW6FoG64zb)eg2(T?ei&UvoIBvYxQn66}*MzOfep*z-Fj~olu@XNZg&E z)D|UaL5^;cLcwphh*=6=8-$Z$y4*~hjPwgd!EU!<0r}Eww=mm{VObd#);wvukZvTN zZtbDEtbmzNlq$(Uf9~yLJa(@DSbp@zLGIkPmTaGgo`De#ow~%9wM`TkL`*!S)PAgoVB0YwH3RjW#s)2 z@7l_q_k=IjUE5ak-q8zl8gEVYRZIsXrGC5o!a*j38K4!YQf2!B2eZg8f+{L(zIFDR;or9HY81@vBl?dWU#R=$sip?;m zRRLm`8?zWF%-0jl7#cZRlBl7Ot(YX@I$1g>_AuUbBSJAiF$qOQ<1ZLZ;IJt~<0XWqa{UBmf*id;Mz~2%Pdy~-k91S&z=@08Dgmq`XIfajL@>XPH@CB4naII3 z>CZepBbs6ZqoOt+niOA;N$_$)4g!fwI}?{~0}FE93P`|nMgmx~hFD)g`7tc(;<%z> z$Z9xY*@$36!6H94&EZm!L+!kFT_QK7x%rQW|Ae-hRj8(cFE~lkrqfxqjJLP`3g7<1 z-*ITogDmVl&trT33a63aa$YTpqS83oMO4%2_Z8zyM7XAUSgwgCU`mzjE5(JTSWFm# zc{wFnSTmBvo0QK#?N;xS4U#-x+EY;wKy>L_JQWoAUGvoeit_wS&4gGgy+rryJC8*?2Nqn^&9L? zKG6Wyk|j&ny?b}&-}dcuyQrtn3pv!XB@3|Gw2%CLT0Xd3`jr55_6{;NJ&Vhsvv^?@ zk!YOOPB8&$b>l+LToPUCHH`~7bx}^STUgAw4w2}rTU5gFD}vqQR!mF_>Wf@l8j`b~ zr2%1MHgrW4GzBIsL3vzhkJ4(mPywGR5|@HR7(>+)v^@~x^gr3oRx~tg@plfMy3B?Z!WZb&#jC8A zd+S*1Fzf3jn=cR+rkH^U4HaU|q{l*cjK*-;6ao>0+B{Ko_%x|Wmuv27(oUh0zy$nq ztq#T^CnbVVN_IiQHYYJn$7UIsJ(2;pOBXQZFT|0Evh&2ta}P$#r1sz*9`8Slg2hW! zn|Y>I6u4i$`ZoS#gf_*`OX@rxLx2`fF`ox>#or$>9Jo}ImWY!TxfYgXQII8q!-$;1 z-7_A=uBmj4hAH$pnTaG>P~yWdE#?)9wVRT!$>H;zEUYXho=j3Br*giu_cV8HT`7R6 zeW$s5n>hU6*nfrxlR=ZR*?r8coPmey6HC<@2UUCG1_P187W zK{QI%FRkW8s{oVME-K~FCGq*zrDYtuB7GHWd>rf)@7Kk6wIIct zgW~fo_Aqt@j?0EfQ>S3x9m^IhmsK;@aGEJ_x#{k@Hm76$){5KdE~?HnMy{4DAnd$; zPHH#!L`~>!8AIaOO#{X4rYj+0@Ioy{n<0{+#ko!{&WPl$#$(bJ5}@0{LKjzt#hJ2d zo|luog88$)p)A8f+p@TX{pSU!zI}NG@1N}zuT^6$Zl{9}WMX^gmKB5|QT84Y_xiwX z8)c{OFwuB|`kG3X*3Zv8_aE(fAIq}Xv1v8M1-UnUzyJ07FJW00cWvK5Rb|O1dJkxt z#-IQGmr+%f7hc~>^QDg(x;q^@zxS2T0q~ut_GFkhUXP1k|BRSO_)p*8gJGC_arYg# z96IM)yEuNXmB$|vXXt;v^ga*YA*Od8IMu>-DM5ex=!Fd1RMs6_>bi!*ZewVChVnu` zhG|lo>%_85N^_iGSrla1F)hJv4N6(|nDjB3mfiCxvIB1^q#|Bsr?b&KVG^2-W!Ol~ z`iWyh&kf*pL>Z5j67HNwX-M4POAGHH(piS{lpjOMBA-5rxQd+^BP^mvS&ML;gMx`` zeBt^3P5FgB0+;J~)xU!kfy*o_ID|TXf*Fqwe>}uscs_aY5PIGu5u0FJjVWGiz?7kb zq7XF2w73LI zah6JN#S@o0DbCGiYC1^DG^s2V-evC}KF6o-6mjHxFTRJSs(k7$(K-LI^pXR3pZb zZWKkqX0ww@87!@vNAneN-bG~sUR)p;?0GWx&GCyfK9Mv4MX>QS;hE-@{yZ^56s;)} zJi72zGf}Y=g-}WnY$Z#jz;0k!3MIN&ON-3_vx-iE73I85}E(m~v&) zkz0j|Me*xD_^DneOHnwu@iPGI>e!1f9%N6gSWDack8!+g8CVLdlY?|>*|@DFU5dEh zsicx=8Ucht0=SKsQ54N!Is!Hgl4c68E*_WVP{6XpDPUPdWKA(SE7?~8!M;i>L5yUI zRJ?%dl47EXAd7149G3PP_itOp!P7BBXDI*xAOJ~3K~yb5`oE!({U!u8VRaae3Sy3L5SOS+*M^zQhxA$f||HkC|d8uQ7Y_FSe zG)|7sO*~NY?DkVMIlvRo{yx9?z5l^)Jo9^OKk_5yUAuyX z!ohV9@y7OFqh!37d)|9eG}Y&CVcXC-3Zm1Dy7O2V6nRoJITR6N2AwiBP7;-3RqW>i z-NFP492TaON=8x^KBw@&(rp@3krb+`GBlk)Q55Za@Qbv*;$NCPE%hayvN=;c$WL5r0})9C-M8T*syYum|FYB0i3$dUAL~2x!Ix2 z`KTTKt6YqhQ2C!BwTYS@>XS}YKUN2ToNknjE<3j9q8|N-}l1dp=loU`> zn8z9UJF6P1IM*%;jg@u9oNgDORYhSIBY_AGyT*vDxEGgtn2e;*HI+eWVw+_b()flf zgVPhzFG>;f4Hjup&e}xRZ1qe(hjRt8ye`m7LbbDBc0bl#IhJ|ehn8+*IIj$6BFa6- z_he*NnZz?EhgDPEteWa3rD!}^vyBXQN>wS7OqOBGNtPm%ycRH%vNFCB3G4a+nw0;) zO}nlQR&)_aG*u-cSyyg{jj%i%JZ=xcjBL=A`P}Pv5{XKX%AqqE5XD)Z^uJ02SPuL3 z!f7@nkN|&{cP@Y>8Ccmq?@t9_dEBl~^d9)xe6W^C0Bf!fR%K}+)s-crQU=G)h@Wj* zecj02G)=ay5r5~%*;eM46;Y7mBN9u1V&Qf=n4FDLQ6P%o6Kx|btr7*JTXq3^rs6p5 zDie_uwfO?5%ynI#iUH6S*03uUfuzMeMZABCOk%omQ)&}IXG-_rkzm%O!;4Km#<&5% zI#(|kNJ~3Uqo+O!;KU{-SrzQ(SFgTkrl~G3$^?vCH#SMos+roV66$Lzh$oV~`N3&wDoa^XS4}Eq z@RszhaXNHv+p>mVUO(G)Mm8;0EM1862LG$eS4G!($-?T40q&)%*8wbmlak51Vfi9D z`i2S2gz&nZEUol$O3LHbHJBwKQ@Rg9TB+U^y-Uto75PC<+u;XGWZxippCn?%;fN6RKtL;E6qy zO$}kHDp$&`o7L;mcL!iZ7i+jUF3#QAg-Z!rDh^C4)C5;E0G7tZ8S%O-^;w)r`(IVK zIN2-iW$io=*y84HyEXgMrj#5$}8XD)?ddT&An4S$&H%~AD zi*vGM%+TaVY1r=4z_Q47OFt;Pf@xVOijo1a0+qlKS56p zDRf$_+sQr{!!t93=}*#rcP_uv_pf*pVS0RJEF0}1HREH{nN3Ch2qAPTiC~~mpon;s zW4AC-$hIpaECrVxA}LT+jbK8NK1b55-sKQXX1|-1VNsmpA)YeH_qm8Ak}Rq&o73>? z8JfW7anUn4&U!fw^4T{I^ZEO?0`T-}2l@Pi!f^M3N*uo6B87dNedX4GIiTinDTLDkxZ0i4<78FRouj2Rx#d0nBvGd!|r@smO+Oi&V%~YBym(qh!RLC__ZW6 zDUB>OMKtQdYX?;ig zU}*obvl$uTrZr1(Idlew$7t*7XL&;{1-X7^Lt#!dw`FRN=9W&D)m34d7OAADy|46K zqoO#McrrEZL@SRv9K#vhR`vY zvfqIPq%bPvso!nfO{b?AS1iQtH~x--DUsh4OkQKdxi|Ry z%YVi_d%ufn8ZI zaiS^;<0(5T3X_tB6;6pWz>x97EhjeSX1RnyBu}t8D+@&(U7j!EhAw5v9RuUI9Cj{V z9boe+5kF2|>ZGBjf@nNR-|z$twUxvY30~cIf=7036U~n|50Xk585!Z5ADqYxYuT`B z360eU2EZD`i3Ygk z)RCZ};*`>@IRKVCTr^cdN`SFRrk35NWB@FWL%aUDzaTSt(BpE<0kG1>er~6OshPR# zs<`wubKFoc&W1#?sINRbl`+A7+u~_OO})zws!Q>P+LJ!UN(_voO7++tXn2P;gc6TSiLws zdNqk|(-@izQ(rD<>4Bh_YSA$oVR4ZFa`N1AtgAFt>y4`Ds>NhdVZKYOCBGv*B3A69 zF4IkwLp^7CI(Fg^8C)1H63(JMHvQkQ92S%sSG?lYgdfC2Cyiez@^if@2NFC5IUH{#2o5W%cg%kgr+Fu zxOJvuDZILhVOb;$i*lF6WKtz!K#{{jcNcOkWy20^u!lL366fc#>1(K#MV~8&Feck9YI4%9JmY2IZD<=@v7rAH~6{DN;vK)*~M{(;m zG!+7&7&%!Es!IHvx*|Zm9UB^XPqM9cZd!(_s_c>LJ3Y+cTuTR6yRYHY^*QG4Z|*zB zOfXDkSy6@^@!{(`KX@6#Ft~NoDjMo)eqrkE|Mm4>A={rtOItTT+H-Tc$N%+Pzk;f& zys`HfZIYqxb~^at!(znyKYZ^c4AbP-AGs5oP2${Bp_-UUJ2Qrgu8MOw8J7(>TN2$H0nOy{#Ckd$3rSA-@C4%&Glb3IAVM|) z${5cpr@yuiOS1?Xg)}$rOsX~MD?I4FlC5hBWMWV!LWqkc9v7avMfBhMl=O>O(i5KHiYEJtaQ^S z-4qE(WkOC8tPvP$H*v80#)dGcZ>%NH*|*KM?R_7jOF*s`V(%d&X&{o_=W z6taHhVocNI#kYj-s@-nmQ+I8f(>(lTESY=hb~|2=Xq2Yqm$z*e5}OZXKDB+ra`vAP zvZ-~;8#sNb6Gc%lWtmo8UQ9A+P+eZg)NBN&!$CZeB0tAR$}q{2Q^9T0o?#}M0#(BT zJZ{0_i={wORSXldqZeGM@vS zDixEDYg>Q1sm7+NacJWsA}{IOi#HKwPn}?2+}U%8gB5~V-egYFrsd+cl5{H~&yP!X zy>1EFZ!)f9nJTeV3RRCW6E(yH!jzmqm@@G>#RNjT?8?XDVt(ATlpl}Fb7g!|#ISfw zu&=60^GKMZ)Xn#E_>2Ipc5PYCi3?Y8*zGJ`Si!lLPTWqNuROMkKl!I;uq=y5?%qm$ zO$GnYcb;Q56lO_X6}zSX+2F`H|NNgX0PxMPe<1^E+3gm7pGjFsidX($_TD>6uJb(e z{C)RU-O8zR&OkTN$bn!0K@t?f9F#>WjU_p1y$;7So?XwGS=(dJ_?-24ob8cTwq#jZ z3=%UzkOTn`IX6;wqjT=+uBxtFb?@CjzOSm$04U0Hyk3vU?;IXfR~M^q-TK1&KJW89 z?@RxK#l%56+LHYHU%!`{>LOmR@>wbf;t7qZX$J#W4bGf*(|5_m@Tim7Ih|xm`&Z3` zeB?g4=fChS0M_Pp-Bd(^#1cu4ossw4Z5Z646d!vJoIumGvMS`YgD1+2tk>T;&7Pf7 zs(1LzWjdQ`F-?oE=9(3NM{* z)AWb}u*wW9mdO^g0U5(rWn$>I$>F*U>}%eEZkv4a&94%P&))Q2Y`X9kAA9k?<1FU6 z+OnR1`0(#=%i-tf%*>H=dU>h!4tC65z!VxeryI9fUX!yf@rD;LNJ@igMi7!93U8rrV&EWcXf(L$j3}H!4_p3lggON zoA(0u-La`$4Edxw-@p0n8|=ArD>W5i<`&|-arg{d*RQ6vsg`sm%PaejDISf+ryjfa zr=Cmy>Hw_$`}fn?*~z+fk_qxFzw#?|c6RcIfB1+0uwP_nZC)qyIMHp3fSD)m^x!s&tY4bq zOr5;0jYFr)*L!M7ahWv72dt00FDZnbD^t_I; zF}o;lh}U8omRU+>prGV}whACUhE8S$150icn&BxUt3kiJEFlc~+@#f};`JCS0@Qw1hu7_*qg4Wx14E-f@wIEZ+6V{zEG5&N zzcjewcekq!cqh+E2BNNO+*b0sI&mH$1UnRHb)s*8om=EQJ$T|Gx0jyppJt=#Kxn9> zWj_IfxT2xU`+UkYc6_; zlN1i(DHFG5aVF*Ao=|GVT)hyr@Hzz(OBOYLokX@sYqg)EY13IRt3tKmQWqgPe+MS! zaX2(iUm0VI@*Q&-66k*G_(dMLQy%0m?LW!Gcb8;@M|t?3?Fb<_dA^^;_!1B8-ckO! z)L!_GZ5vjwX?|A5Kj%4e{kS?RfvWcAm2$F?iBeb7+H!&9@{pWc>sGfjzmQ-i8bjAK zdODgouL>a>RyT5HP!>YEnD(8H!BZEiS94^TRMc zI27PFm7)88``kKnJ zC*N1T^CF*l>~6engR_^0sS5k4tqd_8jZqcyp=%n)FATA3i##uiMS1RDx;lyBa4<3% zCFpaLNaygmbYiJIZl}(oGIEcqgmkIoVe`JO+BSMpwBO`R$MOr2uDjusc zOiTn}r%m1#ICVihFVBZkL9tXl5BuF@^A@Nq7oi7&z$EM~O8K1>4oZPy34R0%UyVvc)v@AAsw{pC1aK(33TPX_( zRjRlfRz5Wa%K`+6OcBE=nIv*v2vS)KO=wuQO+YcOGDU%nAYBl6)aBK=r zNdb*6E5kxlh>W}RY`Vk_rTGg>VEWf-@!t-9$$8ehc3OsxvFjk z!mYT>Je`XpT&iqCw=ANn$iJaDM@+Z~+c_4Bf`Dc+SJZK97Ri(wpANP&Mc9z*+>Hjd zG;jyWzH;b-R3?w#E!kIFI^?z^YZIo_y}h%4DiF3_9KMgcYpJX z8H{)x#9P^u5s^9 z3GP0B4ajw$0(@V3utxfY;uJnZo}Zx)d{-WoAJ6021X}2b7_bV ztD@p}e*7jv2tM}E-78`=fR8=A8|O{zp8l5ruUK>bz%F zD*^wFK1V0dUs2WY)n&8q;jw9E<`*#xCmYvv$u3eCB}?m;jolnm$@?uEx;S=GCLrtE zYdAG15!CHHb(|cKk4rT7RW)ADjLS*tR7v%wh|Qq#!bv2H<%;!$5!=Bj!W;n>-}(Dvxn8HE^Q?(SfZe3lX6qcyO zny@LV%wIT{*-9lcmO~dPmTozq@fkX4B^&g*9VFG`5)kHcI&tVa86^$$d);J9oeJGX z8L%oP*UJp7WdN&`cnMZ+&ZP=e@jZg6a4_^UTQ$6Xlo}WespR`71zI~cOLosYCs)b{ zH?3WT5Q2e`3F1p~^6pfOt+$WK*KX;e3XMPM{U|nqPmfD>(^s_B{IcDT zj?L>CKYJ?WydKPZaBI+?aqw1z@!_u6VxG6}3$jL#_-@P$(3Mg#0wtR&u^y25TKH zb$Hzd=LaOSX>DsY7ltJ>a$Q?h8MxWhSzYdGyQ$g7F~w5a*5c>rm<0Q`N361Z@YX5^ zM^y1-yE8+~cF=FS5y1MC1jvpBW#YOmJ_Z%lj2}9z)}7#DlMJ$+IQl%RrUsS)@LWa# zSW0Rw1lrtkmzWU+V6|ozafHKMNz3)wqi5(VNRYYRudz^o#e%@lY|^G|Mco)O7@n7( zWoxsKBSUg8zP+c01IqvE&h?G#J0#yAUVn_p)Q-DxQ7q z5SC?e>*h7o*Hp5UO7r6D@-u$wv1Rl2O9LaE>g$*6k%w>I+3BnQ_#A~oksVvtv30{5 z-f!bmPwZjcnoi=06o2#=H}|#qjbHdAx~{SJ?PKM5%IkLVbDwwsfIt7cXRs`bUwrCe zgb=*=#!(W<6d&FrWg>t7^y_@$K^fHk_>H67xwQw|wlP$bfTL#zX{rg6%H+!32pg*; z&|eplF;aa<%0Gf02bN`F=z^t;j5p%S4@*~PM%b_rHdN{byzN&A_!ATsE75HySQ=K* zL4LLhr!Pgzs(yT{M{yZxVpawD`4A4%WXTGV$Oee{YM8HR!ps@eMF$DQqtwQ(vf=zb z0{JMe?Nc0h>};)Ao~ z=3{(nj_J854u>qNpHORN-Rd^ZUl}2hOj8jKFs{1bZR%;~($FNjrZGGz&xon{gaTz` zj4?Sc<%8LL5ogIC%`0P!Ou+(8U;_bI%J7iW4JtE>v?eCFSlLBEcMwcQseF%OU}+rQ{hP zd50f$+zkRYSW&Ks2u>^ph0If&w#q3)0c>zt7FOOx-m=kM8RA*VH%w-grZzRrJwX7oo^FJ?(WIIweUAJ2!Q6=F%`;w?Sh~g#M99 zA|XGYdF&qk_$!iC^{bzMoJh#e@BZo6u`G*^KDdj`DlUHWom0HF{}@iEgWvtFFWt~& zDzTL0w}1c7uq=zueDoo1-@fs>_#FH`i<)Yaww40DJapoPO>-{7Zp;gXBf z=UiOwH<*}`(!*l${~u5*5)QIQbsPNl4{y%yed2y8FZ=Op2g~*`dvb? zoIAGk;`6$ho?oPYXri2poVzr{nvN!lMH7!Qu)1<}0-wi4G`>VrZ3NS@XsL|=HkAQ4 zg`$Pw(1<1F-zpVEblavZ8&tqmRGlfA5`jZ8t_&fcuvN~wAlx{yun~xAnZxH4u(YVU zqt~bA@m0Nd6S2p`c1ZvLAOJ~3K~%=+0shVR|1Z3m1T)pG99y-MpPxU1z-C|bHg-+P zV&l20PO7sB7ID!kG87RsC^>qiA(R)ErDW++E#@&a5;+@9*O*INAOwk=B^jG4H&Mq5 zim=AeR1{4UoVYZ?>Nc5&w5r1Gv-^&7-%dGipMUcNkL;Gkt8e}IO`d$@ZiEoLb@VI~ zGf_VA$UQh5I>*jjqJLQ88C4Y_Zr`@ye@y`EpL3MtgWKQL|4IQ^>zBPfO6;pmYrAl{ zoSeNhL?)M~A{?NtskZEYwY8_2lgjgIdruuFuE^x2ySak#`4qYk#8qaxw$97&VjfK_ z8wNIc1g0&ha=}ncc`*qI-ZpAEu1w2BWL0XOOMW>q)+VQ!?pQ}kcj7RM)W+rCyxhE& zg2SLDHcjiy(7WCbXL`9Uw!a{gh9##5&Evt5n3bAwpjes~*KDq8?P68QAV=4h*;oz@ zaw_;T6+-28J4j#C&7mYAEFo9{zl&5RTV`YVz3#H9qQ~XBhH<3;Eaez~tp`@QP4;!w z^HLYe_o@a)6eDf%eE?u}sAT)<$a@DEw{4Rk$l;Ucue)D5EsXuMX4RRD)?+#FJ^l0WVAGJhjU2>DZMS*0)xuKwEy#Ba3Mqx?m!n zr!^w00nI`AJ55zlGHNo;q?PHS?W93uRT7{r16axfE3F&YYA$=KBpp5)l546W@zb^b zUJ&w{f8o-L)MR4Jcp`kI=V9&~e1{%AO&SNU>y7MT8XLhv(SujFxR`NsOHi(Fx0xa*<`*wMd>^pQ?Rk5~~t5&6PE&KF?@so#XT8vN00!3T% z%KJ7lE}w5{lz`yns}gkS>5$;#Mde?zwyPP-vblU!0yMqNe$Ed|IZAJPCFh6aqWT?o!7S>CqV3Qp%`QoqHK=4jD}1+)MkLEye+76}z| z#2s#~daKZEo2`j)5|#B>%DjInQb*G5$6d(MHNBE~>CVe_lrbcLjMSOB;>xlHehpF5qh>YdpR;9*<81@`pf=To4cww z-Y@TGPh*(DsTdAjW+>^~##>+T)vc=dp+hTnVJMx0Iu&%GuKI8P`ajhEgyLOPpc zbw^XVqcFffKJ%(fPVd@5RYmBA?>U{x^4(|UYkv9jAAeuYbzRr_y?^&hXqv{;FTBCg zQ#X1jwl&w60l+`{i{-9`pa1Cngo8c?MkaV+-(k8tnz&=zT1?C08&B`$3m=uNx7Xh} z%dTxb=(@(?GyUvR%|8yDyhwXPHR)WQRV}rp)hB`eML9>JNfpDWL{w9WM71&(b!wvQ zUlLb7SS8bEmuBJcCs?)lFz(t(>GxT5VA?vmFHQ5N6IA+U5RM}2Y7S6z>X=Cn3-JaH zra#2V=mw^=wG@{;cqg+s2L&bu5he&H=Gby#FCRMebp$rYwmigW;~F-f-^ZrDH?V}p zE8YibTAD!*FA)ueaho}&G%qcr$l{<4xxOp4A{K%Qr%B!xxHUo2l-?yv1;yZZDiFe@ zlPg+yTu$N{X~sLdlm`UkN@{s^DvHoF&R?CRxvr8_CRaA&y)rsWOG7n@WSU%|K+x}H za(00W17qyjDbI}`?R^KQ)4_-LNO^imMhNh!$M5~%fOwB_LN!HL*WHfCWpGNdt2VFg z;tgf&e$S5e962j<6NgHMSG6{f%H#+Kyo}B)pzAt`R0fyfB$dtM^U8hSr#cPBGDQ$l zN)~X-$UY+#rWCAY?>M1ilEtFxQf3;sgw1rpfdh-HdPo%w<@Ilvzr^WUnNMw-mixgu z^>h31nV;$&TdtlFa1Mgdma1<1uv7xdI`tlS09y zCgi19G-;|1kk%7NcwFg(+T(DJm^Mabs!Y+2LB%Wq4$`ez@zoB!wg@_hL6 zXCC1j&%DM=G)8Mv4WIwWeLVNtK~DD#;P-j>x4$Hf>NB}K|LOn!3IIR<)MIqDHQjJ; z{^KA04U^OJv^3T8?|$`jKh^y#Ne>(9igb14%YIrNZ3Swoi}-yOnr35~f@Df#dZr{j zTc@KzVHi&C z+983C*AAR4OV{=uJjEUbpbU*o<2DQ?<`&t~BfUSXLK4LHE9)4)QsPuAAFP1KSvGK= zPhQK&vhh1bS$Pyy(!#U?0yCxx zE$Rp%m@gP0AZbZCdMSU7sDgTh*Fn*=33^?mvL;@alZB*Y^G?SyRE0dmmNIm<)L~gR zb*i)K#i3~`LVl*_V|1&z{oKBzd{o(#y!hsEf&o9bZeF7#==-Uz2yu_Z;|` zfCQ5aRry+7>*a##tQ7P}8e(Uqhl@)>C9_Iq5i+<^G}I)QUq`na2244bI?_=Fyb`_b zS(>5GmX(O=_$->*ZDztUk?Nf6fA=ri;Xt2R1}|Ku1cdUMj(=@0SVc;Em%s+yK~Vuj zPO-3~!c$-G>;Moum2(gx@?mRVOmmxGi7uq^eSK97r}^1m{i4h*NGEF1K= zjk4sbBpJ-9MC)1)EUOG)t*j(C9rDmGZ9?xh!is|ZeqdlVDRg{l=Dh)%?HlFXKYjkj z`Lsd#{`4tx>ei+j>T4>==ZjqEA7M>L6E3HdSR%#P^gKH@$hCFu$_U$(4^}!?!0FJK zi)ZL!MkDisKP15lwkINfsx`)+xHlqbme!9&=!4S0)Ley#6mblc*sy7fHQ zatFVdxs1T(S<%AX%%Nj*FyY|gu$)&D1s57{e$k>SppnSibXLl`O?yO{NQUKS4yePl zvA(Xd6=%^L7Pv z4NpiwrmMA{skue6`8XbxuRy9VrG$8|!HO*lzjmyW4VK?KdGmOWjlP*{U z95Q$+TGIbYizS(|oan$hXO^=?IoH>wJl z+&4?is}d6{)Vv&cU-4C81GV`jd}f~cK!muh;}$lZdX95N8JuklAA#A%W$sd`O#hi^D)m#~mlFa0Zg#4^u-O8(POJMf?J2x{j zK1=`b1P+JJo;zhw^tzIJJa*q5E5NBzhoh%HyyvFh^Q&)4W6_S*M((_I)BAS5Z|q&o zlOL80l>hS&{*qko#%344_Qj9maTy#tbCH+!NdVFB^YFz_$&Q47`ZeW+^~r|-DIW+2 zeeBvUy_8;g`y}@%pnY&;it0#!xy2dpe1CuK0aQc=AtUE*3ZExaj8z#~?j588r*zcy^l=Ctj z)~R)mQCJ9K;>5%Ob^&x7JMSd77-o(x!c0<$lEm21ef$KQ&%BC_;I(_cfGq^O4}1%U zS>$TAhvubeJe5(-RClv&R{E~`6nlI|lSx)W$n}#|aulbdlx#S#Y#YO=lg!Ivqq6uS zsKAW6h&1Dk1l(lvCM~r=Ow*#NrUKKl=v2Ni2?Yecb>adK?UL)}<+o4sz%D6Ge{Sz# z9=lJ<2!HhYVNBEF2_=1c{lJN`0q>qWZ&}d+{DX0mqIsVxfUBZ;>E|uIU1b*g`tEin zW)?6E2NQ~kRcdC`QeQ0%maCMEP(2?}EbK(ql${1m8^0^&KYzyU=Y>7L zEaS}6FA=tKd~N;5uo2uddW4r-{%|^0W=H7YO6(a*g{s4b z+t+n)@#;81zn6f|U}|oG#@b3AzH1wQ_kGDE`agc@Ni0*ZA+h|C@Lfd-8u~IGr|;ut{@ck?vJ_Hm%RG zwkJnhOM$9NDLsUhep>y52B**c%lK*Cx^+Drt&OD88J>Ijts8zXgebGHo_^u2Yk-YA z6p$|E%=alDtXKD+VE3&XW#glPF}5mirb8z$vsuNR7%=Zb`U29r_cQ_>RT{G?nMMWwat zi5QH@uExYw09B`1q-_niu!*Z6rI{S#Zh1g8=ijXHUhZo=uuAN$>uI