cpd_late_for_school = TabularCPD('late_for_school', 2,
[[0.9, 0.45, 0.8, 0.1],
[0.1, 0.55, 0.2, 0.9]],
evidence=['getting_up_late', 'traffic_jam'],
evidence_card=[2, 2])
cpd_long_queues = TabularCPD('long_queues', 2,
[[0.9, 0.2],
[0.1, 0.8]],
evidence=['traffic_jam'],
evidence_card=[2])
model.add_cpds(cpd_rain, cpd_accident,
cpd_traffic_jam, cpd_getting_up_late,
cpd_late_for_school, cpd_long_queues)
# Calculating max marginals
model_inference = VariableElimination(model)
model_inference.max_marginal(variables=['late_for_school'])
model_inference.max_marginal(variables=['late_for_school', 'traffic_jam'])
# For any evidence in the network we can simply pass the evidence
# argument which is a dict of the form of {variable: state}
model_inference.max_marginal(variables=['late_for_school'],
evidence={'traffic_jam': 1})
model_inference.max_marginal(variables=['late_for_school'],
evidence={'traffic_jam': 1,
'getting_up_late': 0})
model_inference.max_marginal(variables=['late_for_school','long_queues'],
evidence={'traffic_jam': 1,
'getting_up_late': 0}
# Again as in the case of VariableEliminaion we can also pass the
# elimination order of variables for MAP queries. If not specified
# pgmpy automatically computes the best elimination order for the
# query.
for age in STATE_NAMES['age']:
print('age : ' + age + '\n')
for delay in STATE_NAMES['delay']:
print('delay : ' + delay + '\n')
print(
ratio(data, lambda t: t['age'] == age,
lambda t: t['delay'] == delay))
separator()
q = ve.map_query(variables=None, evidence=None)
print("MAP-query\n")
print(q)
mm = ve.max_marginal(variables=None, evidence=None)
print("Max-Marginal query\n")
print(mm)
mm2 = ve.map_query(variables=['age'], evidence={'delay': '0'})
# End of Task 2
# Task 3 ------------ Reversed PGM
data = pd.DataFrame(data=RAW_DATA)
model = BayesianModel([('age', 'delay'), ('gender', 'delay'),
('avg_mat', 'delay'), ('avg_cs', 'delay')])
model.fit(data) # Uses the default ML-estimation
print('Data size : ' + (str)(np.shape(data)))
class TestVariableEliminationMarkov(unittest.TestCase):
def setUp(self):
# It is just a moralised version of the above Bayesian network so all the results are same. Only factors
# are under consideration for inference so this should be fine.
self.markov_model = MarkovModel([
("A", "J"),
("R", "J"),
("J", "Q"),
("J", "L"),
("G", "L"),
("A", "R"),
("J", "G"),
])
factor_a = TabularCPD("A", 2, values=[[0.2], [0.8]]).to_factor()
factor_r = TabularCPD("R", 2, values=[[0.4], [0.6]]).to_factor()
factor_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],
).to_factor()
factor_q = TabularCPD("Q",
2,
values=[[0.9, 0.2], [0.1, 0.8]],
evidence=["J"],
evidence_card=[2]).to_factor()
factor_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],
).to_factor()
factor_g = TabularCPD("G", 2, [[0.6], [0.4]]).to_factor()
self.markov_model.add_factors(factor_a, factor_r, factor_j, factor_q,
factor_l, factor_g)
self.markov_inference = VariableElimination(self.markov_model)
# All the values that are used for comparision in the all the tests are
# found using SAMIAM (assuming that it is correct ;))
def test_query_single_variable(self):
query_result = self.markov_inference.query(["J"])
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"],
cardinality=[2],
values=np.array([0.416, 0.584])),
)
def test_query_multiple_variable(self):
query_result = self.markov_inference.query(["Q", "J"])
self.assertEqual(
query_result,
DiscreteFactor(
variables=["Q", "J"],
cardinality=[2, 2],
values=np.array([[0.3744, 0.1168], [0.0416, 0.4672]]),
),
)
def test_query_single_variable_with_evidence(self):
query_result = self.markov_inference.query(variables=["J"],
evidence={
"A": 0,
"R": 1
})
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"], cardinality=[2], values=[0.6,
0.4]),
)
def test_query_multiple_variable_with_evidence(self):
query_result = self.markov_inference.query(variables=["J", "Q"],
evidence={
"A": 0,
"R": 0,
"G": 0,
"L": 1
})
self.assertEqual(
query_result,
DiscreteFactor(
variables=["Q", "J"],
cardinality=[2, 2],
values=np.array([[0.081, 0.004], [0.009, 0.016]]),
),
)
def test_query_multiple_times(self):
# This just tests that the models are not getting modified while querying them
query_result = self.markov_inference.query(["J"])
query_result = self.markov_inference.query(["J"])
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"],
cardinality=[2],
values=np.array([0.416, 0.584])),
)
query_result = self.markov_inference.query(["Q", "J"])
query_result = self.markov_inference.query(["Q", "J"])
self.assertEqual(
query_result,
DiscreteFactor(
variables=["Q", "J"],
cardinality=[2, 2],
values=np.array([[0.3744, 0.1168], [0.0416, 0.4672]]),
),
)
query_result = self.markov_inference.query(variables=["J"],
evidence={
"A": 0,
"R": 1
})
query_result = self.markov_inference.query(variables=["J"],
evidence={
"A": 0,
"R": 1
})
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"], cardinality=[2], values=[0.6,
0.4]),
)
query_result = self.markov_inference.query(variables=["J", "Q"],
evidence={
"A": 0,
"R": 0,
"G": 0,
"L": 1
})
query_result = self.markov_inference.query(variables=["J", "Q"],
evidence={
"A": 0,
"R": 0,
"G": 0,
"L": 1
})
self.assertEqual(
query_result,
DiscreteFactor(
variables=["Q", "J"],
cardinality=[2, 2],
values=np.array([[0.081, 0.004], [0.009, 0.016]]),
),
)
def test_max_marginal(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(),
0.1659,
decimal=4)
def test_max_marginal_var(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(["G"]),
0.1659,
decimal=4)
def test_max_marginal_var1(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(
["G", "R"]),
0.1659,
decimal=4)
def test_max_marginal_var2(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(
["G", "R", "A"]),
0.1659,
decimal=4)
def test_map_query(self):
map_query = self.markov_inference.map_query()
self.assertDictEqual(map_query, {
"A": 1,
"R": 1,
"J": 1,
"Q": 1,
"G": 0,
"L": 0
})
def test_map_query_with_evidence(self):
map_query = self.markov_inference.map_query(["A", "R", "L"], {
"J": 0,
"Q": 1,
"G": 0
})
self.assertDictEqual(map_query, {"A": 1, "R": 0, "L": 0})
def test_induced_graph(self):
induced_graph = self.markov_inference.induced_graph(
["G", "Q", "A", "J", "L", "R"])
result_edges = sorted([sorted(x) for x in induced_graph.edges()])
self.assertEqual(
[
["A", "J"],
["A", "R"],
["G", "J"],
["G", "L"],
["J", "L"],
["J", "Q"],
["J", "R"],
["L", "R"],
],
result_edges,
)
def test_induced_width(self):
result_width = self.markov_inference.induced_width(
["G", "Q", "A", "J", "L", "R"])
self.assertEqual(2, result_width)
def tearDown(self):
del self.markov_inference
del self.markov_model
class TestVariableElimination(unittest.TestCase):
def setUp(self):
self.bayesian_model = BayesianModel([('A', 'J'), ('R', 'J'),
('J', 'Q'), ('J', 'L'),
('G', 'L')])
cpd_a = TabularCPD('A', 2, [[0.2], [0.8]])
cpd_r = TabularCPD('R', 2, [[0.4], [0.6]])
cpd_j = TabularCPD('J', 2,
[[0.9, 0.6, 0.7, 0.1], [0.1, 0.4, 0.3, 0.9]],
['R', 'A'], [2, 2])
cpd_q = TabularCPD('Q', 2, [[0.9, 0.2], [0.1, 0.8]], ['J'], [2])
cpd_l = TabularCPD('L', 2,
[[0.9, 0.45, 0.8, 0.1], [0.1, 0.55, 0.2, 0.9]],
['G', 'J'], [2, 2])
cpd_g = TabularCPD('G', 2, [[0.6], [0.4]])
self.bayesian_model.add_cpds(cpd_a, cpd_g, cpd_j, cpd_l, cpd_q, cpd_r)
self.bayesian_inference = VariableElimination(self.bayesian_model)
# All the values that are used for comparision in the all the tests are
# found using SAMIAM (assuming that it is correct ;))
def test_query_single_variable(self):
query_result = self.bayesian_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
def test_query_multiple_variable(self):
query_result = self.bayesian_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
def test_query_single_variable_with_evidence(self):
query_result = self.bayesian_inference.query(variables=['J'],
evidence={
'A': 0,
'R': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
def test_query_multiple_variable_with_evidence(self):
query_result = self.bayesian_inference.query(variables=['J', 'Q'],
evidence={
'A': 0,
'R': 0,
'G': 0,
'L': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_query_multiple_times(self):
# This just tests that the models are not getting modified while querying them
query_result = self.bayesian_inference.query(['J'])
query_result = self.bayesian_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
query_result = self.bayesian_inference.query(['Q', 'J'])
query_result = self.bayesian_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
query_result = self.bayesian_inference.query(variables=['J'],
evidence={
'A': 0,
'R': 1
})
query_result = self.bayesian_inference.query(variables=['J'],
evidence={
'A': 0,
'R': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
query_result = self.bayesian_inference.query(variables=['J', 'Q'],
evidence={
'A': 0,
'R': 0,
'G': 0,
'L': 1
})
query_result = self.bayesian_inference.query(variables=['J', 'Q'],
evidence={
'A': 0,
'R': 0,
'G': 0,
'L': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_max_marginal(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(),
0.1659,
decimal=4)
def test_max_marginal_var(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(['G'
]),
0.5714,
decimal=4)
def test_max_marginal_var1(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(
['G', 'R']),
0.4055,
decimal=4)
def test_max_marginal_var2(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(
['G', 'R', 'A']),
0.3260,
decimal=4)
def test_map_query(self):
map_query = self.bayesian_inference.map_query()
self.assertDictEqual(map_query, {
'A': 1,
'R': 1,
'J': 1,
'Q': 1,
'G': 0,
'L': 0
})
def test_map_query_with_evidence(self):
map_query = self.bayesian_inference.map_query(['A', 'R', 'L'], {
'J': 0,
'Q': 1,
'G': 0
})
self.assertDictEqual(map_query, {'A': 1, 'R': 0, 'L': 0})
def test_induced_graph(self):
induced_graph = self.bayesian_inference.induced_graph(
['G', 'Q', 'A', 'J', 'L', 'R'])
result_edges = sorted([sorted(x) for x in induced_graph.edges()])
self.assertEqual([['A', 'J'], ['A', 'R'], ['G', 'J'], ['G', 'L'],
['J', 'L'], ['J', 'Q'], ['J', 'R'], ['L', 'R']],
result_edges)
def test_induced_width(self):
result_width = self.bayesian_inference.induced_width(
['G', 'Q', 'A', 'J', 'L', 'R'])
self.assertEqual(2, result_width)
def tearDown(self):
del self.bayesian_inference
del self.bayesian_model
class TestVariableElimination(unittest.TestCase):
def setUp(self):
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)
self.bayesian_inference = VariableElimination(self.bayesian_model)
# All the values that are used for comparision in the all the tests are
# found using SAMIAM (assuming that it is correct ;))
def test_query_single_variable(self):
query_result = self.bayesian_inference.query(["J"])
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"],
cardinality=[2],
values=[0.416, 0.584]),
)
def test_query_multiple_variable(self):
query_result = self.bayesian_inference.query(["Q", "J"])
self.assertEqual(
query_result,
DiscreteFactor(
variables=["J", "Q"],
cardinality=[2, 2],
values=np.array([[0.3744, 0.0416], [0.1168, 0.4672]]),
),
)
def test_query_single_variable_with_evidence(self):
query_result = self.bayesian_inference.query(variables=["J"],
evidence={
"A": 0,
"R": 1
})
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"], cardinality=[2], values=[0.6,
0.4]),
)
def test_query_multiple_variable_with_evidence(self):
query_result = self.bayesian_inference.query(variables=["J", "Q"],
evidence={
"A": 0,
"R": 0,
"G": 0,
"L": 1
})
self.assertEqual(
query_result,
DiscreteFactor(
variables=["J", "Q"],
cardinality=[2, 2],
values=np.array([[0.73636364, 0.08181818],
[0.03636364, 0.14545455]]),
),
)
def test_query_multiple_times(self):
# This just tests that the models are not getting modified while querying them
query_result = self.bayesian_inference.query(["J"])
query_result = self.bayesian_inference.query(["J"])
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"],
cardinality=[2],
values=np.array([0.416, 0.584])),
)
query_result = self.bayesian_inference.query(["Q", "J"])
query_result = self.bayesian_inference.query(["Q", "J"])
self.assertEqual(
query_result,
DiscreteFactor(
variables=["J", "Q"],
cardinality=[2, 2],
values=np.array([[0.3744, 0.0416], [0.1168, 0.4672]]),
),
)
query_result = self.bayesian_inference.query(variables=["J"],
evidence={
"A": 0,
"R": 1
})
query_result = self.bayesian_inference.query(variables=["J"],
evidence={
"A": 0,
"R": 1
})
self.assertEqual(
query_result,
DiscreteFactor(variables=["J"], cardinality=[2], values=[0.6,
0.4]),
)
query_result = self.bayesian_inference.query(variables=["J", "Q"],
evidence={
"A": 0,
"R": 0,
"G": 0,
"L": 1
})
query_result = self.bayesian_inference.query(variables=["J", "Q"],
evidence={
"A": 0,
"R": 0,
"G": 0,
"L": 1
})
self.assertEqual(
query_result,
DiscreteFactor(
variables=["J", "Q"],
cardinality=[2, 2],
values=np.array([[0.73636364, 0.08181818],
[0.03636364, 0.14545455]]),
),
)
def test_max_marginal(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(),
0.1659,
decimal=4)
def test_max_marginal_var(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(["G"
]),
0.5714,
decimal=4)
def test_max_marginal_var1(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(
["G", "R"]),
0.3740,
decimal=4)
def test_max_marginal_var2(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(
["G", "R", "A"]),
0.3061,
decimal=4)
def test_map_query(self):
map_query = self.bayesian_inference.map_query()
self.assertDictEqual(map_query, {
"A": 1,
"R": 1,
"J": 1,
"Q": 1,
"G": 0,
"L": 0
})
def test_map_query_with_evidence(self):
map_query = self.bayesian_inference.map_query(["A", "R", "L"], {
"J": 0,
"Q": 1,
"G": 0
})
self.assertDictEqual(map_query, {"A": 1, "R": 0, "L": 0})
def test_induced_graph(self):
induced_graph = self.bayesian_inference.induced_graph(
["G", "Q", "A", "J", "L", "R"])
result_edges = sorted([sorted(x) for x in induced_graph.edges()])
self.assertEqual(
[
["A", "J"],
["A", "R"],
["G", "J"],
["G", "L"],
["J", "L"],
["J", "Q"],
["J", "R"],
["L", "R"],
],
result_edges,
)
def test_induced_width(self):
result_width = self.bayesian_inference.induced_width(
["G", "Q", "A", "J", "L", "R"])
self.assertEqual(2, result_width)
def tearDown(self):
del self.bayesian_inference
del self.bayesian_model
from pgmpy.inference import VariableElimination
# Create a Bayesian model
model = BayesianModel(....)
cpd_var1 = TabularCPD(....)
cpd_var2 = TabularCPD(....)
cpd_var3 = TabularCPD(....)
cpd_var4 = TabularCPD(....)
cpd_var5 = TabularCPD(....)
model.add_cpds(..........)
# Calculating the max marginals
model_inference = VariableElimination(model)
model_inference.max_marginal(variables=['late_for_school'])
" 0.571425378538 "
model_inference.max_marginal(variables=['late_for_school', 'traffic_jam'])
" 0.405745234235 "
model_inference.max_marginal(variables=['late_for_school'], evidence={'traffic_jam':1}) # With evidence
" 0.571425378538 "
model_inference.max_marginal(variables=['no_of_people'], evidence={'location':1}, elimination_order=['quality', 'cost']) # can sepcify elimination sequence / otherwise system will choose automatically
" 0.623481338534 "
** " MAP using belief propagation "
" When sum-product variable elimination is compuattional intractable "
class TestVariableElimination(unittest.TestCase):
def setUp(self):
self.bayesian_model = BayesianModel([('A', 'J'), ('R', 'J'), ('J', 'Q'),
('J', 'L'), ('G', 'L')])
cpd_a = TabularCPD('A', 2, [[0.2], [0.8]])
cpd_r = TabularCPD('R', 2, [[0.4], [0.6]])
cpd_j = TabularCPD('J', 2,
[[0.9, 0.6, 0.7, 0.1],
[0.1, 0.4, 0.3, 0.9]],
['R', 'A'], [2, 2])
cpd_q = TabularCPD('Q', 2,
[[0.9, 0.2],
[0.1, 0.8]],
['J'], [2])
cpd_l = TabularCPD('L', 2,
[[0.9, 0.45, 0.8, 0.1],
[0.1, 0.55, 0.2, 0.9]],
['G', 'J'], [2, 2])
cpd_g = TabularCPD('G', 2, [[0.6], [0.4]])
self.bayesian_model.add_cpds(cpd_a, cpd_g, cpd_j, cpd_l, cpd_q, cpd_r)
self.bayesian_inference = VariableElimination(self.bayesian_model)
# All the values that are used for comparision in the all the tests are
# found using SAMIAM (assuming that it is correct ;))
def test_query_single_variable(self):
query_result = self.bayesian_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
def test_query_multiple_variable(self):
query_result = self.bayesian_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
def test_query_single_variable_with_evidence(self):
query_result = self.bayesian_inference.query(variables=['J'],
evidence={'A': 0, 'R': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
def test_query_multiple_variable_with_evidence(self):
query_result = self.bayesian_inference.query(variables=['J', 'Q'],
evidence={'A': 0, 'R': 0,
'G': 0, 'L': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_query_multiple_times(self):
# This just tests that the models are not getting modified while querying them
query_result = self.bayesian_inference.query(['J'])
query_result = self.bayesian_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
query_result = self.bayesian_inference.query(['Q', 'J'])
query_result = self.bayesian_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
query_result = self.bayesian_inference.query(variables=['J'],
evidence={'A': 0, 'R': 1})
query_result = self.bayesian_inference.query(variables=['J'],
evidence={'A': 0, 'R': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
query_result = self.bayesian_inference.query(variables=['J', 'Q'],
evidence={'A': 0, 'R': 0,
'G': 0, 'L': 1})
query_result = self.bayesian_inference.query(variables=['J', 'Q'],
evidence={'A': 0, 'R': 0,
'G': 0, 'L': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_max_marginal(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(), 0.1659, decimal=4)
def test_max_marginal_var(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(['G']), 0.5714, decimal=4)
def test_max_marginal_var1(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(['G', 'R']),
0.4055, decimal=4)
def test_max_marginal_var2(self):
np_test.assert_almost_equal(self.bayesian_inference.max_marginal(['G', 'R', 'A']),
0.3260, decimal=4)
def test_map_query(self):
map_query = self.bayesian_inference.map_query()
self.assertDictEqual(map_query, {'A': 1, 'R': 1, 'J': 1, 'Q': 1, 'G': 0,
'L': 0})
def test_map_query_with_evidence(self):
map_query = self.bayesian_inference.map_query(['A', 'R', 'L'],
{'J': 0, 'Q': 1, 'G': 0})
self.assertDictEqual(map_query, {'A': 1, 'R': 0, 'L': 0})
def test_induced_graph(self):
induced_graph = self.bayesian_inference.induced_graph(['G', 'Q', 'A', 'J', 'L', 'R'])
result_edges = sorted([sorted(x) for x in induced_graph.edges()])
self.assertEqual([['A', 'J'], ['A', 'R'], ['G', 'J'], ['G', 'L'],
['J', 'L'], ['J', 'Q'], ['J', 'R'], ['L', 'R']],
result_edges)
def test_induced_width(self):
result_width = self.bayesian_inference.induced_width(['G', 'Q', 'A', 'J', 'L', 'R'])
self.assertEqual(2, result_width)
def tearDown(self):
del self.bayesian_inference
del self.bayesian_model
class TestVariableEliminationMarkov(unittest.TestCase):
def setUp(self):
# It is just a moralised version of the above Bayesian network so all the results are same. Only factors
# are under consideration for inference so this should be fine.
self.markov_model = MarkovModel([('A', 'J'), ('R', 'J'), ('J', 'Q'), ('J', 'L'),
('G', 'L'), ('A', 'R'), ('J', 'G')])
factor_a = TabularCPD('A', 2, values=[[0.2], [0.8]]).to_factor()
factor_r = TabularCPD('R', 2, values=[[0.4], [0.6]]).to_factor()
factor_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]).to_factor()
factor_q = TabularCPD('Q', 2, values=[[0.9, 0.2], [0.1, 0.8]],
evidence=['J'], evidence_card=[2]).to_factor()
factor_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]).to_factor()
factor_g = TabularCPD('G', 2, [[0.6], [0.4]]).to_factor()
self.markov_model.add_factors(factor_a, factor_r, factor_j, factor_q, factor_l, factor_g)
self.markov_inference = VariableElimination(self.markov_model)
# All the values that are used for comparision in the all the tests are
# found using SAMIAM (assuming that it is correct ;))
def test_query_single_variable(self):
query_result = self.markov_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
def test_query_multiple_variable(self):
query_result = self.markov_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
def test_query_single_variable_with_evidence(self):
query_result = self.markov_inference.query(variables=['J'],
evidence={'A': 0, 'R': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
def test_query_multiple_variable_with_evidence(self):
query_result = self.markov_inference.query(variables=['J', 'Q'],
evidence={'A': 0, 'R': 0,
'G': 0, 'L': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_query_multiple_times(self):
# This just tests that the models are not getting modified while querying them
query_result = self.markov_inference.query(['J'])
query_result = self.markov_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
query_result = self.markov_inference.query(['Q', 'J'])
query_result = self.markov_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
query_result = self.markov_inference.query(variables=['J'],
evidence={'A': 0, 'R': 1})
query_result = self.markov_inference.query(variables=['J'],
evidence={'A': 0, 'R': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
query_result = self.markov_inference.query(variables=['J', 'Q'],
evidence={'A': 0, 'R': 0,
'G': 0, 'L': 1})
query_result = self.markov_inference.query(variables=['J', 'Q'],
evidence={'A': 0, 'R': 0,
'G': 0, 'L': 1})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_max_marginal(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(), 0.1659, decimal=4)
def test_max_marginal_var(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(['G']), 0.5714, decimal=4)
def test_max_marginal_var1(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(['G', 'R']),
0.4055, decimal=4)
def test_max_marginal_var2(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(['G', 'R', 'A']),
0.3260, decimal=4)
def test_map_query(self):
map_query = self.markov_inference.map_query()
self.assertDictEqual(map_query, {'A': 1, 'R': 1, 'J': 1, 'Q': 1, 'G': 0, 'L': 0})
def test_map_query_with_evidence(self):
map_query = self.markov_inference.map_query(['A', 'R', 'L'],
{'J': 0, 'Q': 1, 'G': 0})
self.assertDictEqual(map_query, {'A': 1, 'R': 0, 'L': 0})
def test_induced_graph(self):
induced_graph = self.markov_inference.induced_graph(['G', 'Q', 'A', 'J', 'L', 'R'])
result_edges = sorted([sorted(x) for x in induced_graph.edges()])
self.assertEqual([['A', 'J'], ['A', 'R'], ['G', 'J'], ['G', 'L'],
['J', 'L'], ['J', 'Q'], ['J', 'R'], ['L', 'R']],
result_edges)
def test_induced_width(self):
result_width = self.markov_inference.induced_width(['G', 'Q', 'A', 'J', 'L', 'R'])
self.assertEqual(2, result_width)
def tearDown(self):
del self.markov_inference
del self.markov_model
class TestVariableEliminationMarkov(unittest.TestCase):
def setUp(self):
# It is just a moralised version of the above Bayesian network so all the results are same. Only factors
# are under consideration for inference so this should be fine.
self.markov_model = MarkovModel([('A', 'J'), ('R', 'J'), ('J', 'Q'),
('J', 'L'), ('G', 'L'), ('A', 'R'),
('J', 'G')])
factor_a = TabularCPD('A', 2, values=[[0.2], [0.8]]).to_factor()
factor_r = TabularCPD('R', 2, values=[[0.4], [0.6]]).to_factor()
factor_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]).to_factor()
factor_q = TabularCPD('Q',
2,
values=[[0.9, 0.2], [0.1, 0.8]],
evidence=['J'],
evidence_card=[2]).to_factor()
factor_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]).to_factor()
factor_g = TabularCPD('G', 2, [[0.6], [0.4]]).to_factor()
self.markov_model.add_factors(factor_a, factor_r, factor_j, factor_q,
factor_l, factor_g)
self.markov_inference = VariableElimination(self.markov_model)
# All the values that are used for comparision in the all the tests are
# found using SAMIAM (assuming that it is correct ;))
def test_query_single_variable(self):
query_result = self.markov_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
def test_query_multiple_variable(self):
query_result = self.markov_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
def test_query_single_variable_with_evidence(self):
query_result = self.markov_inference.query(variables=['J'],
evidence={
'A': 0,
'R': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
def test_query_multiple_variable_with_evidence(self):
query_result = self.markov_inference.query(variables=['J', 'Q'],
evidence={
'A': 0,
'R': 0,
'G': 0,
'L': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_query_multiple_times(self):
# This just tests that the models are not getting modified while querying them
query_result = self.markov_inference.query(['J'])
query_result = self.markov_inference.query(['J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
query_result = self.markov_inference.query(['Q', 'J'])
query_result = self.markov_inference.query(['Q', 'J'])
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.416, 0.584]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.4912, 0.5088]))
query_result = self.markov_inference.query(variables=['J'],
evidence={
'A': 0,
'R': 1
})
query_result = self.markov_inference.query(variables=['J'],
evidence={
'A': 0,
'R': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.60, 0.40]))
query_result = self.markov_inference.query(variables=['J', 'Q'],
evidence={
'A': 0,
'R': 0,
'G': 0,
'L': 1
})
query_result = self.markov_inference.query(variables=['J', 'Q'],
evidence={
'A': 0,
'R': 0,
'G': 0,
'L': 1
})
np_test.assert_array_almost_equal(query_result['J'].values,
np.array([0.818182, 0.181818]))
np_test.assert_array_almost_equal(query_result['Q'].values,
np.array([0.772727, 0.227273]))
def test_max_marginal(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(),
0.1659,
decimal=4)
def test_max_marginal_var(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(['G']),
0.5714,
decimal=4)
def test_max_marginal_var1(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(
['G', 'R']),
0.4055,
decimal=4)
def test_max_marginal_var2(self):
np_test.assert_almost_equal(self.markov_inference.max_marginal(
['G', 'R', 'A']),
0.3260,
decimal=4)
def test_map_query(self):
map_query = self.markov_inference.map_query()
self.assertDictEqual(map_query, {
'A': 1,
'R': 1,
'J': 1,
'Q': 1,
'G': 0,
'L': 0
})
def test_map_query_with_evidence(self):
map_query = self.markov_inference.map_query(['A', 'R', 'L'], {
'J': 0,
'Q': 1,
'G': 0
})
self.assertDictEqual(map_query, {'A': 1, 'R': 0, 'L': 0})
def test_induced_graph(self):
induced_graph = self.markov_inference.induced_graph(
['G', 'Q', 'A', 'J', 'L', 'R'])
result_edges = sorted([sorted(x) for x in induced_graph.edges()])
self.assertEqual([['A', 'J'], ['A', 'R'], ['G', 'J'], ['G', 'L'],
['J', 'L'], ['J', 'Q'], ['J', 'R'], ['L', 'R']],
result_edges)
def test_induced_width(self):
result_width = self.markov_inference.induced_width(
['G', 'Q', 'A', 'J', 'L', 'R'])
self.assertEqual(2, result_width)
def tearDown(self):
del self.markov_inference
del self.markov_model
