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)
