probabilistic-programming

NumPyro now has several excellent introductory examples with no direct counterparts in Pyro. Porting one of these to Pyro would be a great way for someone to simultaneously learn more about Bayesian data analysis and make a valuable open source contribution.

If you are reading this and want to give one of them a try, please leave a comment here so that other peo

The currently implemented version of the horseshoe distribution is not the parameterization that most ML papers use. This limits the ease of use of this as, for example, a prior in a tfp.layers.KLDivergenceAddLoss or in tfp.layers.DenseReparameterization. The regularized horseshoe would also be useful as an implemented distribution.

The alternative parameterization is shown here:
https://www.

Ankit Shah and I are trying to use Gen to support a project and would love the addition of a dirichlet distribution

A quick search for mixture distributions in numpyro only turns up examples using Categorical in conjunction with an array of distributions. Since sampling from discrete distributions is not always desirable, I have implemented a quick general purpose mixture distribution with continuous log probability.

class Mixture(Distribution):
    arg_constraints = {}

    def __init__(self

The current example on MDN from Edward tutorials needs small modifications to run on edward2. Documentation covering these modifications will be appreciated.

Hi,

Looks like there is support for lots of common distribution. There are a handful of other distributions which are not presently supported but could (fingers crossed) be easily implemented. Looking at [Stan's Function Reference] I see...

• Beta Binomial
• [Chi-Square](https://mc-stan.org/docs/2

Rather than trying to rebuild all functionality from Distributions.jl, we're first focusing on reimplementing logdensity (logpdf in Distributions), and delegating most other functions to the current Distributions implementations.

So for example, we have

distproxy(d::Normal{(:μ, :σ)}) = Dists.Normal(d.μ, d.σ)

This makes some functions in Distributions.jl available through

There are a variety of interesting optimisations that can be performed on kernels of the form

k(x, z) = w_1 * k_1(x, z) + w_2 * k_2(x, z) + ... + w_L k_L(x, z)

A naive recursive implementation in terms of the current Sum and Scaled kernels hides opportunities for parallelism in the computation of each term, and the summation over terms.

Notable examples of kernels with th

After #210, it should be straightforward to add multi-pathfinder (ref: https://arxiv.org/pdf/2108.03782.pdf). The code snippet below mostly work (still need implementation of Pareto Smoothed important sampling).

multi_pathfinder = jax.vmap(lambda rng_key, x: blackjax.vi.pathfinder.init(rng_key, logprob_fn, x))
n_batch = 100
rng_keys = jax.random.split(rng_key, n_batch)
xs = w0 * j

Respectively, import should load the predictor+code.