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 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 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_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.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 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 test_dist_normal(self): dist_sample_shape_correct = [1] dist_means_correct = [0] dist_stddevs_correct = [1] dist_log_probs_correct = [-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_dist_normal_multivariate_batched(self): dist_sample_shape_correct = [2, 3] dist_means_correct = [[0, 2, 0], [2, 0, 2]] dist_stddevs_correct = [[1, 3, 1], [3, 1, 3]] dist_log_probs_correct = [[sum([-0.918939, -2.01755, -0.918939])], [sum([-2.01755, -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 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 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 __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 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_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_probs) # 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_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_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_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_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 __init__(self): super().__init__('Gaussian with unknown mean') self.prior_mean = 0. self.prior_stddev = 1. self.likelihood_stddev = math.sqrt(0.2) self.prior_true = Normal(self.prior_mean, self.prior_stddev)
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): mu = self.rejection_sampling() likelihood = Normal(mu, self.likelihood_stddev) pyprob.observe(likelihood, name='obs0') 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 float(categorical_value), normal_value
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