def train_inverses(self, inverse_map, num_training_samples,
precompute_gibbs):
trainer = train.Trainer(self.net, inverse_map, precompute_gibbs)
training_sampler = mcmc.GibbsChain(self.net, self.rng, self.evidence)
training_sampler.initialize_state()
counter = marg.MarginalCounter(self.net)
for _ in xrange(num_training_samples):
training_sampler.transition()
trainer.observe(training_sampler.state)
counter.observe(training_sampler.state)
trainer.finalize()
training_error = (self.marginals - counter.marginals()).mean()
return training_error
def check_inverses_by_samples(self, inverse_map, max_inverse_size,
num_test_samples):
test_sampler = mcmc.InverseChain(self.net, inverse_map, self.rng,
self.evidence, max_inverse_size)
test_sampler.initialize_state()
counter = marg.MarginalCounter(self.net)
num_proposals_accepted = 0
for _ in xrange(num_test_samples):
accept = test_sampler.transition()
counter.observe(test_sampler.state)
num_proposals_accepted += accept
inverse_marginals = counter.marginals()
inverses_error = (self.marginals - inverse_marginals).mean()
return inverses_error, num_proposals_accepted
def marginals(self, num_transitions):
"""Compute marginal distribution of nodes.
Compute marginal distribution of Bayes net nodes by repeatedly
applying self transition kernel and storing state counts.
Args:
num_transitions: number of transitions to apply
Returns:
empirical marginals
"""
counter = marg.MarginalCounter(self.net)
for _ in xrange(num_transitions):
self.transition()
counter.observe(self.state)
return counter.marginals()
def check_inverses_by_time(self, inverse_map, max_inverse_size,
test_seconds):
test_sampler = mcmc.InverseChain(self.net, inverse_map, self.rng,
self.evidence, max_inverse_size)
test_sampler.initialize_state()
counter = marg.MarginalCounter(self.net)
num_proposals_accepted = 0
start_time = datetime.datetime.now()
num_proposals = 0
while (datetime.datetime.now() - start_time).seconds < test_seconds:
accept = test_sampler.transition()
counter.observe(test_sampler.state)
num_proposals_accepted += accept
num_proposals += self.num_latent_nodes
inverse_marginals = counter.marginals()
inverses_error = (self.marginals - inverse_marginals).mean()
return inverses_error, num_proposals, num_proposals_accepted
def test_marg_counter():
rng = utils.RandomState(seed=0)
net = sprinkler_net.get(rng)
counter = marg.MarginalCounter(net)
with pytest.raises(AssertionError):
counter.marginals()
value_lists = [[0, 0, 0], [0, 0, 1], [0, 1, 1]]
for values in value_lists:
world = random_world.RandomWorld([0, 1, 2], values)
counter.observe(world)
assert counter.num_observations == 3
marginals = counter.marginals()
np.testing.assert_almost_equal(marginals[0][0], 1.0)
np.testing.assert_almost_equal(marginals[0][1], 0.0)
np.testing.assert_almost_equal(marginals[1][0], 2 / 3)
np.testing.assert_almost_equal(marginals[1][1], 1 / 3)
np.testing.assert_almost_equal(marginals[2][0], 1 / 3)
np.testing.assert_almost_equal(marginals[2][1], 2 / 3)
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)