In Pyro, how do infer continuous params in a training step, then a discrete latent conditional on first step?

This is an embarrassingly question. But I’m developing course lectures and want to make sure I teach student best practices instead of what’s right to me.

Imagine this were the true DGP

def true_dgp(jenny_inclination, brian_inclination, window_strength):
    # input variables are numbers between 0 and 1
    jenny_throws_ball = jenny_inclination > 0.2
    brian_throws_ball = brian_inclination > 0.8
    if jenny_throws_ball and brian_throws_ball:
        strength_of_impact = 0.8
    elif jenny_throws_ball or brian_throws_ball:
        strength_of_impact = 0.6
        strength_of_impact = 0.0
    window_breaks = window_strength < strength_of_impact
    return jenny_throws_ball, brian_throws_ball, window_breaks

Above, jenny_inclination, brian_inclination, and window_strength are uniformly distributed 0 and 1.

Here is the model of the DGP.

def model():
    # Priors that represent uncertainty about the parameters in our model
    ρ_a = pyro.sample("ρ_a", pyro.distributions.Beta(1, 1))
    ρ_b = pyro.sample("ρ_b", pyro.distributions.Beta(1, 1))
    # Our symbolic explanation generator of the DGP
    jenny_throws_ball = pyro.sample(
        "jenny_throws_ball", pyro.distributions.Bernoulli(ρ_a)
    brian_throws_ball = pyro.sample(
        "brian_throws_ball", pyro.distributions.Bernoulli(ρ_b)
    ρ_strength_of_impact = 0.0
    if jenny_throws_ball and brian_throws_ball:
        ρ_strength_of_impact = 0.8
    elif jenny_throws_ball or brian_throws_ball:
        ρ_strength_of_impact = 0.4
    window_breaks = pyro.sample(
    return jenny_throws_ball, brian_throws_ball, window_breaks

In my lecture notes, I use trueDGP to sample 100 observations of jenny_throws_ball, brian_throws_ball, window_breaks. Call this training_data. Then we are interested in a post training query, such as P(Jenny threw ball | window is broken). So evidence = {‘window_breaks’: torch.tensor(1)}.

What’s the best way to do this in Pyro? My instinct says condition(condition(model, training_data), evidence) (or use the “obs” argument in pyro.sample for the first condition) and then use Importance sampling?

Though that doesn’t seem wise if the space of the continuous parameters that get optimized in the first condition is complex. Moreover, an ideal workflow would be something that learned the continuous “weight” parameters once, then use that object as an input to an inference algorithm that answers conditional queries defined on jenny_throws_ball, brian_throws_ball, window_breaks that come up later.

I was thinking one could use NUTS or SVI to inferring the continuous parameters, then use that “posterior” object in a guide function targeting the other variables, perhaps using importance sampling?

That seems pretty complicated. Perhaps I do something with the Predictive class? I feel like I’m missing something obvious, sorry.

Hi @osazuwa! I assume DGP means “data generating process”? I guess each query like P(Jenny threw ball | window is broken) involves different evidence and this requires inference. From Pyro’s perspective there’s no difference between data and evidence, so just as you’ll need fresh inference when data changes, you’ll need fresh inference when evidence changes.

I guess there are a few tactics to make query-time inference cheap. One tactic is to use importance sampling, as you suggest. Another tactic is to either enumerate over evidence (essentially precompute posteriors of all possible evidence) or to amortize. Amortization is probably the most scalable approach if your evidence space is large: you could train a VAE on (data, evidence) pairs where data is fixed and evidence is sampled from a distribution over the kinds of queries you expect (e.g. a uniform distribution).