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)