def generate_MAP_Ind_Simplification(graph, exp_var, explanadum, threshold):
"""A method that outputs MAP(Simplified MPE) using Independence-based simplification rule."""
MPE = generate_MPE(graph, exp_var, explanadum)
best_simplified_exp = []
key_set = {}
for (explanation, prob) in MPE:
ori_metric = graph.prob_given(explanadum, explanation)
lower_bound = ori_metric * (1 - threshold)
upper_bound = ori_metric * (1 + threshold)
simplified_space = []
keys = explanation.keys()
# Loop over all possible abductions of an explanation to find all simplifications
for i in range(len(explanation)):
for abduction in combination(i, keys):
# retrieve assignments from the explanation
abducted_assignment = {}
for var in abduction:
abducted_assignment[var] = explanation[var]
# test equivalence
if graph.prob_given(explanadum, abducted_assignment) >= lower_bound \
and graph.prob_given(explanadum, abducted_assignment) <= upper_bound:
simplified_space.append(abducted_assignment)
# find out the best simplification and its posterior probability
if not len(simplified_space) == 0:
cur_min = len(simplified_space[0])
candidates = []
for simplification in simplified_space:
if len(simplification) == cur_min:
candidates.append(simplification)
elif len(simplification) < cur_min:
candidates = [simplification]
cur_min = len(simplification)
min_imprecision = graph.prob_given(explanadum,
candidates[0]) - ori_metric
cur_best = candidates[0]
for candidate in candidates:
if graph.prob_given(explanadum,
candidate) - ori_metric < min_imprecision:
min_imprecision = graph.prob_given(explanadum,
candidate) - ori_metric
cur_best = candidate
if cur_best.__str__() not in key_set:
best_simplified_exp.append(
(cur_best, graph.prob_given(cur_best, explanadum)))
key_set[cur_best.__str__()] = 0
return sorted(best_simplified_exp, key=lambda x: -x[1])
def generate_MAP_Ind_Simplification(graph, exp_var, explanadum, threshold):
"""A method that outputs MAP(Simplified MPE) using Independence-based simplification rule."""
MPE = generate_MPE(graph, exp_var, explanadum)
best_simplified_exp = []
key_set = {}
for (explanation, prob) in MPE:
ori_metric = graph.prob_given(explanadum, explanation)
lower_bound = ori_metric * (1 - threshold)
upper_bound = ori_metric * (1 + threshold)
simplified_space = []
keys = explanation.keys()
# Loop over all possible abductions of an explanation to find all simplifications
for i in range(len(explanation)):
for abduction in combination(i, keys):
# retrieve assignments from the explanation
abducted_assignment = {}
for var in abduction:
abducted_assignment[var] = explanation[var]
# test equivalence
if (
graph.prob_given(explanadum, abducted_assignment) >= lower_bound
and graph.prob_given(explanadum, abducted_assignment) <= upper_bound
):
simplified_space.append(abducted_assignment)
# find out the best simplification and its posterior probability
if not len(simplified_space) == 0:
cur_min = len(simplified_space[0])
candidates = []
for simplification in simplified_space:
if len(simplification) == cur_min:
candidates.append(simplification)
elif len(simplification) < cur_min:
candidates = [simplification]
cur_min = len(simplification)
min_imprecision = graph.prob_given(explanadum, candidates[0]) - ori_metric
cur_best = candidates[0]
for candidate in candidates:
if graph.prob_given(explanadum, candidate) - ori_metric < min_imprecision:
min_imprecision = graph.prob_given(explanadum, candidate) - ori_metric
cur_best = candidate
if cur_best.__str__() not in key_set:
best_simplified_exp.append((cur_best, graph.prob_given(cur_best, explanadum)))
key_set[cur_best.__str__()] = 0
return sorted(best_simplified_exp, key=lambda x: -x[1])
test_tree = generate_causal_explanation_tree(lake_graph, lake_graph, ['Bird', 'Island'], {}, {'Pox':'T'}, [], 0.0001)
print test_tree
print "========================="
print "Testing Explanation Forest:"
forest = generate_CET_forest(lake_graph, lake_graph, ['Bird', 'Island'], {}, {'Pox':'T'}, [])
for tree in forest:
print tree
print "========================="
print "Testing scores calculations of different methods:"
print "BGF of [Island being true]: ", calculate_GBF( lake_graph, {"Island" : "T" }, {"Pox" : "T"} )
print "BGF of [Bird being true, Island being false]: ", calculate_GBF( lake_graph, {"Island" : "T", "Bird" : "T" }, {"Pox" : "T"} )
print "ET score of [Island being true], which is essentially posterior probability of the explanation given explanadum : ", calculate_ET_score( lake_graph, {"Island" : "T"}, {"Pox" : "T"})
print "CET score of [Island being true]", calculate_CET_score( lake_graph, {"Island" : "T"}, {}, {"Pox" : "T"}) #The empty hash is for Observation
print "========================="
print "Testing MPE:"
MRE = generate_MPE(lake_graph, ['Bird', 'Island'], {'Pox':'T'})
for x in MRE:
print x
print "========================="
print "Testing MAP:"
MRE = generate_MAP_Ind_Simplification(lake_graph, ['Bird', 'Island'], {'Pox':'T'}, 0.1)
for x in MRE:
print x
print "========================="
print "========================="
print "Testing scores calculations of different methods:"
print "BGF of [Island being true]: ", calculate_GBF(lake_graph,
{"Island": "T"},
{"Pox": "T"})
print "BGF of [Bird being true, Island being false]: ", calculate_GBF(
lake_graph, {
"Island": "T",
"Bird": "T"
}, {"Pox": "T"})
print "ET score of [Island being true], which is essentially posterior probability of the explanation given explanadum : ", calculate_ET_score(
lake_graph, {"Island": "T"}, {"Pox": "T"})
print "CET score of [Island being true]", calculate_CET_score(
lake_graph, {"Island": "T"}, {},
{"Pox": "T"}) #The empty hash is for Observation
print "========================="
print "Testing MPE:"
MRE = generate_MPE(lake_graph, ['Bird', 'Island'], {'Pox': 'T'})
for x in MRE:
print x
print "========================="
print "Testing MAP:"
MRE = generate_MAP_Ind_Simplification(lake_graph, ['Bird', 'Island'],
{'Pox': 'T'}, 0.1)
for x in MRE:
print x
print "========================="
def fill_in_csv(graph, exp_var, explanadum, path = "temp.csv", lake = 0):
# Assume for now that the codes in csv use the some scheme as implied
# by this script
assignments = []
code_hash = encode_nodes_to_hash([graph.variables[name] for name in exp_var])
MPE_space = generate_MPE(graph, exp_var, explanadum)
MAP_threshold = 0.1
MAP_space = generate_MAP_Ind_Simplification(graph, exp_var, explanadum, MAP_threshold)
MRE_space = generate_MRE(graph, exp_var, explanadum)
alpha = 0.01
beta = 0.2
ET = generate_explanation_tree(graph, exp_var, explanadum, [], alpha, beta)
ET_space = sorted(ET.assignment_space(), key = lambda x: -x[1])
ET_score_space = sorted(
[(code_hash[key], calculate_ET_score(graph, code_hash[key], explanadum)) for key in code_hash.keys() if len(code_hash[key])],
key = lambda x: -x[1])
# print ET_score_space
alpha_CET = 0.0001
CET = generate_causal_explanation_tree(graph, graph, exp_var, {}, explanadum, [], alpha_CET)
# print "Printing cet", CET
CET_space = sorted(CET.assignment_space(), key = lambda x: -x[1])
CET_score_space = sorted(
[(code_hash[key], calculate_CET_score(graph, code_hash[key], {}, explanadum)) for key in code_hash.keys() if len(code_hash[key])],
key = lambda x: -x[1] if not math.isnan(x[1]) else 9999999999999)
# print CET_score_space
with open(path, 'r') as csvfile:
reader = csv.reader(csvfile, dialect = 'excel')
for row in reader:
processed_code = join([row[0][i] for i in range(len(exp_var))], "")
assignments.append((row[0], code_hash[processed_code]))
# print assignments
with open(path, 'w') as csvfile:
writer = csv.writer(csvfile, dialect = 'excel')
writer.writerow(["CondensedString","MPE_rank","MPE_score","MAP_I_rank","MAP_I_score","MAP_I_para_theta","MRE_rank","MRE_score","ET_rank_for_tree","ET_rank_for_score","ET_score","ET_leaf","ET_ALPHA","ET_BETA","CET_rank_for_tree","CET_rank_for_score","CET_score","CET_leaf","CET_ALPHA"])
for code, assignment in assignments:
row = ['"' + code + '"']
# escape all empty explanations
# and all invalid assignemnts for lake.py
print lake, code[2] != '9', code[3] != '9'
if (not len(assignment)) or (lake and (code[2] != '9' or code[3] != '9')):
print "escaping"
row += ["NaN" for _ in range(18)]
writer.writerow(row)
continue
rank = space_rank(MPE_space, assignment)
if rank:
row.append(rank)# MPE rank
row.append(MPE_space[int(rank) - 1][1]) # MPE score
else:
row.append("NaN")
row.append("NaN")
rank = space_rank(MAP_space, assignment)
if rank:
row.append(rank)# map rank
row.append(MAP_space[int(rank) - 1][1]) # MAP score
else:
row.append("NaN")
row.append("NaN")
row.append(MAP_threshold)
rank = space_rank(MRE_space, assignment)
if rank:
row.append(rank)# mre rank
row.append(MRE_space[int(rank) - 1][1]) # MRE score
else:
row.append("NaN")
row.append("NaN")
rank = space_rank(ET_space, assignment)
if rank:
row.append(rank)# et tree rank
else:
row.append("NaN")
rank = space_rank(ET_score_space, assignment)
# print code, assignment, rank, ET_score_space[int(rank) - 1][1]
if rank:
row.append(rank) # et score rank
row.append(ET_score_space[int(rank) - 1][1]) # ET score
else:
row.append("ERROR ! should not happen") #should not happen
row += [1] if ET.is_leaf(assignment) else [0]
row.append(alpha)
row.append(beta)
rank = space_rank(CET_space, assignment)
if rank:
row.append(rank)# et tree rank
else:
row.append("NaN")
rank = space_rank(CET_score_space, assignment)
if rank:
row.append(rank) # et score rank
row.append(CET_score_space[int(rank) - 1][1]) # ET score
else:
row.append("ERROR ! should not happen") #should not happen
# print "determining leaf for", code
row += [1] if CET.is_leaf(assignment) else [0]
row.append(alpha_CET)
writer.writerow(row)
def fill_in_csv(graph, exp_var, explanadum, path="temp.csv", lake=0):
# Assume for now that the codes in csv use the some scheme as implied
# by this script
assignments = []
code_hash = encode_nodes_to_hash(
[graph.variables[name] for name in exp_var])
MPE_space = generate_MPE(graph, exp_var, explanadum)
MAP_threshold = 0.1
MAP_space = generate_MAP_Ind_Simplification(graph, exp_var, explanadum,
MAP_threshold)
MRE_space = generate_MRE(graph, exp_var, explanadum)
alpha = 0.01
beta = 0.2
ET = generate_explanation_tree(graph, exp_var, explanadum, [], alpha, beta)
ET_space = sorted(ET.assignment_space(), key=lambda x: -x[1])
ET_score_space = sorted([
(code_hash[key], calculate_ET_score(graph, code_hash[key], explanadum))
for key in code_hash.keys() if len(code_hash[key])
],
key=lambda x: -x[1])
# print ET_score_space
alpha_CET = 0.0001
CET = generate_causal_explanation_tree(graph, graph, exp_var, {},
explanadum, [], alpha_CET)
# print "Printing cet", CET
CET_space = sorted(CET.assignment_space(), key=lambda x: -x[1])
CET_score_space = sorted(
[(code_hash[key],
calculate_CET_score(graph, code_hash[key], {}, explanadum))
for key in code_hash.keys() if len(code_hash[key])],
key=lambda x: -x[1] if not math.isnan(x[1]) else 9999999999999)
# print CET_score_space
with open(path, 'r') as csvfile:
reader = csv.reader(csvfile, dialect='excel')
for row in reader:
processed_code = join([row[0][i] for i in range(len(exp_var))], "")
assignments.append((row[0], code_hash[processed_code]))
# print assignments
with open(path, 'w') as csvfile:
writer = csv.writer(csvfile, dialect='excel')
writer.writerow([
"CondensedString", "MPE_rank", "MPE_score", "MAP_I_rank",
"MAP_I_score", "MAP_I_para_theta", "MRE_rank", "MRE_score",
"ET_rank_for_tree", "ET_rank_for_score", "ET_score", "ET_leaf",
"ET_ALPHA", "ET_BETA", "CET_rank_for_tree", "CET_rank_for_score",
"CET_score", "CET_leaf", "CET_ALPHA"
])
for code, assignment in assignments:
row = ['"' + code + '"']
# escape all empty explanations
# and all invalid assignemnts for lake.py
print lake, code[2] != '9', code[3] != '9'
if (not len(assignment)) or (lake and
(code[2] != '9' or code[3] != '9')):
print "escaping"
row += ["NaN" for _ in range(18)]
writer.writerow(row)
continue
rank = space_rank(MPE_space, assignment)
if rank:
row.append(rank) # MPE rank
row.append(MPE_space[int(rank) - 1][1]) # MPE score
else:
row.append("NaN")
row.append("NaN")
rank = space_rank(MAP_space, assignment)
if rank:
row.append(rank) # map rank
row.append(MAP_space[int(rank) - 1][1]) # MAP score
else:
row.append("NaN")
row.append("NaN")
row.append(MAP_threshold)
rank = space_rank(MRE_space, assignment)
if rank:
row.append(rank) # mre rank
row.append(MRE_space[int(rank) - 1][1]) # MRE score
else:
row.append("NaN")
row.append("NaN")
rank = space_rank(ET_space, assignment)
if rank:
row.append(rank) # et tree rank
else:
row.append("NaN")
rank = space_rank(ET_score_space, assignment)
# print code, assignment, rank, ET_score_space[int(rank) - 1][1]
if rank:
row.append(rank) # et score rank
row.append(ET_score_space[int(rank) - 1][1]) # ET score
else:
row.append("ERROR ! should not happen") #should not happen
row += [1] if ET.is_leaf(assignment) else [0]
row.append(alpha)
row.append(beta)
rank = space_rank(CET_space, assignment)
if rank:
row.append(rank) # et tree rank
else:
row.append("NaN")
rank = space_rank(CET_score_space, assignment)
if rank:
row.append(rank) # et score rank
row.append(CET_score_space[int(rank) - 1][1]) # ET score
else:
row.append("ERROR ! should not happen") #should not happen
# print "determining leaf for", code
row += [1] if CET.is_leaf(assignment) else [0]
row.append(alpha_CET)
writer.writerow(row)
