def test_get_assertions(self): self.Independencies1 = Independencies(['X', 'Y', 'Z']) self.assertEqual(self.Independencies1.independencies, self.Independencies1.get_assertions()) self.Independencies2 = Independencies(['A', 'B', 'C'], ['D', 'E', 'F']) self.assertEqual(self.Independencies2.independencies, self.Independencies2.get_assertions())
def get_independencies(self, condition=None): """ Returns the independent variables in the joint probability distribution. Returns marginally independent variables if condition=None. Returns conditionally independent variables if condition!=None Parameter --------- condition: array_like Random Variable on which to condition the Joint Probability Distribution. Examples -------- >>> import numpy as np >>> from pgm.factors.discrete import JointProbabilityDistribution >>> prob = JointProbabilityDistribution(['x1', 'x2', 'x3'], [2, 3, 2], np.ones(12)/12) >>> prob.get_independencies() (x1 _|_ x2) (x1 _|_ x3) (x2 _|_ x3) """ JPD = self.copy() if condition: JPD.conditional_distribution(condition) independencies = Independencies() for variable_pair in itertools.combinations(list(JPD.variables), 2): if (JPD.marginal_distribution(variable_pair, inplace=False) == JPD.marginal_distribution(variable_pair[0], inplace=False) * JPD.marginal_distribution(variable_pair[1], inplace=False)): independencies.add_assertions(variable_pair) return independencies
def test_local_independencies(self): self.assertListEqual(self.G1.local_independencies('a'), [None]) self.assertListEqual(self.G1.local_independencies('b'), [Independencies(['b', ['e', 'c', 'd'], 'a'])]) self.assertListEqual(self.G1.local_independencies('c'), [Independencies(['c', ['e', 'b', 'd'], 'a'])]) self.assertListEqual(self.G1.local_independencies('d'), [Independencies(['d', ['b', 'c', 'e'], 'a'])])
def test_get_independencies(self): chain = BayesianModel([('X', 'Y'), ('Y', 'Z')]) self.assertEqual(chain.get_independencies(), Independencies(('X', 'Z', 'Y'), ('Z', 'X', 'Y'))) fork = BayesianModel([('Y', 'X'), ('Y', 'Z')]) self.assertEqual(fork.get_independencies(), Independencies(('X', 'Z', 'Y'), ('Z', 'X', 'Y'))) collider = BayesianModel([('X', 'Y'), ('Z', 'Y')]) self.assertEqual(collider.get_independencies(), Independencies(('X', 'Z'), ('Z', 'X')))
def setUp(self): self.Independencies = Independencies() self.Independencies3 = Independencies( ['a', ['b', 'c', 'd'], ['e', 'f', 'g']], ['c', ['d', 'e', 'f'], ['g', 'h']]) self.Independencies4 = Independencies( [['f', 'd', 'e'], 'c', ['h', 'g']], [['b', 'c', 'd'], 'a', ['f', 'g', 'e']]) self.Independencies5 = Independencies( ['a', ['b', 'c', 'd'], ['e', 'f', 'g']], ['c', ['d', 'e', 'f'], 'g'])
def local_independencies(self, variables): """ Returns a independencies object containing the local independencies of each of the variables. Parameters ---------- variables: str or array like variables whose local independencies are to be found. Examples -------- >>> from pgm.models import BayesianModel >>> student = BayesianModel() >>> student.add_edges_from([('diff', 'grade'), ('intel', 'grade'), >>> ('grade', 'letter'), ('intel', 'SAT')]) >>> ind = student.local_independencies('grade') >>> ind.event1 {'grade'} >>> ind.event2 {'SAT'} >>> ind.event3 {'diff', 'intel'} """ def dfs(node): """ Returns the descendents of node. Since Bayesian Networks are acyclic, this is a very simple dfs which does not remember which nodes it has visited. """ descendents = [] visit = [node] while visit: n = visit.pop() neighbors = self.neighbors(n) visit.extend(neighbors) descendents.extend(neighbors) return descendents independencies = Independencies() for variable in [variables] if isinstance(variables, str) else variables: non_descendents = set(self.nodes()) - {variable} - set( dfs(variable)) parents = set(self.get_parents(variable)) if non_descendents - parents: independencies.add_assertions( [variable, non_descendents - parents, parents]) return independencies
def local_independencies(self, variables): """ Returns a list of independencies objects containing the local independencies of each of the variables. If local independencies does not exist for a variable it gives a None for that variable. Parameters ---------- variables: str or array like variables whose local independencies are to found. Examples -------- >>> from pgm.models import NaiveBayes >>> model = NaiveBayes() >>> model.add_edges_from([('a', 'b'), ('a', 'c'), ('a', 'd')]) >>> ind = model.local_independencies('b') >>> ind [(b _|_ d, c | a)] """ independencies = [] for variable in [variables] if isinstance(variables, str) else variables: if variable != self.parent_node: independencies.append( Independencies([ variable, list(set(self.children_nodes) - set(variable)), self.parent_node ])) else: independencies.append(None) return independencies
def get_independencies(self, latex=False): """ Computes independencies in the Bayesian Network, by checking d-seperation. Parameters ---------- latex: boolean If latex=True then latex string of the independence assertion would be created. Examples -------- >>> from pgm.models import BayesianModel >>> chain = BayesianModel([('X', 'Y'), ('Y', 'Z')]) >>> chain.get_independencies() (X _|_ Z | Y) (Z _|_ X | Y) """ independencies = Independencies() for start in (self.nodes()): rest = set(self.nodes()) - {start} for r in range(len(rest)): for observed in itertools.combinations(rest, r): d_seperated_variables = rest - set(observed) - set( self.active_trail_nodes(start, observed=observed)) if d_seperated_variables: independencies.add_assertions( [start, d_seperated_variables, observed]) independencies.reduce() if not latex: return independencies else: return independencies.latex_string()
def test_is_equivalent(self): ind1 = Independencies(['X', ['Y', 'W'], 'Z']) ind2 = Independencies(['X', 'Y', 'Z'], ['X', 'W', 'Z']) ind3 = Independencies(['X', 'Y', 'Z'], ['X', 'W', 'Z'], ['X', 'Y', ['W', 'Z']]) self.assertFalse(ind1.is_equivalent(ind2)) self.assertTrue(ind1.is_equivalent(ind3))
def test_eq(self): self.assertTrue(self.Independencies3 == self.Independencies4) self.assertFalse(self.Independencies3 != self.Independencies4) self.assertTrue(self.Independencies3 != self.Independencies5) self.assertFalse(self.Independencies4 == self.Independencies5) self.assertFalse(Independencies() == Independencies(['A', 'B', 'C'])) self.assertFalse(Independencies(['A', 'B', 'C']) == Independencies()) self.assertTrue(Independencies() == Independencies())
def test_local_independencies(self): self.assertEqual(self.G.local_independencies('a'), Independencies(['a', ['b', 'c']])) self.assertEqual(self.G.local_independencies('c'), Independencies(['c', ['a', 'd', 'e'], 'b'])) self.assertEqual(self.G.local_independencies('d'), Independencies(['d', 'c', ['b', 'a']])) self.assertEqual(self.G.local_independencies('e'), Independencies(['e', ['c', 'b', 'a'], 'd'])) self.assertEqual(self.G.local_independencies('b'), Independencies(['b', 'a'])) self.assertEqual(self.G1.local_independencies('grade'), Independencies())
def get_local_independencies(self, latex=False): """ Returns all the local independencies present in the markov model. Local independencies are the independence assertion in the form of .. math:: {X \perp W - {X} - MB(X) | MB(X)} where MB is the markov blanket of all the random variables in X Parameters ---------- latex: boolean If latex=True then latex string of the indepedence assertion would be created Examples -------- >>> from pgm.models import MarkovModel >>> 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')]) >>> mm.get_local_independecies() """ local_independencies = Independencies() all_vars = set(self.nodes()) for node in self.nodes(): markov_blanket = set(self.markov_blanket(node)) rest = all_vars - set([node]) - markov_blanket try: local_independencies.add_assertions( [node, list(rest), list(markov_blanket)]) except ValueError: pass local_independencies.reduce() if latex: return local_independencies.latex_string() else: return local_independencies
def test_entails(self): ind1 = Independencies([['A', 'B'], ['C', 'D'], 'E']) ind2 = Independencies(['A', 'C', 'E']) self.assertTrue(ind1.entails(ind2)) self.assertFalse(ind2.entails(ind1)) ind3 = Independencies(('W', ['X', 'Y', 'Z'])) self.assertTrue(ind3.entails(ind3.closure())) self.assertTrue(ind3.closure().entails(ind3))
def test_local_independencies(self): self.graph.add_edges_from([('a', 'b'), ('b', 'c')]) independencies = self.graph.get_local_independencies() self.assertIsInstance(independencies, Independencies) self.assertEqual(independencies, Independencies(['a', 'c', 'b']))
def test_init(self): self.Independencies1 = Independencies(['X', 'Y', 'Z']) self.assertEqual(self.Independencies1, Independencies(['X', 'Y', 'Z'])) self.Independencies2 = Independencies() self.assertEqual(self.Independencies2, Independencies())
def test_add_assertions(self): self.Independencies1 = Independencies(['X', 'Y', 'Z']) self.assertEqual(self.Independencies1, Independencies(['X', 'Y', 'Z'])) self.Independencies2 = Independencies(['A', 'B', 'C'], ['D', 'E', 'F']) self.assertEqual(self.Independencies2, Independencies(['A', 'B', 'C'], ['D', 'E', 'F']))
def test_closure(self): ind1 = Independencies(('A', ['B', 'C'], 'D')) self.assertEqual( ind1.closure(), Independencies(('A', ['B', 'C'], 'D'), ('A', 'B', ['C', 'D']), ('A', 'C', ['B', 'D']), ('A', 'B', 'D'), ('A', 'C', 'D'))) ind2 = Independencies(('W', ['X', 'Y', 'Z'])) self.assertEqual( ind2.closure(), Independencies(('W', 'Y'), ('W', 'Y', 'X'), ('W', 'Y', 'Z'), ('W', 'Y', ['X', 'Z']), ('W', ['Y', 'X']), ('W', 'X', ['Y', 'Z']), ('W', ['X', 'Z'], 'Y'), ('W', 'X'), ('W', ['X', 'Z']), ('W', ['Y', 'Z'], 'X'), ('W', ['Y', 'X', 'Z']), ('W', 'X', 'Z'), ('W', ['Y', 'Z']), ('W', 'Z', 'X'), ('W', 'Z'), ('W', ['Y', 'X'], 'Z'), ('W', 'X', 'Y'), ('W', 'Z', ['Y', 'X']), ('W', 'Z', 'Y'))) ind3 = Independencies(('c', 'a', ['b', 'e', 'd']), (['e', 'c'], 'b', ['a', 'd']), (['b', 'd'], 'e', 'a'), ('e', ['b', 'd'], 'c'), ('e', ['b', 'c'], 'd'), (['e', 'c'], 'a', 'b')) self.assertEqual(len(ind3.closure().get_assertions()), 78)
class TestIndependencies(unittest.TestCase): def setUp(self): self.Independencies = Independencies() self.Independencies3 = Independencies( ['a', ['b', 'c', 'd'], ['e', 'f', 'g']], ['c', ['d', 'e', 'f'], ['g', 'h']]) self.Independencies4 = Independencies( [['f', 'd', 'e'], 'c', ['h', 'g']], [['b', 'c', 'd'], 'a', ['f', 'g', 'e']]) self.Independencies5 = Independencies( ['a', ['b', 'c', 'd'], ['e', 'f', 'g']], ['c', ['d', 'e', 'f'], 'g']) def test_init(self): self.Independencies1 = Independencies(['X', 'Y', 'Z']) self.assertEqual(self.Independencies1, Independencies(['X', 'Y', 'Z'])) self.Independencies2 = Independencies() self.assertEqual(self.Independencies2, Independencies()) def test_add_assertions(self): self.Independencies1 = Independencies(['X', 'Y', 'Z']) self.assertEqual(self.Independencies1, Independencies(['X', 'Y', 'Z'])) self.Independencies2 = Independencies(['A', 'B', 'C'], ['D', 'E', 'F']) self.assertEqual(self.Independencies2, Independencies(['A', 'B', 'C'], ['D', 'E', 'F'])) def test_get_assertions(self): self.Independencies1 = Independencies(['X', 'Y', 'Z']) self.assertEqual(self.Independencies1.independencies, self.Independencies1.get_assertions()) self.Independencies2 = Independencies(['A', 'B', 'C'], ['D', 'E', 'F']) self.assertEqual(self.Independencies2.independencies, self.Independencies2.get_assertions()) def test_closure(self): ind1 = Independencies(('A', ['B', 'C'], 'D')) self.assertEqual( ind1.closure(), Independencies(('A', ['B', 'C'], 'D'), ('A', 'B', ['C', 'D']), ('A', 'C', ['B', 'D']), ('A', 'B', 'D'), ('A', 'C', 'D'))) ind2 = Independencies(('W', ['X', 'Y', 'Z'])) self.assertEqual( ind2.closure(), Independencies(('W', 'Y'), ('W', 'Y', 'X'), ('W', 'Y', 'Z'), ('W', 'Y', ['X', 'Z']), ('W', ['Y', 'X']), ('W', 'X', ['Y', 'Z']), ('W', ['X', 'Z'], 'Y'), ('W', 'X'), ('W', ['X', 'Z']), ('W', ['Y', 'Z'], 'X'), ('W', ['Y', 'X', 'Z']), ('W', 'X', 'Z'), ('W', ['Y', 'Z']), ('W', 'Z', 'X'), ('W', 'Z'), ('W', ['Y', 'X'], 'Z'), ('W', 'X', 'Y'), ('W', 'Z', ['Y', 'X']), ('W', 'Z', 'Y'))) ind3 = Independencies(('c', 'a', ['b', 'e', 'd']), (['e', 'c'], 'b', ['a', 'd']), (['b', 'd'], 'e', 'a'), ('e', ['b', 'd'], 'c'), ('e', ['b', 'c'], 'd'), (['e', 'c'], 'a', 'b')) self.assertEqual(len(ind3.closure().get_assertions()), 78) def test_entails(self): ind1 = Independencies([['A', 'B'], ['C', 'D'], 'E']) ind2 = Independencies(['A', 'C', 'E']) self.assertTrue(ind1.entails(ind2)) self.assertFalse(ind2.entails(ind1)) ind3 = Independencies(('W', ['X', 'Y', 'Z'])) self.assertTrue(ind3.entails(ind3.closure())) self.assertTrue(ind3.closure().entails(ind3)) def test_is_equivalent(self): ind1 = Independencies(['X', ['Y', 'W'], 'Z']) ind2 = Independencies(['X', 'Y', 'Z'], ['X', 'W', 'Z']) ind3 = Independencies(['X', 'Y', 'Z'], ['X', 'W', 'Z'], ['X', 'Y', ['W', 'Z']]) self.assertFalse(ind1.is_equivalent(ind2)) self.assertTrue(ind1.is_equivalent(ind3)) def test_eq(self): self.assertTrue(self.Independencies3 == self.Independencies4) self.assertFalse(self.Independencies3 != self.Independencies4) self.assertTrue(self.Independencies3 != self.Independencies5) self.assertFalse(self.Independencies4 == self.Independencies5) self.assertFalse(Independencies() == Independencies(['A', 'B', 'C'])) self.assertFalse(Independencies(['A', 'B', 'C']) == Independencies()) self.assertTrue(Independencies() == Independencies()) def tearDown(self): del self.Independencies del self.Independencies3 del self.Independencies4 del self.Independencies5