def test_pred(self):
a = BNNode([], [])
b = BNNode([], [])
c = BNNode([], [])
l = [a,b,c]
ret = BN.pred(c, l)
self.assertEquals(a, ret[0])
self.assertEquals(b, ret[1])
def test_cartesian_product(self):
my_list = [[1,0],[1,0],[1,0]]
end_list = [(1,1,1),(1,1,0),(1,0,1),(0,1,1),(1,0,0),(0,0,1),(0,1,0),(0,0,0)]
c_list = BN.cartesian_product(my_list)
self.assertEquals(8, len(c_list))
for tup in end_list:
self.assertTrue(tup in c_list)
def test_match_counts(self):
child = BNNode([0,1], [1,0,1])
p1 = BNNode([0,1], [1,1,1])
p2 = BNNode([0,1], [1,1,0])
parents = [p1,p2]
counts = BN.match_counts(child, parents, [1,1])
self.assertEquals(1, counts[0])
self.assertEquals(1, counts[1])
p1 = BNNode([0,1], [0,0,0])
p2 = BNNode([0,1], [1,1,1])
child = BNNode([0,1], [0,0,0])
parents = [p1,p2]
counts = BN.match_counts(child, parents, [0,1])
self.assertEquals(3, counts[0])
self.assertEquals(0, counts[1])
def test_get_all_potential_values(self):
a = BNNode([0,1], [])
b = BNNode([0,1], [])
c = BNNode([0,1], [])
vals = BN.get_all_potential_values([a,b,c])
self.assertEquals(3, len(vals))
for val in vals:
self.assertEquals(0, val[0])
self.assertEquals(1, val[1])
def test_remove_parental_diff_from_pred(self):
a = BNNode([], [])
b = BNNode([], [])
c = BNNode([], [])
pred = [a,b,c]
node = BNNode([], [])
node.parents = [c]
new_pred = BN.remove_parental_diff_from_pred(node, pred)
self.assertEquals(2, len(new_pred))
self.assertEquals(True, new_pred[0] == a)
self.assertEquals(True, new_pred[1] == b)
def test_create_row_from_child_n_parents(self):
child = BNNode([0,1], [0,0,1])
p1 = BNNode([0,1], [1,0,1])
p2 = BNNode([0,1], [0,1,0])
parents = [p1,p2]
row1 = BN.create_row_from_child_n_parents(child, parents, 0)
self.assertEquals(True, BN.lists_match([1,0,0], row1))
row2 = BN.create_row_from_child_n_parents(child, parents, 1)
self.assertEquals(True, BN.lists_match([0,1,0], row2))
row3 = BN.create_row_from_child_n_parents(child, parents, 2)
self.assertEquals(True, BN.lists_match([1,0,1], row3))
def readBN(filename):
f = open(filename, 'r')
# 读取变量数
nums = int(f.readline())
f.readline()
# 读取变量名称
variables = f.readline()[:-1].split(' ')
f.readline()
# 读取有向图邻接表
graph = []
for i in range(nums):
line = f.readline()[:-1].split(' ')
graph.append(list(map(int, line)))
f.readline()
# 读取cpt表
# 注意，文件中数据格式必须完全按照指定要求，不可有多余的空行或空格
cpts = []
for i in range(nums):
probabilities = []
while True:
line = f.readline()[:-1].split(' ')
if line != ['']:
probabilities.append(list(map(float, line)))
else:
break
CPT = cpt(variables[i], [], probabilities)
cpts.append(CPT)
f.close()
# 根据邻接表为每个节点生成其父亲节点
# 注意，这里父亲节点的顺序是按照输入的variables的顺序排列的，不保证更换测试文件时的正确性
for i in range(nums):
for j in range(nums):
if graph[i][j] == 1:
cpts[j].parents.append(variables[i])
# 测试父节点生成情况
# for i in range(nums):
# print(cpts[i].parents)
bayesnet = BN(nums, variables, graph, cpts)
return bayesnet
from BN import BN
net = BN('test/test_example.bn')
print("Query: P(A|C=0)")
net.P("A|C=0")
print("\nQuery: P(A)")
net.P("A")
print("\nQuery: P(D)")
net.P("D")
print("\nQuery: P(A=fa,B=tr)")
net.P("A=fa,B=tr")
print("\nQuery: P(D=True|B=1, C=f)")
net.P("D=True|B=1, C=f")
def setUp(self):
self.net_alarm = BN('test/test_alarm.bn')
self.net_ex2 = BN('test/test_example.bn')
class TestBayesNet(unittest.TestCase):
def setUp(self):
self.net_alarm = BN('test/test_alarm.bn')
self.net_ex2 = BN('test/test_example.bn')
def test_parse(self):
# func(self)
# self.assert...(self, value)
pass
def test_normalize0(self):
inputs = [[0.00059224, 0.0014919]]
outputs = [(0.284165171, 0.715834828)]
for i1, i2 in enumerate(inputs):
res = self.net_alarm.normalize(i2)
self.assertAlmostEqual(res[0], outputs[i1][0])
self.assertAlmostEqual(res[1], outputs[i1][1])
def test_toposort0(self):
res = self.net_alarm.toposort()
self.assertEqual(res, ['B', 'E', 'A', 'J', 'M'])
def test_toposort1(self):
res = self.net_ex2.toposort()
self.assertEqual(res, ['A', 'B', 'C', 'D', 'E'])
def test_querygiven_alarm(self):
cases = [(('B', {
'B': False
}), .999), (('B', {
'B': True
}), .001), (('A', {
'A': True,
'B': True,
'E': False
}), .94), (('A', {
'A': False,
'B': False,
'E': True
}), .71), (('A', {
'A': False,
'B': False,
'E': False
}), .999), (('M', {
'M': False,
'A': False
}), .99)]
for i, o in cases:
self.assertAlmostEqual(self.net_alarm.querygiven(*i), o)
def test_querygiven_ex2(self):
cases = [(('A', {
'A': False
}), 0.7), (('B', {
'B': True
}), 0.6), (('E', {
'C': True,
'E': False
}), 0.3), (('D', {
'B': False,
'A': True,
'D': False
}), 0.2), (('D', {
'B': False,
'A': True,
'D': True
}), 0.8), (('C', {
'C': True,
'A': True
}), 0.8), (('C', {
'C': False,
'A': False
}), 0.6)]
for i, o in cases:
self.assertAlmostEqual(self.net_ex2.querygiven(*i), o)
def test_genpermutations(self):
cases = [0, 1, 2, 5]
for c in cases:
res = self.net_alarm.genpermutations(c)
for r in res:
self.assertEqual(len(r), c)
self.assertEqual(len(set(res)), len(res))
def test_makefactor0(self):
i = ('D', {'D': ['D', 'A']}, {'B': True})
o = (['A', 'D'], {
(True, True): 0.7,
(True, False): 0.30000000000000004,
(False, True): 0.1,
(False, False): 0.9
})
self.assertEqual(self.net_ex2.makefactor(*i), o)
def test_pointwise0(self):
i1 = (['C', 'E'], {
(False, False): 0.8,
(False, True): 0.2,
(True, True): 0.7,
(True, False): 0.3
})
i2 = (['A', 'C'], {
(True, True): 0.8,
(True, False): 0.2,
(False, True): 0.4,
(False, False): 0.6
})
o = (['A', 'C', 'E'], {
(False, True, True): 0.27999999999999997,
(False, False, False): 0.48,
(True, True, False): 0.24,
(True, False, False): 0.16000000000000003,
(False, True, False): 0.12,
(False, False, True): 0.12,
(True, True, True): 0.5599999999999999,
(True, False, True): 0.04000000000000001
})
self.assertEqual(self.net_ex2.pointwise('C', i1, i2), o)
def test_sumout0(self):
self.assertEqual(
self.net_ex2.sumout('D', [(['A', 'D'], {
(True, True): 0.7,
(True, False): 0.3,
(False, True): 0.1,
(False, False): 0.9
})]), [(['A'], {
(False, ): 1.0,
(True, ): 1.0
})])
def test_alarm_ask1(self):
inputs = [('B', {
'J': False,
'M': True
}), ('A', {
'B': True,
'E': False,
'J': True,
'M': True
}), ('M', {
'B': False,
'E': False
}), ('E', {
'B': True
}), ('E', {
'A': True,
'M': False
})]
outputs = [(0.9931, 0.0069), (0.0001, 0.9999), (0.9893, 0.0107),
(0.9980, 0.0020), (0.7690, 0.2310)]
for i, i1 in enumerate(inputs):
res = self.net_alarm.enum_ask(*i1)
self.assertEqual(round(res[0] - outputs[i][0], 3), 0)
self.assertEqual(round(res[1] - outputs[i][1], 3), 0)
res = self.net_alarm.elim_ask(*i1)
self.assertEqual(round(res[0] - outputs[i][0], 3), 0)
self.assertEqual(round(res[1] - outputs[i][1], 3), 0)
input2 = sys.argv[2]
graph = Graph()
if ".bn" in input1:
# it is Bayesian Network specification extension
fileBN = readBNFile(input1)
graph = fileBN.readfile(graph.graph)
if ".in" in input2:
fileIn = readINFile(input2)
q_variable = fileIn.readfile(graph)
else:
print("ERROR: wrong format")
# start algorithm
BN = BN(graph, q_variable)
sol = BN.run()
solution = sol[0][-1]
# the probability of the query being false (in case it has 2 evidence variables)
solution_1 = sol[pow(2, 2)][-1]
output = input1.replace(".bn", ".sol")
output = open(output, "w")
output.write("########## SOLUTION ##########\n")
output.write("QUERY " + str(fileIn.query) + "\n")
output.write("QUERY_DIST " + "T " + str(solution) + " F " + str(solution_1) + "\n")
def test_lists_match(self):
l1 = [0,1,2,3,4]
l2 = [0,1,2,3,4]
self.assertEquals(True, BN.lists_match([0,1,2,3,4], [0,1,2,3,4]))
self.assertEquals(False, BN.lists_match([1,2,3], [1]))
self.assertEquals(False, BN.lists_match([1,2,3], [1,2,4]))
nodes, data, classes = get_data()
# randomly permute the data
srt = range(0, len(data)-1)
shuffle(srt)
# make new_data from the permutation
new_data = []
new_classes = []
for index in srt:
new_data.append(data[index])
new_classes.append(classes[index])
# setup the network
for node in nodes:
BN.setup_node(node, nodes)
# initial confusion matrix
confusion = {'0':{'0':0, '1':0}, '1':{'0':0, '1':0}}
# do k-fold validation
total_count = 0
kfold = KFold(100, new_data, new_classes)
while kfold.has_next():
dat, cls = kfold.get_next()
correct_count = 0
for i in range(0, len(dat)):
row = dat[i]
guess = BNClassifier.classify(row, nodes, dat, cls, ['0', '1'])
