def forward(self):
mu = pyprob.sample(Normal(self.prior_mean, self.prior_stddev))
likelihood = Normal(mu, self.likelihood_stddev)
# pyprob.observe usage alternative #2
pyprob.sample(likelihood, name='obs0')
pyprob.sample(likelihood, name='obs1')
return mu
def test_dist_normal_batched(self):
dist_sample_shape_correct = [2, 1]
dist_means_correct = [[0], [2]]
dist_stddevs_correct = [[1], [3]]
dist_log_probs_correct = [[-0.918939], [-2.01755]]
dist = Normal(dist_means_correct, dist_stddevs_correct)
dist_sample_shape = list(dist.sample().size())
dist_empirical = Empirical(
[dist.sample() for i in range(empirical_samples)])
dist_means = util.to_numpy(dist.mean)
dist_means_empirical = util.to_numpy(dist_empirical.mean)
dist_stddevs = util.to_numpy(dist.stddev)
dist_stddevs_empirical = util.to_numpy(dist_empirical.stddev)
dist_log_probs = util.to_numpy(dist.log_prob(dist_means_correct))
util.debug('dist_sample_shape', 'dist_sample_shape_correct',
'dist_means', 'dist_means_empirical', 'dist_means_correct',
'dist_stddevs', 'dist_stddevs_empirical',
'dist_stddevs_correct', 'dist_log_probs',
'dist_log_probs_correct')
self.assertEqual(dist_sample_shape, dist_sample_shape_correct)
self.assertTrue(np.allclose(dist_means, dist_means_correct, atol=0.1))
self.assertTrue(
np.allclose(dist_means_empirical, dist_means_correct, atol=0.1))
self.assertTrue(
np.allclose(dist_stddevs, dist_stddevs_correct, atol=0.1))
self.assertTrue(
np.allclose(dist_stddevs_empirical, dist_stddevs_correct,
atol=0.1))
self.assertTrue(
np.allclose(dist_log_probs, dist_log_probs_correct, atol=0.1))
def forward(self):
mu = pyprob.sample(Normal(self.prior_mean, self.prior_stddev))
likelihood = Normal(mu, self.likelihood_stddev)
likelihood_func = lambda x: likelihood.log_prob(x)
pyprob.factor(log_prob=likelihood_func(8))
pyprob.factor(log_prob=likelihood_func(9))
return mu
def test_dist_mixture_batched(self):
dist_sample_shape_correct = [2, 1]
dist_1 = Normal([[0], [1]], [[0.1], [1]])
dist_2 = Normal([[2], [5]], [[0.1], [1]])
dist_3 = Normal([[3], [10]], [[0.1], [1]])
dist_means_correct = [[0.7], [8.1]]
dist_stddevs_correct = [[1.10454], [3.23883]]
dist_log_probs_correct = [[-23.473], [-3.06649]]
dist = Mixture([dist_1, dist_2, dist_3], probs=[[0.7, 0.2, 0.1], [0.1, 0.2, 0.7]])
dist_sample_shape = list(dist.sample().size())
dist_empirical = Empirical([dist.sample() for i in range(empirical_samples)])
dist_means = util.to_numpy(dist.mean)
dist_means_empirical = util.to_numpy(dist_empirical.mean)
dist_stddevs = util.to_numpy(dist.stddev)
dist_stddevs_empirical = util.to_numpy(dist_empirical.stddev)
dist_log_probs = util.to_numpy(dist.log_prob(dist_means_correct))
util.debug('dist_sample_shape', 'dist_sample_shape_correct', 'dist_means', 'dist_means_empirical', 'dist_means_correct', 'dist_stddevs', 'dist_stddevs_empirical', 'dist_stddevs_correct', 'dist_log_probs', 'dist_log_probs_correct')
self.assertEqual(dist_sample_shape, dist_sample_shape_correct)
self.assertTrue(np.allclose(dist_means, dist_means_correct, atol=0.1))
self.assertTrue(np.allclose(dist_means_empirical, dist_means_correct, atol=0.1))
self.assertTrue(np.allclose(dist_stddevs, dist_stddevs_correct, atol=0.1))
self.assertTrue(np.allclose(dist_stddevs_empirical, dist_stddevs_correct, atol=0.1))
self.assertTrue(np.allclose(dist_log_probs, dist_log_probs_correct, atol=0.1))
def test_model_remote_gum_marsaglia_posterior_importance_sampling(self):
observation = [8, 9]
posterior_mean_correct = 7.25
posterior_stddev_correct = math.sqrt(1 / 1.2)
posterior = self._model.posterior_distribution(samples,
observation=observation)
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
kl_divergence = float(
util.kl_divergence_normal(
Normal(posterior_mean_correct, posterior_stddev_correct),
Normal(posterior.mean, posterior_stddev)))
util.debug('samples', 'posterior_mean_unweighted', 'posterior_mean',
'posterior_mean_correct', 'posterior_stddev_unweighted',
'posterior_stddev', 'posterior_stddev_correct',
'kl_divergence')
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
places=0)
self.assertLess(kl_divergence, 0.25)
def test_factor2_gum_posterior_lightweight_metropolis_hastings(self):
samples = lightweight_metropolis_hastings_samples
burn_in = lightweight_metropolis_hastings_burn_in
true_posterior = Normal(7.25, math.sqrt(1 / 1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
posterior = self._model2.posterior_results(
samples,
inference_engine=InferenceEngine.LIGHTWEIGHT_METROPOLIS_HASTINGS
)[burn_in:]
posterior_mean = float(posterior.mean)
posterior_stddev = float(posterior.stddev)
kl_divergence = float(
pyprob.distributions.Distribution.kl_divergence(
true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('samples', 'burn_in', 'posterior_mean',
'posterior_mean_correct', 'posterior_stddev',
'posterior_stddev_correct', 'kl_divergence')
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
delta=0.75)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
delta=0.75)
self.assertLess(kl_divergence, 0.33)
def test_dist_normal_multivariate(self):
dist_sample_shape_correct = [1, 3]
dist_means_correct = [[0, 2, 0]]
dist_stddevs_correct = [[1, 3, 1]]
dist_log_probs_correct = [sum([-0.918939, -2.01755, -0.918939])]
dist = Normal(dist_means_correct, dist_stddevs_correct)
dist_sample_shape = list(dist.sample().size())
dist_empirical = Empirical(
[dist.sample() for i in range(empirical_samples)])
dist_means = util.to_numpy(dist.mean)
dist_means_empirical = util.to_numpy(dist_empirical.mean)
dist_stddevs = util.to_numpy(dist.stddev)
dist_stddevs_empirical = util.to_numpy(dist_empirical.stddev)
dist_log_probs = util.to_numpy(dist.log_prob(dist_means_correct))
util.debug('dist_sample_shape', 'dist_sample_shape_correct',
'dist_means', 'dist_means_empirical', 'dist_means_correct',
'dist_stddevs', 'dist_stddevs_empirical',
'dist_stddevs_correct', 'dist_log_probs',
'dist_log_probs_correct')
self.assertEqual(dist_sample_shape, dist_sample_shape_correct)
self.assertTrue(np.allclose(dist_means, dist_means_correct, atol=0.1))
self.assertTrue(
np.allclose(dist_means_empirical, dist_means_correct, atol=0.1))
self.assertTrue(
np.allclose(dist_stddevs, dist_stddevs_correct, atol=0.1))
self.assertTrue(
np.allclose(dist_stddevs_empirical, dist_stddevs_correct,
atol=0.1))
self.assertTrue(
np.allclose(dist_log_probs, dist_log_probs_correct, atol=0.1))
def test_model_remote_gum_marsaglia_posterior_random_walk_metropolis_hastings(
self):
observation = [8, 9]
posterior_mean_correct = 7.25
posterior_stddev_correct = math.sqrt(1 / 1.2)
posterior = self._model.posterior_distribution(
samples,
inference_engine=pyprob.InferenceEngine.
RANDOM_WALK_METROPOLIS_HASTINGS,
observation=observation)
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
kl_divergence = float(
util.kl_divergence_normal(
Normal(posterior_mean_correct, posterior_stddev_correct),
Normal(posterior.mean, posterior_stddev)))
util.debug('samples', 'posterior_mean_unweighted', 'posterior_mean',
'posterior_mean_correct', 'posterior_stddev_unweighted',
'posterior_stddev', 'posterior_stddev_correct',
'kl_divergence')
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
places=0)
self.assertLess(kl_divergence, 0.25)
def test_dist_mixture(self):
dist_sample_shape_correct = [1]
dist_1 = Normal(0, 0.1)
dist_2 = Normal(2, 0.1)
dist_3 = Normal(3, 0.1)
dist_means_correct = [0.7]
dist_stddevs_correct = [1.10454]
dist_log_probs_correct = [-23.473]
dist = Mixture([dist_1, dist_2, dist_3], probs=[0.7, 0.2, 0.1])
dist_sample_shape = list(dist.sample().size())
dist_empirical = Empirical([dist.sample() for i in range(empirical_samples)])
dist_means = util.to_numpy(dist.mean)
dist_means_empirical = util.to_numpy(dist_empirical.mean)
dist_stddevs = util.to_numpy(dist.stddev)
dist_stddevs_empirical = util.to_numpy(dist_empirical.stddev)
dist_log_probs = util.to_numpy(dist.log_prob(dist_means_correct))
# print(dist.log_prob([2,2]))
util.debug('dist_sample_shape', 'dist_sample_shape_correct', 'dist_means', 'dist_means_empirical', 'dist_means_correct', 'dist_stddevs', 'dist_stddevs_empirical', 'dist_stddevs_correct', 'dist_log_probs', 'dist_log_probs_correct')
self.assertEqual(dist_sample_shape, dist_sample_shape_correct)
self.assertTrue(np.allclose(dist_means, dist_means_correct, atol=0.1))
self.assertTrue(np.allclose(dist_means_empirical, dist_means_correct, atol=0.1))
self.assertTrue(np.allclose(dist_stddevs, dist_stddevs_correct, atol=0.1))
self.assertTrue(np.allclose(dist_stddevs_empirical, dist_stddevs_correct, atol=0.1))
self.assertTrue(np.allclose(dist_log_probs, dist_log_probs_correct, atol=0.1))
def test_inference_gum_posterior_random_walk_metropolis_hastings(self):
samples = random_walk_metropolis_hastings_samples
burn_in = random_walk_metropolis_hastings_burn_in
true_posterior = Normal(7.25, math.sqrt(1 / 1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
start = time.time()
posterior = self._model.posterior_distribution(
samples,
inference_engine=InferenceEngine.RANDOM_WALK_METROPOLIS_HASTINGS,
observe={
'obs0': 8,
'obs1': 9
})[burn_in:]
add_random_walk_metropolis_hastings_duration(time.time() - start)
posterior_mean = float(posterior.mean)
posterior_stddev = float(posterior.stddev)
kl_divergence = float(
pyprob.distributions.Distribution.kl_divergence(
true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('samples', 'burn_in', 'posterior_mean',
'posterior_mean_correct', 'posterior_stddev',
'posterior_stddev_correct', 'kl_divergence')
add_random_walk_metropolis_hastings_kl_divergence(kl_divergence)
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
places=0)
self.assertLess(kl_divergence, 0.25)
def test_inference_gum_marsaglia_replacement_posterior_importance_sampling(
self):
samples = importance_sampling_samples
true_posterior = Normal(7.25, math.sqrt(1 / 1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
prior_mean_correct = 1.
prior_stddev_correct = math.sqrt(5)
posterior_effective_sample_size_min = samples * 0.005
start = time.time()
posterior = self._model.posterior_distribution(
samples,
inference_engine=InferenceEngine.IMPORTANCE_SAMPLING,
observe={
'obs0': 8,
'obs1': 9
})
add_importance_sampling_duration(time.time() - start)
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
posterior_effective_sample_size = float(
posterior.effective_sample_size)
kl_divergence = float(
pyprob.distributions.Distribution.kl_divergence(
true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('samples', 'prior_mean_correct',
'posterior_mean_unweighted', 'posterior_mean',
'posterior_mean_correct', 'prior_stddev_correct',
'posterior_stddev_unweighted', 'posterior_stddev',
'posterior_stddev_correct',
'posterior_effective_sample_size',
'posterior_effective_sample_size_min', 'kl_divergence')
add_importance_sampling_kl_divergence(kl_divergence)
self.assertAlmostEqual(posterior_mean_unweighted,
prior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev_unweighted,
prior_stddev_correct,
places=0)
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
places=0)
self.assertGreater(posterior_effective_sample_size,
posterior_effective_sample_size_min)
self.assertLess(kl_divergence, 0.25)
def test_model_rmh_posterior_with_stop_and_resume_on_disk(self):
file_name = os.path.join(tempfile.mkdtemp(), str(uuid.uuid4()))
posterior_num_runs = 50
posterior_num_traces_each_run = 50
posterior_num_traces_correct = posterior_num_traces_each_run * posterior_num_runs
true_posterior = Normal(7.25, math.sqrt(1 / 1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
prior_mean_correct = 1.
prior_stddev_correct = math.sqrt(5)
initial_trace = None
for i in range(posterior_num_runs):
posterior_traces = self._model.posterior(
num_traces=posterior_num_traces_each_run,
inference_engine=InferenceEngine.
RANDOM_WALK_METROPOLIS_HASTINGS,
observe={
'obs0': 8,
'obs1': 9
},
initial_trace=initial_trace,
file_name=file_name)
initial_trace = posterior_traces[-1]
posterior_traces.close()
posterior = Empirical(file_name=file_name)
posterior.finalize()
posterior = posterior.map(lambda trace: trace.result)
posterior_num_traces = posterior.length
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
kl_divergence = float(
pyprob.distributions.Distribution.kl_divergence(
true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('posterior_num_runs', 'posterior_num_traces_each_run',
'posterior_num_traces', 'posterior_num_traces_correct',
'prior_mean_correct', 'posterior_mean_unweighted',
'posterior_mean', 'posterior_mean_correct',
'prior_stddev_correct', 'posterior_stddev_unweighted',
'posterior_stddev', 'posterior_stddev_correct',
'kl_divergence')
self.assertEqual(posterior_num_traces, posterior_num_traces_correct)
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
places=0)
self.assertLess(kl_divergence, 0.25)
def test_model_rmh_posterior_with_stop_and_resume(self):
posterior_num_runs = 100
posterior_num_traces_each_run = 20
posterior_num_traces_correct = posterior_num_traces_each_run * posterior_num_runs
true_posterior = Normal(7.25, math.sqrt(1 / 1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
prior_mean_correct = 1.
prior_stddev_correct = math.sqrt(5)
posteriors = []
initial_trace = None
for i in range(posterior_num_runs):
posterior = self._model.posterior(
num_traces=posterior_num_traces_each_run,
inference_engine=InferenceEngine.
RANDOM_WALK_METROPOLIS_HASTINGS,
observe={
'obs0': 8,
'obs1': 9
},
initial_trace=initial_trace)
initial_trace = posterior[-1]
posteriors.append(posterior)
posterior = Empirical(
concat_empiricals=posteriors).map(lambda trace: trace.result)
posterior_num_traces = posterior.length
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
kl_divergence = float(
pyprob.distributions.Distribution.kl_divergence(
true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('posterior_num_runs', 'posterior_num_traces_each_run',
'posterior_num_traces', 'posterior_num_traces_correct',
'prior_mean_correct', 'posterior_mean_unweighted',
'posterior_mean', 'posterior_mean_correct',
'prior_stddev_correct', 'posterior_stddev_unweighted',
'posterior_stddev', 'posterior_stddev_correct',
'kl_divergence')
self.assertEqual(posterior_num_traces, posterior_num_traces_correct)
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
places=0)
self.assertLess(kl_divergence, 0.25)
def test_factor_gum_posterior_importance_sampling(self):
samples = importance_sampling_samples
true_posterior = Normal(7.25, math.sqrt(1 / 1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
prior_mean_correct = 1.
prior_stddev_correct = math.sqrt(5)
posterior_effective_sample_size_min = samples * 0.005
posterior = self._model.posterior_results(
samples,
inference_engine=InferenceEngine.IMPORTANCE_SAMPLING,
observe={
'obs0': 8,
'obs1': 9
})
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
posterior_effective_sample_size = float(
posterior.effective_sample_size)
kl_divergence = float(
pyprob.distributions.Distribution.kl_divergence(
true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('samples', 'prior_mean_correct',
'posterior_mean_unweighted', 'posterior_mean',
'posterior_mean_correct', 'prior_stddev_correct',
'posterior_stddev_unweighted', 'posterior_stddev',
'posterior_stddev_correct',
'posterior_effective_sample_size',
'posterior_effective_sample_size_min', 'kl_divergence')
self.assertAlmostEqual(posterior_mean_unweighted,
prior_mean_correct,
delta=0.75)
self.assertAlmostEqual(posterior_stddev_unweighted,
prior_stddev_correct,
delta=0.75)
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
delta=0.75)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
delta=0.75)
self.assertGreater(posterior_effective_sample_size,
posterior_effective_sample_size_min)
self.assertLess(kl_divergence, 0.33)
def test_dist_empirical_resample(self):
dist_means_correct = [2]
dist_stddevs_correct = [5]
dist = Normal(dist_means_correct, dist_stddevs_correct)
dist_empirical = Empirical([dist.sample() for i in range(empirical_samples)])
dist_empirical = dist_empirical.resample(int(empirical_samples/2))
dist_means_empirical = util.to_numpy(dist_empirical.mean)
dist_stddevs_empirical = util.to_numpy(dist_empirical.stddev)
util.debug('dist_means_empirical', 'dist_means_correct', 'dist_stddevs_empirical', 'dist_stddevs_correct')
self.assertTrue(np.allclose(dist_means_empirical, dist_means_correct, atol=0.25))
self.assertTrue(np.allclose(dist_stddevs_empirical, dist_stddevs_correct, atol=0.25))
def test_model_lmh_posterior_with_online_thinning(self):
thinning_steps = 10
posterior_num_traces = 4000
posterior_with_thinning_num_traces_correct = posterior_num_traces / thinning_steps
true_posterior = Normal(7.25, math.sqrt(1/1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
posterior = self._model.posterior_results(num_traces=posterior_num_traces, inference_engine=InferenceEngine.LIGHTWEIGHT_METROPOLIS_HASTINGS, observe={'obs0': 8, 'obs1': 9})
posterior_num_traces = posterior.length
posterior_mean = float(posterior.mean)
posterior_stddev = float(posterior.stddev)
kl_divergence = float(pyprob.distributions.Distribution.kl_divergence(true_posterior, Normal(posterior.mean, posterior.stddev)))
posterior_with_thinning = self._model.posterior_results(num_traces=posterior_num_traces, inference_engine=InferenceEngine.LIGHTWEIGHT_METROPOLIS_HASTINGS, observe={'obs0': 8, 'obs1': 9}, thinning_steps=thinning_steps)
posterior_with_thinning_num_traces = posterior_with_thinning.length
posterior_with_thinning_mean = float(posterior_with_thinning.mean)
posterior_with_thinning_stddev = float(posterior_with_thinning.stddev)
kl_divergence_with_thinning = float(pyprob.distributions.Distribution.kl_divergence(true_posterior, Normal(posterior_with_thinning.mean, posterior_with_thinning.stddev)))
util.eval_print('posterior_num_traces', 'posterior_mean', 'posterior_mean_correct', 'posterior_stddev', 'posterior_stddev_correct', 'kl_divergence', 'thinning_steps', 'posterior_with_thinning_num_traces', 'posterior_with_thinning_num_traces_correct', 'posterior_with_thinning_mean', 'posterior_with_thinning_stddev', 'kl_divergence_with_thinning')
self.assertEqual(posterior_with_thinning_num_traces, posterior_with_thinning_num_traces_correct)
self.assertAlmostEqual(posterior_mean, posterior_mean_correct, places=0)
self.assertAlmostEqual(posterior_stddev, posterior_stddev_correct, places=0)
self.assertLess(kl_divergence, 0.25)
self.assertAlmostEqual(posterior_with_thinning_mean, posterior_mean_correct, places=0)
self.assertAlmostEqual(posterior_with_thinning_stddev, posterior_stddev_correct, places=0)
self.assertLess(kl_divergence_with_thinning, 0.25)
def test_inference_gum_marsaglia_replacement_posterior_importance_sampling_with_inference_network(self):
samples = importance_sampling_samples
true_posterior = Normal(7.25, math.sqrt(1/1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
posterior_effective_sample_size_min = samples * 0.03
self._model.reset_inference_network()
self._model.learn_inference_network(num_traces=importance_sampling_with_inference_network_training_traces, observe_embeddings={'obs0': {'dim': 256, 'depth': 1}, 'obs1': {'dim': 256, 'depth': 1}})
start = time.time()
posterior = self._model.posterior_results(samples, inference_engine=InferenceEngine.IMPORTANCE_SAMPLING_WITH_INFERENCE_NETWORK, observe={'obs0': 8, 'obs1': 9})
add_importance_sampling_with_inference_network_duration(time.time() - start)
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
posterior_effective_sample_size = float(posterior.effective_sample_size)
kl_divergence = float(pyprob.distributions.Distribution.kl_divergence(true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('samples', 'posterior_mean_unweighted', 'posterior_mean', 'posterior_mean_correct', 'posterior_stddev_unweighted', 'posterior_stddev', 'posterior_stddev_correct', 'posterior_effective_sample_size', 'posterior_effective_sample_size_min', 'kl_divergence')
add_importance_sampling_with_inference_network_kl_divergence(kl_divergence)
self.assertAlmostEqual(posterior_mean, posterior_mean_correct, places=0)
self.assertAlmostEqual(posterior_stddev, posterior_stddev_correct, places=0)
self.assertGreater(posterior_effective_sample_size, posterior_effective_sample_size_min)
self.assertLess(kl_divergence, 0.25)
def forward(self):
mu = self.marsaglia(self.prior_mean, self.prior_stddev)
likelihood = Normal(mu, self.likelihood_stddev)
pyprob.tag(mu, name='mu')
pyprob.observe(likelihood, name='obs0')
pyprob.observe(likelihood, name='obs1')
return mu
def __init__(self, *args, **kwargs):
# http://www.robots.ox.ac.uk/~fwood/assets/pdf/Wood-AISTATS-2014.pdf
class HiddenMarkovModel(Model):
def __init__(self, init_dist, trans_dists, obs_dists, obs_length):
self.init_dist = init_dist
self.trans_dists = trans_dists
self.obs_dists = obs_dists
self.obs_length = obs_length
super().__init__('Hidden Markov model')
def forward(self):
states = [pyprob.sample(init_dist)]
for i in range(self.obs_length):
state = pyprob.sample(self.trans_dists[int(states[-1])])
pyprob.observe(self.obs_dists[int(state)], name='obs{}'.format(i))
states.append(state)
return torch.stack([util.one_hot(3, int(s)) for s in states])
init_dist = Categorical([1, 1, 1])
trans_dists = [Categorical([0.1, 0.5, 0.4]),
Categorical([0.2, 0.2, 0.6]),
Categorical([0.15, 0.15, 0.7])]
obs_dists = [Normal(-1, 1),
Normal(1, 1),
Normal(0, 1)]
self._observation = [0.9, 0.8, 0.7, 0.0, -0.025, -5.0, -2.0, -0.1, 0.0, 0.13, 0.45, 6, 0.2, 0.3, -1, -1]
self._model = HiddenMarkovModel(init_dist, trans_dists, obs_dists, len(self._observation))
self._posterior_mean_correct = util.to_tensor([[0.3775, 0.3092, 0.3133],
[0.0416, 0.4045, 0.5539],
[0.0541, 0.2552, 0.6907],
[0.0455, 0.2301, 0.7244],
[0.1062, 0.1217, 0.7721],
[0.0714, 0.1732, 0.7554],
[0.9300, 0.0001, 0.0699],
[0.4577, 0.0452, 0.4971],
[0.0926, 0.2169, 0.6905],
[0.1014, 0.1359, 0.7626],
[0.0985, 0.1575, 0.7440],
[0.1781, 0.2198, 0.6022],
[0.0000, 0.9848, 0.0152],
[0.1130, 0.1674, 0.7195],
[0.0557, 0.1848, 0.7595],
[0.2017, 0.0472, 0.7511],
[0.2545, 0.0611, 0.6844]])
super().__init__(*args, **kwargs)
def posterior_true(self, obs):
n = len(obs)
posterior_var = 1 / (n / self.likelihood_stddev**2 +
1 / self.prior_stddev**2)
posterior_mu = posterior_var * (
self.prior_mean / self.prior_stddev**2 +
n * np.mean(obs) / self.likelihood_stddev**2)
return Normal(posterior_mu, math.sqrt(posterior_var))
def test_observation_style2_gum_posterior_importance_sampling(self):
samples = importance_sampling_samples
true_posterior = Normal(7.25, math.sqrt(1 / 1.2))
posterior_mean_correct = float(true_posterior.mean)
posterior_stddev_correct = float(true_posterior.stddev)
prior_mean_correct = 1.
prior_stddev_correct = math.sqrt(5)
posterior = self._model.posterior_distribution(
samples,
inference_engine=InferenceEngine.IMPORTANCE_SAMPLING,
observe={
'obs0': 8,
'obs1': 9
})
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
kl_divergence = float(
pyprob.distributions.Distribution.kl_divergence(
true_posterior, Normal(posterior.mean, posterior.stddev)))
util.eval_print('samples', 'prior_mean_correct',
'posterior_mean_unweighted', 'posterior_mean',
'posterior_mean_correct', 'prior_stddev_correct',
'posterior_stddev_unweighted', 'posterior_stddev',
'posterior_stddev_correct', 'kl_divergence')
self.assertAlmostEqual(posterior_mean_unweighted,
prior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev_unweighted,
prior_stddev_correct,
places=0)
self.assertAlmostEqual(posterior_mean,
posterior_mean_correct,
places=0)
self.assertAlmostEqual(posterior_stddev,
posterior_stddev_correct,
places=0)
self.assertLess(kl_divergence, 0.25)
def rejection_sampling(self):
u = pyprob.sample(Uniform(0, 1), control=False)
if u > 0.5:
while True:
x = pyprob.sample(Normal(self.prior_mean,
self.prior_stddev * 4),
replace=True)
u2 = pyprob.sample(Uniform(0, 1), control=False)
if x < 0 and u2 < 0.25 * torch.exp(
Normal(self.prior_mean, self.prior_stddev).log_prob(x)
- Normal(self.prior_mean, self.prior_stddev *
4).log_prob(x)):
return x
else:
while True:
x = pyprob.sample(Normal(self.prior_mean, self.prior_stddev),
replace=True)
if x >= 0:
return x
def forward(self):
uniform = Uniform(-1, 1)
for i in range(2):
x = pyprob.sample(uniform)
y = pyprob.sample(uniform)
s = x * x + y * y
likelihood = Normal(s, 0.1)
pyprob.observe(likelihood, name='obs0')
pyprob.observe(likelihood, name='obs1')
return s
def test_dist_empirical_combine_non_uniform_weights_use_initial(self):
samples1 = 10000
samples2 = 1000
observation = [8, 9]
posterior_mean_correct = 7.25
posterior_stddev_correct = math.sqrt(1/1.2)
posterior1 = self._model_gum.posterior_distribution(samples1, observation=observation)
posterior1_mean = float(posterior1.mean)
posterior1_mean_unweighted = float(posterior1.unweighted().mean)
posterior1_stddev = float(posterior1.stddev)
posterior1_stddev_unweighted = float(posterior1.unweighted().stddev)
kl_divergence1 = float(util.kl_divergence_normal(Normal(posterior_mean_correct, posterior_stddev_correct), Normal(posterior1.mean, posterior1_stddev)))
posterior2 = self._model_gum.posterior_distribution(samples2, observation=observation)
posterior2_mean = float(posterior2.mean)
posterior2_mean_unweighted = float(posterior2.unweighted().mean)
posterior2_stddev = float(posterior2.stddev)
posterior2_stddev_unweighted = float(posterior2.unweighted().stddev)
kl_divergence2 = float(util.kl_divergence_normal(Normal(posterior_mean_correct, posterior_stddev_correct), Normal(posterior2.mean, posterior2_stddev)))
posterior = Empirical.combine([posterior1, posterior2], use_initial_values_and_weights=True)
posterior_mean = float(posterior.mean)
posterior_mean_unweighted = float(posterior.unweighted().mean)
posterior_stddev = float(posterior.stddev)
posterior_stddev_unweighted = float(posterior.unweighted().stddev)
kl_divergence = float(util.kl_divergence_normal(Normal(posterior_mean_correct, posterior_stddev_correct), Normal(posterior.mean, posterior_stddev)))
util.debug('samples1', 'posterior1_mean_unweighted', 'posterior1_mean', 'posterior1_stddev_unweighted', 'posterior1_stddev', 'kl_divergence1', 'samples2', 'posterior2_mean_unweighted', 'posterior2_mean', 'posterior2_stddev_unweighted', 'posterior2_stddev', 'kl_divergence2', 'posterior_mean_unweighted', 'posterior_mean', 'posterior_mean_correct', 'posterior_stddev_unweighted', 'posterior_stddev', 'posterior_stddev_correct', 'kl_divergence')
self.assertAlmostEqual(posterior1_mean, posterior_mean_correct, places=0)
self.assertAlmostEqual(posterior1_stddev, posterior_stddev_correct, places=0)
self.assertLess(kl_divergence1, 0.25)
self.assertAlmostEqual(posterior2_mean, posterior_mean_correct, places=0)
self.assertAlmostEqual(posterior2_stddev, posterior_stddev_correct, places=0)
self.assertLess(kl_divergence2, 0.25)
self.assertAlmostEqual(posterior_mean, posterior_mean_correct, places=0)
self.assertAlmostEqual(posterior_stddev, posterior_stddev_correct, places=0)
self.assertLess(kl_divergence, 0.25)
def test_dist_empirical_combine_uniform_weights(self):
dist1_mean_correct = 1
dist1_stddev_correct = 3
dist2_mean_correct = 5
dist2_stddev_correct = 2
dist3_mean_correct = -2.5
dist3_stddev_correct = 1.2
dist_combined_mean_correct = 1.16667
dist_combined_stddev_correct = 3.76858
dist1 = Normal(dist1_mean_correct, dist1_stddev_correct)
dist1_empirical = Empirical([dist1.sample() for i in range(empirical_samples)])
dist1_empirical_mean = float(dist1_empirical.mean)
dist1_empirical_stddev = float(dist1_empirical.stddev)
dist2 = Normal(dist2_mean_correct, dist2_stddev_correct)
dist2_empirical = Empirical([dist2.sample() for i in range(empirical_samples)])
dist2_empirical_mean = float(dist2_empirical.mean)
dist2_empirical_stddev = float(dist2_empirical.stddev)
dist3 = Normal(dist3_mean_correct, dist3_stddev_correct)
dist3_empirical = Empirical([dist3.sample() for i in range(empirical_samples)])
dist3_empirical_mean = float(dist3_empirical.mean)
dist3_empirical_stddev = float(dist3_empirical.stddev)
dist_combined_empirical = Empirical.combine([dist1_empirical, dist2_empirical, dist3_empirical])
dist_combined_empirical_mean = float(dist_combined_empirical.mean)
dist_combined_empirical_stddev = float(dist_combined_empirical.stddev)
util.debug('dist1_empirical_mean', 'dist1_empirical_stddev', 'dist1_mean_correct', 'dist1_stddev_correct', 'dist2_empirical_mean', 'dist2_empirical_stddev', 'dist2_mean_correct', 'dist2_stddev_correct', 'dist3_empirical_mean', 'dist3_empirical_stddev', 'dist3_mean_correct', 'dist3_stddev_correct', 'dist_combined_empirical_mean', 'dist_combined_empirical_stddev', 'dist_combined_mean_correct', 'dist_combined_stddev_correct')
self.assertAlmostEqual(dist1_empirical_mean, dist1_mean_correct, places=1)
self.assertAlmostEqual(dist1_empirical_stddev, dist1_stddev_correct, places=1)
self.assertAlmostEqual(dist2_empirical_mean, dist2_mean_correct, places=1)
self.assertAlmostEqual(dist2_empirical_stddev, dist2_stddev_correct, places=1)
self.assertAlmostEqual(dist3_empirical_mean, dist3_mean_correct, places=1)
self.assertAlmostEqual(dist3_empirical_stddev, dist3_stddev_correct, places=1)
self.assertAlmostEqual(dist_combined_empirical_mean, dist_combined_mean_correct, places=1)
self.assertAlmostEqual(dist_combined_empirical_stddev, dist_combined_stddev_correct, places=1)
def forward(self, observation=[]):
mu = self.marsaglia(self.prior_mean, self.prior_stddev)
likelihood = Normal(mu, self.likelihood_stddev)
for o in observation:
pyprob.observe(likelihood, o)
return mu
def forward(self, observation=[]):
mu = pyprob.sample(Normal(self.prior_mean, self.prior_stddev))
likelihood = Normal(mu, self.likelihood_stddev)
for o in observation:
pyprob.observe(likelihood, o)
return mu
def forward(self, observation=None):
categorical_value = pyprob.sample(Categorical([0.1, 0.1, 0.8]))
normal_value = pyprob.sample(Normal(5, 2))
return categorical_value, normal_value
def get_sample(s):
address = s.Address().decode("utf-8")
distribution = None
# sample.instance = s.Instance()
value = NDArray_to_Tensor(s.Value())
distribution_type = s.DistributionType()
if distribution_type != infcomp.protocol.Distribution.Distribution().NONE:
if distribution_type == infcomp.protocol.Distribution.Distribution(
).UniformDiscrete:
p = infcomp.protocol.UniformDiscrete.UniformDiscrete()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = UniformDiscrete(p.PriorMin(), p.PriorSize())
if value.dim() > 0:
value = util.one_hot(distribution.prior_size,
int(value[0]) - distribution.prior_min)
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).MultivariateNormal:
p = infcomp.protocol.MultivariateNormal.MultivariateNormal()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = MultivariateNormal(NDArray_to_Tensor(p.PriorMean()),
NDArray_to_Tensor(p.PriorCov()))
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).Normal:
p = infcomp.protocol.Normal.Normal()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = Normal(p.PriorMean(), p.PriorStd())
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).Flip:
distribution = Flip()
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).Discrete:
p = infcomp.protocol.Discrete.Discrete()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = Discrete(p.PriorSize())
if value.dim() > 0:
value = util.one_hot(distribution.prior_size, int(value[0]))
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).Categorical:
p = infcomp.protocol.Categorical.Categorical()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = Categorical(p.PriorSize())
if value.dim() > 0:
value = util.one_hot(distribution.prior_size, int(value[0]))
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).UniformContinuous:
p = infcomp.protocol.UniformContinuous.UniformContinuous()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = UniformContinuous(p.PriorMin(), p.PriorMax())
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).UniformContinuousAlt:
p = infcomp.protocol.UniformContinuousAlt.UniformContinuousAlt()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = UniformContinuousAlt(p.PriorMin(), p.PriorMax())
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).Laplace:
p = infcomp.protocol.Laplace.Laplace()
p.Init(s.Distribution().Bytes, s.Distribution().Pos)
distribution = Laplace(p.PriorLocation(), p.PriorScale())
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).Gamma:
distribution = Gamma()
elif distribution_type == infcomp.protocol.Distribution.Distribution(
).Beta:
distribution = Beta()
else:
util.logger.log(
'get_sample: Unknown distribution:Distribution id: {0}.'.
format(distribution_type))
sample = Sample(address, distribution, value)
return sample
def forward(self, observation=None):
categorical_value = pyprob.sample(Categorical([0.1, 0.1, 0.8]))
normal_value = pyprob.sample(Normal(5., 2.))
return float(categorical_value), normal_value
