class VOrientTests(unittest.TestCase):
# tests for v structure orientation
def setUp(self):
self.data = PCAlg.prepare_data('data/asia_1000.data', ' ', True)
self.pcalg = PCAlg(self.data, chi)
self.fcialg = FCIAlg(self.data, chi)
self.directed = nx.DiGraph()
self.undirected = nx.Graph()
self.directed.add_nodes_from([1, 2, 3, 4])
self.undirected.add_nodes_from(self.directed)
self.pag = PAG()
self.pag.add_nodes_from(self.undirected)
self.sepset = {(x, y): []
for x in [1, 2, 3, 4, 5] for y in [1, 2, 3, 4, 5]
if x != y}
def test1(self):
self.undirected.add_edges_from([(1, 2), (2, 3)])
self.pcalg.orient_V(self.undirected, self.directed, self.sepset)
part1 = not self.undirected.has_edge(
1, 2) and not self.undirected.has_edge(3, 2)
part2 = self.directed.has_edge(1, 2) and self.directed.has_edge(3, 2)
assert (part1 and part2)
def test2(self):
self.undirected.add_edges_from([(1, 2), (2, 3)])
self.sepset[(1, 3)].append(2)
self.sepset[(3, 1)].append(2)
self.pcalg.orient_V(self.undirected, self.directed, self.sepset)
part1 = not self.undirected.has_edge(
1, 2) and not self.undirected.has_edge(3, 2)
part2 = self.directed.has_edge(1, 2) and self.directed.has_edge(3, 2)
assert (not (part1 and part2))
def test3(self):
self.pag.add_edges_from([(1, 2), (2, 3)])
self.fcialg.orient_V(self.pag, self.sepset)
assert (self.pag.has_directed_edge(1, 2)
and self.pag.has_directed_edge(3, 2))
def test4(self):
self.pag.add_edges_from([(1, 2), (2, 3)])
self.sepset[(1, 3)].append(2)
self.sepset[(3, 1)].append(2)
self.fcialg.orient_V(self.pag, self.sepset)
assert (not self.pag.has_directed_edge(1, 2)
and not self.pag.has_directed_edge(3, 2))
def learnSkeleton(self):
""" A function to build the skeleton of a causal graph from data
Returns
-------
PDAG
The skeleton of the causal network
dict
Dicitonary containg separation sets of all pairs of nodes
"""
skeleton, sepSet = super().learnSkeleton()
pag = PAG()
pag.add_nodes_from(skeleton)
pag.add_edges_from(skeleton.edges)
print('finalising skeleton')
self.orient_V(pag, sepSet)
dseps = self.possible_d_seps( pag)
pag.write_to_file('tmp')
print(dseps)
for x in pag:
for y in pag:
if y in pag.neighbors(x):
indep = False
for i in range(1,len(dseps[x])+1):
for dsepset in itertools.combinations(dseps[x],i):
indep = False
dsepset = list(dsepset)
if y in dsepset:
dsepset.remove(y)
if len(dsepset )>= 1:
print('testing {} indep {} given {}'.format(x,y,dsepset) )
p, *_ = self.indep_test(self.data, x, y, dsepset)
indep = p > self.alpha
#stop testing if independence is found and remove edge
if indep:
print('removing edge {},{}'.format(x,y))
pag.remove_edge(x,y)
sepSet[(x,y)] = dsepset
sepSet[(y,x)] = dsepset
break
if indep:
break
if indep:
break
return pag, sepSet
class DiscPathTest(unittest.TestCase):
# tests for finding discriminating paths on a graph
def setUp(self):
self.pag = PAG()
self.pag.add_nodes_from([1, 2, 3, 4])
def test1(self):
self.pag.add_edges_from([[1, 2], [2, 3], [3, 4], [2, 4]])
self.pag.fully_direct_edge(1, 2)
self.pag.fully_direct_edge(3, 2)
self.pag.fully_direct_edge(2, 4)
self.pag.fully_direct_edge(3, 4)
assert (self.pag.hasDiscPath(1, 4, 3))
def test2(self):
self.pag.add_edges_from([[1, 2], [2, 3], [2, 4]])
self.pag.fully_direct_edge(1, 2)
self.pag.fully_direct_edge(3, 2)
self.pag.fully_direct_edge(2, 4)
assert (not self.pag.hasDiscPath(1, 4, 3))
def test3(self):
self.pag.add_edges_from([[1, 2], [2, 3], [3, 4], [2, 4]])
self.pag.fully_direct_edge(1, 2)
self.pag.fully_direct_edge(2, 3)
self.pag.fully_direct_edge(2, 4)
self.pag.fully_direct_edge(3, 4)
assert (not self.pag.hasDiscPath(1, 4, 3))
def test4(self):
self.pag.add_edges_from([[1, 2], [2, 3], [3, 4], [2, 4]])
self.pag.fully_direct_edge(1, 2)
self.pag.fully_direct_edge(3, 2)
self.pag.fully_direct_edge(3, 4)
assert (not self.pag.hasDiscPath(1, 4, 3))
def test5(self):
self.pag.add_edges_from([[1, 2], [2, 3], [3, 4], [2, 4]])
self.pag.fully_direct_edge(1, 2)
self.pag.fully_direct_edge(3, 2)
self.pag.fully_direct_edge(3, 4)
self.pag.fully_direct_edge(1, 4)
assert (not self.pag.hasDiscPath(1, 4, 3))
def orientEdges(self, skeleton, sepSet):
"""
A function to orient the edges of a skeleton using the orientation rules of the FCI algorithm
Parameters
----------
skeleton: networkx Graph(),
skeleton estimation
sepSet: dict
Dicitonary containg separation sets of all pairs of nodes
Returns
-------
PAG containing estimated causal relationships in data
"""
pag = PAG()
pag.add_nodes_from(skeleton)
pag.add_edges_from(skeleton.edges)
self.orient_V(pag, sepSet)
old_pag = nx.DiGraph()
while old_pag.edges != pag.edges:
old_pag = copy.deepcopy(pag)
for i in pag:
for j in pag:
for k in pag:
if k not in [i,j] and j != i:
self.rule1(pag,i,j,k)
self.rule2(pag,i,j,k)
for l in pag:
if l not in [i,j,k]:
self.rule3(pag,i,j,k,l)
self.rule4(pag,i,j,k,l, sepSet)
self.rule5(pag,i,j,k,l)
self.rule67(pag,i,j,k)
self.rule8(pag,i,j,k)
self.rule9(pag,i,j,k,l)
self.rule10(pag,i,j,k,l)
return pag