def test_str():
entry1 = PotentialEntry().add(0, 'on').add(1, 'on')
entry2 = PotentialEntry().add(0, 'on').add(1, 'off')
entry3 = PotentialEntry().add(0, 'off').add(1, 'on')
entry4 = PotentialEntry().add(0, 'off').add(1, 'off')
potential = Potential() \
.add_entry(entry1) \
.add_entry(entry2) \
.add_entry(entry3) \
.add_entry(entry4)
assert potential.__str__(
) == '0=on,1=on|1.0\n0=on,1=off|1.0\n0=off,1=on|1.0\n0=off,1=off|1.0'
def test_str():
"""
Tests str function.
:return: None.
"""
entry1 = PotentialEntry().add(0, 'on').add(1, 'on')
entry2 = PotentialEntry().add(0, 'on').add(1, 'off')
entry3 = PotentialEntry().add(0, 'off').add(1, 'on')
entry4 = PotentialEntry().add(0, 'off').add(1, 'off')
potential = Potential() \
.add_entry(entry1) \
.add_entry(entry2) \
.add_entry(entry3) \
.add_entry(entry4)
assert potential.__str__(
) == '0=on,1=on|1.0\n0=on,1=off|1.0\n0=off,1=on|1.0\n0=off,1=off|1.0'
def test_potential_get_matching_entry():
entry1 = PotentialEntry().add(0, 'on').add(1, 'on')
entry2 = PotentialEntry().add(0, 'on').add(1, 'off')
entry3 = PotentialEntry().add(0, 'off').add(1, 'on')
entry4 = PotentialEntry().add(0, 'off').add(1, 'off')
entry5 = PotentialEntry().add(3, 'off').add(1, 'off')
potential = Potential()\
.add_entry(entry1)\
.add_entry(entry2)\
.add_entry(entry3)\
.add_entry(entry4)
assert len(potential.get_matching_entries(entry1)) == 1
assert len(potential.get_matching_entries(entry2)) == 1
assert len(potential.get_matching_entries(entry3)) == 1
assert len(potential.get_matching_entries(entry4)) == 1
assert len(potential.get_matching_entries(entry5)) == 0
def test_reapply():
"""
Tests reinitializing join tree after updating CPTs.
:return: None.
"""
a = BbnNode(Variable(0, 'a', ['t', 'f']), [0.2, 0.8])
b = BbnNode(Variable(1, 'b', ['t', 'f']), [0.1, 0.9, 0.9, 0.1])
bbn = Bbn().add_node(a).add_node(b) \
.add_edge(Edge(a, b, EdgeType.DIRECTED))
lhs = InferenceController.apply(bbn)
rhs = InferenceController.reapply(lhs, {
0: [0.3, 0.7],
1: [0.2, 0.8, 0.8, 0.2]
})
lhs_pot = [lhs.get_bbn_potential(n) for n in lhs.get_bbn_nodes()]
rhs_pot = [rhs.get_bbn_potential(n) for n in rhs.get_bbn_nodes()]
lhs_d = Potential.to_dict(lhs_pot)
rhs_d = Potential.to_dict(rhs_pot)
# lhs should not match rhs after CPT update
for k, prob in lhs_d.items():
assert k in rhs_d
assert prob != rhs_d[k]
# now create lhs with same params as param used to update old
# should match with rhs since params are now the same
a = BbnNode(Variable(0, 'a', ['t', 'f']), [0.3, 0.7])
b = BbnNode(Variable(1, 'b', ['t', 'f']), [0.2, 0.8, 0.8, 0.2])
bbn = Bbn().add_node(a).add_node(b) \
.add_edge(Edge(a, b, EdgeType.DIRECTED))
lhs = InferenceController.apply(bbn)
lhs_pot = [lhs.get_bbn_potential(n) for n in lhs.get_bbn_nodes()]
lhs_d = Potential.to_dict(lhs_pot)
for k, prob in lhs_d.items():
assert k in rhs_d
assert_almost_equals(prob, rhs_d[k], 0.001)
def get_evidence(self, node, value):
"""
Gets the evidence associated with the specified BBN node and value.
:param node: BBN node.
:param value: Value.
:return: Potential (the evidence).
"""
if node.id not in self.evidences:
self.evidences[node.id] = dict()
if value not in self.evidences[node.id]:
entry = PotentialEntry()
entry.add(node.id, value)
entry.value = 1.0
potential = Potential()
potential.add_entry(entry)
self.evidences[node.id][value] = potential
return self.evidences[node.id][value]
def test_potential_get_matching_entry():
"""
Tests get matching entry from potential.
:return: None.
"""
entry1 = PotentialEntry().add(0, 'on').add(1, 'on')
entry2 = PotentialEntry().add(0, 'on').add(1, 'off')
entry3 = PotentialEntry().add(0, 'off').add(1, 'on')
entry4 = PotentialEntry().add(0, 'off').add(1, 'off')
entry5 = PotentialEntry().add(3, 'off').add(1, 'off')
potential = Potential() \
.add_entry(entry1) \
.add_entry(entry2) \
.add_entry(entry3) \
.add_entry(entry4)
assert len(potential.get_matching_entries(entry1)) == 1
assert len(potential.get_matching_entries(entry2)) == 1
assert len(potential.get_matching_entries(entry3)) == 1
assert len(potential.get_matching_entries(entry4)) == 1
assert len(potential.get_matching_entries(entry5)) == 0
def test_simple_serde():
"""
Tests join tree serde with only 1 clique.
:return: None.
"""
a = BbnNode(Variable(0, 'a', ['t', 'f']), [0.2, 0.8])
b = BbnNode(Variable(1, 'b', ['t', 'f']), [0.1, 0.9, 0.9, 0.1])
bbn = Bbn().add_node(a).add_node(b) \
.add_edge(Edge(a, b, EdgeType.DIRECTED))
lhs = InferenceController.apply(bbn)
d = JoinTree.to_dict(lhs)
rhs = JoinTree.from_dict(d)
rhs = InferenceController.apply_from_serde(rhs)
lhs_pot = [lhs.get_bbn_potential(n) for n in lhs.get_bbn_nodes()]
rhs_pot = [rhs.get_bbn_potential(n) for n in rhs.get_bbn_nodes()]
lhs_pot = Potential.to_dict(lhs_pot)
rhs_pot = Potential.to_dict(rhs_pot)
assert len(lhs_pot) == len(rhs_pot)
def test_forest_inference():
"""
Tests inference on a disconnected DAG; sub-DAGs are a -> b, c -> d and e -> f.
:return: None.
"""
a = BbnNode(Variable(0, 'a', ['t', 'f']), [0.2, 0.8])
b = BbnNode(Variable(1, 'b', ['t', 'f']), [0.1, 0.9, 0.9, 0.1])
c = BbnNode(Variable(2, 'c', ['t', 'f']), [0.2, 0.8])
d = BbnNode(Variable(3, 'd', ['t', 'f']), [0.1, 0.9, 0.9, 0.1])
e = BbnNode(Variable(4, 'e', ['t', 'f']), [0.2, 0.8])
f = BbnNode(Variable(5, 'f', ['t', 'f']), [0.1, 0.9, 0.9, 0.1])
bbn = Bbn().add_node(a).add_node(b).add_node(c).add_node(d).add_node(e).add_node(f) \
.add_edge(Edge(a, b, EdgeType.DIRECTED)) \
.add_edge(Edge(c, d, EdgeType.DIRECTED)) \
.add_edge(Edge(e, f, EdgeType.DIRECTED))
jt = InferenceController.apply(bbn)
pot = [jt.get_bbn_potential(n) for n in jt.get_bbn_nodes()]
o = Potential.to_dict(pot)
e = {
'0=t': 0.2,
'0=f': 0.8,
'1=t': 0.7400000000000001,
'1=f': 0.26,
'2=t': 0.2,
'2=f': 0.8,
'3=t': 0.7400000000000001,
'3=f': 0.26,
'4=t': 0.2,
'4=f': 0.8,
'5=t': 0.7400000000000001,
'5=f': 0.26
}
for k, p in e.items():
assert_almost_equals(p, o[k], 0.001)
def test_from_dict():
"""
Tests deserializing from dictionary.
:return:
"""
s = """{
"bbn_nodes": {
"0": {
"probs": [
0.2,
0.8
],
"variable": {
"id": 0,
"name": "n0",
"values": [
"t",
"f"
]
}
},
"1": {
"probs": [
0.9,
0.1,
0.9,
0.1
],
"variable": {
"id": 1,
"name": "n1",
"values": [
"t",
"f"
]
}
},
"2": {
"probs": [
0.6,
0.4,
0.4,
0.6
],
"variable": {
"id": 2,
"name": "n2",
"values": [
"t",
"f"
]
}
}
},
"jt": {
"edges": [
"0-1-1-1-2"
],
"nodes": {
"0-1": {
"node_ids": [
0,
1
],
"type": "clique"
},
"0-1-1-1-2": {
"left": "0-1",
"right": "1-2",
"type": "sepset"
},
"1-2": {
"node_ids": [
1,
2
],
"type": "clique"
}
},
"parent_info": {
"0": [],
"1": [
0
],
"2": [
1
]
}
}
}"""
d = json.loads(s)
lhs = JoinTree.from_dict(d)
lhs = InferenceController.apply_from_serde(lhs)
n0 = BbnNode(Variable(0, 'n0', ['t', 'f']), [0.2, 0.8])
n1 = BbnNode(Variable(1, 'n1', ['t', 'f']), [0.9, 0.1, 0.9, 0.1])
n2 = BbnNode(Variable(2, 'n2', ['t', 'f']), [0.6, 0.4, 0.4, 0.6])
bbn = Bbn().add_node(n0).add_node(n1).add_node(n2) \
.add_edge(Edge(n0, n1, EdgeType.DIRECTED)) \
.add_edge(Edge(n1, n2, EdgeType.DIRECTED))
rhs = InferenceController.apply(bbn)
lhs_pot = [lhs.get_bbn_potential(n) for n in lhs.get_bbn_nodes()]
rhs_pot = [rhs.get_bbn_potential(n) for n in rhs.get_bbn_nodes()]
lhs_pot = Potential.to_dict(lhs_pot)
rhs_pot = Potential.to_dict(rhs_pot)
assert len(lhs_pot) == len(rhs_pot)
for k, p in lhs_pot.items():
assert_almost_equals(p, rhs_pot[k], 0.001)