def setup(self, determinism=95, seed=None): seed = 0 if seed is None else seed self.rng = utils.RandomState(seed) self.net = triangle_net.get(self.rng, determinism) self.evidence = triangle_net.evidence(0, determinism) self.evidence_nodes = [ self.net.nodes_by_index[index] for index in self.evidence.keys() ] self.num_latent_nodes = len(self.net.nodes()) - len( self.evidence_nodes) self.marginals = triangle_net.marginals(0, determinism)
def test_max_inverse_size(self, max_inverse_size): evidence = triangle_net.evidence(0) evidence_nodes = [ self.net.nodes_by_index[index] for index in evidence.keys() ] inverse_map = invert.compute_inverse_map( self.net, evidence_nodes, self.rng, max_inverse_size=max_inverse_size) assert len(inverse_map) == self.net.node_count - len(evidence_nodes) for fwd_final_node, inverse_net in inverse_map.items(): inverse_net.compile() inv_final_node = inverse_net.nodes_by_index[fwd_final_node.index] assert inverse_net.nodes_by_topology[-1] == inv_final_node assert inv_final_node.parents num_nodes_with_parents = 0 for node in inverse_net.nodes_by_index: if node.parents: num_nodes_with_parents += 1 assert (num_nodes_with_parents == min( max_inverse_size, self.net.node_count - len(evidence_nodes)))
def setup(self): self.rng = utils.RandomState(seed=0) self.net = triangle_net.get(self.rng) self.evidence = triangle_net.evidence(0)
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 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)