def test_logpt_incsubtensor(indices, size):
"""Make sure we can compute a log-likelihood for ``Y[idx] = data`` where ``Y`` is univariate."""
mu = floatX(np.power(10, np.arange(np.prod(size)))).reshape(size)
data = mu[indices]
sigma = 0.001
rng = np.random.RandomState(232)
a_val = rng.normal(mu, sigma, size=size).astype(aesara.config.floatX)
rng = aesara.shared(rng, borrow=False)
a = Normal.dist(mu, sigma, size=size, rng=rng)
a_value_var = a.type()
a.name = "a"
a_idx = at.set_subtensor(a[indices], data)
assert isinstance(a_idx.owner.op, (IncSubtensor, AdvancedIncSubtensor, AdvancedIncSubtensor1))
a_idx_value_var = a_idx.type()
a_idx_value_var.name = "a_idx_value"
a_idx_logp = logpt(a_idx, {a_idx: a_value_var}, sum=False)
logp_vals = a_idx_logp.eval({a_value_var: a_val})
# The indices that were set should all have the same log-likelihood values,
# because the values they were set to correspond to the unique means along
# that dimension. This helps us confirm that the log-likelihood is
# associating the assigned values with their correct parameters.
a_val_idx = a_val.copy()
a_val_idx[indices] = data
exp_obs_logps = sp.norm.logpdf(a_val_idx, mu, sigma)
np.testing.assert_almost_equal(logp_vals, exp_obs_logps)
def test_logpt_basic():
"""Make sure we can compute a log-likelihood for a hierarchical model with transforms."""
with Model() as m:
a = Uniform("a", 0.0, 1.0)
c = Normal("c")
b_l = c * a + 2.0
b = Uniform("b", b_l, b_l + 1.0)
a_value_var = m.rvs_to_values[a]
assert a_value_var.tag.transform
b_value_var = m.rvs_to_values[b]
assert b_value_var.tag.transform
c_value_var = m.rvs_to_values[c]
b_logp = logpt(b, b_value_var, sum=False)
res_ancestors = list(walk_model((b_logp,), walk_past_rvs=True))
res_rv_ancestors = [
v for v in res_ancestors if v.owner and isinstance(v.owner.op, RandomVariable)
]
# There shouldn't be any `RandomVariable`s in the resulting graph
assert len(res_rv_ancestors) == 0
assert b_value_var in res_ancestors
assert c_value_var in res_ancestors
assert a_value_var in res_ancestors
def test_logpt_subtensor():
"""Make sure we can compute a log-likelihood for ``Y[I]`` where ``Y`` and ``I`` are random variables."""
size = 5
mu_base = floatX(np.power(10, np.arange(np.prod(size)))).reshape(size)
mu = np.stack([mu_base, -mu_base])
sigma = 0.001
rng = aesara.shared(np.random.RandomState(232), borrow=True)
A_rv = Normal.dist(mu, sigma, rng=rng)
A_rv.name = "A"
p = 0.5
I_rv = Bernoulli.dist(p, size=size, rng=rng)
I_rv.name = "I"
A_idx = A_rv[I_rv, at.ogrid[A_rv.shape[-1]:]]
assert isinstance(A_idx.owner.op,
(Subtensor, AdvancedSubtensor, AdvancedSubtensor1))
A_idx_value_var = A_idx.type()
A_idx_value_var.name = "A_idx_value"
I_value_var = I_rv.type()
I_value_var.name = "I_value"
A_idx_logp = logpt(A_idx, {
A_idx: A_idx_value_var,
I_rv: I_value_var
},
sum=False)
logp_vals_fn = aesara.function([A_idx_value_var, I_value_var], A_idx_logp)
# The compiled graph should not contain any `RandomVariables`
assert_no_rvs(logp_vals_fn.maker.fgraph.outputs[0])
decimals = select_by_precision(float64=6, float32=4)
for i in range(10):
bern_sp = sp.bernoulli(p)
I_value = bern_sp.rvs(size=size).astype(I_rv.dtype)
norm_sp = sp.norm(mu[I_value, np.ogrid[mu.shape[1]:]], sigma)
A_idx_value = norm_sp.rvs().astype(A_idx.dtype)
exp_obs_logps = norm_sp.logpdf(A_idx_value)
exp_obs_logps += bern_sp.logpmf(I_value)
logp_vals = logp_vals_fn(A_idx_value, I_value)
np.testing.assert_almost_equal(logp_vals,
exp_obs_logps,
decimal=decimals)
def assert_moment_is_expected(model, expected, check_finite_logp=True):
fn = make_initial_point_fn(
model=model,
return_transformed=False,
default_strategy="moment",
)
moment = fn(0)["x"]
expected = np.asarray(expected)
try:
random_draw = model["x"].eval()
except NotImplementedError:
random_draw = moment
assert moment.shape == expected.shape == random_draw.shape
assert np.allclose(moment, expected)
if check_finite_logp:
logp_moment = logpt(model["x"], at.constant(moment), transformed=False).eval()
assert np.isfinite(logp_moment)