def test_reduce_logaddexp(int_inputs, real_inputs):
int_inputs = OrderedDict(sorted(int_inputs.items()))
real_inputs = OrderedDict(sorted(real_inputs.items()))
inputs = int_inputs.copy()
inputs.update(real_inputs)
t = random_tensor(int_inputs)
g = random_gaussian(inputs)
truth = {
name: random_tensor(int_inputs, domain)
for name, domain in real_inputs.items()
}
state = 0
state += g
state += t
for name, point in truth.items():
with xfail_if_not_implemented():
state += Delta(name, point)
actual = state.reduce(ops.logaddexp, frozenset(truth))
expected = t + g(**truth)
assert_close(actual,
expected,
atol=1e-5,
rtol=1e-4 if get_backend() == "jax" else 1e-5)
def test_lognormal_distribution(moment):
num_samples = 100000
inputs = OrderedDict(batch=bint(10))
loc = random_tensor(inputs)
scale = random_tensor(inputs).exp()
log_measure = dist.LogNormal(loc, scale)(value='x')
probe = Variable('x', reals())**moment
with monte_carlo_interpretation(particle=bint(num_samples)):
with xfail_if_not_implemented():
actual = Integrate(log_measure, probe, frozenset(['x']))
samples = backend_dist.LogNormal(loc, scale).sample((num_samples, ))
expected = (samples**moment).mean(0)
assert_close(actual.data, expected, atol=1e-2, rtol=1e-2)
def test_lognormal_distribution(moment):
num_samples = 100000
inputs = OrderedDict(batch=Bint[10])
loc = random_tensor(inputs)
scale = random_tensor(inputs).exp()
log_measure = dist.LogNormal(loc, scale)(value='x')
probe = Variable('x', Real)**moment
with interpretation(MonteCarlo(particle=Bint[num_samples])):
with xfail_if_not_implemented():
actual = Integrate(log_measure, probe, frozenset(['x']))
_, (loc_data, scale_data) = align_tensors(loc, scale)
samples = backend_dist.LogNormal(loc_data, scale_data).sample(
(num_samples, ))
expected = (samples**moment).mean(0)
assert_close(actual.data, expected, atol=1e-2, rtol=1e-2)
def test_eager_subs(int_inputs, real_inputs):
int_inputs = OrderedDict(sorted(int_inputs.items()))
real_inputs = OrderedDict(sorted(real_inputs.items()))
inputs = int_inputs.copy()
inputs.update(real_inputs)
g = random_gaussian(inputs)
for order in itertools.permutations(inputs):
ground_values = {}
dependent_values = {}
for i, name in enumerate(order):
upstream = OrderedDict([(k, inputs[k]) for k in order[:i]
if k in int_inputs])
value = random_tensor(upstream, inputs[name])
ground_values[name] = value(**ground_values)
dependent_values[name] = value
expected = g(**ground_values)
actual = g
for k in reversed(order):
with xfail_if_not_implemented():
actual = actual(**{k: dependent_values[k]})
assert_close(actual, expected, atol=1e-4)
@pytest.mark.parametrize("case", TEST_CASES, ids=str)
@pytest.mark.parametrize("expand", [False, True])
def test_generic_enumerate_support(case, expand):
with xfail_if_not_found():
raw_dist = eval(case.raw_dist)
dim_to_name, name_to_dim = _default_dim_to_name(raw_dist.batch_shape)
with interpretation(normalize_with_subs):
funsor_dist = to_funsor(raw_dist, output=funsor.Real, dim_to_name=dim_to_name)
assert getattr(raw_dist, "has_enumerate_support", False) == getattr(funsor_dist, "has_enumerate_support", False)
if getattr(funsor_dist, "has_enumerate_support", False):
name_to_dim["value"] = -1 if not name_to_dim else min(name_to_dim.values()) - 1
with xfail_if_not_implemented("enumerate support not implemented"):
raw_support = raw_dist.enumerate_support(expand=expand)
funsor_support = funsor_dist.enumerate_support(expand=expand)
assert_close(to_data(funsor_support, name_to_dim=name_to_dim), raw_support)
@pytest.mark.parametrize("case", TEST_CASES, ids=str)
@pytest.mark.parametrize("sample_shape", [(), (2,), (4, 3)], ids=str)
def test_generic_sample(case, sample_shape):
with xfail_if_not_found():
raw_dist = eval(case.raw_dist)
dim_to_name, name_to_dim = _default_dim_to_name(sample_shape + raw_dist.batch_shape)
with interpretation(normalize_with_subs):
funsor_dist = to_funsor(raw_dist, output=funsor.Real, dim_to_name=dim_to_name)