a ;ghb|@sddZddlmZddlZddlZddlmZddlmZ ddl Z ddl m Z ddl mZmZmZmZmZddlmZmZgdZGd d d eZGd d d eZGd ddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZGdddeZ GdddeZ!Gdd d eZ"Gd!d"d"eZ#Gd#d$d$eZ$dS)%u This provides a small set of effect handlers in NumPyro that are modeled after Pyro's `poutine `_ module. For a tutorial on effect handlers more generally, readers are encouraged to read `Poutine: A Guide to Programming with Effect Handlers in Pyro `_. These simple effect handlers can be composed together or new ones added to enable implementation of custom inference utilities and algorithms. **Example** As an example, we are using :class:`~numpyro.handlers.seed`, :class:`~numpyro.handlers.trace` and :class:`~numpyro.handlers.substitute` handlers to define the `log_likelihood` function below. We first create a logistic regression model and sample from the posterior distribution over the regression parameters using :func:`~numpyro.infer.MCMC`. The `log_likelihood` function uses effect handlers to run the model by substituting sample sites with values from the posterior distribution and computes the log density for a single data point. The `log_predictive_density` function computes the log likelihood for each draw from the joint posterior and aggregates the results for all the data points, but does so by using JAX's auto-vectorize transform called `vmap` so that we do not need to loop over all the data points. .. doctest:: >>> import jax.numpy as jnp >>> from jax import random, vmap >>> from jax.scipy.special import logsumexp >>> import numpyro >>> import numpyro.distributions as dist >>> from numpyro import handlers >>> from numpyro.infer import MCMC, NUTS >>> N, D = 3000, 3 >>> def logistic_regression(data, labels): ... coefs = numpyro.sample('coefs', dist.Normal(jnp.zeros(D), jnp.ones(D))) ... intercept = numpyro.sample('intercept', dist.Normal(0., 10.)) ... logits = jnp.sum(coefs * data + intercept, axis=-1) ... return numpyro.sample('obs', dist.Bernoulli(logits=logits), obs=labels) >>> data = random.normal(random.PRNGKey(0), (N, D)) >>> true_coefs = jnp.arange(1., D + 1.) >>> logits = jnp.sum(true_coefs * data, axis=-1) >>> labels = dist.Bernoulli(logits=logits).sample(random.PRNGKey(1)) >>> num_warmup, num_samples = 1000, 1000 >>> 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 mean sd 5.5% 94.5% n_eff Rhat coefs[0] 0.96 0.07 0.85 1.07 455.35 1.01 coefs[1] 2.05 0.09 1.91 2.20 332.00 1.01 coefs[2] 3.18 0.13 2.96 3.37 320.27 1.00 intercept -0.03 0.02 -0.06 0.00 402.53 1.00 >>> def log_likelihood(rng_key, params, model, *args, **kwargs): ... model = handlers.substitute(handlers.seed(model, rng_key), params) ... model_trace = handlers.trace(model).get_trace(*args, **kwargs) ... obs_node = model_trace['obs'] ... return obs_node['fn'].log_prob(obs_node['value']) >>> def log_predictive_density(rng_key, params, model, *args, **kwargs): ... n = list(params.values())[0].shape[0] ... log_lk_fn = vmap(lambda rng_key, params: log_likelihood(rng_key, params, model, *args, **kwargs)) ... log_lk_vals = log_lk_fn(random.split(rng_key, n), params) ... return jnp.sum(logsumexp(log_lk_vals, 0) - jnp.log(n)) >>> print(log_predictive_density(random.PRNGKey(2), mcmc.get_samples(), ... logistic_regression, data, labels)) # doctest: +SKIP -874.89813 ) OrderedDictN)random) COERCIONS) _PYRO_STACKCondIndepStackFrame Messenger apply_stackplate)find_stack_levelnot_jax_tracer)blockcollapse condition infer_configliftmaskreparamreplayscalescopeseed substitutetracedocs0eZdZdZfddZddZddZZS)ra Returns a handler that records the inputs and outputs at primitive calls inside `fn`. **Example:** .. doctest:: >>> from jax import random >>> import numpyro >>> import numpyro.distributions as dist >>> from numpyro.handlers import seed, trace >>> import pprint as pp >>> def model(): ... numpyro.sample('a', dist.Normal(0., 1.)) >>> exec_trace = trace(seed(model, random.PRNGKey(0))).get_trace() >>> pp.pprint(exec_trace) # doctest: +SKIP OrderedDict([('a', {'args': (), 'fn': , 'is_observed': False, 'kwargs': {'rng_key': DeviceArray([0, 0], dtype=uint32)}, 'name': 'a', 'type': 'sample', 'value': DeviceArray(-0.20584235, dtype=float32)})]) cstt|t|_|jSN)superr __enter__rself __class__`/mounts/lovelace/software/anaconda3/envs/metaDMG/lib/python3.9/site-packages/numpyro/handlers.pyrsztrace.__enter__cCsNd|vr dS|ddvr8|d|jvr8Jd|d||j|d<dS)Nnametype)sample deterministicz8all sites must have unique names but got `{}` duplicated)rformatcopyrmsgr!r!r"postprocess_messages  ztrace.postprocess_messagecOs||i||jS)z Run the wrapped callable and return the recorded trace. :param `*args`: arguments to the callable. :param `**kwargs`: keyword arguments to the callable. :return: `OrderedDict` containing the execution trace. )rrargskwargsr!r!r" get_tracesztrace.get_trace)__name__ __module__ __qualname____doc__rr+r/ __classcell__r!r!rr"rts  rcs*eZdZdZdfdd ZddZZS)ra Given a callable `fn` and an execution trace `trace`, return a callable which substitutes `sample` calls in `fn` with values from the corresponding site names in `trace`. :param fn: Python callable with NumPyro primitives. :param trace: an OrderedDict containing execution metadata. **Example:** .. doctest:: >>> from jax import random >>> import numpyro >>> import numpyro.distributions as dist >>> from numpyro.handlers import replay, seed, trace >>> def model(): ... numpyro.sample('a', dist.Normal(0., 1.)) >>> exec_trace = trace(seed(model, random.PRNGKey(0))).get_trace() >>> print(exec_trace['a']['value']) # doctest: +SKIP -0.20584235 >>> replayed_trace = trace(replay(model, exec_trace)).get_trace() >>> print(exec_trace['a']['value']) # doctest: +SKIP -0.20584235 >>> assert replayed_trace['a']['value'] == exec_trace['a']['value'] Ncs&|dus J||_tt||dSr)rrr__init__)rfnrrr!r"r5s zreplay.__init__cCs|ddvr|d|jvr|d}|ddvr||jvr|j|}|ddkrz|ddkrjtd|d|d|d<dS|drdS|dd ks|drtd|d |d|d<|d |d <dS) Nr$)r%r r#r zSite z must be a plate in trace.value is_observedr%z must be sampled in trace.infer)r RuntimeError)rr*r#Z guide_msgr!r!r"process_messages     zreplay.process_message)NNr0r1r2r3r5r;r4r!r!rr"rsrcs*eZdZdZdfdd ZddZZS)r a Given a callable `fn`, return another callable that selectively hides primitive sites where `hide_fn` returns True from other effect handlers on the stack. :param callable fn: Python callable with NumPyro primitives. :param callable hide_fn: function which when given a dictionary containing site-level metadata returns whether it should be blocked. :param list hide: list of site names to hide. :param list expose_types: list of site types to expose, e.g. `['param']`. **Example:** .. doctest:: >>> from jax import random >>> import numpyro >>> from numpyro.handlers import block, seed, trace >>> import numpyro.distributions as dist >>> def model(): ... a = numpyro.sample('a', dist.Normal(0., 1.)) ... return numpyro.sample('b', dist.Normal(a, 1.)) >>> model = seed(model, random.PRNGKey(0)) >>> block_all = block(model) >>> block_a = block(model, lambda site: site['name'] == 'a') >>> trace_block_all = trace(block_all).get_trace() >>> assert not {'a', 'b'}.intersection(trace_block_all.keys()) >>> trace_block_a = trace(block_a).get_trace() >>> assert 'a' not in trace_block_a >>> assert 'b' in trace_block_a Ncs^|dur||_n:dur(fdd|_n"dur@fdd|_n dd|_tt||dS)Ncs|dvS)Nr#getr*)hider!r" z block.__init__..cs|dvS)Nr$r=r?) expose_typesr!r"rA rBcSsdS)NTr!r?r!r!r"rArB)hide_fnrr r5)rr6rDr@rCr)rCr@r"r5s zblock.__init__cCs||rd|d<dS)NTstop)rDr)r!r!r"r;s zblock.process_message)NNNNr<r!r!rr"r s" r csDeZdZdZdZfddZddZfddZfd d ZZ S) r a4 EXPERIMENTAL Collapses all sites in the context by lazily sampling and attempting to use conjugacy relations. If no conjugacy is known this will fail. Code using the results of sample sites must be written to accept Funsors rather than Tensors. This requires ``funsor`` to be installed. NcsHtjdur2ddl}ddlm}|d|dt_tj|i|dS)Nr)CoerceDistributionToFunsorjax)r _coercefunsorZfunsor.distributionrFZ set_backendrr5)rr-r.rIrFrr!r"r5!s     zcollapse.__init__cCs\ddlm}|ddkrX|ddur0|d|d<t|d|sPt|dt|frXd|d <dS) Nr)Funsorr$r%r7r#r6TrE)Z funsor.termsrJ isinstancestr)rr*rJr!r!r"r;*s      zcollapse.process_messagecs*tddtD|_t|jtS)Ncss|]}t|tr|jVqdSr)rKr r#).0hr!r!r" 5sz%collapse.__enter__..) frozensetrpreserved_platesrappendrHrrrrr!r"r4s   zcollapse.__enter__csNddl}t}||jusJt||||dur:dSg}g}t}|jD]\} } | ddkrhqR| dsz| | dd| dD} | | d|j | } | d } t | t s| | d | jd | } | | | d |td d | dDO}qR|sJd ||j}|jj|jj|jj|t||B|d}|d} t| |jdS)Nrr$r%r8cSsi|]}|j|jqSr!)dimr#rMfr!r!r" NrBz%collapse.__exit__..cond_indep_stackr6r7)r7css|] }|jVqdSr)r#rTr!r!r"rOTrBz$collapse.__exit__..znothing to collapse)Z eliminateplates)rIrpoprHr__exit__rPritemsrRZ to_funsorRealrKrLinputsrQZ sum_productopsZ logaddexpaddnumpyrofactordata)rexc_type exc_value tracebackrIrHZ reduced_varsZlog_prob_termsrXr#siteZ dim_to_namer6r7Zreduced_platesZlog_probrr!r"rZ;s@     zcollapse.__exit__) r0r1r2r3rHr5r;rrZr4r!r!rr"r s   r cs*eZdZdZdfdd ZddZZS)ra" Conditions unobserved sample sites to values from `data` or `condition_fn`. Similar to :class:`~numpyro.handlers.substitute` except that it only affects `sample` sites and changes the `is_observed` property to `True`. :param fn: Python callable with NumPyro primitives. :param dict data: dictionary of `numpy.ndarray` values keyed by site names. :param condition_fn: callable that takes in a site dict and returns a numpy array or `None` (in which case the handler has no side effect). **Example:** .. doctest:: >>> from jax import random >>> import numpyro >>> from numpyro.handlers import condition, seed, substitute, trace >>> import numpyro.distributions as dist >>> def model(): ... numpyro.sample('a', dist.Normal(0., 1.)) >>> model = seed(model, random.PRNGKey(0)) >>> exec_trace = trace(condition(model, {'a': -1})).get_trace() >>> assert exec_trace['a']['value'] == -1 >>> assert exec_trace['a']['is_observed'] NcsB||_||_tdd||fDdkr.tdtt||dS)Ncss|]}|duVqdSrr!rMxr!r!r"rOrBz%condition.__init__..z8Only one of `data` or `condition_fn` should be provided.) condition_fnrbsum ValueErrorrrr5)rr6rbrjrr!r"r5szcondition.__init__cCs|ddks|ddrl|ddkrh|jdurF|ddd|jf|jdurh|ddd|jfdS|jdur|j|d }n ||}|dur||d <d |d <dS) Nr$r%_control_flow_doneF control_flowr.substitute_stackrr#r7Tr8)r>rbrRrjrr*r7r!r!r"r;s      zcondition.process_message)NNNr<r!r!rr"rbs rcs*eZdZdZdfdd ZddZZS)ra 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). :param fn: a stochastic function (callable containing NumPyro primitive calls) :param config_fn: a callable taking a site and returning an infer dict Ncst|||_dSr)rr5 config_fn)rr6rqrr!r"r5s zinfer_config.__init__cCs$|ddvr |d||dS)Nr$)r%r9)updaterqr)r!r!r"r;s zinfer_config.process_message)NNr<r!r!rr"rs rcsBeZdZdZd fdd ZfddZfddZd d ZZS) ra- Given a stochastic function with ``param`` calls and a prior distribution, create a stochastic function where all param calls are replaced by sampling from prior. Prior should be a distribution or a dict of names to distributions. Consider the following NumPyro program: >>> import numpyro >>> import numpyro.distributions as dist >>> from numpyro.handlers import lift >>> >>> def model(x): ... s = numpyro.param("s", 0.5) ... z = numpyro.sample("z", dist.Normal(x, s)) ... return z ** 2 >>> lifted_model = lift(model, prior={"s": dist.Exponential(0.3)}) ``lift`` makes ``param`` statements behave like ``sample`` statements using the distributions in ``prior``. In this example, site `s` will now behave as if it was replaced with ``s = numpyro.sample("s", dist.Exponential(0.3))``. :param fn: function whose parameters will be lifted to random values :param prior: prior function in the form of a Distribution or a dict of Distributions Ncst|||_i|_dSr)rr5prior_samples_cache)rr6rsrr!r"r5s z lift.__init__csi|_tSr)rtrrrrr!r"rszlift.__enter__csi|_tj|i|Sr)rtrrZr,rr!r"rZsz lift.__exit__cCs|ddkrdS|d}t|jtr0|j|n|j}t|tjjrd|d<||d<d|d<|dd d|dd dd |d<g|d <|d i|d <ndS||jvr|j|d|d<d|d<d|d<n||j|<d|d<dS)Nr$paramr#r%r6r!r-r.rng_key sample_shape)rvrwZ intermediatesr9r7Tr8rEF)rKrsdictr>r` distributions Distributionrt)rr*r#r6r!r!r"r;s(     zlift.process_message)NN) r0r1r2r3r5rrZr;r4r!r!rr"rs   rcs*eZdZdZdfdd ZddZZS) rz This messenger masks out some of the sample statements elementwise. :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). NTcs,t|dkrtd||_t|dS)Nboolz`mask` should be a bool array.)jnpZ result_typerlrrr5)rr6rrr!r"r5sz mask.__init__cCsX|ddkr@|ddkr<|ddur*|jn |j|d@|d<dS|d|j|d<dS)Nr$r%inspectrr6)rr)r!r!r"r;s   zmask.process_message)NTr<r!r!rr"rsrcs*eZdZdZdfdd ZddZZS)ra Reparametrizes each affected sample site into one or more auxiliary sample sites followed by a deterministic transformation [1]. To specify reparameterizers, pass a ``config`` dict or callable to the constructor. See the :mod:`numpyro.infer.reparam` module for available reparameterizers. Note some reparameterizers can examine the ``*args,**kwargs`` inputs of functions they affect; these reparameterizers require using ``handlers.reparam`` as a decorator rather than as a context manager. [1] Maria I. Gorinova, Dave Moore, Matthew D. Hoffman (2019) "Automatic Reparameterisation of Probabilistic Programs" https://arxiv.org/pdf/1906.03028.pdf :param config: Configuration, either a dict mapping site name to :class:`~numpyro.infer.reparam.Reparam` , or a function mapping site to :class:`~numpyro.infer.reparam.Reparam` or None. :type config: dict or callable Ncs,t|tst|sJ||_t|dSr)rKrxcallableconfigrr5)rr6rrr!r"r5)szreparam.__init__cCs|ddkrdSt|jtr.|j|d}n ||}|durDdS||d|d|d\}}|dur|durd|d<||d<t|D]}|dvr||=qdS|ddurd|d <||d<||d<dS) Nr$r%r#r6r7r&)r$r#r7Tr8)rKrrxr>listkeys)rr*rZnew_fnr7keyr!r!r"r;.s(    zreparam.process_message)NNr<r!r!rr"rsrcs*eZdZdZdfdd ZddZZS) ran This messenger rescales the log probability score. This is typically used for data subsampling or for stratified sampling of data (e.g. in fraud detection where negatives vastly outnumber positives). :param scale: a positive scaling factor that is broadcastable to the shape of log probability. :type scale: float or numpy.ndarray N?cs8t|r"tt|dr"td||_t|dS)Nrz$'scale' argument should be positive.)r npanyZ less_equalrlrrr5)rr6rrr!r"r5Vs zscale.__init__cCs:|ddvrdS|ddur$|jn |j|d|d<dS)Nr$)rur%r r)r>rr)r!r!r"r;]s  zscale.process_message)Nrr<r!r!rr"rJs rcs0eZdZdZd ddfdd Zdd ZZS) ra- This handler prepend a prefix followed by a divider to the name of sample sites. **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="."): ... 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 :param str divider: a string to join the prefix and sample name; default to `'/'` :param list hide_types: an optional list of side types to skip renaming. N/) hide_typescs.||_||_|durgn||_t|dSr)prefixdividerrrr5)rr6rrrrr!r"r5szscope.__init__csf|dr4|djvr4jj|d|d<|drbdjvrbfdd|dD|d<dS)Nr#r$rWr cs.g|]&}tjj|j|j|jqSr!)rrrr#rSsize)rMirr!r" sz)scope.process_message..)r>rrrr)r!rr"r;s  zscope.process_message)Nrrr<r!r!rr"rfsrcs*eZdZdZdfdd ZddZZS)ra JAX uses a functional pseudo random number generator that requires passing in a seed :func:`~jax.random.PRNGKey` to every stochastic function. The `seed` handler allows us to initially seed a stochastic function with a :func:`~jax.random.PRNGKey`. Every call to the :func:`~numpyro.handlers.sample` primitive inside the function results in a splitting of this initial seed so that we use a fresh seed for each subsequent call without having to explicitly pass in a `PRNGKey` to each `sample` call. :param fn: Python callable with NumPyro primitives. :param rng_seed: a random number generator seed. :type rng_seed: int, jnp.ndarray scalar, or jax.random.PRNGKey .. note:: Unlike in Pyro, `numpyro.sample` primitive cannot be used without wrapping it in seed handler since there is no global random state. As such, users need to use `seed` as a contextmanager to generate samples from distributions or as a decorator for their model callable (See below). **Example:** .. doctest:: >>> from jax import random >>> import numpyro >>> import numpyro.handlers >>> import numpyro.distributions as dist >>> # as context manager >>> with handlers.seed(rng_seed=1): ... x = numpyro.sample('x', dist.Normal(0., 1.)) >>> def model(): ... return numpyro.sample('y', dist.Normal(0., 1.)) >>> # as function decorator (/modifier) >>> y = handlers.seed(model, rng_seed=1)() >>> assert x == y Ncst|ts&t|tjtjfr0t|s0t|}t|tjtjfrX|jtj krX|jdksjt d t |||_ tt||dS)N)zIncorrect type for rng_seed: {})rKintrZndarrayr|shaperZPRNGKeyZdtypeZuint32 TypeErrorr'r$rvrrr5)rr6Zrng_seedrr!r"r5s   z seed.__init__cCsb|ddkr$|ds$|dddus0|ddvr^|ddur@dSt|j\|_}||dd<dS)Nr$r%r8r.rv)Zprng_keyr rnr7)rsplitrv)rr*Zrng_key_sampler!r!r"r;s   zseed.process_message)NNr<r!r!rr"rs)rcs*eZdZdZdfdd ZddZZS)ra Given a callable `fn` and a dict `data` keyed by site names (alternatively, a callable `substitute_fn`), return a callable which substitutes all primitive calls in `fn` with values from `data` whose key matches the site name. If the site name is not present in `data`, there is no side effect. If a `substitute_fn` is provided, then the value at the site is 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 use the :class:`condition` handler. :param fn: Python callable with NumPyro primitives. :param dict data: dictionary of `numpy.ndarray` values keyed by site names. :param substitute_fn: callable that takes in a site dict and returns a numpy array or `None` (in which case the handler has no side effect). **Example:** .. doctest:: >>> from jax import random >>> import numpyro >>> from numpyro.handlers import seed, substitute, trace >>> import numpyro.distributions as dist >>> def model(): ... numpyro.sample('a', dist.Normal(0., 1.)) >>> model = seed(model, random.PRNGKey(0)) >>> exec_trace = trace(substitute(model, {'a': -1})).get_trace() >>> assert exec_trace['a']['value'] == -1 NcsB||_||_tdd||fDdkr.tdtt||dS)Ncss|]}|duVqdSrr!rgr!r!r"rOrBz&substitute.__init__..riz9Only one of `data` or `substitute_fn` should be provided.) substitute_fnrbrkrlrrr5)rr6rbrrr!r"r5szsubstitute.__init__cCs|ddvs|ddrl|ddkrh|jdurF|ddd|jf|jdurh|ddd|jfdS|jdur|j|d }n ||}|dur||d <dS) Nr$)r%ruZmutabler rmFrnr.rorr#r7)r>rbrRrrpr!r!r"r;s       zsubstitute.process_message)NNNr<r!r!rr"rs' rcs*eZdZdZdfdd ZddZZS)ra Given a stochastic function with some sample statements and a dictionary of values at names, set the return values of those sites equal to the values as if they were hard-coded to those values and introduce fresh sample sites with the same names whose values do not propagate. Composes freely with :func:`~numpyro.handlers.condition` to represent counterfactual distributions over potential outcomes. See Single World Intervention Graphs [1] for additional details and theory. This is equivalent to replacing `z = numpyro.sample("z", ...)` with `z = 1.` and introducing a fresh sample site `numpyro.sample("z", ...)` whose value is not used elsewhere. **References:** 1. *Single World Intervention Graphs: A Primer*, Thomas Richardson, James Robins :param fn: a stochastic function (callable containing Pyro primitive calls) :param data: a ``dict`` mapping sample site names to interventions **Example:** .. doctest:: >>> import jax.numpy as jnp >>> import numpyro >>> from numpyro.handlers import do, trace, seed >>> import numpyro.distributions as dist >>> def model(x): ... s = numpyro.sample("s", dist.LogNormal()) ... z = numpyro.sample("z", dist.Normal(x, s)) ... return z ** 2 >>> intervened_model = handlers.do(model, data={"z": 1.}) >>> with trace() as exec_trace: ... z_square = seed(intervened_model, 0)(1) >>> assert exec_trace['z']['value'] != 1. >>> assert not exec_trace['z']['is_observed'] >>> assert not exec_trace['z'].get('stop', None) >>> assert z_square == 1 Ncs(||_tt||_tt||dSr)rbrLid_intervener_idrrr5)rr6rbrr!r"r5Jsz do.__init__cCs|ddkrdS|dd|jkr|j|ddur|dddurbtjd|dttd|j|d<|}t ||j|d}|dd|d<||d<d |d <d |d <dS) Nr$r%rr#zaAttempting to intervene on variable {} multiple times,this is almost certainly incorrect behavior) stacklevelZ__CFr7Tr8rE) r>rrbwarningswarnr'RuntimeWarningr r(r)rr*Znew_msgZ interventionr!r!r"r;Os,  zdo.process_message)NNr<r!r!rr"rs+r)%r3 collectionsrrnumpyrrGrZ jax.numpyr|r`Z"numpyro.distributions.distributionrZnumpyro.primitivesrrrrr Z numpyro.utilr r __all__rrr r rrrrrrrrrrr!r!r!r"s0K    ;53K=F9,EG