def test_count_learner(): """Verify that count learner makes correct predictions.""" rng = utils.RandomState(seed=0) learner = learn.CountLearner(support=[0, 1], rng=rng) num_samples = 10000 # Check predictions with empty input, no observations null = () check_sampler(lambda: learner.sample(null), [0.5, 0.5], num_samples) check_scorer(lambda v: learner.log_probability(null, v), [0.5, 0.5]) # Check predictions with empty input, observations learner.observe(null, 1) check_sampler(lambda: learner.sample(null), [1 / 3, 2 / 3], num_samples) check_scorer(lambda v: learner.log_probability(null, v), [1 / 3, 2 / 3]) learner.observe(null, 1) check_sampler(lambda: learner.sample(null), [1 / 4, 3 / 4], num_samples) check_scorer(lambda v: learner.log_probability(null, v), [1 / 4, 3 / 4]) # Check with different input inputs = (0, 1) learner.observe(inputs, 0) check_sampler(lambda: learner.sample(inputs), [2 / 3, 1 / 3], num_samples) check_scorer(lambda v: learner.log_probability(inputs, v), [2 / 3, 1 / 3]) check_sampler(lambda: learner.sample(null), [1 / 4, 3 / 4], num_samples) check_scorer(lambda v: learner.log_probability(null, v), [1 / 4, 3 / 4]) # For the sake of completeness learner.finalize()
def setup(self): self.rng = utils.RandomState(seed=0) self.reflectance = bayesnet.DistRealBayesNetNode( index=0, distribution=dist.GaussianDistribution(self.rng, 1, 1)) self.illumination_1 = bayesnet.DistRealBayesNetNode( index=1, distribution=dist.GammaDistribution(self.rng, 9, 0.5)) self.illumination_2 = bayesnet.DistRealBayesNetNode( index=2, distribution=dist.GaussianDistribution(self.rng, 1, 0.5)) self.illumination = bayesnet.DistRealBayesNetNode( index=3, distribution=dist.FunctionDistribution( self.rng, lambda parents: dist.GaussianDistribution( self.rng, parents[0] + parents[1], 0.2))) self.observation = bayesnet.DistRealBayesNetNode( index=4, distribution=dist.FunctionDistribution( self.rng, lambda parents: dist.GaussianDistribution( self.rng, parents[0] * parents[1], 2))) self.net = bayesnet.BayesNet( self.rng, nodes=[ self.reflectance, self.illumination_1, self.illumination_2, self.illumination, self.observation ], edges=[(self.reflectance, self.observation), (self.illumination_1, self.illumination), (self.illumination_2, self.illumination), (self.illumination, self.observation)]) self.net.compile()
def test_smoothing(self): """Check that smoothing of network probabilities works.""" for epsilon in [0.0, 0.1, 0.2, 0.4]: for network_string in [NETWORK_STRING_A, NETWORK_STRING_B]: net = uai_import.network_from_string(network_string, utils.RandomState(), epsilon=epsilon) for node in net.nodes(): for cpt_prob in node.cpt_probabilities: assert epsilon <= cpt_prob <= 1.0 - epsilon
def test_string_import(self): """Check that probabilities for imported Bayes net are as expected.""" for network_string in [NETWORK_STRING_A, NETWORK_STRING_B]: net = uai_import.network_from_string(network_string, utils.RandomState()) assert len(net.sample()) == 3 for (values, prob) in NETWORK_PROBABILITIES: world = random_world.RandomWorld(keys=net.nodes_by_index, values=values) np.testing.assert_almost_equal(net.log_probability(world), utils.safe_log(prob))
def test_distance_scorer(): rng = utils.RandomState(seed=0) net = triangle_net.get(rng) nodes = net.nodes_by_index for i in [1, 2]: start_nodes = nodes[:i] scorer = invert.distance_scorer(net, start_nodes) end_nodes = [node for node in nodes if node not in start_nodes] for end_node in end_nodes: for node in nodes: score = scorer(node, end_node) if node == end_node: assert score == float("-inf") elif node in start_nodes: assert score == float("+inf") else: assert float("-inf") < score < float("+inf")
def test_gibbs_learner(): """Verify that Gibbs learner makes same predictions as enumerator.""" num_samples = 10000 rng = utils.RandomState(seed=0) net = sprinkler_net.get(rng) for node in net.nodes_by_index: learner = learn.GibbsLearner(node, rng) learner.finalize() for markov_blanket_values in utils.lexicographic_combinations( [[0, 1]] * len(node.markov_blanket)): world = random_world.RandomWorld( [n.index for n in node.markov_blanket], markov_blanket_values) enumerator = exact_inference.Enumerator(net, world) probabilities = enumerator.marginalize_node(node) check_scorer( lambda v: learner.log_probability( markov_blanket_values, v), probabilities) check_sampler( lambda: learner.sample( markov_blanket_values), probabilities, num_samples)
def run(job, session): print "Starting job..." job.start_time = datetime.datetime.now() rng = utils.RandomState(job.seed) net = triangle_net.get(rng, job.determinism) evidence = triangle_net.evidence(0, job.determinism) evidence_nodes = [net.nodes_by_index[index] for index in evidence.keys()] num_latent_nodes = len(net.nodes()) - len(evidence_nodes) marginals = triangle_net.marginals(0, job.determinism) job.status = "started" session.commit() print "Computing inverse map..." t0 = datetime.datetime.now() inverse_map = invert.compute_inverse_map(net, evidence_nodes, rng, job.max_inverse_size) t1 = datetime.datetime.now() job.inversion_seconds = (t1 - t0).total_seconds() job.status = "inverted" session.commit() print "Training inverses..." if job.learner == "counts": learner_class = learn.CountLearner elif job.learner == "lr": learner_class = learn.LogisticRegressionLearner else: raise ValueError("Unknown learner type!") trainer = train.Trainer(net, inverse_map, job.precompute_gibbs, learner_class) counter = marg.MarginalCounter(net) if job.training_source in ("gibbs", "prior+gibbs"): training_sampler = mcmc.GibbsChain(net, rng, evidence) training_sampler.initialize_state() for _ in xrange(job.num_training_samples): training_sampler.transition() trainer.observe(training_sampler.state) counter.observe(training_sampler.state) if job.training_source in ("prior", "prior+gibbs"): for _ in xrange(job.num_training_samples): world = net.sample() trainer.observe(world) counter.observe(world) trainer.finalize() job.training_error = (marginals - counter.marginals()).mean() t2 = datetime.datetime.now() job.training_seconds = (t2 - t1).total_seconds() job.status = "trained" session.commit() print "Testing inverse sampler..." test_sampler = mcmc.InverseChain(net, inverse_map, rng, evidence, job.max_inverse_size) test_sampler.initialize_state() counter = marg.MarginalCounter(net) num_proposals_accepted = 0 test_start_time = datetime.datetime.now() i = 0 error_integrator = utils.TemporalIntegrator() while ((datetime.datetime.now() - test_start_time).total_seconds() < job.test_seconds): accept = test_sampler.transition() counter.observe(test_sampler.state) num_proposals_accepted += accept i += 1 if i % 100 == 0: error = (marginals - counter.marginals()).mean() error_integrator.observe(error) final_error = (marginals - counter.marginals()).mean() final_time = datetime.datetime.now() empirical_test_seconds = (final_time - test_start_time).total_seconds() error_integrator.observe(final_error) job.test_error = final_error job.integrated_error = error_integrator.integral / empirical_test_seconds job.test_proposals = i * num_latent_nodes job.test_proposals_accepted = num_proposals_accepted job.empirical_test_seconds = empirical_test_seconds
def setup(self): self.rng = utils.RandomState(seed=0)
def test_sprinkler_net(proposal_size, evidence_index): rng = utils.RandomState(seed=0) net = sprinkler_net.get(rng) evidence = sprinkler_net.evidence(evidence_index) run_test(rng, net, evidence, proposal_size=proposal_size)
def test_logistic_regression_mcmc(learner_class_index=0, seed=0): max_inverse_size = 30 train_seconds = 2 * 60 test_seconds = 60 rng = utils.RandomState(seed=seed) net = triangle_net.get(rng) evidence = triangle_net.evidence(0) marginals = triangle_net.marginals(0) evidence_nodes = [net.nodes_by_index[index] for index in evidence.keys()] learner_classes = [ lambda support, rng: learn.LogisticRegressionLearner( support, rng, transform_inputs=learn.identity_transformer), lambda support, rng: learn.LogisticRegressionLearner( support, rng, transform_inputs=learn.square_transformer), learn.CountLearner ] learner_class = learner_classes[learner_class_index] num_latent_nodes = len(net.nodes()) - len(evidence_nodes) print "Inverting network..." inverse_map = invert.compute_inverse_map(net, evidence_nodes, rng, max_inverse_size) train_start_time = datetime.datetime.now() print "Initializing trainer..." trainer = train.Trainer(net, inverse_map, False, learner_class=learner_class) print "Training..." sample = random_world.RandomWorld() while ((datetime.datetime.now() - train_start_time).total_seconds() < train_seconds): sample = net.sample(sample) # Prior! trainer.observe(sample) sample.data = {} trainer.finalize() print "Testing..." test_sampler = mcmc.InverseChain(net, inverse_map, rng, evidence, proposal_size=max_inverse_size) test_sampler.initialize_state() error_integrator = utils.TemporalIntegrator() test_start_time = datetime.datetime.now() counter = marg.MarginalCounter(net) i = 0 num_proposals_accepted = 0 while ((datetime.datetime.now() - test_start_time).total_seconds() < test_seconds): accept = test_sampler.transition() num_proposals_accepted += accept counter.observe(test_sampler.state) i += 1 if i % 100 == 0: error = (marginals - counter.marginals()).mean() error_integrator.observe(error) final_time = datetime.datetime.now() empirical_test_seconds = (final_time - test_start_time).total_seconds() final_error = (marginals - counter.marginals()).mean() error_integrator.observe(final_error) num_proposals = i * num_latent_nodes return (num_proposals, num_proposals_accepted, error_integrator.integral / empirical_test_seconds, final_error)
def test_file_import(self): """Check that importing big files doesn't throw errors.""" rng = utils.RandomState(seed=0) triangle_net.get(rng) triangle_net.evidence(0) triangle_net.marginals(0)