def is_adjacent_of(self, e1: Edge, e2: Edge) -> bool:
"""!
\brief check if edges have a common node
"""
n1_ids = e1.node_ids()
n2_ids = e2.node_ids()
return len(n1_ids.intersection(n2_ids)) > 0
def check_edge_between_components(self, e: Edge) -> Tuple[bool, str, str]:
"""!
Check if the given edge is between chain components
"""
estart = e.start()
eend = e.end()
start_component_id = None
end_component_id = None
for cid, component in self.chain_components.items():
if isinstance(component, UndiGraph) is True:
cnodes = component.nodes()
if estart in cnodes:
start_component_id = cid
if eend in cnodes:
end_component_id = cid
else:
if estart in component:
start_component_id = cid
if eend in component:
end_component_id = cid
return (
start_component_id != end_component_id,
start_component_id,
end_component_id,
)
def cond(n_1: Node, n_2: Node, e: Edge):
""
if e.type() == EdgeType.DIRECTED:
c1 = n_1 == e.start() and e.end() == n_2
return c1
else:
c1 = n_1 == e.start() and e.end() == n_2
c2 = n_2 == e.start() and e.end() == n_1
return c1 or c2
def test_equal(self):
n1 = Node("n1", {})
n2 = Node("n2", {})
n3 = Node("n3", {})
n4 = Node("n4", {})
e1 = Edge("e1", start_node=n1, end_node=n2, edge_type=EdgeType.UNDIRECTED)
e2 = Edge("e2", start_node=n2, end_node=n3, edge_type=EdgeType.UNDIRECTED)
graph = Graph("g1", data={}, nodes=set([n1, n2, n3, n4]), edges=set([e1, e2]))
self.assertEqual(graph, self.graph)
def setUp(self):
""
self.a = Node("a")
self.b = Node("b")
self.c = Node("c")
self.d = Node("d")
self.e = Node("e")
self.f = Node("f")
self.g = Node("g")
self.h = Node("h")
self.j = Node("j")
self.k = Node("k")
self.m = Node("m")
#
# +--a --+
# | |
# b c
# | \
# +--+--+ g
# | | | |
# d e f h -- j
# |
# +--+---+
# | |
# k m
#
#
self.ab = Edge(edge_id="ab", start_node=self.a, end_node=self.b)
self.ac = Edge(edge_id="ac", start_node=self.a, end_node=self.c)
self.bd = Edge(edge_id="bd", start_node=self.b, end_node=self.d)
self.be = Edge(edge_id="be", start_node=self.b, end_node=self.e)
self.bf = Edge(edge_id="bf", start_node=self.b, end_node=self.f)
self.fk = Edge(edge_id="fk", start_node=self.f, end_node=self.k)
self.fm = Edge(edge_id="fm", start_node=self.f, end_node=self.m)
self.cg = Edge(edge_id="cg", start_node=self.c, end_node=self.g)
self.gh = Edge(edge_id="gh", start_node=self.g, end_node=self.h)
self.hj = Edge(edge_id="hj", start_node=self.h, end_node=self.j)
self.gtree = Tree(
gid="t",
edges=set([
self.ab,
self.ac,
self.bd,
self.be,
self.bf,
self.fk,
self.fm,
self.cg,
self.gh,
self.hj,
]),
)
def __init__(self, pmodel: PGModel):
self.model = pmodel
(self.mst, self.edge_order) = self.model.find_minimum_spanning_tree(
weight_fn=lambda x: x.data()["factor"]
if "factor" in x.data() else 1)
# expand mst to cover values
es = set()
for e in self.mst.edges():
n = e.start()
ndata = n.data()
if "evidence" in ndata:
es.add(e)
else:
values = ndata["outcome-values"]
for v in values:
ncp = deepcopy(n)
ncp.add_evidence(v)
ne = Edge(
edge_id=str(uuid4()),
edge_type=e.type(),
start_node=ncp,
end_node=e.end(),
)
es.add(ne)
#
super().__init__(gid=str(uuid4()), edges=es)
def get_chain_dag(self):
"""!
Get the directed acyclic graph composed of chain components
"""
dag_nodes = {
cid: NumCatRVariable(
node_id=cid,
input_data={"outcome-values": [True, False]},
distribution=lambda x: 1.0 / self.nb_components,
)
for cid in self.chain_components
}
dag_edges = set()
for e in self.edges():
if e.type() == EdgeType.DIRECTED:
(
edge_between_components_check,
start_component_id,
end_component_id,
) = self.check_edge_between_components(e)
if edge_between_components_check is True and (
start_component_id is not None and end_component_id is not None
):
dag_edge = Edge(
edge_id=str(uuid4()),
start_node=dag_nodes[start_component_id],
end_node=dag_nodes[end_component_id],
edge_type=EdgeType.DIRECTED,
)
dag_edges.add(dag_edge)
if len(dag_edges) > 0:
dag = Tree.from_edgeset(dag_edges)
else:
dag = None
return dag
def setUp(self):
""
n1 = Node("m1", {})
n2 = Node("m2", {})
self.dedge = Edge(
edge_id="medge",
start_node=n1,
end_node=n2,
edge_type=EdgeType.DIRECTED,
data={"my": "data"},
)
self.uedge = Edge(
edge_id="uedge",
start_node=n1,
end_node=n2,
edge_type=EdgeType.UNDIRECTED,
data={"my": "data"},
)
def test__sub__g(self):
""
n = Node("n646", {})
n1 = Node("n647", {})
n2 = Node("n648", {})
e = Edge("e8", start_node=self.n1, end_node=n, edge_type=EdgeType.UNDIRECTED)
gg = Graph(gid="temp", data={}, nodes=set([n, n1, n2]), edges=set([e, self.e1]))
g = self.graph - gg
self.assertEqual(g.edges(), set([]))
self.assertEqual(g.nodes(), set([self.n3, self.n4]))
def test_is_trivial(self):
""
n = Node("n646", {})
e = Edge("e8", start_node=self.n1, end_node=n, edge_type=EdgeType.UNDIRECTED)
check = False
try:
gg = Graph(gid="temp", data={}, nodes=set([n]), edges=set([e]))
except ValueError:
check = True
self.assertTrue(check)
def setUp(self):
"""
"""
self.n1 = Node("n1", {})
self.n2 = Node("n2", {})
self.n3 = Node("n3", {})
self.e1 = Edge("e1",
start_node=self.n1,
end_node=self.n2,
edge_type=EdgeType.DIRECTED)
self.e2 = Edge("e2",
start_node=self.n2,
end_node=self.n3,
edge_type=EdgeType.DIRECTED)
self.q = PriorityQueue(is_min=True)
self.q.insert(2, self.n1)
self.q.insert(5, self.n2)
self.q.insert(1, self.n3)
self.qm = PriorityQueue(is_min=False)
self.qm.insert(2, self.n1)
self.qm.insert(5, self.n2)
self.qm.insert(1, self.n3)
def from_node_tuples(cls, ntpls: Set[Tuple[Node, Node, EdgeType]]):
""
edges: Set[Edge] = set()
root = None
for e in ntpls:
child = e[0]
parent = e[1]
edge = Edge(edge_id=str(uuid4()),
start_node=parent,
end_node=child,
edge_type=e[2])
edges.add(edge)
return Tree(gid=str(uuid4()), edges=edges)
class EdgeTest(unittest.TestCase):
""
def setUp(self):
""
n1 = Node("m1", {})
n2 = Node("m2", {})
self.dedge = Edge(
edge_id="medge",
start_node=n1,
end_node=n2,
edge_type=EdgeType.DIRECTED,
data={"my": "data"},
)
self.uedge = Edge(
edge_id="uedge",
start_node=n1,
end_node=n2,
edge_type=EdgeType.UNDIRECTED,
data={"my": "data"},
)
def test_id(self):
""
self.assertEqual(self.uedge.id(), "uedge")
def test_type(self):
""
self.assertEqual(self.uedge.type(), EdgeType.UNDIRECTED)
def test_start(self):
self.assertEqual(self.uedge.start(), Node("m1", {}))
def test_end(self):
self.assertEqual(self.uedge.end(), Node("m2", {}))
def test_node_ids(self):
self.assertEqual(self.uedge.node_ids(), set(["m1", "m2"]))
def test_is_endvertice_true(self):
""
positive = self.uedge.is_endvertice(Node("m1", {}))
self.assertEqual(positive, True)
def test_is_endvertice_false(self):
""
negative = self.uedge.is_endvertice(Node("m3", {}))
self.assertEqual(negative, False)
def moralize(self) -> MarkovNetwork:
"""!
Moralize given chain graph: For any \f X,Y \in Pa_{K_i} \f add an edge
between them if it does not exist. Then drop the direction of edges.
"""
edges = self.edges()
enodes = set([frozenset([e.start(), e.end()]) for e in edges])
# add edges
for cid in range(len(self.ccomponents)):
pa_k_i: Set[NumCatRVariable] = self.parents_of_K(i=cid)
pa_k_i_cp = set([p for p in pa_k_i])
while len(pa_k_i_cp) > 0:
parent_node = pa_k_i_cp.pop()
for pnode in pa_k_i:
is_n_ind = self.is_node_independent_of(parent_node, pnode)
if (
is_n_ind is True
and frozenset([parent_node, pnode]).issubset(enodes) is False
):
e = Edge(
edge_id=str(uuid4()),
start_node=parent_node,
end_node=pnode,
edge_type=EdgeType.UNDIRECTED,
)
edges.add(e)
# drop orientation
nedges = set()
for e in edges:
if e.type() == EdgeType.DIRECTED:
ne = Edge(
edge_id=str(uuid4()),
start_node=e.start(),
end_node=e.end(),
edge_type=EdgeType.UNDIRECTED,
data=e.data(),
)
nedges.add(ne)
else:
nedges.add(e)
#
return MarkovNetwork(
gid=str(uuid4()), nodes=self.nodes(), edges=nedges, factors=self.factors()
)
def find_transitive_closure(self) -> Graph:
"""!
From algorithmic graph theory Joyner, Phillips, Nguyen, 2013, p.134
"""
T = self.transitive_closure_matrix()
nodes = set()
edges = set()
for tpl, tval in T.items():
if tval is False:
n1 = self.V[tpl[0]]
n2 = self.V[tpl[1]]
nodes.add(n1)
nodes.add(n2)
e = Edge(
edge_id=str(uuid4()),
start_node=n1,
end_node=n2,
edge_type=EdgeType.DIRECTED,
)
edges.add(e)
return DiGraph(gid=str(uuid4()), nodes=nodes, edges=edges)
def setUp(self):
#
self.n1 = Node("n1", {})
self.n2 = Node("n2", {})
self.n3 = Node("n3", {})
self.n4 = Node("n4", {})
self.n5 = Node("n5", {})
self.e1 = Edge("e1",
start_node=self.n1,
end_node=self.n2,
edge_type=EdgeType.DIRECTED)
self.e2 = Edge("e2",
start_node=self.n2,
end_node=self.n3,
edge_type=EdgeType.DIRECTED)
self.e3 = Edge("e3",
start_node=self.n3,
end_node=self.n4,
edge_type=EdgeType.DIRECTED)
self.e4 = Edge("e4",
start_node=self.n1,
end_node=self.n4,
edge_type=EdgeType.DIRECTED)
self.graph_2 = DiGraph(
"g2",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.n1, self.n2, self.n3, self.n4]),
edges=set([self.e1, self.e2, self.e3]),
)
#
# n1 → n2 → n3 → n4
# | ↑
# +--------------+
self.a = Node("a", {}) # b
self.b = Node("b", {}) # c
self.c = Node("c", {})
self.d = Node("d", {})
self.f = Node("f", {}) # d
self.e = Node("e", {}) # e
self.g = Node("g", {})
self.h = Node("h", {})
self.ae = Edge("ae",
start_node=self.a,
end_node=self.e,
edge_type=EdgeType.DIRECTED)
self.ab = Edge("ab",
start_node=self.a,
end_node=self.b,
edge_type=EdgeType.DIRECTED)
self.af = Edge("af",
start_node=self.a,
end_node=self.f,
edge_type=EdgeType.DIRECTED)
self.ah = Edge("ah",
start_node=self.a,
end_node=self.h,
edge_type=EdgeType.DIRECTED)
self.bh = Edge("bh",
start_node=self.b,
end_node=self.h,
edge_type=EdgeType.DIRECTED)
self.be = Edge("be",
start_node=self.b,
end_node=self.e,
edge_type=EdgeType.DIRECTED)
self.ef = Edge("ef",
start_node=self.e,
end_node=self.f,
edge_type=EdgeType.DIRECTED)
self.de = Edge("de",
start_node=self.d,
end_node=self.e,
edge_type=EdgeType.DIRECTED)
self.df = Edge("df",
start_node=self.d,
end_node=self.f,
edge_type=EdgeType.DIRECTED)
self.cd = Edge("cd",
start_node=self.c,
end_node=self.d,
edge_type=EdgeType.DIRECTED)
self.cg = Edge("cg",
start_node=self.c,
end_node=self.g,
edge_type=EdgeType.DIRECTED)
self.gd = Edge("gd",
start_node=self.g,
end_node=self.d,
edge_type=EdgeType.DIRECTED)
self.bg = Edge("bg",
start_node=self.b,
end_node=self.g,
edge_type=EdgeType.DIRECTED)
self.fg = Edge("fg",
start_node=self.f,
end_node=self.g,
edge_type=EdgeType.DIRECTED)
self.bc = Edge("bc",
start_node=self.b,
end_node=self.c,
edge_type=EdgeType.DIRECTED)
# directed graph
self.dgraph1 = DiGraph(
"dg1",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set([
self.ae,
# self.ab,
self.af,
# self.be,
self.ef,
]),
)
# dgraph1:
#
#
# a --------> e b
# | |
# +---> f <---+
#
self.dgraph2 = DiGraph(
"dg2",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set([
self.ae,
self.ab,
self.af,
self.be,
self.ef,
]),
)
# dgraph2 :
#
# a -> b -> e -> f
# | ↑ ↑
# +---------+----+
self.dgraph3 = DiGraph(
"dg3",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set([
self.ab,
self.af,
self.be,
]),
)
# dgraph3 :
#
# a -> b -> e
# \
# +---> f
self.dgraph4 = DiGraph(
"dg4",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=self.dgraph2.nodes().union(self.graph_2.nodes()),
edges=self.dgraph2.edges().union(self.graph_2.edges()),
)
# dgraph 4
#
# a -> b -> e -> f n1 -> n2 -> n3 -> n4
# | ↑ ↑ | ↑
# +---------+----+ +------------------+
self.e_n = Edge("en",
start_node=self.e,
end_node=self.n1,
edge_type=EdgeType.DIRECTED)
self.dgraph5 = DiGraph(
"dg5",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.c, self.d, self.e, self.f,
self.g]),
edges=set([
self.ab, self.bc, self.bg, self.cd, self.gd, self.df, self.de,
self.ef
]),
)
# dgraph 5
# +--> c +---> e
# / \ / |
# a -> b +--> d |
# \ / \ v
# +--> g +---> f
self.dgraph6 = DiGraph(
"dg6",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([
self.a, self.b, self.c, self.d, self.e, self.f, self.g, self.h
]),
edges=set([
self.ab,
self.ah,
self.bc,
self.bh,
self.cd,
self.de,
self.df,
self.cg,
self.fg,
]),
)
def test_union_e(self):
n = Node("n646", {})
e = Edge("e8", start_node=self.n1, end_node=n, edge_type=EdgeType.UNDIRECTED)
eset = self.graph.union(set([e]))
self.assertEqual(eset, set([e, self.e1, self.e2]))
def setUp(self):
#
self.n1 = Node("n1", {})
self.n2 = Node("n2", {})
self.n3 = Node("n3", {})
self.n4 = Node("n4", {})
self.n5 = Node("n5", {})
self.e1 = Edge("e1",
start_node=self.n1,
end_node=self.n2,
edge_type=EdgeType.UNDIRECTED)
self.e2 = Edge("e2",
start_node=self.n2,
end_node=self.n3,
edge_type=EdgeType.UNDIRECTED)
self.e3 = Edge("e3",
start_node=self.n3,
end_node=self.n4,
edge_type=EdgeType.UNDIRECTED)
self.e4 = Edge("e4",
start_node=self.n1,
end_node=self.n4,
edge_type=EdgeType.UNDIRECTED)
self.graph_2 = UndiGraph(
"g2",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.n1, self.n2, self.n3, self.n4]),
edges=set([self.e1, self.e2, self.e3]),
)
self.a = Node("a", {}) # b
self.b = Node("b", {}) # c
self.c = Node("c", {})
self.d = Node("d", {})
self.f = Node("f", {}) # d
self.e = Node("e", {}) # e
self.g = Node("g", {})
self.h = Node("h", {})
self.ae = Edge("ae",
start_node=self.a,
end_node=self.e,
edge_type=EdgeType.UNDIRECTED)
self.ab = Edge(
"ab",
start_node=self.a,
end_node=self.b,
data={"w": 1},
edge_type=EdgeType.UNDIRECTED,
)
self.af = Edge("af",
start_node=self.a,
end_node=self.f,
edge_type=EdgeType.UNDIRECTED)
self.ah = Edge("ah",
start_node=self.a,
end_node=self.h,
edge_type=EdgeType.UNDIRECTED)
self.bh = Edge("bh",
start_node=self.b,
end_node=self.h,
edge_type=EdgeType.UNDIRECTED)
self.be = Edge("be",
start_node=self.b,
end_node=self.e,
edge_type=EdgeType.UNDIRECTED)
self.ef = Edge(
"ef",
data={"w": 5},
start_node=self.e,
end_node=self.f,
edge_type=EdgeType.UNDIRECTED,
)
self.de = Edge(
"de",
data={"w": 4},
start_node=self.d,
end_node=self.e,
edge_type=EdgeType.UNDIRECTED,
)
self.df = Edge(
"df",
data={"w": 8},
start_node=self.d,
end_node=self.f,
edge_type=EdgeType.UNDIRECTED,
)
self.cd = Edge(
"cd",
data={"w": 3},
start_node=self.c,
end_node=self.d,
edge_type=EdgeType.UNDIRECTED,
)
self.cg = Edge("cg",
start_node=self.c,
end_node=self.g,
edge_type=EdgeType.UNDIRECTED)
self.gd = Edge(
"gd",
data={"w": 7},
start_node=self.g,
end_node=self.d,
edge_type=EdgeType.UNDIRECTED,
)
self.bg = Edge(
"bg",
data={"w": 6},
start_node=self.b,
end_node=self.g,
edge_type=EdgeType.UNDIRECTED,
)
self.fg = Edge("fg",
start_node=self.f,
end_node=self.g,
edge_type=EdgeType.UNDIRECTED)
self.bc = Edge(
"bc",
start_node=self.b,
end_node=self.c,
data={"w": 2},
edge_type=EdgeType.UNDIRECTED,
)
# undirected graph
self.ugraph1 = UndiGraph(
"ug1",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set([
self.ae,
# self.ab,
self.af,
# self.be,
self.ef,
]),
)
# ugraph1:
# +-----+
# / \
# a b e
# \ /
# +-----f
self.ugraph2 = UndiGraph(
"ug2",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set([
self.ae,
self.ab,
self.af,
self.be,
self.ef,
]),
)
# ugraph2 :
# +-----+
# / \
# a -- b -- e
# \ /
# +-----f
self.ugraph3 = UndiGraph(
"ug3",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set([
self.ab,
self.af,
self.be,
]),
)
# ugraph3 :
#
#
# a -- b -- e
# \
# +-----f
self.ugraph4 = UndiGraph(
"ug4",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=self.ugraph2.nodes().union(self.graph_2.nodes()),
edges=self.ugraph2.edges().union(self.graph_2.edges()),
)
# ugraph 4
# +-----+ n1 -- n2 -- n3 -- n4
# / \ \ /
# a -- b -- e +--------------+
# \ /
# +-----f
self.ugraph5 = UndiGraph(
"ug5",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.a, self.b, self.c, self.d, self.e, self.f,
self.g]),
edges=set([
self.ab, self.bc, self.bg, self.cd, self.gd, self.df, self.de,
self.ef
]),
)
# ugraph 5
# +----c---+ +--e
# / 2 3 \ / 4 |
# a --- b d | 5
# 1 \ 6 7 / \ 8 |
# +---g---+ +--f
self.ugraph6 = UndiGraph(
"ug6",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([
self.a, self.b, self.c, self.d, self.e, self.f, self.g, self.h
]),
edges=set([
self.ab,
self.ah,
self.bc,
self.bh,
self.cd,
self.de,
self.df,
self.cg,
self.fg,
]),
)
# ugraph 6
# a--+ e----d
# | \ / \
# | b----c f
# | / \ /
# h--+ g
self.ad = Edge("ad",
start_node=self.a,
end_node=self.d,
edge_type=EdgeType.UNDIRECTED)
#
self.ugraph7 = UndiGraph(
"ug7",
nodes=set([self.a, self.b, self.c, self.d]),
edges=set([self.ab, self.bc, self.cd, self.ad]),
)
def setUp(self):
""
idata = {
"rain": {
"outcome-values": [True, False]
},
"sprink": {
"outcome-values": [True, False]
},
"wet": {
"outcome-values": [True, False]
},
}
self.rain = NumCatRVariable(
input_data=idata["rain"],
node_id="rain",
distribution=lambda x: 0.2 if x is True else 0.8,
)
self.sprink = NumCatRVariable(
node_id="sprink",
input_data=idata["sprink"],
distribution=lambda x: 0.6 if x is True else 0.4,
)
self.wet = NumCatRVariable(
node_id="wet",
input_data=idata["wet"],
distribution=lambda x: 0.7 if x is True else 0.3,
)
self.rain_wet = Edge(
edge_id="rain_wet",
start_node=self.rain,
end_node=self.wet,
edge_type=EdgeType.DIRECTED,
)
self.rain_sprink = Edge(
edge_id="rain_sprink",
start_node=self.rain,
end_node=self.sprink,
edge_type=EdgeType.DIRECTED,
)
self.sprink_wet = Edge(
edge_id="sprink_wet",
start_node=self.sprink,
end_node=self.wet,
edge_type=EdgeType.DIRECTED,
)
def sprink_rain_factor(scope_product):
""
sfs = set(scope_product)
if sfs == set([("rain", True), ("sprink", True)]):
return 0.01
elif sfs == set([("rain", True), ("sprink", False)]):
return 0.99
elif sfs == set([("rain", False), ("sprink", True)]):
return 0.4
elif sfs == set([("rain", False), ("sprink", False)]):
return 0.6
else:
raise ValueError("unknown product")
self.rain_sprink_f = Factor.from_conditional_vars(
X_i=self.sprink, Pa_Xi=set([self.rain]), fn=sprink_rain_factor)
def grass_wet_factor(scope_product):
""
sfs = set(scope_product)
if sfs == set([("rain", False), ("sprink", False), ("wet", True)]):
return 0.0
elif sfs == set([("rain", False), ("sprink", False),
("wet", False)]):
return 1.0
elif sfs == set([("rain", False), ("sprink", True),
("wet", True)]):
return 0.8
elif sfs == set([("rain", False), ("sprink", True),
("wet", False)]):
return 0.2
elif sfs == set([("rain", True), ("sprink", False),
("wet", True)]):
return 0.9
elif sfs == set([("rain", True), ("sprink", False),
("wet", False)]):
return 0.1
elif sfs == set([("rain", True), ("sprink", True), ("wet", True)]):
return 0.99
elif sfs == set([("rain", True), ("sprink", True),
("wet", False)]):
return 0.01
else:
raise ValueError("unknown product")
self.grass_wet_f = Factor.from_conditional_vars(
X_i=self.wet,
Pa_Xi=set([self.rain, self.sprink]),
fn=grass_wet_factor)
self.bayes = BayesianNetwork(
gid="b",
nodes=set([self.rain, self.sprink, self.wet]),
edges=set([self.rain_wet, self.rain_sprink, self.sprink_wet]),
factors=set([self.grass_wet_f, self.rain_sprink_f]),
)
idata = {"outcome-values": [True, False]}
self.C = NumCatRVariable(node_id="C",
input_data=idata,
distribution=lambda x: 0.5)
self.E = NumCatRVariable(node_id="E",
input_data=idata,
distribution=lambda x: 0.5)
self.F = NumCatRVariable(node_id="F",
input_data=idata,
distribution=lambda x: 0.5)
self.D = NumCatRVariable(node_id="D",
input_data=idata,
distribution=lambda x: 0.5)
self.CE = Edge(
edge_id="CE",
start_node=self.C,
end_node=self.E,
edge_type=EdgeType.DIRECTED,
)
self.ED = Edge(
edge_id="ED",
start_node=self.E,
end_node=self.D,
edge_type=EdgeType.DIRECTED,
)
self.EF = Edge(
edge_id="EF",
start_node=self.E,
end_node=self.F,
edge_type=EdgeType.DIRECTED,
)
def phi_c(scope_product):
ss = set(scope_product)
if ss == set([("C", True)]):
return 0.8
elif ss == set([("C", False)]):
return 0.2
else:
raise ValueError("scope product unknown")
def phi_ec(scope_product):
ss = set(scope_product)
if ss == set([("C", True), ("E", True)]):
return 0.9
elif ss == set([("C", True), ("E", False)]):
return 0.1
elif ss == set([("C", False), ("E", True)]):
return 0.7
elif ss == set([("C", False), ("E", False)]):
return 0.3
else:
raise ValueError("scope product unknown")
def phi_fe(scope_product):
ss = set(scope_product)
if ss == set([("E", True), ("F", True)]):
return 0.9
elif ss == set([("E", True), ("F", False)]):
return 0.1
elif ss == set([("E", False), ("F", True)]):
return 0.5
elif ss == set([("E", False), ("F", False)]):
return 0.5
else:
raise ValueError("scope product unknown")
def phi_de(scope_product):
ss = set(scope_product)
if ss == set([("E", True), ("D", True)]):
return 0.7
elif ss == set([("E", True), ("D", False)]):
return 0.3
elif ss == set([("E", False), ("D", True)]):
return 0.4
elif ss == set([("E", False), ("D", False)]):
return 0.6
else:
raise ValueError("scope product unknown")
self.CE_f = Factor(gid="CE_f",
scope_vars=set([self.C, self.E]),
factor_fn=phi_ec)
self.C_f = Factor(gid="C_f", scope_vars=set([self.C]), factor_fn=phi_c)
self.FE_f = Factor(gid="FE_f",
scope_vars=set([self.F, self.E]),
factor_fn=phi_fe)
self.DE_f = Factor(gid="DE_f",
scope_vars=set([self.D, self.E]),
factor_fn=phi_de)
self.bayes_n = BayesianNetwork(
gid="ba",
nodes=set([self.C, self.E, self.D, self.F]),
edges=set([self.EF, self.CE, self.ED]),
factors=set([self.C_f, self.DE_f, self.CE_f, self.FE_f]),
)
def setUp(self):
""
idata = {"outcome-values": [True, False]}
self.A = NumCatRVariable(
node_id="A", input_data=idata, distribution=lambda x: 0.5
)
self.B = NumCatRVariable(
node_id="B", input_data=idata, distribution=lambda x: 0.5
)
self.C = NumCatRVariable(
node_id="C", input_data=idata, distribution=lambda x: 0.5
)
self.D = NumCatRVariable(
node_id="D", input_data=idata, distribution=lambda x: 0.5
)
self.E = NumCatRVariable(
node_id="E", input_data=idata, distribution=lambda x: 0.5
)
self.F = NumCatRVariable(
node_id="F", input_data=idata, distribution=lambda x: 0.5
)
self.G = NumCatRVariable(
node_id="G", input_data=idata, distribution=lambda x: 0.5
)
self.H = NumCatRVariable(
node_id="H", input_data=idata, distribution=lambda x: 0.5
)
self.I = NumCatRVariable(
node_id="I", input_data=idata, distribution=lambda x: 0.5
)
self.K = NumCatRVariable(
node_id="K", input_data=idata, distribution=lambda x: 0.5
)
self.L = NumCatRVariable(
node_id="L", input_data=idata, distribution=lambda x: 0.5
)
#
# Cowell 2005, p. 110
#
# A E---+
# | |
# +----+ F <-+
# | |
# B <--+---> C --> D <---+
# | |
# +---> H <--------+----> G
# | |
# +---> I
#
self.AB_c = Edge(
edge_id="AB",
start_node=self.A,
end_node=self.B,
edge_type=EdgeType.DIRECTED,
)
self.AC_c = Edge(
edge_id="AC",
start_node=self.A,
end_node=self.C,
edge_type=EdgeType.DIRECTED,
)
self.CD_c = Edge(
edge_id="CD",
start_node=self.C,
end_node=self.D,
edge_type=EdgeType.DIRECTED,
)
self.EF_c = Edge(
edge_id="EF",
start_node=self.E,
end_node=self.F,
edge_type=EdgeType.DIRECTED,
)
self.FD_c = Edge(
edge_id="FD",
start_node=self.F,
end_node=self.D,
edge_type=EdgeType.DIRECTED,
)
self.DG_c = Edge(
edge_id="DG",
start_node=self.D,
end_node=self.G,
edge_type=EdgeType.DIRECTED,
)
self.DH_c = Edge(
edge_id="DH",
start_node=self.D,
end_node=self.H,
edge_type=EdgeType.DIRECTED,
)
self.BH_c = Edge(
edge_id="BH",
start_node=self.B,
end_node=self.H,
edge_type=EdgeType.DIRECTED,
)
self.BI_c = Edge(
edge_id="BI",
start_node=self.B,
end_node=self.I,
edge_type=EdgeType.DIRECTED,
)
self.HI_c = Edge(
edge_id="HI",
start_node=self.H,
end_node=self.I,
edge_type=EdgeType.UNDIRECTED,
)
#
# Factors
#
def phi_e(scope_product):
"""!
Visit to Asia factor
p(a)
"""
ss = set(scope_product)
if ss == set([("E", True)]):
return 0.01
elif ss == set([("E", False)]):
return 0.99
else:
raise ValueError("Unknown scope product")
self.E_cf = Factor(gid="E_cf", scope_vars=set([self.E]), factor_fn=phi_e)
def phi_fe(scope_product):
"""!
Tuberculosis | Visit to Asia factor
p(t,a)
"""
ss = set(scope_product)
if ss == set([("F", True), ("E", True)]):
return 0.05
elif ss == set([("F", False), ("E", True)]):
return 0.95
elif ss == set([("F", True), ("E", False)]):
return 0.01
elif ss == set([("F", False), ("E", False)]):
return 0.99
else:
raise ValueError("Unknown scope product")
self.EF_cf = Factor(
gid="EF_cf", scope_vars=set([self.E, self.F]), factor_fn=phi_fe
)
def phi_dg(scope_product):
"""!
either tuberculosis or lung cancer | x ray
p(e,x)
"""
ss = set(scope_product)
if ss == set([("D", True), ("G", True)]):
return 0.98
elif ss == set([("D", False), ("G", True)]):
return 0.05
elif ss == set([("D", True), ("G", False)]):
return 0.02
elif ss == set([("D", False), ("G", False)]):
return 0.95
else:
raise ValueError("Unknown scope product")
self.DG_cf = Factor(
gid="DG_cf", scope_vars=set([self.D, self.G]), factor_fn=phi_dg
)
def phi_a(scope_product):
"""!
smoke factor
p(s)
"""
ss = set(scope_product)
if ss == set([("A", True)]):
return 0.5
elif ss == set([("A", False)]):
return 0.5
else:
raise ValueError("Unknown scope product")
self.A_cf = Factor(gid="A_cf", scope_vars=set([self.A]), factor_fn=phi_a)
def phi_ab(scope_product):
"""!
smoke given bronchitis
p(s,b)
"""
ss = set(scope_product)
if ss == set([("A", True), ("B", True)]):
return 0.6
elif ss == set([("A", False), ("B", True)]):
return 0.3
elif ss == set([("A", True), ("B", False)]):
return 0.4
elif ss == set([("A", False), ("B", False)]):
return 0.7
else:
raise ValueError("Unknown scope product")
self.AB_cf = Factor(
gid="AB_cf", scope_vars=set([self.A, self.B]), factor_fn=phi_ab
)
def phi_ac(scope_product):
"""!
lung cancer given smoke
p(s,l)
"""
ss = set(scope_product)
if ss == set([("A", True), ("C", True)]):
return 0.1
elif ss == set([("A", False), ("C", True)]):
return 0.01
elif ss == set([("A", True), ("C", False)]):
return 0.9
elif ss == set([("A", False), ("C", False)]):
return 0.99
else:
raise ValueError("Unknown scope product")
self.AC_cf = Factor(
gid="AC_cf", scope_vars=set([self.A, self.C]), factor_fn=phi_ac
)
def phi_cdf(scope_product):
"""!
either tuberculosis or lung given lung cancer and tuberculosis
p(e, l, t)
"""
ss = set(scope_product)
if ss == set([("C", True), ("D", True), ("F", True)]):
return 1
elif ss == set([("C", True), ("D", False), ("F", True)]):
return 0
elif ss == set([("C", False), ("D", True), ("F", True)]):
return 1
elif ss == set([("C", False), ("D", False), ("F", True)]):
return 0
elif ss == set([("C", True), ("D", True), ("F", False)]):
return 1
elif ss == set([("C", True), ("D", False), ("F", False)]):
return 0
elif ss == set([("C", False), ("D", True), ("F", False)]):
return 0
elif ss == set([("C", False), ("D", False), ("F", False)]):
return 1
else:
raise ValueError("Unknown scope product")
self.CDF_cf = Factor(
gid="CDF_cf", scope_vars=set([self.D, self.C, self.F]), factor_fn=phi_cdf
)
def phi_ihb(scope_product):
"""!
cough, dyspnoea, bronchitis
I, H, B
p(c,d,b)
"""
ss = set(scope_product)
if ss == set([("H", True), ("I", True), ("B", True)]):
return 16
elif ss == set([("H", True), ("I", False), ("B", True)]):
return 1
elif ss == set([("H", False), ("I", True), ("B", True)]):
return 4
elif ss == set([("H", False), ("I", False), ("B", True)]):
return 1
elif ss == set([("H", True), ("I", True), ("B", False)]):
return 2
elif ss == set([("H", True), ("I", False), ("B", False)]):
return 1
elif ss == set([("H", False), ("I", True), ("B", False)]):
return 1
elif ss == set([("H", False), ("I", False), ("B", False)]):
return 1
else:
raise ValueError("Unknown scope product")
self.IHB_cf = Factor(
gid="IHB_cf", scope_vars=set([self.H, self.I, self.B]), factor_fn=phi_ihb
)
def phi_hbd(scope_product):
"""!
cough, either tuberculosis or lung cancer, bronchitis
D, H, B
p(c,b,e)
"""
ss = set(scope_product)
if ss == set([("H", True), ("D", True), ("B", True)]):
return 5
elif ss == set([("H", True), ("D", False), ("B", True)]):
return 2
elif ss == set([("H", False), ("D", True), ("B", True)]):
return 1
elif ss == set([("H", False), ("D", False), ("B", True)]):
return 1
elif ss == set([("H", True), ("D", True), ("B", False)]):
return 3
elif ss == set([("H", True), ("D", False), ("B", False)]):
return 1
elif ss == set([("H", False), ("D", True), ("B", False)]):
return 1
elif ss == set([("H", False), ("D", False), ("B", False)]):
return 1
else:
raise ValueError("Unknown scope product")
self.HBD_cf = Factor(
gid="HBD_cf", scope_vars=set([self.H, self.D, self.B]), factor_fn=phi_hbd
)
def phi_bd(scope_product):
"""!
bronchitis, either tuberculosis or lung cancer
B, D
p(b,e)
"""
ss = set(scope_product)
if ss == set([("B", True), ("D", True)]):
return 1 / 90
elif ss == set([("B", False), ("D", True)]):
return 1 / 11
elif ss == set([("B", True), ("D", False)]):
return 1 / 39
elif ss == set([("B", False), ("D", False)]):
return 1 / 5
else:
raise ValueError("Unknown scope product")
self.BD_cf = Factor(
gid="BD_cf", scope_vars=set([self.D, self.B]), factor_fn=phi_bd
)
self.cowell = LWFChainGraph(
gid="cowell",
nodes=set(
[self.A, self.B, self.C, self.D, self.E, self.F, self.G, self.H, self.I]
),
edges=set(
[
self.AB_c,
self.AC_c,
self.CD_c,
self.EF_c,
self.FD_c,
self.DG_c,
self.DH_c,
self.BH_c,
self.BI_c,
self.HI_c,
]
),
factors=set(
[
self.E_cf,
self.EF_cf,
self.DG_cf,
self.A_cf,
self.AB_cf,
self.AC_cf,
self.CDF_cf,
self.IHB_cf,
self.HBD_cf,
self.BD_cf,
]
),
)
# Koller, Friedman 2009, p. 149
#
# +--------------+
# | |
# | A + B
# | | | |
# | +--> C -- D -- E <--+
# | | | |
# | +--+ | v
# | | +-------> I <---- H
# | F <-+
# | |
# | +----- G
# | ^
# | |
# +----------+
self.AC_k = Edge(
edge_id="AC",
start_node=self.A,
end_node=self.C,
edge_type=EdgeType.DIRECTED,
)
self.FG_k = Edge(
edge_id="FG",
start_node=self.F,
end_node=self.G,
edge_type=EdgeType.UNDIRECTED,
)
self.DG_k = Edge(
edge_id="DG",
start_node=self.D,
end_node=self.G,
edge_type=EdgeType.DIRECTED,
)
self.CF_k = Edge(
edge_id="CF",
start_node=self.C,
end_node=self.F,
edge_type=EdgeType.UNDIRECTED,
)
self.CD_k = Edge(
edge_id="CD",
start_node=self.C,
end_node=self.D,
edge_type=EdgeType.UNDIRECTED,
)
self.CI_k = Edge(
edge_id="CI",
start_node=self.C,
end_node=self.I,
edge_type=EdgeType.DIRECTED,
)
self.DE_k = Edge(
edge_id="DE",
start_node=self.D,
end_node=self.E,
edge_type=EdgeType.UNDIRECTED,
)
self.EI_k = Edge(
edge_id="EI",
start_node=self.E,
end_node=self.I,
edge_type=EdgeType.DIRECTED,
)
self.BE_k = Edge(
edge_id="BE",
start_node=self.B,
end_node=self.E,
edge_type=EdgeType.DIRECTED,
)
self.HI_k = Edge(
edge_id="HI",
start_node=self.H,
end_node=self.I,
edge_type=EdgeType.DIRECTED,
)
self.koller = LWFChainGraph(
gid="koller",
nodes=set([self.A, self.C, self.D, self.E, self.B, self.I, self.F, self.G]),
edges=set(
[
self.AC_k,
self.FG_k,
self.CF_k,
self.HI_k,
self.CD_k,
self.CI_k,
self.DE_k,
self.DG_k,
self.EI_k,
self.BE_k,
]
),
factors=None,
)
# evidence values taken from
# Cowell 2005, p. 119, table 6.12
e_comp_val = [("E", True, 0.0096), ("E", False, 0.9904)]
h_comp_val = [("H", True, 0.7635), ("H", False, 0.2365)]
c_comp_val = [("C", True, 0.0025), ("C", False, 0.9975)]
i_comp_val = [("I", True, 0.7939), ("I", False, 0.2061)]
g_comp_val = [("G", True, 0.1849), ("G", False, 0.8151)]
a_comp_val = [("A", True, 0.4767), ("A", False, 0.5233)]
f_comp_val = [("F", True, 0.0012), ("F", False, 0.9988)]
d_comp_val = [("D", True, 0.0036), ("D", False, 0.9964)]
b_comp_val = [("B", True, 0.60), ("B", False, 0.40)]
self.evidences = set([("E", True), ("A", True), ("G", False)])
self.q_tsts = {
(self.E): e_comp_val, # asia
(self.I): i_comp_val, # dyspnoea
(self.H): h_comp_val, # cough
(self.A): a_comp_val, # smoke
(self.B): b_comp_val, # bronchitis
(self.C): c_comp_val, # lung
(self.D): d_comp_val, # either
(self.F): f_comp_val, # tuberculosis
(self.G): g_comp_val, # x ray
}
def cond(n_1: Node, n_2: Node, e: Edge):
""
c = n_1 == e.start() and e.end() == n_2
return c
def setUp(self):
self.n1 = Node("n1", {})
self.n2 = Node("n2", {})
self.n3 = Node("n3", {})
self.n4 = Node("n4", {})
self.n5 = Node("n5", {})
self.e1 = Edge(
"e1", start_node=self.n1, end_node=self.n2, edge_type=EdgeType.UNDIRECTED
)
self.e2 = Edge(
"e2", start_node=self.n2, end_node=self.n3, edge_type=EdgeType.UNDIRECTED
)
self.e3 = Edge(
"e3", start_node=self.n3, end_node=self.n4, edge_type=EdgeType.UNDIRECTED
)
self.e4 = Edge(
"e4", start_node=self.n1, end_node=self.n4, edge_type=EdgeType.UNDIRECTED
)
self.graph = Graph(
"g1",
data={"my": "graph", "data": "is", "very": "awesome"},
nodes=set([self.n1, self.n2, self.n3, self.n4]),
edges=set([self.e1, self.e2]),
)
self.graph_2 = Graph(
"g2",
data={"my": "graph", "data": "is", "very": "awesome"},
nodes=set([self.n1, self.n2, self.n3, self.n4]),
edges=set([self.e1, self.e2, self.e3]),
)
#
self.a = Node("a", {}) # b
self.b = Node("b", {}) # c
self.f = Node("f", {}) # d
self.e = Node("e", {}) # e
self.ae = Edge(
"ae", start_node=self.a, end_node=self.e, edge_type=EdgeType.UNDIRECTED
)
self.ab = Edge(
"ab", start_node=self.a, end_node=self.b, edge_type=EdgeType.UNDIRECTED
)
self.af = Edge(
"af", start_node=self.a, end_node=self.f, edge_type=EdgeType.UNDIRECTED
)
self.be = Edge(
"be", start_node=self.b, end_node=self.e, edge_type=EdgeType.UNDIRECTED
)
self.ef = Edge(
"ef", start_node=self.e, end_node=self.f, edge_type=EdgeType.UNDIRECTED
)
# undirected graph
self.ugraph1 = Graph(
"ug1",
data={"my": "graph", "data": "is", "very": "awesome"},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set(
[
self.ae,
# self.ab,
self.af,
# self.be,
self.ef,
]
),
)
# ugraph1:
# +-----+
# / \
# a b e
# \ /
# +-----f
self.ugraph2 = Graph(
"ug2",
data={"my": "graph", "data": "is", "very": "awesome"},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set([self.ae, self.ab, self.af, self.be, self.ef,]),
)
# ugraph2 :
# +-----+
# / \
# a -- b -- e
# \ /
# +-----f
self.ugraph3 = Graph(
"ug3",
data={"my": "graph", "data": "is", "very": "awesome"},
nodes=set([self.a, self.b, self.e, self.f]),
edges=set(
[
self.ab,
# self.af,
self.be,
]
),
)
# ugraph3 :
#
#
# a -- b -- e
# \
# +-----f
self.ugraph4 = Graph(
"ug4",
data={"my": "graph", "data": "is", "very": "awesome"},
nodes=self.ugraph2.nodes().union(self.graph_2.nodes()),
edges=self.ugraph2.edges().union(self.graph_2.edges()),
)
# ugraph 4
# +-----+ n1 -- n2 -- n3 -- n4
# / \ \ /
# a -- b -- e +--------------+
# \ /
# +-----f
# make some directed edges
self.bb = Node("bb", {})
self.cc = Node("cc", {})
self.dd = Node("dd", {})
self.ee = Node("ee", {})
self.bb_cc = Edge(
"bb_cc", start_node=self.bb, end_node=self.cc, edge_type=EdgeType.DIRECTED
)
self.cc_dd = Edge(
"cc_dd", start_node=self.cc, end_node=self.dd, edge_type=EdgeType.DIRECTED
)
self.dd_ee = Edge(
"dd_ee", start_node=self.dd, end_node=self.ee, edge_type=EdgeType.DIRECTED
)
self.ee_bb = Edge(
"ee_bb", start_node=self.ee, end_node=self.bb, edge_type=EdgeType.DIRECTED
)
self.bb_dd = Edge(
"bb_dd", start_node=self.bb, end_node=self.dd, edge_type=EdgeType.DIRECTED
)
self.dgraph = Graph(
"g1",
data={"my": "graph", "data": "is", "very": "awesome"},
nodes=set([self.bb, self.cc, self.dd, self.ee]),
edges=set([self.bb_cc, self.cc_dd, self.dd_ee, self.ee_bb, self.bb_dd]),
)
def setUp(self):
"""!
Graph made from values of
Darwiche 2009, p. 132, figure 6.4
"""
idata = {
"a": {
"outcome-values": [True, False]
},
"b": {
"outcome-values": [True, False]
},
"c": {
"outcome-values": [True, False]
},
}
self.a = NumCatRVariable(node_id="a",
input_data=idata["a"],
distribution=lambda x: 0.6 if x else 0.4)
self.b = NumCatRVariable(node_id="b",
input_data=idata["b"],
distribution=lambda x: 0.5 if x else 0.5)
self.c = NumCatRVariable(node_id="c",
input_data=idata["c"],
distribution=lambda x: 0.5 if x else 0.5)
self.ab = Edge(
edge_id="ab",
edge_type=EdgeType.UNDIRECTED,
start_node=self.a,
end_node=self.b,
)
self.bc = Edge(
edge_id="bc",
edge_type=EdgeType.UNDIRECTED,
start_node=self.b,
end_node=self.c,
)
def phi_ba(scope_product):
""
ss = set(scope_product)
if ss == set([("a", True), ("b", True)]):
return 0.9
elif ss == set([("a", True), ("b", False)]):
return 0.1
elif ss == set([("a", False), ("b", True)]):
return 0.2
elif ss == set([("a", False), ("b", False)]):
return 0.8
else:
raise ValueError("product error")
def phi_cb(scope_product):
""
ss = set(scope_product)
if ss == set([("c", True), ("b", True)]):
return 0.3
elif ss == set([("c", True), ("b", False)]):
return 0.5
elif ss == set([("c", False), ("b", True)]):
return 0.7
elif ss == set([("c", False), ("b", False)]):
return 0.5
else:
raise ValueError("product error")
def phi_a(scope_product):
s = set(scope_product)
if s == set([("a", True)]):
return 0.6
elif s == set([("a", False)]):
return 0.4
else:
raise ValueError("product error")
self.ba_f = Factor(gid="ba",
scope_vars=set([self.b, self.a]),
factor_fn=phi_ba)
self.cb_f = Factor(gid="cb",
scope_vars=set([self.c, self.b]),
factor_fn=phi_cb)
self.a_f = Factor(gid="a", scope_vars=set([self.a]), factor_fn=phi_a)
self.pgm = PGModel(
gid="pgm",
nodes=set([self.a, self.b, self.c]),
edges=set([self.ab, self.bc]),
factors=set([self.ba_f, self.cb_f, self.a_f]),
)
# most probable explanation instantiations
# graph
odata = {"outcome-values": [True, False]}
self.J = NumCatRVariable(node_id="J",
input_data=odata,
distribution=lambda x: 0.5)
self.I = NumCatRVariable(node_id="I",
input_data=odata,
distribution=lambda x: 0.5)
self.X = NumCatRVariable(node_id="X",
input_data=odata,
distribution=lambda x: 0.5)
self.Y = NumCatRVariable(node_id="Y",
input_data=odata,
distribution=lambda x: 0.5)
self.O = NumCatRVariable(node_id="O",
input_data=odata,
distribution=lambda x: 0.5)
self.JX = Edge(
edge_id="JX",
edge_type=EdgeType.DIRECTED,
start_node=self.J,
end_node=self.X,
)
self.JY = Edge(
edge_id="JY",
edge_type=EdgeType.DIRECTED,
start_node=self.J,
end_node=self.Y,
)
self.IX = Edge(
edge_id="IX",
edge_type=EdgeType.DIRECTED,
start_node=self.I,
end_node=self.X,
)
self.XO = Edge(
edge_id="XO",
edge_type=EdgeType.DIRECTED,
start_node=self.X,
end_node=self.O,
)
self.YO = Edge(
edge_id="YO",
edge_type=EdgeType.DIRECTED,
start_node=self.Y,
end_node=self.O,
)
def phi_ij(scope_product, i: str):
""
ss = set(scope_product)
if ss == set([(i, True)]):
return 0.5
elif ss == set([(i, False)]):
return 0.5
else:
raise ValueError("unknown scope product")
def phi_i(scope_product):
""
return phi_ij(scope_product, i="I")
self.I_f = Factor(gid="I_f", scope_vars=set([self.I]), factor_fn=phi_i)
def phi_j(scope_product):
""
return phi_ij(scope_product, i="J")
self.J_f = Factor(gid="J_f", scope_vars=set([self.J]), factor_fn=phi_j)
def phi_jy(scope_product):
""
ss = set(scope_product)
if ss == set([("J", True), ("Y", True)]):
return 0.01
elif ss == set([("J", True), ("Y", False)]):
return 0.99
elif ss == set([("J", False), ("Y", True)]):
return 0.99
elif ss == set([("J", False), ("Y", False)]):
return 0.01
else:
raise ValueError("scope product unknown")
self.JY_f = Factor(gid="JY_f",
scope_vars=set([self.J, self.Y]),
factor_fn=phi_jy)
def phi_ijx(scope_product):
""
ss = set(scope_product)
if ss == set([("I", True), ("J", True), ("X", True)]):
return 0.95
elif ss == set([("I", True), ("J", True), ("X", False)]):
return 0.05
elif ss == set([("I", True), ("J", False), ("X", True)]):
return 0.05
elif ss == set([("I", True), ("J", False), ("X", False)]):
return 0.95
elif ss == set([("I", False), ("J", True), ("X", True)]):
return 0.05
elif ss == set([("I", False), ("J", True), ("X", False)]):
return 0.95
elif ss == set([("I", False), ("J", False), ("X", True)]):
return 0.05
elif ss == set([("I", False), ("J", False), ("X", False)]):
return 0.95
else:
raise ValueError("scope product unknown")
self.IJX_f = Factor(gid="IJX_f",
scope_vars=set([self.J, self.X, self.I]),
factor_fn=phi_ijx)
def phi_xyo(scope_product):
""
ss = set(scope_product)
if ss == set([("X", True), ("Y", True), ("O", True)]):
return 0.98
elif ss == set([("X", True), ("Y", True), ("O", False)]):
return 0.02
elif ss == set([("X", True), ("Y", False), ("O", True)]):
return 0.98
elif ss == set([("X", True), ("Y", False), ("O", False)]):
return 0.02
elif ss == set([("X", False), ("Y", True), ("O", True)]):
return 0.98
elif ss == set([("X", False), ("Y", True), ("O", False)]):
return 0.02
elif ss == set([("X", False), ("Y", False), ("O", True)]):
return 0.02
elif ss == set([("X", False), ("Y", False), ("O", False)]):
return 0.98
else:
raise ValueError("scope product unknown")
self.XYO_f = Factor(gid="XYO_f",
scope_vars=set([self.Y, self.X, self.O]),
factor_fn=phi_xyo)
self.pgm_mpe = PGModel(
gid="mpe",
nodes=set([self.J, self.Y, self.X, self.I, self.O]),
edges=set([self.JY, self.JX, self.YO, self.IX, self.XO]),
factors=set(
[self.I_f, self.J_f, self.JY_f, self.IJX_f, self.XYO_f]),
)
def test__sub__e(self):
""
n = Node("n646", {})
e = Edge("e8", start_node=self.n1, end_node=n, edge_type=EdgeType.UNDIRECTED)
g = self.graph - e
self.assertEqual(g.edges(), set([self.e1, self.e2]))
def setUp(self):
self.n1 = Node("a", {}) # b
self.n2 = Node("b", {}) # c
self.n3 = Node("f", {}) # d
self.n4 = Node("e", {}) # e
self.e1 = Edge("e1",
start_node=self.n1,
end_node=self.n4,
edge_type=EdgeType.UNDIRECTED)
self.e2 = Edge("e2",
start_node=self.n1,
end_node=self.n2,
edge_type=EdgeType.UNDIRECTED)
self.e3 = Edge("e3",
start_node=self.n1,
end_node=self.n3,
edge_type=EdgeType.UNDIRECTED)
self.e4 = Edge("e4",
start_node=self.n2,
end_node=self.n4,
edge_type=EdgeType.UNDIRECTED)
self.e5 = Edge("e5",
start_node=self.n3,
end_node=self.n4,
edge_type=EdgeType.UNDIRECTED)
# undirected graph
self.ugraph = Graph(
"g1",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.n1, self.n2, self.n3, self.n4]),
edges=set([self.e1, self.e2, self.e3, self.e4, self.e5]),
)
# make some directed edges
self.e6 = Edge("e6",
start_node=self.n1,
end_node=self.n3,
edge_type=EdgeType.DIRECTED)
self.e7 = Edge("e7",
start_node=self.n3,
end_node=self.n2,
edge_type=EdgeType.DIRECTED)
self.e8 = Edge("e8",
start_node=self.n3,
end_node=self.n4,
edge_type=EdgeType.DIRECTED)
self.e9 = Edge("e9",
start_node=self.n4,
end_node=self.n2,
edge_type=EdgeType.DIRECTED)
self.e10 = Edge("e10",
start_node=self.n4,
end_node=self.n1,
edge_type=EdgeType.DIRECTED)
self.dgraph = Graph(
"g1",
data={
"my": "graph",
"data": "is",
"very": "awesome"
},
nodes=set([self.n1, self.n2, self.n3, self.n4]),
edges=set([self.e6, self.e7, self.e8, self.e9, self.e10]),
)
self.path = Path(
gid="mpath",
data={},
edges=[self.e2, self.e4, self.e5],
)
# tree
self.a = Node("a")
self.b = Node("b")
self.c = Node("c")
self.d = Node("d")
self.e = Node("e")
self.f = Node("f")
self.g = Node("g")
self.h = Node("h")
self.j = Node("j")
self.k = Node("k")
self.m = Node("m")
#
# +--a --+
# | |
# b c
# | \
# +--+--+ g
# | | | |
# d e f h -- j
# |
# +--+---+
# | |
# k m
#
#
self.ab = Edge(edge_id="ab", start_node=self.a, end_node=self.b)
self.ac = Edge(edge_id="ac", start_node=self.a, end_node=self.c)
self.bd = Edge(edge_id="bd", start_node=self.b, end_node=self.d)
self.be = Edge(edge_id="be", start_node=self.b, end_node=self.e)
self.bf = Edge(edge_id="bf", start_node=self.b, end_node=self.f)
self.fk = Edge(edge_id="fk", start_node=self.f, end_node=self.k)
self.fm = Edge(edge_id="fm", start_node=self.f, end_node=self.m)
self.cg = Edge(edge_id="cg", start_node=self.c, end_node=self.g)
self.gh = Edge(edge_id="gh", start_node=self.g, end_node=self.h)
self.hj = Edge(edge_id="hj", start_node=self.h, end_node=self.j)
self.gtree = Graph.from_edgeset(edges=set([
self.ab,
self.ac,
self.bd,
self.be,
self.bf,
self.fk,
self.fm,
self.cg,
self.gh,
self.hj,
]), )
def test_union_v(self):
n = Node("n646", {})
e = Edge("e8", start_node=self.n1, end_node=n, edge_type=EdgeType.UNDIRECTED)
vset = self.graph.union(set([n]))
self.assertEqual(vset, set([self.n1, self.n2, self.n3, self.n4, n]))