def test_traverse_graph_nostop_noparams(self):
"""Traversing the whole graph excluding param nodes"""
counter = [0]
nodes = [None] * 10
def fun(node):
nodes[counter[0]] = node
counter[0] += 1
# Generate graph
v1 = spn.RawLeaf(num_vars=1)
v2 = spn.RawLeaf(num_vars=1)
v3 = spn.RawLeaf(num_vars=1)
s1 = spn.Sum(v1, v1, v2) # v1 included twice
s2 = spn.Sum(v1, v3)
s3 = spn.Sum(v2, v3, v3) # v3 included twice
s4 = spn.Sum(s1, v1)
s5 = spn.Sum(s2, v3, s3)
s6 = spn.Sum(s4, s2, s5, s4, s5) # s4 and s5 included twice
spn.generate_weights(s6)
# Traverse
spn.traverse_graph(s6, fun=fun, skip_params=True)
# Test
self.assertEqual(counter[0], 9)
self.assertIs(nodes[0], s6)
self.assertIs(nodes[1], s4)
self.assertIs(nodes[2], s2)
self.assertIs(nodes[3], s5)
self.assertIs(nodes[4], s1)
self.assertIs(nodes[5], v1)
self.assertIs(nodes[6], v3)
self.assertIs(nodes[7], s3)
self.assertIs(nodes[8], v2)
def test_traversing_on_dense(self):
"""Compare traversal algs on dense SPN"""
def fun1(node, *args):
counter[0] += 1
def fun2(node, *args):
counter[0] += 1
if node.is_op:
return [None] * len(node.inputs)
# Generate dense graph
v1 = spn.IndicatorLeaf(num_vars=3, num_vals=2, name="IndicatorLeaf1")
v2 = spn.IndicatorLeaf(num_vars=3, num_vals=2, name="IndicatorLeaf2")
gen = spn.DenseSPNGenerator(num_decomps=2,
num_subsets=3,
num_mixtures=2,
input_dist=spn.DenseSPNGenerator.InputDist.MIXTURE,
num_input_mixtures=None)
root = gen.generate(v1, v2)
spn.generate_weights(root)
# Run traversal algs and count nodes
counter = [0]
spn.compute_graph_up_down(root, down_fun=fun2, graph_input=1)
c1 = counter[0]
counter = [0]
spn.compute_graph_up(root, val_fun=fun1)
c2 = counter[0]
counter = [0]
spn.traverse_graph(root, fun=fun1, skip_params=False)
c3 = counter[0]
# Compare
self.assertEqual(c1, c3)
self.assertEqual(c2, c3)
def test_traverse_graph_stop(self):
"""Traversing the graph until fun returns True"""
counter = [0]
nodes = [None] * 9
true_node_no = 4 # s5
def fun(node):
nodes[counter[0]] = node
counter[0] += 1
if counter[0] == true_node_no:
return True
# Generate graph
v1 = spn.RawLeaf(num_vars=1)
v2 = spn.RawLeaf(num_vars=1)
v3 = spn.RawLeaf(num_vars=1)
s1 = spn.Sum(v1, v1, v2) # v1 included twice
s2 = spn.Sum(v1, v3)
s3 = spn.Sum(v2, v3, v3) # v3 included twice
s4 = spn.Sum(s1, v1)
s5 = spn.Sum(s2, v3, s3)
s6 = spn.Sum(s4, s2, s5, s4, s5) # s4 and s5 included twice
# Traverse
spn.traverse_graph(s6, fun=fun, skip_params=True)
# Test
self.assertEqual(counter[0], 4)
self.assertIs(nodes[0], s6)
self.assertIs(nodes[1], s4)
self.assertIs(nodes[2], s2)
self.assertIs(nodes[3], s5)
self.assertIs(nodes[4], None)
self.assertIs(nodes[5], None)
self.assertIs(nodes[6], None)
self.assertIs(nodes[7], None)
self.assertIs(nodes[8], None)
def test_generate_spn(self, num_decomps, num_subsets, num_mixtures,
num_input_mixtures, input_dims, input_dist, balanced,
node_type, log_weights):
"""A generic test for DenseSPNGenerator."""
if input_dist == spn.DenseSPNGenerator.InputDist.RAW \
and num_input_mixtures != 1:
# Redundant test case, so just return
return
# Input parameters
num_inputs = input_dims[0]
num_vars = input_dims[1]
num_vals = 2
printc("\n- num_inputs: %s" % num_inputs)
printc("- num_vars: %s" % num_vars)
printc("- num_vals: %s" % num_vals)
printc("- num_decomps: %s" % num_decomps)
printc("- num_subsets: %s" % num_subsets)
printc("- num_mixtures: %s" % num_mixtures)
printc("- input_dist: %s" %
("MIXTURE" if input_dist
== spn.DenseSPNGenerator.InputDist.MIXTURE else "RAW"))
printc("- balanced: %s" % balanced)
printc("- num_input_mixtures: %s" % num_input_mixtures)
printc("- node_type: %s" %
("SINGLE" if node_type == spn.DenseSPNGenerator.NodeType.SINGLE
else "BLOCK" if node_type
== spn.DenseSPNGenerator.NodeType.BLOCK else "LAYER"))
printc("- log_weights: %s" % log_weights)
# Inputs
inputs = [
spn.IVs(num_vars=num_vars,
num_vals=num_vals,
name=("IVs_%d" % (i + 1))) for i in range(num_inputs)
]
gen = spn.DenseSPNGenerator(num_decomps=num_decomps,
num_subsets=num_subsets,
num_mixtures=num_mixtures,
input_dist=input_dist,
balanced=balanced,
num_input_mixtures=num_input_mixtures,
node_type=node_type)
# Generate Sub-SPNs
sub_spns = [
gen.generate(*inputs, root_name=("sub_root_%d" % (i + 1)))
for i in range(3)
]
# Generate random weights for the first sub-SPN
with tf.name_scope("Weights"):
spn.generate_weights(sub_spns[0],
tf.initializers.random_uniform(0.0, 1.0),
log=log_weights)
# Initialize weights of the first sub-SPN
sub_spn_init = spn.initialize_weights(sub_spns[0])
# Testing validity of the first sub-SPN
self.assertTrue(sub_spns[0].is_valid())
# Generate value ops of the first sub-SPN
sub_spn_v = sub_spns[0].get_value()
sub_spn_v_log = sub_spns[0].get_log_value()
# Generate path ops of the first sub-SPN
sub_spn_mpe_path_gen = spn.MPEPath(log=False)
sub_spn_mpe_path_gen_log = spn.MPEPath(log=True)
sub_spn_mpe_path_gen.get_mpe_path(sub_spns[0])
sub_spn_mpe_path_gen_log.get_mpe_path(sub_spns[0])
sub_spn_path = [sub_spn_mpe_path_gen.counts[inp] for inp in inputs]
sub_spn_path_log = [
sub_spn_mpe_path_gen_log.counts[inp] for inp in inputs
]
# Collect all weight nodes of the first sub-SPN
sub_spn_weight_nodes = []
def fun(node):
if node.is_param:
sub_spn_weight_nodes.append(node)
spn.traverse_graph(sub_spns[0], fun=fun)
# Generate an upper-SPN over sub-SPNs
products_lower = []
for sub_spn in sub_spns:
products_lower.append([v.node for v in sub_spn.values])
num_top_mixtures = [2, 1, 3]
sums_lower = []
for prods, num_top_mix in zip(products_lower, num_top_mixtures):
if node_type == spn.DenseSPNGenerator.NodeType.SINGLE:
sums_lower.append(
[spn.Sum(*prods) for _ in range(num_top_mix)])
elif node_type == spn.DenseSPNGenerator.NodeType.BLOCK:
sums_lower.append([spn.ParSums(*prods, num_sums=num_top_mix)])
else:
sums_lower.append([
spn.SumsLayer(*prods * num_top_mix,
num_or_size_sums=num_top_mix)
])
# Generate upper-SPN
root = gen.generate(*list(itertools.chain(*sums_lower)),
root_name="root")
# Generate random weights for the SPN
with tf.name_scope("Weights"):
spn.generate_weights(root,
tf.initializers.random_uniform(0.0, 1.0),
log=log_weights)
# Initialize weight of the SPN
spn_init = spn.initialize_weights(root)
# Testing validity of the SPN
self.assertTrue(root.is_valid())
# Generate value ops of the SPN
spn_v = root.get_value()
spn_v_log = root.get_log_value()
# Generate path ops of the SPN
spn_mpe_path_gen = spn.MPEPath(log=False)
spn_mpe_path_gen_log = spn.MPEPath(log=True)
spn_mpe_path_gen.get_mpe_path(root)
spn_mpe_path_gen_log.get_mpe_path(root)
spn_path = [spn_mpe_path_gen.counts[inp] for inp in inputs]
spn_path_log = [spn_mpe_path_gen_log.counts[inp] for inp in inputs]
# Collect all weight nodes in the SPN
spn_weight_nodes = []
def fun(node):
if node.is_param:
spn_weight_nodes.append(node)
spn.traverse_graph(root, fun=fun)
# Create a session
with self.test_session() as sess:
# Initializing weights
sess.run(sub_spn_init)
sess.run(spn_init)
# Generate input feed
feed = np.array(
list(
itertools.product(range(num_vals),
repeat=(num_inputs * num_vars))))
batch_size = feed.shape[0]
feed_dict = {}
for inp, f in zip(inputs, np.split(feed, num_inputs, axis=1)):
feed_dict[inp] = f
# Compute all values and paths of sub-SPN
sub_spn_out = sess.run(sub_spn_v, feed_dict=feed_dict)
sub_spn_out_log = sess.run(tf.exp(sub_spn_v_log),
feed_dict=feed_dict)
sub_spn_out_path = sess.run(sub_spn_path, feed_dict=feed_dict)
sub_spn_out_path_log = sess.run(sub_spn_path_log,
feed_dict=feed_dict)
# Compute all values and paths of the complete SPN
spn_out = sess.run(spn_v, feed_dict=feed_dict)
spn_out_log = sess.run(tf.exp(spn_v_log), feed_dict=feed_dict)
spn_out_path = sess.run(spn_path, feed_dict=feed_dict)
spn_out_path_log = sess.run(spn_path_log, feed_dict=feed_dict)
# Test if partition function of the sub-SPN and of the
# complete SPN is 1.0
self.assertAlmostEqual(sub_spn_out.sum(), 1.0, places=6)
self.assertAlmostEqual(sub_spn_out_log.sum(), 1.0, places=6)
self.assertAlmostEqual(spn_out.sum(), 1.0, places=6)
self.assertAlmostEqual(spn_out_log.sum(), 1.0, places=6)
# Test if the sum of counts for each value of each variable
# (6 variables, with 2 values each) = batch-size / num-vals
self.assertEqual(
np.sum(np.hstack(sub_spn_out_path), axis=0).tolist(),
[batch_size // num_vals] * num_inputs * num_vars * num_vals)
self.assertEqual(
np.sum(np.hstack(sub_spn_out_path_log), axis=0).tolist(),
[batch_size // num_vals] * num_inputs * num_vars * num_vals)
self.assertEqual(
np.sum(np.hstack(spn_out_path), axis=0).tolist(),
[batch_size // num_vals] * num_inputs * num_vars * num_vals)
self.assertEqual(
np.sum(np.hstack(spn_out_path_log), axis=0).tolist(),
[batch_size // num_vals] * num_inputs * num_vars * num_vals)
