class TestBayesianModelCPD(unittest.TestCase):
def setUp(self):
self.G = BayesianModel([('d', 'g'), ('i', 'g'), ('g', 'l'),
('i', 's')])
def test_active_trail_nodes(self):
self.assertEqual(sorted(self.G.active_trail_nodes('d')),
['d', 'g', 'l'])
self.assertEqual(sorted(self.G.active_trail_nodes('i')),
['g', 'i', 'l', 's'])
def test_active_trail_nodes_args(self):
self.assertEqual(sorted(self.G.active_trail_nodes('d', observed='g')),
['d', 'i', 's'])
self.assertEqual(sorted(self.G.active_trail_nodes('l', observed='g')),
['l'])
self.assertEqual(
sorted(self.G.active_trail_nodes('s', observed=['i', 'l'])), ['s'])
self.assertEqual(
sorted(self.G.active_trail_nodes('s', observed=['d', 'l'])),
['g', 'i', 's'])
def test_is_active_trail_triplets(self):
self.assertTrue(self.G.is_active_trail('d', 'l'))
self.assertTrue(self.G.is_active_trail('g', 's'))
self.assertFalse(self.G.is_active_trail('d', 'i'))
self.assertTrue(self.G.is_active_trail('d', 'i', observed='g'))
self.assertFalse(self.G.is_active_trail('d', 'l', observed='g'))
self.assertFalse(self.G.is_active_trail('i', 'l', observed='g'))
self.assertTrue(self.G.is_active_trail('d', 'i', observed='l'))
self.assertFalse(self.G.is_active_trail('g', 's', observed='i'))
def test_is_active_trail(self):
self.assertFalse(self.G.is_active_trail('d', 's'))
self.assertTrue(self.G.is_active_trail('s', 'l'))
self.assertTrue(self.G.is_active_trail('d', 's', observed='g'))
self.assertFalse(self.G.is_active_trail('s', 'l', observed='g'))
def test_is_active_trail_args(self):
self.assertFalse(self.G.is_active_trail('s', 'l', 'i'))
self.assertFalse(self.G.is_active_trail('s', 'l', 'g'))
self.assertTrue(self.G.is_active_trail('d', 's', 'l'))
self.assertFalse(self.G.is_active_trail('d', 's', ['i', 'l']))
def test_get_cpds(self):
cpd_d = TabularCPD('d', 2, values=np.random.rand(2, 1))
cpd_i = TabularCPD('i', 2, values=np.random.rand(2, 1))
cpd_g = TabularCPD('g',
2,
values=np.random.rand(2, 4),
evidence=['d', 'i'],
evidence_card=[2, 2])
cpd_l = TabularCPD('l',
2,
values=np.random.rand(2, 2),
evidence=['g'],
evidence_card=[2])
cpd_s = TabularCPD('s',
2,
values=np.random.rand(2, 2),
evidence=['i'],
evidence_card=[2])
self.G.add_cpds(cpd_d, cpd_i, cpd_g, cpd_l, cpd_s)
self.assertEqual(self.G.get_cpds('d').variable, 'd')
def test_get_cpds1(self):
self.model = BayesianModel([('A', 'AB')])
cpd_a = TabularCPD('A', 2, values=np.random.rand(2, 1))
cpd_ab = TabularCPD('AB',
2,
values=np.random.rand(2, 2),
evidence=['A'],
evidence_card=[2])
self.model.add_cpds(cpd_a, cpd_ab)
self.assertEqual(self.model.get_cpds('A').variable, 'A')
self.assertEqual(self.model.get_cpds('AB').variable, 'AB')
self.assertRaises(ValueError, self.model.get_cpds, 'B')
self.model.add_node('B')
self.assertRaises(ValueError, self.model.get_cpds, 'B')
def test_add_single_cpd(self):
cpd_s = TabularCPD('s', 2, np.random.rand(2, 2), ['i'], [2])
self.G.add_cpds(cpd_s)
self.assertListEqual(self.G.get_cpds(), [cpd_s])
def test_add_multiple_cpds(self):
cpd_d = TabularCPD('d', 2, values=np.random.rand(2, 1))
cpd_i = TabularCPD('i', 2, values=np.random.rand(2, 1))
cpd_g = TabularCPD('g',
2,
values=np.random.rand(2, 4),
evidence=['d', 'i'],
evidence_card=[2, 2])
cpd_l = TabularCPD('l',
2,
values=np.random.rand(2, 2),
evidence=['g'],
evidence_card=[2])
cpd_s = TabularCPD('s',
2,
values=np.random.rand(2, 2),
evidence=['i'],
evidence_card=[2])
self.G.add_cpds(cpd_d, cpd_i, cpd_g, cpd_l, cpd_s)
self.assertEqual(self.G.get_cpds('d'), cpd_d)
self.assertEqual(self.G.get_cpds('i'), cpd_i)
self.assertEqual(self.G.get_cpds('g'), cpd_g)
self.assertEqual(self.G.get_cpds('l'), cpd_l)
self.assertEqual(self.G.get_cpds('s'), cpd_s)
def test_check_model(self):
cpd_g = TabularCPD('g',
2,
values=np.array([[0.2, 0.3, 0.4, 0.6],
[0.8, 0.7, 0.6, 0.4]]),
evidence=['d', 'i'],
evidence_card=[2, 2])
cpd_s = TabularCPD('s',
2,
values=np.array([[0.2, 0.3], [0.8, 0.7]]),
evidence=['i'],
evidence_card=[2])
cpd_l = TabularCPD('l',
2,
values=np.array([[0.2, 0.3], [0.8, 0.7]]),
evidence=['g'],
evidence_card=[2])
self.G.add_cpds(cpd_g, cpd_s, cpd_l)
self.assertRaises(ValueError, self.G.check_model)
cpd_d = TabularCPD('d', 2, values=[[0.8, 0.2]])
cpd_i = TabularCPD('i', 2, values=[[0.7, 0.3]])
self.G.add_cpds(cpd_d, cpd_i)
self.assertTrue(self.G.check_model())
def test_check_model1(self):
cpd_g = TabularCPD('g',
2,
values=np.array([[0.2, 0.3], [0.8, 0.7]]),
evidence=['i'],
evidence_card=[2])
self.G.add_cpds(cpd_g)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_g)
cpd_g = TabularCPD('g',
2,
values=np.array([[0.2, 0.3, 0.4, 0.6],
[0.8, 0.7, 0.6, 0.4]]),
evidence=['d', 's'],
evidence_card=[2, 2])
self.G.add_cpds(cpd_g)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_g)
cpd_g = TabularCPD('g',
2,
values=np.array([[0.2, 0.3], [0.8, 0.7]]),
evidence=['l'],
evidence_card=[2])
self.G.add_cpds(cpd_g)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_g)
cpd_l = TabularCPD('l',
2,
values=np.array([[0.2, 0.3], [0.8, 0.7]]),
evidence=['d'],
evidence_card=[2])
self.G.add_cpds(cpd_l)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_l)
cpd_l = TabularCPD('l',
2,
values=np.array([[0.2, 0.3, 0.4, 0.6],
[0.8, 0.7, 0.6, 0.4]]),
evidence=['d', 'i'],
evidence_card=[2, 2])
self.G.add_cpds(cpd_l)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_l)
cpd_l = TabularCPD('l',
2,
values=np.array(
[[0.2, 0.3, 0.4, 0.6, 0.2, 0.3, 0.4, 0.6],
[0.8, 0.7, 0.6, 0.4, 0.8, 0.7, 0.6, 0.4]]),
evidence=['g', 'd', 'i'],
evidence_card=[2, 2, 2])
self.G.add_cpds(cpd_l)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_l)
def test_check_model2(self):
cpd_s = TabularCPD('s',
2,
values=np.array([[0.5, 0.3], [0.8, 0.7]]),
evidence=['i'],
evidence_card=[2])
self.G.add_cpds(cpd_s)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_s)
cpd_g = TabularCPD('g',
2,
values=np.array([[0.2, 0.3, 0.4, 0.6],
[0.3, 0.7, 0.6, 0.4]]),
evidence=['d', 'i'],
evidence_card=[2, 2])
self.G.add_cpds(cpd_g)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_g)
cpd_l = TabularCPD('l',
2,
values=np.array([[0.2, 0.3], [0.1, 0.7]]),
evidence=['g'],
evidence_card=[2])
self.G.add_cpds(cpd_l)
self.assertRaises(ValueError, self.G.check_model)
self.G.remove_cpds(cpd_l)
def tearDown(self):
del self.G
class TestBaseModelCreation(unittest.TestCase):
def setUp(self):
self.G = BayesianModel()
def test_class_init_without_data(self):
self.assertIsInstance(self.G, nx.DiGraph)
def test_class_init_with_data_string(self):
self.g = BayesianModel([('a', 'b'), ('b', 'c')])
self.assertListEqual(sorted(self.g.nodes()), ['a', 'b', 'c'])
self.assertListEqual(hf.recursive_sorted(self.g.edges()),
[['a', 'b'], ['b', 'c']])
def test_class_init_with_data_nonstring(self):
BayesianModel([(1, 2), (2, 3)])
def test_add_node_string(self):
self.G.add_node('a')
self.assertListEqual(self.G.nodes(), ['a'])
def test_add_node_nonstring(self):
self.G.add_node(1)
def test_add_nodes_from_string(self):
self.G.add_nodes_from(['a', 'b', 'c', 'd'])
self.assertListEqual(sorted(self.G.nodes()), ['a', 'b', 'c', 'd'])
def test_add_nodes_from_non_string(self):
self.G.add_nodes_from([1, 2, 3, 4])
def test_add_edge_string(self):
self.G.add_edge('d', 'e')
self.assertListEqual(sorted(self.G.nodes()), ['d', 'e'])
self.assertListEqual(self.G.edges(), [('d', 'e')])
self.G.add_nodes_from(['a', 'b', 'c'])
self.G.add_edge('a', 'b')
self.assertListEqual(hf.recursive_sorted(self.G.edges()),
[['a', 'b'], ['d', 'e']])
def test_add_edge_nonstring(self):
self.G.add_edge(1, 2)
def test_add_edge_selfloop(self):
self.assertRaises(ValueError, self.G.add_edge, 'a', 'a')
def test_add_edge_result_cycle(self):
self.G.add_edges_from([('a', 'b'), ('a', 'c')])
self.assertRaises(ValueError, self.G.add_edge, 'c', 'a')
def test_add_edges_from_string(self):
self.G.add_edges_from([('a', 'b'), ('b', 'c')])
self.assertListEqual(sorted(self.G.nodes()), ['a', 'b', 'c'])
self.assertListEqual(hf.recursive_sorted(self.G.edges()),
[['a', 'b'], ['b', 'c']])
self.G.add_nodes_from(['d', 'e', 'f'])
self.G.add_edges_from([('d', 'e'), ('e', 'f')])
self.assertListEqual(sorted(self.G.nodes()),
['a', 'b', 'c', 'd', 'e', 'f'])
self.assertListEqual(
hf.recursive_sorted(self.G.edges()),
hf.recursive_sorted([('a', 'b'), ('b', 'c'), ('d', 'e'),
('e', 'f')]))
def test_add_edges_from_nonstring(self):
self.G.add_edges_from([(1, 2), (2, 3)])
def test_add_edges_from_self_loop(self):
self.assertRaises(ValueError, self.G.add_edges_from, [('a', 'a')])
def test_add_edges_from_result_cycle(self):
self.assertRaises(ValueError, self.G.add_edges_from, [('a', 'b'),
('b', 'c'),
('c', 'a')])
def test_update_node_parents_bm_constructor(self):
self.g = BayesianModel([('a', 'b'), ('b', 'c')])
self.assertListEqual(self.g.predecessors('a'), [])
self.assertListEqual(self.g.predecessors('b'), ['a'])
self.assertListEqual(self.g.predecessors('c'), ['b'])
def test_update_node_parents(self):
self.G.add_nodes_from(['a', 'b', 'c'])
self.G.add_edges_from([('a', 'b'), ('b', 'c')])
self.assertListEqual(self.G.predecessors('a'), [])
self.assertListEqual(self.G.predecessors('b'), ['a'])
self.assertListEqual(self.G.predecessors('c'), ['b'])
def tearDown(self):
del self.G