def setUp(self):
self.factor1 = Factor(['a', 'b'], [2, 2], np.random.rand(4))
self.factor2 = Factor(['b', 'c'], [2, 2], np.random.rand(4))
self.factor3 = Factor(['d', 'e'], [2, 2], np.random.rand(4))
self.factor4 = Factor(['e', 'f'], [2, 2], np.random.rand(4))
self.factor5 = Factor(['a', 'b', 'e'], [2, 2, 2], np.random.rand(8))
self.graph1 = JunctionTree()
self.graph1.add_edge(('a', 'b'), ('b', 'c'))
self.graph1.add_factors(self.factor1, self.factor2)
self.graph2 = JunctionTree()
self.graph2.add_nodes_from([('a', 'b'), ('b', 'c'), ('d', 'e')])
self.graph2.add_edge(('a', 'b'), ('b', 'c'))
self.graph2.add_factors(self.factor1, self.factor2, self.factor3)
self.graph3 = JunctionTree()
self.graph3.add_edges_from([(('a', 'b'), ('b', 'c')),
(('d', 'e'), ('e', 'f'))])
self.graph3.add_factors(self.factor1, self.factor2, self.factor3,
self.factor4)
self.graph4 = JunctionTree()
self.graph4.add_edges_from([(('a', 'b', 'e'), ('b', 'c')),
(('a', 'b', 'e'), ('e', 'f')),
(('d', 'e'), ('e', 'f'))])
self.graph4.add_factors(self.factor5, self.factor2, self.factor3,
self.factor4)
def setUp(self):
self.factor1 = DiscreteFactor(["a", "b"], [2, 2], np.random.rand(4))
self.factor2 = DiscreteFactor(["b", "c"], [2, 2], np.random.rand(4))
self.factor3 = DiscreteFactor(["d", "e"], [2, 2], np.random.rand(4))
self.factor4 = DiscreteFactor(["e", "f"], [2, 2], np.random.rand(4))
self.factor5 = DiscreteFactor(["a", "b", "e"], [2, 2, 2],
np.random.rand(8))
self.graph1 = JunctionTree()
self.graph1.add_edge(("a", "b"), ("b", "c"))
self.graph1.add_factors(self.factor1, self.factor2)
self.graph2 = JunctionTree()
self.graph2.add_nodes_from([("a", "b"), ("b", "c"), ("d", "e")])
self.graph2.add_edge(("a", "b"), ("b", "c"))
self.graph2.add_factors(self.factor1, self.factor2, self.factor3)
self.graph3 = JunctionTree()
self.graph3.add_edges_from([(("a", "b"), ("b", "c")),
(("d", "e"), ("e", "f"))])
self.graph3.add_factors(self.factor1, self.factor2, self.factor3,
self.factor4)
self.graph4 = JunctionTree()
self.graph4.add_edges_from([
(("a", "b", "e"), ("b", "c")),
(("a", "b", "e"), ("e", "f")),
(("d", "e"), ("e", "f")),
])
self.graph4.add_factors(self.factor5, self.factor2, self.factor3,
self.factor4)
def setUp(self):
self.junction_tree = JunctionTree([(("A", "B"), ("B", "C")),
(("B", "C"), ("C", "D"))])
phi1 = DiscreteFactor(["A", "B"], [2, 3], range(6))
phi2 = DiscreteFactor(["B", "C"], [3, 2], range(6))
phi3 = DiscreteFactor(["C", "D"], [2, 2], range(4))
self.junction_tree.add_factors(phi1, phi2, phi3)
self.bayesian_model = BayesianModel([("A", "J"), ("R", "J"),
("J", "Q"), ("J", "L"),
("G", "L")])
cpd_a = TabularCPD("A", 2, values=[[0.2], [0.8]])
cpd_r = TabularCPD("R", 2, values=[[0.4], [0.6]])
cpd_j = TabularCPD(
"J",
2,
values=[[0.9, 0.6, 0.7, 0.1], [0.1, 0.4, 0.3, 0.9]],
evidence=["A", "R"],
evidence_card=[2, 2],
)
cpd_q = TabularCPD("Q",
2,
values=[[0.9, 0.2], [0.1, 0.8]],
evidence=["J"],
evidence_card=[2])
cpd_l = TabularCPD(
"L",
2,
values=[[0.9, 0.45, 0.8, 0.1], [0.1, 0.55, 0.2, 0.9]],
evidence=["J", "G"],
evidence_card=[2, 2],
)
cpd_g = TabularCPD("G", 2, values=[[0.6], [0.4]])
self.bayesian_model.add_cpds(cpd_a, cpd_g, cpd_j, cpd_l, cpd_q, cpd_r)
def setUp(self):
self.junction_tree = JunctionTree([(('A', 'B'), ('B', 'C')),
(('B', 'C'), ('C', 'D'))])
phi1 = DiscreteFactor(['A', 'B'], [2, 3], range(6))
phi2 = DiscreteFactor(['B', 'C'], [3, 2], range(6))
phi3 = DiscreteFactor(['C', 'D'], [2, 2], range(4))
self.junction_tree.add_factors(phi1, phi2, phi3)
self.bayesian_model = BayesianModel([('A', 'J'), ('R', 'J'),
('J', 'Q'), ('J', 'L'),
('G', 'L')])
cpd_a = TabularCPD('A', 2, values=[[0.2], [0.8]])
cpd_r = TabularCPD('R', 2, values=[[0.4], [0.6]])
cpd_j = TabularCPD('J',
2,
values=[[0.9, 0.6, 0.7, 0.1], [0.1, 0.4, 0.3, 0.9]],
evidence=['A', 'R'],
evidence_card=[2, 2])
cpd_q = TabularCPD('Q',
2,
values=[[0.9, 0.2], [0.1, 0.8]],
evidence=['J'],
evidence_card=[2])
cpd_l = TabularCPD('L',
2,
values=[[0.9, 0.45, 0.8, 0.1],
[0.1, 0.55, 0.2, 0.9]],
evidence=['J', 'G'],
evidence_card=[2, 2])
cpd_g = TabularCPD('G', 2, values=[[0.6], [0.4]])
self.bayesian_model.add_cpds(cpd_a, cpd_g, cpd_j, cpd_l, cpd_q, cpd_r)
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 import Factor
>>> 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 = [Factor(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('Factor 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 = Factor(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 _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(list(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)
# Firstly import JunctionTree class
from pgmpy.models import JunctionTree
junction_tree = JunctionTree()
# Each node in the junction tree is a cluster of random variables
# represented as a tuple
junction_tree.add_nodes_from([('A', 'B', 'C'), ('C', 'D')])
junction_tree.add_edge(('A', 'B', 'C'), ('C', 'D'))
junction_tree.add_edge(('A', 'B', 'C'), ('D', 'E', 'F'))
def setUp(self):
self.graph = JunctionTree()
