def activeTrails(model: BayesianModel,
variables: List[RandomVariable],
observed: List[RandomVariable] = None,
skipSelfTrail: bool = True) -> List[Trail]:
'''Creates trails by threading the way through the dictionary returned by the pgmpy function `active_trail_nodes`'''
varNames: List[Name] = list(map(lambda randomVar: randomVar.var,
variables))
obsNames: List[Name] = None if observed is None else list(
map(lambda obsVar: obsVar.var, observed))
trails: Dict[Name,
Set[Name]] = model.active_trail_nodes(variables=varNames,
observed=obsNames)
trailTupleList: List[List[Tuple[Name, Name]]] = [[
(startVar, endVar) for endVar in endVarList
] for (startVar, endVarList) in trails.items()]
trailTuples: List[Tuple[Name,
Name]] = list(itertools.chain(*trailTupleList))
if skipSelfTrail: # then remove the ones with same start and end
trailTuples = list(filter(lambda tup: tup[0] != tup[1], trailTuples))
explicitTrails: List[Trail] = list(
map(lambda tup: f"{tup[0]} --> {tup[1]}", trailTuples))
return explicitTrails
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')
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.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
('INT', 'VALV'),
('PRSS', 'VTUB'),
('DISC', 'VTUB'),
('MVS', 'VMCH'),
('VMCH', 'VTUB'),('VMCH', 'VALV'),
('VTUB', 'VLNG'),('VTUB', 'VALV'),
('VLNG', 'VALV'),('VLNG', 'ACO2'),
('VALV', 'ACO2'),
('CCHL', 'HR'),
('HR', 'CO'),
('CO', 'BP')])
# mle = MaximumLikelihoodEstimator(model, df)
# print(mle.estimate_cpd('VALV')) # unconditional
# print(mle.estimate_cpd('PVS')) # conditional
print (model.active_trail_nodes("MINV"))
print (model.active_trail_nodes("PVS"))
print (model.active_trail_nodes("SAO2"))
print (model.active_trail_nodes("MVS"))
print (model.active_trail_nodes("VMCH"))
print (model.active_trail_nodes("PRSS"))
print (model.active_trail_nodes("DISC"))
print (model.active_trail_nodes("VTUB"))
print (model.active_trail_nodes("ECO2"))
print (model.active_trail_nodes("VLNG"))
print (model.active_trail_nodes("VALV"))
print (model.active_trail_nodes("ACO2"))
print (model.active_trail_nodes("INT"))
print (model.active_trail_nodes("SHNT"))
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, np.random.rand(2, 1))
cpd_i = TabularCPD('i', 2, np.random.rand(2, 1))
cpd_g = TabularCPD('g', 2, np.random.rand(2, 4), ['d', 'i'], [2, 2])
cpd_l = TabularCPD('l', 2, np.random.rand(2, 2), ['g'], 2)
cpd_s = TabularCPD('s', 2, np.random.rand(2, 2), ['i'], 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, np.random.rand(2, 1))
cpd_ab = TabularCPD('AB', 2, 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')
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, np.random.rand(2, 1))
cpd_i = TabularCPD('i', 2, np.random.rand(2, 1))
cpd_g = TabularCPD('g', 2, np.random.rand(2, 4), ['d', 'i'], [2, 2])
cpd_l = TabularCPD('l', 2, np.random.rand(2, 2), ['g'], 2)
cpd_s = TabularCPD('s', 2, np.random.rand(2, 2), ['i'], 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,
np.array([[0.2, 0.3, 0.4, 0.6],
[0.8, 0.7, 0.6, 0.4]]),
['d', 'i'], [2, 2])
cpd_s = TabularCPD('s', 2,
np.array([[0.2, 0.3],
[0.8, 0.7]]),
['i'], 2)
cpd_l = TabularCPD('l', 2,
np.array([[0.2, 0.3],
[0.8, 0.7]]),
['g'], 2)
self.G.add_cpds(cpd_g, cpd_s, cpd_l)
self.assertTrue(self.G.check_model())
def test_check_model1(self):
cpd_g = TabularCPD('g', 2,
np.array([[0.2, 0.3],
[0.8, 0.7]]),
['i'], 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,
np.array([[0.2, 0.3, 0.4, 0.6],
[0.8, 0.7, 0.6, 0.4]]),
['d', 's'], [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,
np.array([[0.2, 0.3],
[0.8, 0.7]]),
['l'], 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,
np.array([[0.2, 0.3],
[0.8, 0.7]]),
['d'], 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,
np.array([[0.2, 0.3, 0.4, 0.6],
[0.8, 0.7, 0.6, 0.4]]),
['d', 'i'], [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,
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]]),
['g', 'd', 'i'], [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,
np.array([[0.5, 0.3],
[0.8, 0.7]]),
['i'], 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,
np.array([[0.2, 0.3, 0.4, 0.6],
[0.3, 0.7, 0.6, 0.4]]),
['d', 'i'], [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,
np.array([[0.2, 0.3],
[0.1, 0.7]]),
['g'], 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 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, np.random.rand(2, 1))
cpd_i = TabularCPD('i', 2, np.random.rand(2, 1))
cpd_g = TabularCPD('g', 2, np.random.rand(2, 4), ['d', 'i'], [2, 2])
cpd_l = TabularCPD('l', 2, np.random.rand(2, 2), ['g'], 2)
cpd_s = TabularCPD('s', 2, np.random.rand(2, 2), ['i'], 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, np.random.rand(2, 1))
cpd_ab = TabularCPD('AB', 2, 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')
def test_add_single_cpd(self):
from pgmpy.factors import TabularCPD
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):
from pgmpy.factors import TabularCPD
cpd_d = TabularCPD('d', 2, np.random.rand(2, 1))
cpd_i = TabularCPD('i', 2, np.random.rand(2, 1))
cpd_g = TabularCPD('g', 2, np.random.rand(2, 4), ['d', 'i'], [2, 2])
cpd_l = TabularCPD('l', 2, np.random.rand(2, 2), ['g'], 2)
cpd_s = TabularCPD('s', 2, np.random.rand(2, 2), ['i'], 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 tearDown(self):
del self.G
class TestBayesianModelCPD(unittest.TestCase):
def setUp(self):
self.G = BayesianModel([('d', 'g'), ('i', 'g'), ('g', 'l'),
('i', 's')])
# self.G.set_states(
# {'d': ['easy', 'hard'], 'g': ['A', 'B', 'C'], 'i': ['dumb', 'smart'], 's': ['bad', 'avg', 'good'],
# 'l': ['yes', 'no']})
# def test_set_cpd(self):
# self.G.set_cpd('g', [[0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.8, 0.8, 0.8, 0.8, 0.8, 0.8]])
# self.assertIsInstance(self.G.node['g']['_cpd'], bm.CPD.TabularCPD)
# np.testing.assert_array_equal(self.G.node['g']['_cpd'].cpd, np.array((
# [[0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.8, 0.8, 0.8, 0.8, 0.8, 0.8]])))
#
# def test_get_cpd(self):
# self.G.set_cpd('g', [[0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.8, 0.8, 0.8, 0.8, 0.8, 0.8]])
# np.testing.assert_array_equal(self.G.get_cpd('g'), np.array((
# [[0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.1, 0.1, 0.1, 0.1, 0.1, 0.1],
# [0.8, 0.8, 0.8, 0.8, 0.8, 0.8]])))
# def test_set_observations_single_state_reset_false(self):
# self.G.set_observations({'d': 'easy'})
# for state in self.G.node['d']['_states']:
# if state['name'] == 'easy':
# break
# self.assertTrue(state['observed_status'])
# self.assertTrue(self.G.node['d']['_observed'])
#
# def test_set_observation_multiple_state_reset_false(self):
# self.G.set_observations({'d': 'easy', 'g': 'A'})
# for state in self.G.node['d']['_states']:
# if state['name'] == 'easy':
# break
# self.assertTrue(state['observed_status'])
# self.assertTrue(self.G.node['d']['_observed'])
# for state in self.G.node['g']['_states']:
# if state['name'] == 'A':
# break
# self.assertTrue(state['observed_status'])
# self.assertTrue(self.G.node['g']['_observed'])
#
# def test_set_observation_multiple_state_reset_false_not_found(self):
# self.assertRaises(ValueError, self.G.set_observations, {'d': 'unknow_state'})
#
# def test_reset_observations_single_state(self):
# self.G.reset_observations({'d': 'easy'})
# # TODO change this as the function has changed
# self.G.reset_observations({'d': 'easy'})
# for state in self.G.node['d']['_states']:
# if state['name'] == 'easy':
# break
# self.assertFalse(state['observed_status'])
# self.assertFalse(self.G.node['g']['_observed'])
#
# def test_reset_observations_multiple_state(self):
# self.G.set_observations({'d': 'easy', 'g': 'A', 'i': 'dumb'})
# self.G.reset_observations({'d': 'easy', 'i': 'dumb'})
# for state in self.G.node['d']['_states']:
# if state['name'] == 'easy':
# break
# self.assertFalse(state['observed_status'])
# self.assertFalse(self.G.node['d']['_observed'])
# for state in self.G.node['g']['_states']:
# if state['name'] == 'A':
# break
# self.assertTrue(state['observed_status'])
# self.assertTrue(self.G.node['g']['_observed'])
#
# def test_reset_observation_node_none(self):
# self.G.set_observations({'d': 'easy', 'g': 'A'})
# self.G.reset_observations()
# self.assertFalse(self.G.node['d']['_observed'])
# for state in self.G.node['d']['_states']:
# self.assertFalse(state['observed_status'])
# self.assertFalse(self.G.node['g']['_observed'])
# for state in self.G.node['g']['_states']:
# self.assertFalse(state['observed_status'])
#
# def test_reset_observations_node_not_none(self):
# self.G.set_observations({'d': 'easy', 'g': 'A'})
# self.G.reset_observations('d')
# self.assertFalse(self.G.node['d']['_observed'])
# for state in self.G.node['d']['_states']:
# self.assertFalse(state['observed_status'])
# self.assertTrue(self.G.node['g']['_observed'])
# for state in self.G.node['g']['_states']:
# if state['name'] == 'A':
# self.assertTrue(state['observed_status'])
# else:
# self.assertFalse(state['observed_status'])
#
# def test_reset_observations_node_error(self):
# self.assertRaises(KeyError, self.G.reset_observations, 'j')
#
# def test_is_observed(self):
# self.G.set_observations({'d': 'easy'})
# self.assertTrue(self.G.is_observed('d'))
# self.assertFalse(self.G.is_observed('i'))
#
# # def test_get_ancestros_observation(self):
# # self.G.set_observations({'d': 'easy', 'g': 'A'})
# # self.assertListEqual(list(self.G._get_ancestors_observation(['d'])), [])
# # self.assertListEqual(list(sorted(self.G._get_ancestors_observation(['d', 'g']))), ['d', 'i'])
#
# def test_get_observed_list(self):
# self.G.set_observations({'d': 'hard', 'i': 'smart'})
# self.assertListEqual(sorted(self.G._get_observed_list()), ['d', 'i'])
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 tearDown(self):
del self.G
\ / \ \
AGE GENDER BP
^ /
| /
| /
| /
| /
CP
"""
model.fit(dataset, estimator=MaximumLikelihoodEstimator)
print('\n Inferencing with Bayesian Network:')
HeartDisease_infer = VariableElimination(model)
for cpd in model.get_cpds():
print("CPD of {variable}:".format(variable=cpd.variable))
print(cpd)
print(model.check_model())
print('\n1.Probability of HeartDisease given Gender = Female')
q = HeartDisease_infer.query(variables=['HD'], evidence={'GENDER': 1})
print(q['HD'])
print('\n2. Probability of HeartDisease given BP = Low')
q = HeartDisease_infer.query(variables=['HD'], evidence={'BP': 1})
print(q['HD'])
print(model.get_independencies())
print(model.active_trail_nodes('HD'))
# In[26]:
# Getting the local independencies of a variable.
model.local_independencies('G')
# In[27]:
# Getting all the local independencies in the network.
model.local_independencies(['D', 'I', 'S', 'G', 'L'])
# In[28]:
# Active trail: For any two variables A and B in a network if any change in A influences the values of B then we say
# that there is an active trail between A and B.
# In pgmpy active_trail_nodes gives a set of nodes which are affected by any change in the node passed in the argument.
model.active_trail_nodes('D')
# In[29]:
model.active_trail_nodes('D', observed='G')
# ### 3. How is this Bayesian Network representing the Joint Distribution over the variables ?
# Till now we just have been considering that the Bayesian Network can represent the Joint Distribution without any proof. Now let's see how to compute the Joint Distribution from the Bayesian Network.
#
# From the chain rule of probabiliy we know that:
# $$ P(A, B) = P(A | B) * P(B) $$
#
# Now in this case:
# $$ P(D, I, G, L, S) = P(L| S, G, D, I) * P(S | G, D, I) * P(G | D, I) * P(D | I) * P(I) $$
#
# Applying the local independence conditions in the above equation we will get:
