class TestJunctionTreeCreation(unittest.TestCase):
def setUp(self):
self.graph = JunctionTree()
def test_add_single_node(self):
self.graph.add_node(('a', 'b'))
self.assertListEqual(self.graph.nodes(), [('a', 'b')])
def test_add_single_node_raises_error(self):
self.assertRaises(TypeError, self.graph.add_node, 'a')
def test_add_multiple_nodes(self):
self.graph.add_nodes_from([('a', 'b'), ('b', 'c')])
self.assertListEqual(hf.recursive_sorted(self.graph.nodes()),
[['a', 'b'], ['b', 'c']])
def test_add_single_edge(self):
self.graph.add_edge(('a', 'b'), ('b', 'c'))
self.assertListEqual(hf.recursive_sorted(self.graph.nodes()),
[['a', 'b'], ['b', 'c']])
self.assertListEqual(sorted([node for edge in self.graph.edges()
for node in edge]),
[('a', 'b'), ('b', 'c')])
def test_add_single_edge_raises_error(self):
self.assertRaises(ValueError, self.graph.add_edge,
('a', 'b'), ('c', 'd'))
def test_add_cyclic_path_raises_error(self):
self.graph.add_edge(('a', 'b'), ('b', 'c'))
self.graph.add_edge(('b', 'c'), ('c', 'd'))
self.assertRaises(ValueError, self.graph.add_edge, ('c', 'd'), ('a', 'b'))
def tearDown(self):
del self.graph
def _query(self, variables, operation, evidence=None):
"""
This is a generalized query method that can be used for both query and map query.
Parameters
----------
variables: list
list of variables for which you want to compute the probability
operation: str ('marginalize' | 'maximize')
The operation to do for passing messages between nodes.
evidence: dict
a dict key, value pair as {var: state_of_var_observed}
None if no evidence
Examples
--------
>>> from pgmpy.inference import BeliefPropagation
>>> from pgmpy.models import BayesianModel
>>> import numpy as np
>>> import pandas as pd
>>> values = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
... columns=['A', 'B', 'C', 'D', 'E'])
>>> model = BayesianModel([('A', 'B'), ('C', 'B'), ('C', 'D'), ('B', 'E')])
>>> model.fit(values)
>>> inference = BeliefPropagation(model)
>>> phi_query = inference.query(['A', 'B'])
References
----------
Algorithm 10.4 Out-of-clique inference in clique tree
Probabilistic Graphical Models: Principles and Techniques Daphne Koller and Nir Friedman.
"""
is_calibrated = self._is_converged(operation=operation)
# Calibrate the junction tree if not calibrated
if not is_calibrated:
self.calibrate()
if not isinstance(variables, (list, tuple, set)):
query_variables = [variables]
else:
query_variables = list(variables)
query_variables.extend(evidence.keys() if evidence else [])
# Find a tree T' such that query_variables are a subset of scope(T')
nodes_with_query_variables = set()
for var in query_variables:
nodes_with_query_variables.update(filter(lambda x: var in x, self.junction_tree.nodes()))
subtree_nodes = nodes_with_query_variables
# Conversion of set to tuple just for indexing
nodes_with_query_variables = tuple(nodes_with_query_variables)
# As junction tree is a tree, that means that there would be only path between any two nodes in the tree
# thus we can just take the path between any two nodes; no matter there order is
for i in range(len(nodes_with_query_variables) - 1):
subtree_nodes.update(nx.shortest_path(self.junction_tree, nodes_with_query_variables[i],
nodes_with_query_variables[i + 1]))
subtree_undirected_graph = self.junction_tree.subgraph(subtree_nodes)
# Converting subtree into a junction tree
if len(subtree_nodes) == 1:
subtree = JunctionTree()
subtree.add_node(subtree_nodes.pop())
else:
subtree = JunctionTree(subtree_undirected_graph.edges())
# Selecting a node is root node. Root node would be having only one neighbor
if len(subtree.nodes()) == 1:
root_node = subtree.nodes()[0]
else:
root_node = tuple(filter(lambda x: len(subtree.neighbors(x)) == 1, subtree.nodes()))[0]
clique_potential_list = [self.clique_beliefs[root_node]]
# For other nodes in the subtree compute the clique potentials as follows
# As all the nodes are nothing but tuples so simple set(root_node) won't work at it would update the set with'
# all the elements of the tuple; instead use set([root_node]) as it would include only the tuple not the
# internal elements within it.
parent_nodes = set([root_node])
nodes_traversed = set()
while parent_nodes:
parent_node = parent_nodes.pop()
for child_node in set(subtree.neighbors(parent_node)) - nodes_traversed:
clique_potential_list.append(self.clique_beliefs[child_node] /
self.sepset_beliefs[frozenset([parent_node, child_node])])
parent_nodes.update([child_node])
nodes_traversed.update([parent_node])
# Add factors to the corresponding junction tree
subtree.add_factors(*clique_potential_list)
# Sum product variable elimination on the subtree
variable_elimination = VariableElimination(subtree)
if operation == 'marginalize':
return variable_elimination.query(variables=variables, evidence=evidence)
elif operation == 'maximize':
return variable_elimination.map_query(variables=variables, evidence=evidence)
def _query(self, variables, operation, evidence=None):
"""
This is a generalized query method that can be used for both query and map query.
Parameters
----------
variables: list
list of variables for which you want to compute the probability
operation: str ('marginalize' | 'maximize')
The operation to do for passing messages between nodes.
evidence: dict
a dict key, value pair as {var: state_of_var_observed}
None if no evidence
Examples
--------
>>> from pgmpy.inference import BeliefPropagation
>>> from pgmpy.models import BayesianModel
>>> import numpy as np
>>> import pandas as pd
>>> values = pd.DataFrame(np.random.randint(low=0, high=2, size=(1000, 5)),
... columns=['A', 'B', 'C', 'D', 'E'])
>>> model = BayesianModel([('A', 'B'), ('C', 'B'), ('C', 'D'), ('B', 'E')])
>>> model.fit(values)
>>> inference = BeliefPropagation(model)
>>> phi_query = inference.query(['A', 'B'])
References
----------
Algorithm 10.4 Out-of-clique inference in clique tree
Probabilistic Graphical Models: Principles and Techniques Daphne Koller and Nir Friedman.
"""
is_calibrated = self._is_converged(operation=operation)
# Calibrate the junction tree if not calibrated
if not is_calibrated:
self.calibrate()
if not isinstance(variables, (list, tuple, set)):
query_variables = [variables]
else:
query_variables = list(variables)
query_variables.extend(evidence.keys() if evidence else [])
# Find a tree T' such that query_variables are a subset of scope(T')
nodes_with_query_variables = set()
for var in query_variables:
nodes_with_query_variables.update(
filter(lambda x: var in x, self.junction_tree.nodes()))
subtree_nodes = nodes_with_query_variables
# Conversion of set to tuple just for indexing
nodes_with_query_variables = tuple(nodes_with_query_variables)
# As junction tree is a tree, that means that there would be only path between any two nodes in the tree
# thus we can just take the path between any two nodes; no matter there order is
for i in range(len(nodes_with_query_variables) - 1):
subtree_nodes.update(
nx.shortest_path(self.junction_tree,
nodes_with_query_variables[i],
nodes_with_query_variables[i + 1]))
subtree_undirected_graph = self.junction_tree.subgraph(subtree_nodes)
# Converting subtree into a junction tree
if len(subtree_nodes) == 1:
subtree = JunctionTree()
subtree.add_node(subtree_nodes.pop())
else:
subtree = JunctionTree(subtree_undirected_graph.edges())
# Selecting a node is root node. Root node would be having only one neighbor
if len(subtree.nodes()) == 1:
root_node = subtree.nodes()[0]
else:
root_node = tuple(
filter(lambda x: len(subtree.neighbors(x)) == 1,
subtree.nodes()))[0]
clique_potential_list = [self.clique_beliefs[root_node]]
# For other nodes in the subtree compute the clique potentials as follows
# As all the nodes are nothing but tuples so simple set(root_node) won't work at it would update the set with'
# all the elements of the tuple; instead use set([root_node]) as it would include only the tuple not the
# internal elements within it.
parent_nodes = set([root_node])
nodes_traversed = set()
while parent_nodes:
parent_node = parent_nodes.pop()
for child_node in set(
subtree.neighbors(parent_node)) - nodes_traversed:
clique_potential_list.append(
self.clique_beliefs[child_node] /
self.sepset_beliefs[frozenset([parent_node, child_node])])
parent_nodes.update([child_node])
nodes_traversed.update([parent_node])
# Add factors to the corresponding junction tree
subtree.add_factors(*clique_potential_list)
# Sum product variable elimination on the subtree
variable_elimination = VariableElimination(subtree)
if operation == 'marginalize':
return variable_elimination.query(variables=variables,
evidence=evidence)
elif operation == 'maximize':
return variable_elimination.map_query(variables=variables,
evidence=evidence)
def to_junction_tree(self):
"""
Creates a junction tree (or clique tree) for a given markov model.
For a given markov model (H) a junction tree (G) is a graph
1. where each node in G corresponds to a maximal clique in H
2. each sepset in G separates the variables strictly on one side of the
edge to other.
Examples
--------
>>> from pgmpy.models import MarkovModel
>>> from pgmpy.factors.discrete import DiscreteFactor
>>> mm = MarkovModel()
>>> mm.add_nodes_from(['x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7'])
>>> mm.add_edges_from([('x1', 'x3'), ('x1', 'x4'), ('x2', 'x4'),
... ('x2', 'x5'), ('x3', 'x6'), ('x4', 'x6'),
... ('x4', 'x7'), ('x5', 'x7')])
>>> phi = [DiscreteFactor(edge, [2, 2], np.random.rand(4)) for edge in mm.edges()]
>>> mm.add_factors(*phi)
>>> junction_tree = mm.to_junction_tree()
"""
from pgmpy.models import JunctionTree
# Check whether the model is valid or not
self.check_model()
# Triangulate the graph to make it chordal
triangulated_graph = self.triangulate()
# Find maximal cliques in the chordal graph
cliques = list(map(tuple, nx.find_cliques(triangulated_graph)))
# If there is only 1 clique, then the junction tree formed is just a
# clique tree with that single clique as the node
if len(cliques) == 1:
clique_trees = JunctionTree()
clique_trees.add_node(cliques[0])
# Else if the number of cliques is more than 1 then create a complete
# graph with all the cliques as nodes and weight of the edges being
# the length of sepset between two cliques
elif len(cliques) >= 2:
complete_graph = UndirectedGraph()
edges = list(itertools.combinations(cliques, 2))
weights = list(map(lambda x: len(set(x[0]).intersection(set(x[1]))),
edges))
for edge, weight in zip(edges, weights):
complete_graph.add_edge(*edge, weight=-weight)
# Create clique trees by minimum (or maximum) spanning tree method
clique_trees = JunctionTree(nx.minimum_spanning_tree(complete_graph).edges())
# Check whether the factors are defined for all the random variables or not
all_vars = itertools.chain(*[factor.scope() for factor in self.factors])
if set(all_vars) != set(self.nodes()):
ValueError('DiscreteFactor for all the random variables not specified')
# Dictionary stating whether the factor is used to create clique
# potential or not
# If false, then it is not used to create any clique potential
is_used = {factor: False for factor in self.factors}
for node in clique_trees.nodes():
clique_factors = []
for factor in self.factors:
# If the factor is not used in creating any clique potential as
# well as has any variable of the given clique in its scope,
# then use it in creating clique potential
if not is_used[factor] and set(factor.scope()).issubset(node):
clique_factors.append(factor)
is_used[factor] = True
# To compute clique potential, initially set it as unity factor
var_card = [self.get_cardinality()[x] for x in node]
clique_potential = DiscreteFactor(node, var_card, np.ones(np.product(var_card)))
# multiply it with the factors associated with the variables present
# in the clique (or node)
clique_potential *= factor_product(*clique_factors)
clique_trees.add_factors(clique_potential)
if not all(is_used.values()):
raise ValueError('All the factors were not used to create Junction Tree.'
'Extra factors are defined.')
return clique_trees
def to_junction_tree(self):
"""
Creates a junction tree (or clique tree) for a given markov model.
For a given markov model (H) a junction tree (G) is a graph
1. where each node in G corresponds to a maximal clique in H
2. each sepset in G separates the variables strictly on one side of the
edge to other.
Examples
--------
>>> from pgmpy.models import MarkovModel
>>> from pgmpy.factors.discrete import DiscreteFactor
>>> mm = MarkovModel()
>>> mm.add_nodes_from(['x1', 'x2', 'x3', 'x4', 'x5', 'x6', 'x7'])
>>> mm.add_edges_from([('x1', 'x3'), ('x1', 'x4'), ('x2', 'x4'),
... ('x2', 'x5'), ('x3', 'x6'), ('x4', 'x6'),
... ('x4', 'x7'), ('x5', 'x7')])
>>> phi = [DiscreteFactor(edge, [2, 2], np.random.rand(4)) for edge in mm.edges()]
>>> mm.add_factors(*phi)
>>> junction_tree = mm.to_junction_tree()
"""
from pgmpy.models import JunctionTree
# Check whether the model is valid or not
self.check_model()
# Triangulate the graph to make it chordal
triangulated_graph = self.triangulate()
# Find maximal cliques in the chordal graph
cliques = list(map(tuple, nx.find_cliques(triangulated_graph)))
# If there is only 1 clique, then the junction tree formed is just a
# clique tree with that single clique as the node
if len(cliques) == 1:
clique_trees = JunctionTree()
clique_trees.add_node(cliques[0])
# Else if the number of cliques is more than 1 then create a complete
# graph with all the cliques as nodes and weight of the edges being
# the length of sepset between two cliques
elif len(cliques) >= 2:
complete_graph = UndirectedGraph()
edges = list(itertools.combinations(cliques, 2))
weights = list(
map(lambda x: len(set(x[0]).intersection(set(x[1]))), edges))
for edge, weight in zip(edges, weights):
complete_graph.add_edge(*edge, weight=-weight)
# Create clique trees by minimum (or maximum) spanning tree method
clique_trees = JunctionTree(
nx.minimum_spanning_tree(complete_graph).edges())
# Check whether the factors are defined for all the random variables or not
all_vars = itertools.chain(
*[factor.scope() for factor in self.factors])
if set(all_vars) != set(self.nodes()):
ValueError(
'DiscreteFactor for all the random variables not specified')
# Dictionary stating whether the factor is used to create clique
# potential or not
# If false, then it is not used to create any clique potential
is_used = {factor: False for factor in self.factors}
for node in clique_trees.nodes():
clique_factors = []
for factor in self.factors:
# If the factor is not used in creating any clique potential as
# well as has any variable of the given clique in its scope,
# then use it in creating clique potential
if not is_used[factor] and set(factor.scope()).issubset(node):
clique_factors.append(factor)
is_used[factor] = True
# To compute clique potential, initially set it as unity factor
var_card = [self.get_cardinality()[x] for x in node]
clique_potential = DiscreteFactor(node, var_card,
np.ones(np.product(var_card)))
# multiply it with the factors associated with the variables present
# in the clique (or node)
# Checking if there's clique_factors, to handle the case when clique_factors
# is empty, otherwise factor_product with throw an error [ref #889]
if clique_factors:
clique_potential *= factor_product(*clique_factors)
clique_trees.add_factors(clique_potential)
if not all(is_used.values()):
raise ValueError(
'All the factors were not used to create Junction Tree.'
'Extra factors are defined.')
return clique_trees
class TestJunctionTreeCopy(unittest.TestCase):
def setUp(self):
self.graph = JunctionTree()
def test_copy_with_nodes(self):
self.graph.add_nodes_from([('a', 'b', 'c'), ('a', 'b'), ('a', 'c')])
self.graph.add_edges_from([(('a', 'b', 'c'), ('a', 'b')),
(('a', 'b', 'c'), ('a', 'c'))])
graph_copy = self.graph.copy()
self.graph.remove_edge(('a', 'b', 'c'), ('a', 'c'))
self.assertFalse(self.graph.has_edge(('a', 'b', 'c'), ('a', 'c')))
self.assertTrue(graph_copy.has_edge(('a', 'b', 'c'), ('a', 'c')))
self.graph.remove_node(('a', 'c'))
self.assertFalse(self.graph.has_node(('a', 'c')))
self.assertTrue(graph_copy.has_node(('a', 'c')))
self.graph.add_node(('c', 'd'))
self.assertTrue(self.graph.has_node(('c', 'd')))
self.assertFalse(graph_copy.has_node(('c', 'd')))
def test_copy_with_factors(self):
self.graph.add_edges_from([[('a', 'b'), ('b', 'c')]])
phi1 = Factor(['a', 'b'], [2, 2], np.random.rand(4))
phi2 = Factor(['b', 'c'], [2, 2], np.random.rand(4))
self.graph.add_factors(phi1, phi2)
graph_copy = self.graph.copy()
self.assertIsInstance(graph_copy, JunctionTree)
self.assertIsNot(self.graph, graph_copy)
self.assertEqual(hf.recursive_sorted(self.graph.nodes()),
hf.recursive_sorted(graph_copy.nodes()))
self.assertEqual(hf.recursive_sorted(self.graph.edges()),
hf.recursive_sorted(graph_copy.edges()))
self.assertTrue(graph_copy.check_model())
self.assertEqual(self.graph.get_factors(), graph_copy.get_factors())
self.graph.remove_factors(phi1, phi2)
self.assertTrue(phi1 not in self.graph.factors
and phi2 not in self.graph.factors)
self.assertTrue(phi1 in graph_copy.factors
and phi2 in graph_copy.factors)
self.graph.add_factors(phi1, phi2)
self.graph.factors[0] = Factor(['a', 'b'], [2, 2], np.random.rand(4))
self.assertNotEqual(self.graph.get_factors()[0],
graph_copy.get_factors()[0])
self.assertNotEqual(self.graph.factors, graph_copy.factors)
def test_copy_with_factorchanges(self):
self.graph.add_edges_from([[('a', 'b'), ('b', 'c')]])
phi1 = Factor(['a', 'b'], [2, 2], np.random.rand(4))
phi2 = Factor(['b', 'c'], [2, 2], np.random.rand(4))
self.graph.add_factors(phi1, phi2)
graph_copy = self.graph.copy()
self.graph.factors[0].reduce([('a', 0)])
self.assertNotEqual(self.graph.factors[0].scope(),
graph_copy.factors[0].scope())
self.assertNotEqual(self.graph, graph_copy)
self.graph.factors[1].marginalize(['b'])
self.assertNotEqual(self.graph.factors[1].scope(),
graph_copy.factors[1].scope())
self.assertNotEqual(self.graph, graph_copy)
def tearDown(self):
del self.graph
class TestJunctionTreeCopy(unittest.TestCase):
def setUp(self):
self.graph = JunctionTree()
def test_copy_with_nodes(self):
self.graph.add_nodes_from([('a', 'b', 'c'), ('a', 'b'), ('a', 'c')])
self.graph.add_edges_from([(('a', 'b', 'c'), ('a', 'b')),
(('a', 'b', 'c'), ('a', 'c'))])
graph_copy = self.graph.copy()
self.graph.remove_edge(('a', 'b', 'c'), ('a', 'c'))
self.assertFalse(self.graph.has_edge(('a', 'b', 'c'), ('a', 'c')))
self.assertTrue(graph_copy.has_edge(('a', 'b', 'c'), ('a', 'c')))
self.graph.remove_node(('a', 'c'))
self.assertFalse(self.graph.has_node(('a', 'c')))
self.assertTrue(graph_copy.has_node(('a', 'c')))
self.graph.add_node(('c', 'd'))
self.assertTrue(self.graph.has_node(('c', 'd')))
self.assertFalse(graph_copy.has_node(('c', 'd')))
def test_copy_with_factors(self):
self.graph.add_edges_from([[('a', 'b'), ('b', 'c')]])
phi1 = DiscreteFactor(['a', 'b'], [2, 2], np.random.rand(4))
phi2 = DiscreteFactor(['b', 'c'], [2, 2], np.random.rand(4))
self.graph.add_factors(phi1, phi2)
graph_copy = self.graph.copy()
self.assertIsInstance(graph_copy, JunctionTree)
self.assertIsNot(self.graph, graph_copy)
self.assertEqual(hf.recursive_sorted(self.graph.nodes()),
hf.recursive_sorted(graph_copy.nodes()))
self.assertEqual(hf.recursive_sorted(self.graph.edges()),
hf.recursive_sorted(graph_copy.edges()))
self.assertTrue(graph_copy.check_model())
self.assertEqual(self.graph.get_factors(), graph_copy.get_factors())
self.graph.remove_factors(phi1, phi2)
self.assertTrue(phi1 not in self.graph.factors and phi2 not in self.graph.factors)
self.assertTrue(phi1 in graph_copy.factors and phi2 in graph_copy.factors)
self.graph.add_factors(phi1, phi2)
self.graph.factors[0] = DiscreteFactor(['a', 'b'], [2, 2], np.random.rand(4))
self.assertNotEqual(self.graph.get_factors()[0], graph_copy.get_factors()[0])
self.assertNotEqual(self.graph.factors, graph_copy.factors)
def test_copy_with_factorchanges(self):
self.graph.add_edges_from([[('a', 'b'), ('b', 'c')]])
phi1 = DiscreteFactor(['a', 'b'], [2, 2], np.random.rand(4))
phi2 = DiscreteFactor(['b', 'c'], [2, 2], np.random.rand(4))
self.graph.add_factors(phi1, phi2)
graph_copy = self.graph.copy()
self.graph.factors[0].reduce([('a', 0)])
self.assertNotEqual(self.graph.factors[0].scope(), graph_copy.factors[0].scope())
self.assertNotEqual(self.graph, graph_copy)
self.graph.factors[1].marginalize(['b'])
self.assertNotEqual(self.graph.factors[1].scope(), graph_copy.factors[1].scope())
self.assertNotEqual(self.graph, graph_copy)
def tearDown(self):
del self.graph
