def test_scope_expand3(self):
tree1 = pt_utils.parse("X( a, ->(b, c))")
tree2 = pt_utils.parse("X( a, +(b, c))")
# log = create_event_log("ebf")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
align = [{'alignment': [(('t_e_0', '>>'), ('e', '>>')), (('>>', '1_s'), ('>>', '1_s')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '4_s'), ('>>', '4_s')),
(('t_b_1', 'b'), ('b', 'b')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '5_s'), ('>>', '5_s')), (('>>', 'c'), ('>>', 'c')),
(('>>', '5_e'), ('>>', '5_e')), (('>>', '3_e'), ('>>', '3_e')),
(('>>', '1_e'), ('>>', '1_e')), (('t_f_2', '>>'), ('f', '>>'))],
'cost': 12, 'visited_states': 22, 'queued_states': 27, 'traversed_arcs': 27,
'fitness': 0.2941176470588235}]
s_align = se_rd_lock.apply_with_lock(align, tree1, tree2)
g_s_align = se_rd_lock_general.apply(align, tree1, tree2, self.parameters)
e_s_align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '3_s'), ('>>', '3_s')),
(('t_e_0', '>>'), ('e', '>>')), (('>>', '4_s'), ('>>', '4_s')),
(('t_b_1', 'b'), ('b', 'b')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '5_s'), ('>>', '5_s')), (('>>', 'c'), ('>>', 'c')),
(('>>', '5_e'), ('>>', '5_e')), (('t_f_2', '>>'), ('f', '>>')),
(('>>', '3_e'), ('>>', '3_e')), (('>>', '1_e'), ('>>', '1_e'))],
'cost': 12, 'visited_states': 22, 'queued_states': 27,
'traversed_arcs': 27, 'fitness': 0.2941176470588235}]
self.assertEqual(str(s_align), str(e_s_align))
self.assertEqual(str(g_s_align), str(e_s_align))
def test_align_repair4(self):
tree1 = pt_utils.parse("->( a, +(b, c)) ")
tree2 = pt_utils.parse("->( a, X(b, c))")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
log = utils.create_event_log("abdc")
alignments = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '3_tau_1'), ('>>', None)),
(('>>', '4_s'), ('>>', '4_s')), (('>>', '5_s'), ('>>', '5_s')),
(('t_b_1', 'b'), ('b', 'b')), (('t_d_2', '>>'), ('d', '>>')),
(('t_c_3', 'c'), ('c', 'c')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '5_e'), ('>>', '5_e')), (('>>', '3_tau_2'), ('>>', None)),
(('>>', '3_e'), ('>>', '3_e')), (('>>', '1_e'), ('>>', '1_e'))],
'cost': 5, 'visited_states': 18, 'queued_states': 37, 'traversed_arcs': 38,
'fitness': 0.8076923076923077}]
a_repair = ar_lock.apply(tree1, tree2, log, alignments, self.parameters)
exp_a_repair = [{'alignment': [],
'cost': 10, 'visited_states': 18, 'queued_states': 37, 'traversed_arcs': 38,
'fitness': 1 - 10 / (20 + 4)}]
# l_alignments = [{'alignment': [('>>', '1_s'), ('>>', '2_s'), ('a', 'a'), ('>>', '2_e'), ('>>', None),
# ('>>', '3_s'), ('>>', '4_s'), ('b', 'b'), ('>>', '4_e'), ('d', '>>'),
# ('>>', '5_s'), ('c', 'c'), ('>>', '5_e'), ('>>', '3_e'), ('>>', None),
# ('>>', '1_e')], 'cost': 5, 'visited_states': 7, 'queued_states': 14,
# 'traversed_arcs': 14, 'fitness': 0.8076923076923077}]
# l_a_repair = repair_alignment.apply(tree1, tree2, log, l_alignments, self.parameters_tuple_false)
# exp_l_a_repair = [{'alignment': [('>>', '1_s'), ('>>', '2_s'), ('a', 'a'), ('>>', '2_e'), ('>>', None),
# ('>>', '6_s'), ('>>', '8_s'), ('b', '>>'), ('d', '>>'), ('c', 'c'),
# ('>>', '8_e'), ('>>', '6_e'), ('>>', None), ('>>', '1_e')], 'cost': 10,
# 'visited_states': 6, 'queued_states': 6, 'traversed_arcs': 5,
# 'fitness': 0.5833333333333333}]
for i in range(len(alignments)):
self.assertEqual(a_repair[i]["cost"], exp_a_repair[i]["cost"])
self.assertEqual(a_repair[i]["fitness"], exp_a_repair[i]["fitness"])
def compute_align_grade(num, version, option, file):
mp_trees = pd.read_excel(m_tree_file, sheet_name=SHEET_NAME)
# logs = pd.read_excel(log_file, sheet_name=SHEET_NAME)
align_result = list()
for i in mp_trees:
# log_list = logs[i]['log'].tolist()
log_list = pd.read_csv(PATH + '/0.2/log' + i + ".csv")['log'].tolist()
tree_list = mp_trees[i]['tree'].tolist()
mpt_list = mp_trees[i]['m_tree'].tolist()
align_info = pd.DataFrame(columns=[
"optimal time", "optimal cost", "repair align time",
"repair align cost", "grade"
])
for j, m_tree in enumerate(mpt_list):
m_tree = pt_utils.parse(m_tree)
tree = pt_utils.parse(tree_list[j])
log = create_event_log(log_list[j // num])
align_info.loc[len(align_info.index)] = apply_align_on_one_pt(
tree, m_tree, log, version, option)
align_result.append(align_info)
return
with pd.ExcelWriter(file) as writer:
for i, align in enumerate(align_result):
align.to_excel(writer, sheet_name=SHEET_NAME[i], index=False)
def test_compare_diff_tree_option2(self):
result = PTUtilsTest.compare_diff_tree(" +( ->( j, k ), a, b )",
" +( a, ->( j, k ), b )", 2)
self.assertTrue(result.value)
result = PTUtilsTest.compare_diff_tree(" *( *( j, k , τ), a, b )",
" *( a, ->( j, k ), b )", 2)
self.assertFalse(result.value)
self.assertEqual(str(result.subtree1), str(pt_utils.parse("*( *( j, k , τ), a, b )")))
self.assertEqual(str(result.subtree2), str(pt_utils.parse("*( a, ->( j, k ), b )")))
result = PTUtilsTest.compare_diff_tree(" +( *( j, k, τ ), a )",
" +( a, ->( j, k ), b )", 2)
self.assertFalse(result.value)
self.assertEqual(str(result.subtree1), str(pt_utils.parse("+( *( j, k, τ ), a )")))
self.assertEqual(str(result.subtree2), str(pt_utils.parse("+( a, ->( j, k ), b )")))
result = PTUtilsTest.compare_diff_tree(" +( ->( j, k ), a, X(c, d) )",
" +( a, ->( j, k ), b )", 2)
self.assertFalse(result.value)
self.assertEqual(str(result.subtree1), str(pt_utils.parse("+( ->( j, k ), a, X(c, d) )")))
self.assertEqual(str(result.subtree2), str(pt_utils.parse("+( a, ->( j, k ), b )")))
result = PTUtilsTest.compare_diff_tree("X( a, *( b, f, τ ), X( g, h ) ) ",
"X( a, *( b, f, τ ), +( g, h ) ) ", 2)
self.assertEqual(str(result.subtree1), str(pt_utils.parse("X( a, *( b, f, τ ), X( g, h ) )")))
self.assertEqual(str(result.subtree2), str(pt_utils.parse("X( a, *( b, f, τ ), +( g, h ) )")))
result = PTUtilsTest.compare_diff_tree("->( a, *( ->( *( b, +( c, d ) ), e ), f, τ )) ",
"->( a, *( ->( *( b, X( c, d ) ), e ), f, τ )) ", 2)
self.assertEqual(str(result.subtree1), str(pt_utils.parse("*( b, +( c, d ) )")))
self.assertEqual(str(result.subtree2), str(pt_utils.parse("*( b, X( c, d ) )")))
def test_compute_cost_time(parameters):
tree1 = pt_utils.parse("->( a, *( *( c, X( d, e ), τ ), b, τ ) )")
tree2 = pt_utils.parse("->( a, *( *( τ, X( d, e ), τ ), b, τ ) )")
log = create_event_log("chcb")
result = compute_cost_and_time(tree1, tree2, log, parameters)
print_tree_align_compare(result)
def test_align_repair2(self):
tree1 = pt_utils.parse("X( a, ->(b, c)) ")
tree2 = pt_utils.parse("X( τ, ->(b, c))")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
log = utils.create_event_log("")
alignments = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('>>', 'a'), ('>>', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '1_e'), ('>>', '1_e'))],
'cost': 2, 'visited_states': 6, 'queued_states': 6, 'traversed_arcs': 6, 'fitness': 0.0}]
a_repair = ar_lock.apply(tree1, tree2, log, alignments, self.parameters)
exp_a_repair = [{'alignment': [(('>>', '6_s'), ('>>', '6_s')), (('>>', '7_s'), ('>>', '7_s')),
(('t_a_0', 'a'), ('>>', None)), (('>>', '7_e'), ('>>', '7_e')),
(('>>', '6_e'), ('>>', '6_e'))],
'cost': 0, 'visited_states': 9, 'queued_states': 13, 'traversed_arcs': 13,
'fitness': 1}]
# l_alignments = [
# {'alignment': [('>>', '1_s'), ('>>', '2_s'), ('>>', 'a'), ('>>', '2_e'), ('>>', '1_e')], 'cost': 2,
# 'visited_states': 2, 'queued_states': 2, 'traversed_arcs': 2, 'fitness': 0.0}]
#
# l_a_repair = repair_alignment.apply(tree1, tree2, log, l_alignments, self.parameters_tuple_false)
# exp_l_a_repair = [
# {'alignment': [('>>', '6_s'), ('>>', '7_s'), ('>>', None), ('>>', '7_e'), ('>>', '6_e')], 'cost': 0,
# 'visited_states': 2, 'queued_states': 2, 'traversed_arcs': 2, 'fitness': 1}]
for i in range(len(alignments)):
self.assertEqual(list(map(lambda x: x[1], a_repair[i]["alignment"])),
list(map(lambda x: x[1], exp_a_repair[i]["alignment"])))
self.assertEqual(a_repair[i]["cost"], exp_a_repair[i]["cost"])
self.assertEqual(a_repair[i]["fitness"], exp_a_repair[i]["fitness"])
def test_scope_expand2(self):
tree1 = pt_utils.parse("+( a, ->(b, c))")
tree2 = pt_utils.parse("+( a, X(b, c))")
# log = create_event_log("bac")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '1_tau_1'), ('>>', None)),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '2_s'), ('>>', '2_s')),
(('>>', '4_s'), ('>>', '4_s')), (('t_b_0', 'b'), ('b', 'b')),
(('>>', '4_e'), ('>>', '4_e')), (('>>', '5_s'), ('>>', '5_s')),
(('t_a_1', 'a'), ('a', 'a')), (('t_c_2', 'c'), ('c', 'c')),
(('>>', '5_e'), ('>>', '5_e')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_e'), ('>>', '3_e')), (('>>', '1_tau_2'), ('>>', None)),
(('>>', '1_e'), ('>>', '1_e'))], 'cost': 0, 'visited_states': 24,
'queued_states': 57, 'traversed_arcs': 64, 'fitness': 1}]
s_align = se_rd_lock.apply_with_lock(align, tree1, tree2)
g_s_align = se_rd_lock_general.apply(align, tree1, tree2, self.parameters)
e_s_align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '3_s'), ('>>', '3_s')),
(('>>', '1_tau_1'), ('>>', None)), (('>>', '2_s'), ('>>', '2_s')),
(('>>', '4_s'), ('>>', '4_s')), (('t_b_0', 'b'), ('b', 'b')),
(('>>', '4_e'), ('>>', '4_e')), (('>>', '5_s'), ('>>', '5_s')),
(('t_a_1', 'a'), ('a', 'a')), (('t_c_2', 'c'), ('c', 'c')),
(('>>', '5_e'), ('>>', '5_e')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '1_tau_2'), ('>>', None)), (('>>', '3_e'), ('>>', '3_e')),
(('>>', '1_e'), ('>>', '1_e'))], 'cost': 0, 'visited_states': 24,
'queued_states': 57, 'traversed_arcs': 64, 'fitness': 1}]
self.assertEqual(str(s_align), str(e_s_align))
self.assertEqual(str(g_s_align), str(e_s_align))
def operator_analyse():
from repair_alignment.process_tree.operation import pt_compare
from pm4py.objects.process_tree.pt_operator import Operator
opt, labels = [0, 0, 0, 0], ["Xor", "Sequence", "Parallel", "Loop"]
for i in [(11, 15), (16, 18), (19, 21), (22, 24)]:
sn = str(i[0]) + "-" + str(i[1])
data = pd.read_excel(PATH + "MProcessTree.xlsx", sheet_name=sn, header=0)
grade = pd.read_excel(PATH + "iar.xlsx", sheet_name=sn, header=0)['grade'].tolist()
trees = data['tree']
m_trees = data['m_tree']
for index in range(len(grade)):
com_res = pt_compare.apply(pt_utils.parse(trees[index]), pt_utils.parse(m_trees[index]))
if grade[index] != 1 and com_res.subtree1.parent is not None:
if com_res.subtree1.parent.operator == Operator.XOR:
opt[0] += 1
if com_res.subtree1.parent.operator == Operator.SEQUENCE:
opt[1] += 1
if com_res.subtree1.parent.operator == Operator.PARALLEL:
opt[2] += 1
if com_res.subtree1.parent.operator == Operator.LOOP:
opt[3] += 1
df = pd.DataFrame({"Ratio of Operators": opt}, index=["Xor", "Sequence", "Parallel", "Loop"])
df.plot.pie(subplots=True, colors=palette, figsize=(5, 5), autopct='%.0f%%')
import matplotlib.pyplot as plt
# explode = (0.1, 0) # only "explode" the 2nd slice (i.e. 'Hogs')
# plt.pie(opt, labels=labels, autopct='%1.01f%%', startangle=90, pattern="muted")
plt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.
plt.show()
plt.savefig(PATH + "../figure/ParentOperatorAnalyse.png", dpi=300)
def test_pt_depth(self):
tree = pt_utils.parse("a")
self.assertEqual(1, pt_mani_utils.pt_depth(tree))
tree = pt_utils.parse("X(a, b)")
self.assertEqual(2, pt_mani_utils.pt_depth(tree))
tree = pt_utils.parse("X(a, ->(b, c), d)")
self.assertEqual(3, pt_mani_utils.pt_depth(tree))
tree = pt_utils.parse("X(a, ->(b, c, +(e, f)), *(d, X(g, h), τ))")
self.assertEqual(4, pt_mani_utils.pt_depth(tree))
def test_range4(self):
tree = pt_utils.parse("+( ->( + (a, b), X(c, d)), e")
pt_number.apply(tree, 'D', 1)
alignments = [{
'alignment': [('>>', None), ('>>', None), ('>>', 'b'), ('a', 'a'),
('f', '>>'), ('e', 'e'), ('>>', None), ('d', 'd'),
('>>', None), ('g', '>>')],
'cost':
12,
'visited_states':
12,
'queued_states':
27,
'traversed_arcs':
28,
'fitness':
0.6363636363636364
}]
ranges = to_lock_align.compute_lock_range(tree, alignments, [])
expect_ranges = [{
1: [[0, 9]],
2: [[2, 7]],
3: [[2, 3]],
4: [[3, 3]],
5: [[2, 2]],
6: [[7, 7]],
8: [[7, 7]],
9: [[5, 5]]
}]
self.assertEqual(str(expect_ranges), str(ranges))
def apply(net, im, fm, parameters=None):
"""
Transforms a WF-net to a process tree
Parameters
-------------
net
Petri net
im
Initial marking
fm
Final marking
Returns
-------------
tree
Process tree
"""
if parameters is None:
parameters = {}
debug = exec_utils.get_param_value(Parameters.DEBUG, parameters, False)
fold = exec_utils.get_param_value(Parameters.FOLD, parameters, True)
grouped_net = group_blocks_in_net(net, parameters=parameters)
if len(grouped_net.transitions) == 1:
pt_str = list(grouped_net.transitions)[0].label
pt = pt_util.parse(pt_str)
return pt_util.fold(pt) if fold else pt
else:
if debug:
from pm4py.visualization.petrinet import visualizer as pn_viz
pn_viz.view(pn_viz.apply(grouped_net, parameters={"format": "svg"}))
raise ValueError('Parsing of WF-net Failed')
def test_tree_parsing(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
tree = pt_util.parse("->(X('a', 'b', tau), +('c', 'd'))")
# test log generation
log = pt_semantics.generate_log(tree)
def test_range2(self):
tree = pt_utils.parse("*( a, b, τ)")
pt_number.apply(tree, 'D', 1)
alignments = [{
'alignment': [('>>', None), ('>>', '2_s'), ('a', 'a'),
('>>', '2_e'), ('>>', '3_s'), ('b', 'b'),
('>>', '3_e'), ('>>', '2_s'), ('a', 'a'),
('>>', '2_e'), ('>>', '3_s'), ('b', 'b'),
('>>', '3_e'), ('>>', '2_s'), ('a', 'a'),
('>>', '2_e'), ('>>', None)],
'cost':
0,
'visited_states':
20,
'queued_states':
42,
'traversed_arcs':
42,
'fitness':
1
}]
ranges = to_lock_align.compute_lock_range(tree, alignments, [])
expect_ranges = [{
1: [[0, 16]],
2: [[1, 3], [7, 9], [13, 15]],
3: [[4, 6], [10, 12]]
}]
self.assertEqual(str(expect_ranges), str(ranges))
def read_trees_from_file(file, sheet_index=0):
col = 1 if sheet_index == 0 else 6
data = excel_utils.open_excel(file)
table = data.sheets()[sheet_index]
return list(
map(lambda t: pt_utils.parse(t[0]),
excel_utils.read_table_columns(table, [col])))
def test_scope_expand4(self):
tree1 = pt_utils.parse("*( a, X(b, c), τ)")
tree2 = pt_utils.parse("*( a, ->(b, c), τ)")
# log = create_event_log("abeaf")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '4_s'), ('>>', '4_s')),
(('t_b_1', 'b'), ('b', 'b')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '3_e'), ('>>', '3_e')), (('>>', '2_s'), ('>>', '2_s')),
(('t_e_2', '>>'), ('e', '>>')), (('t_a_3', 'a'), ('a', 'a')),
(('>>', '2_e'), ('>>', '2_e')), (('>>', '6_s'), ('>>', '6_s')),
(('>>', '6_skip_1'), ('>>', None)), (('>>', '6_e'), ('>>', '6_e')),
(('>>', '1_e'), ('>>', '1_e')), (('t_f_4', '>>'), ('f', '>>'))],
'cost': 10, 'visited_states': 31, 'queued_states': 50, 'traversed_arcs': 50,
'fitness': 0.6296296296296297}]
s_align = se_rd_lock.apply_with_lock(align, tree1, tree2)
g_s_align = se_rd_lock_general.apply(align, tree1, tree2, self.parameters)
e_s_align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '4_s'), ('>>', '4_s')),
(('t_b_1', 'b'), ('b', 'b')), (('>>', '4_e'), ('>>', '4_e')),
(('t_e_2', '>>'), ('e', '>>')), (('>>', '3_e'), ('>>', '3_e')),
(('>>', '2_s'), ('>>', '2_s')), (('t_a_3', 'a'), ('a', 'a')),
(('>>', '2_e'), ('>>', '2_e')), (('>>', '6_s'), ('>>', '6_s')),
(('>>', '6_skip_1'), ('>>', None)), (('>>', '6_e'), ('>>', '6_e')),
(('>>', '1_e'), ('>>', '1_e')), (('t_f_4', '>>'), ('f', '>>'))],
'cost': 10, 'visited_states': 31, 'queued_states': 50, 'traversed_arcs': 50,
'fitness': 0.6296296296296297}]
e_g_s_align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '4_s'), ('>>', '4_s')),
(('t_b_1', 'b'), ('b', 'b')), (('>>', '4_e'), ('>>', '4_e')),
(('t_e_2', '>>'), ('e', '>>')), (('>>', '3_e'), ('>>', '3_e')),
(('>>', '2_s'), ('>>', '2_s')), (('t_a_3', 'a'), ('a', 'a')),
(('t_f_4', '>>'), ('f', '>>')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '6_s'), ('>>', '6_s')),
(('>>', '6_skip_1'), ('>>', None)), (('>>', '6_e'), ('>>', '6_e')),
(('>>', '1_e'), ('>>', '1_e'))],
'cost': 10, 'visited_states': 31, 'queued_states': 50, 'traversed_arcs': 50,
'fitness': 0.6296296296296297}]
self.assertEqual(str(s_align), str(e_s_align))
self.assertEqual(str(g_s_align), str(e_g_s_align))
def compute_align_grade1(num):
trees = pd.read_excel(tree_file, sheet_name=SHEET_NAME)
mp_trees = pd.read_excel(m_tree_file, sheet_name=SHEET_NAME)
# logs = pd.read_excel(log_file, sheet_name=SHEET_NAME)
align_result = list()
align_result2 = list()
align_result3 = list()
# align_result4 = list()
for i in trees:
itree_list = trees[i]['tree'].tolist()
log_list = pd.read_csv(PATH + 'log' + i + ".csv")['log'].tolist()
# log_list = logs[i]['log'].tolist()
tree_list = mp_trees[i]['tree'].tolist()
mpt_list = mp_trees[i]['m_tree'].tolist()
align_info = pd.DataFrame(columns=[
"optimal time", "optimal cost", "repair align time",
"repair align cost", "grade"
])
align_info2 = pd.DataFrame(columns=[
"optimal time", "optimal cost", "repair align time",
"repair align cost", "grade"
])
align_info3 = pd.DataFrame(columns=[
"optimal time", "optimal cost", "repair align time",
"repair align cost", "grade"
])
# align_info4 = pd.DataFrame(columns=["optimal time", "optimal cost", "best worst cost",
# "repair align time", "repair align cost", "grade"])
for k, tree in enumerate(tree_list):
log = create_event_log(log_list[k])
alignments = alignment_on_pt(tree, log)
for j in range(num):
m_tree = pt_utils.parse(mpt_list[k * num + j])
info = apply_align_on_one_pt2(tree, m_tree, log, alignments)
align_info.loc[len(align_info.index)] = info[0]
align_info2.loc[len(align_info.index)] = info[1]
align_info3.loc[len(align_info.index)] = info[2]
# align_info4.loc[len(align_info.index)] = info[3]
align_result.append(align_info)
align_result2.append(align_info2)
align_result3.append(align_info3)
# align_result4.append(align_info4)
with pd.ExcelWriter(PATH + 'ar.xlsx') as writer:
for i, align in enumerate(align_result):
align.to_excel(writer, sheet_name=SHEET_NAME[i], index=False)
with pd.ExcelWriter(PATH + 'iar.xlsx') as writer:
for i, align in enumerate(align_result2):
align.to_excel(writer, sheet_name=SHEET_NAME[i], index=False)
with pd.ExcelWriter(PATH + 'iar_ud.xlsx') as writer:
for i, align in enumerate(align_result3):
align.to_excel(writer, sheet_name=SHEET_NAME[i], index=False)
def test_align_repair1(self):
tree1 = pt_utils.parse("+( a, X( g, h ) ) ")
tree2 = pt_utils.parse("+( a, ->( g, h ) )")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
log = utils.create_event_log("gah")
alignments = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '1_tau_1'), ('>>', None)),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_g_0', '>>'), ('g', '>>')),
(('t_a_1', 'a'), ('a', 'a')), (('>>', '5_s'), ('>>', '5_s')),
(('t_h_2', 'h'), ('h', 'h')),
(('>>', '5_e'), ('>>', '5_e')), (('>>', '3_e'), ('>>', '3_e')),
(('>>', '2_e'), ('>>', '2_e')),
(('>>', '1_tau_2'), ('>>', None)), (('>>', '1_e'), ('>>', '1_e'))], 'cost': 5,
'visited_states': 18, 'queued_states': 35, 'traversed_arcs': 35, 'fitness': 0.736842105263158}]
a_repair = ar_lock.apply(tree1, tree2, log, alignments, self.parameters)
exp_a_repair = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '1_tau_1'), ('>>', None)),
(('>>', '6_s'), ('>>', '6_s')), (('>>', '7_s'), ('>>', '7_s')),
(('>>', '2_s'), ('>>', '2_s')),
(('t_g_0', 'g'), ('g', 'g')), (('>>', '7_e'), ('>>', '7_e')),
(('>>', '8_s'), ('>>', '8_s')),
(('t_a_1', 'a'), ('a', 'a')), (('t_h_1', 'h'), ('h', 'h')),
(('>>', '8_e'), ('>>', '8_e')),
(('>>', '6_e'), ('>>', '6_e')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '1_tau_2'), ('>>', None)), (('>>', '1_e'), ('>>', '1_e'))], 'cost': 0,
'fitness': 1.0}]
# l_alignments = [{'alignment': [('>>', '1_s'), ('>>', None), ('>>', '3_s'), ('g', '>>'), ('>>', '2_s'),
# ('a', 'a'), ('>>', '2_e'), ('>>', '5_s'), ('h', 'h'), ('>>', '5_e'),
# ('>>', '3_e'), ('>>', None), ('>>', '1_e')], 'cost': 5, 'visited_states': 7,
# 'queued_states': 13, 'traversed_arcs': 15, 'fitness': 0.736842105263158}]
# l_a_repair = repair_alignment.apply(tree1, tree2, log, l_alignments, self.parameters_tuple_false)
# exp_l_a_repair = [{'alignment': [('>>', '1_s'), ('>>', None), ('>>', '6_s'), ('>>', '7_s'), ('g', 'g'),
# ('>>', '7_e'), ('>>', '8_s'), ('a', 'a'), ('h', 'h'), ('>>', '8_e'),
# ('>>', '6_e'), ('>>', None), ('>>', '1_e')], 'cost': 0, 'visited_states': 6,
# 'queued_states': 13, 'traversed_arcs': 15, 'fitness': 1}]
for i in range(len(alignments)):
self.assertEqual(list(map(lambda x: x[1], a_repair[i]["alignment"])),
list(map(lambda x: x[1], exp_a_repair[i]["alignment"])))
self.assertEqual(a_repair[i]["cost"], exp_a_repair[i]["cost"])
self.assertEqual(a_repair[i]["fitness"], exp_a_repair[i]["fitness"])
def compute_alignment1(version, option):
# tree_num, mutated_num, log_num, non_fit_pro = 10, 5, 5, 0.2
# node_num = [20, 25]
# tree = [pt_create.apply(random.randint(node_num[0], node_num[1])) for _ in range(tree_num)]
# m_tree = [[pt_mutate.apply(tree) for _ in range(mutated_num)] for tree in tree]
# log = [log_create.apply(tree, log_num, non_fit_pro) for tree in tree]
# for i in range(len(tree)):
# for j in range(len(m_tree[0])):
# optimal_time, optimal_cost, best_worst_cost, ra_time, ra_cost, grade = \
# align_info(tree[i], m_tree[i][j], log[i], apply, option)
data = pd.read_excel(PATH + "MProcessTree.xlsx",
sheet_name='16-18',
header=0)
log_d = pd.read_excel(PATH + "0.2/log.xlsx", sheet_name='16-18', header=0)
trees = data['tree']
m_trees = data['m_tree']
logs = log_d['log']
optimal_time, optimal_cost, best_worst_cost = list(), list(), list()
ra_time, ra_cost, grade = list(), list(), list()
for i in range(len(trees)):
info = align_info(pt_utils.parse(trees[i]), pt_utils.parse(m_trees[i]),
create_event_log(logs[i // 15]), version, option)
optimal_time.append(info[0])
optimal_cost.append(info[1])
best_worst_cost.append(info[2])
ra_time.append(info[3])
ra_cost.append(info[4])
grade.append(info[5])
if i > 200:
repair_align_compare(pt_utils.parse(trees[i]),
pt_utils.parse(m_trees[i]),
create_event_log(logs[i // 15]))
df = pd.DataFrame({
"optimal time": optimal_time,
"optimal cost": optimal_cost,
"best worst cost": best_worst_cost,
"repair align time": ra_time,
"repair align cost": ra_cost,
"grade": grade
})
df.to_csv(PATH + "align_repair_opt2.csv")
def create_logs(pts):
logs_list = list()
for trees in pts:
logs = pd.DataFrame(columns=['log'])
for i, s_tree in enumerate(trees['tree']):
tree = pt_utils.parse(s_tree)
logs.loc[i] = [
parse_string_list(
log_create.apply(tree, trace_num, non_fit_pro))
]
logs_list.append(logs)
return logs_list
def test_scope_expand1(self):
tree1 = pt_utils.parse("->( a, *( X(c, b), d, τ), e)")
tree2 = pt_utils.parse("->( a, *(->(c, b), d, τ), e)")
# log = create_event_log("abdce")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '4_s'), ('>>', '4_s')),
(('>>', '6_s'), ('>>', '6_s')), (('t_b_1', 'b'), ('b', 'b')),
(('>>', '6_e'), ('>>', '6_e')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '7_s'), ('>>', '7_s')), (('t_d_2', 'd'), ('d', 'd')),
(('>>', '7_e'), ('>>', '7_e')), (('>>', '4_s'), ('>>', '4_s')),
(('>>', '5_s'), ('>>', '5_s')), (('t_c_3', 'c'), ('c', 'c')),
(('>>', '5_e'), ('>>', '5_e')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '8_s'), ('>>', '8_s')), (('>>', '8_skip_1'), ('>>', None)),
(('>>', '8_e'), ('>>', '8_e')), (('>>', '3_e'), ('>>', '3_e')),
(('>>', '9_s'), ('>>', '9_s')), (('t_e_4', 'e'), ('e', 'e')),
(('>>', '9_e'), ('>>', '9_e')), (('>>', '1_e'), ('>>', '1_e'))],
'cost': 0, 'visited_states': 33, 'queued_states': 71, 'traversed_arcs': 71, 'fitness': 1}]
s_align = se_rd_lock.apply_with_lock(align, tree1, tree2)
g_s_align = se_rd_lock_general.apply(align, tree1, tree2, self.parameters)
e_s_align = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '4_s'), ('>>', '4_s')),
(('>>', '6_s'), ('>>', '6_s')), (('t_b_1', 'b'), ('b', 'b')),
(('>>', '6_e'), ('>>', '6_e')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '7_s'), ('>>', '7_s')), (('t_d_2', 'd'), ('d', 'd')),
(('>>', '7_e'), ('>>', '7_e')), (('>>', '4_s'), ('>>', '4_s')),
(('>>', '5_s'), ('>>', '5_s')), (('t_c_3', 'c'), ('c', 'c')),
(('>>', '5_e'), ('>>', '5_e')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '8_s'), ('>>', '8_s')), (('>>', '8_skip_1'), ('>>', None)),
(('>>', '8_e'), ('>>', '8_e')), (('>>', '3_e'), ('>>', '3_e')),
(('>>', '9_s'), ('>>', '9_s')), (('t_e_4', 'e'), ('e', 'e')),
(('>>', '9_e'), ('>>', '9_e')), (('>>', '1_e'), ('>>', '1_e'))],
'cost': 0, 'visited_states': 33, 'queued_states': 71, 'traversed_arcs': 71, 'fitness': 1}]
self.assertEqual(str(s_align), str(e_s_align))
self.assertEqual(str(g_s_align), str(e_s_align))
def test_align_repair3(self):
tree1 = pt_utils.parse("->( a, X(b, c)) ")
tree2 = pt_utils.parse("->( a, X(b, τ))")
pt_number.apply(tree1, 'D', 1)
pt_number.apply(tree2, 'D', 1)
log = utils.create_event_log("a")
alignments = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '3_s'), ('>>', '3_s')), (('>>', '4_s'), ('>>', '4_s')),
(('>>', 'b'), ('>>', 'b')), (('>>', '4_e'), ('>>', '4_e')),
(('>>', '3_e'), ('>>', '3_e')), (('>>', '1_e'), ('>>', '1_e'))],
'cost': 2, 'visited_states': 11, 'queued_states': 15, 'traversed_arcs': 15,
'fitness': 0.7777777777777778}]
a_repair = ar_lock.apply(tree1, tree2, log, alignments, self.parameters)
exp_a_repair = [{'alignment': [(('>>', '1_s'), ('>>', '1_s')), (('>>', '2_s'), ('>>', '2_s')),
(('t_a_0', 'a'), ('a', 'a')), (('>>', '2_e'), ('>>', '2_e')),
(('>>', '6_s'), ('>>', '6_s')), (('>>', '8_s'), ('>>', '8_s')),
(('>>', 'b'), ('>>', None)), (('>>', '8_e'), ('>>', '8_e')),
(('>>', '6_e'), ('>>', '6_e')), (('>>', '1_e'), ('>>', '1_e'))],
'cost': 0, 'visited_states': 11, 'queued_states': 15, 'traversed_arcs': 15,
'fitness': 1}]
# l_alignments = [{'alignment': [('>>', '1_s'), ('>>', '2_s'), ('a', 'a'), ('>>', '2_e'), ('>>', '3_s'),
# ('>>', '5_s'), ('>>', 'c'), ('>>', '5_e'), ('>>', '3_e'), ('>>', '1_e')],
# 'cost': 2, 'visited_states': 3, 'queued_states': 4, 'traversed_arcs': 5,
# 'fitness': 0.7777777777777778}]
#
# l_a_repair = repair_alignment.apply(tree1, tree2, log, l_alignments, self.parameters_tuple_false)
# exp_l_a_repair = [{'alignment': [('>>', '1_s'), ('>>', '2_s'), ('a', 'a'), ('>>', '2_e'), ('>>', '6_s'),
# ('>>', '8_s'), ('>>', None), ('>>', '8_e'), ('>>', '6_e'), ('>>', '1_e')],
# 'cost': 0, 'visited_states': 3, 'queued_states': 4, 'traversed_arcs': 5, 'fitness': 1}]
for i in range(len(alignments)):
self.assertEqual(list(map(lambda x: x[1], a_repair[i]["alignment"])),
list(map(lambda x: x[1], exp_a_repair[i]["alignment"])))
self.assertEqual(a_repair[i]["cost"], exp_a_repair[i]["cost"])
self.assertEqual(a_repair[i]["fitness"], exp_a_repair[i]["fitness"])
def test_random_create_tree(self):
for _ in range(100):
tree1 = pt_create.apply(random.randint(10, 35))
tree2 = pt_utils.parse(str(tree1))
q1, q2 = list(), list()
q1.append(tree1)
q2.append(tree2)
while len(q1) != 0:
node1 = q1.pop(0)
node2 = q2.pop(0)
self.assertEqual(str(node1.parent), str(node2.parent))
self.assertEqual(str(node1.children), str(node2.children))
for i in range(len(node1.children)):
q1.append(node1.children[i])
q2.append(node2.children[i])
def create_m_pts(pts):
m_pts = list()
for trees in pts:
m_trees = pd.DataFrame(columns=[
'tree', '#node', 'depth', 'root-op', 'm_tree', 'sub_depth'
])
for i, s_tree in enumerate(trees['tree']):
tree = pt_utils.parse(s_tree)
for depth in depths:
for j in range(mpt_num):
m_tree = pt_mutate.apply(tree, depth)
m_trees.loc[len(m_trees.index)] = trees.loc[i].tolist() + [
str(m_tree), depth
]
m_pts.append(m_trees)
return m_pts
def parse_process_tree(tree_string: str) -> ProcessTree:
"""
Parse a process tree from a string
Parameters
----------------
tree_string
String representing a process tree (e.g. '-> ( 'A', O ( 'B', 'C' ), 'D' )')
Operators are '->': sequence, '+': parallel, 'X': xor choice, '*': binary loop, 'O' or choice
Returns
----------------
tree
Process tree
"""
from pm4py.objects.process_tree.util import parse
return parse(tree_string)
def export_file(orig_tree, activity_set):
"""
Export petri net to pnml file
:param orig_tree: string of the tree from the main algorithm
:param activity_set: set of all the activities
:return: pnml file
"""
string_tree = tree_for_eval(orig_tree, activity_set)
tree = pt_util.parse(string_tree)
net, initial_marking, final_marking = tree_to_petri.apply(tree)
file_name = config.data_file[:config.data_file.find('.')] + '_' + str(
config.silhouette_threshold) + '.pnml'
output_file = os.path.join(config.base_directory, config.data_dir,
file_name)
petri_exporter.export_net(net,
initial_marking,
output_file,
final_marking=final_marking)
def test_range5(self):
tree = pt_utils.parse("+( a, X(b, τ))")
pt_number.apply(tree, 'D', 1)
alignments = [{
'alignment': [('>>', None), ('>>', '5_s'), ('a', 'a'),
('>>', None), ('>>', '5_e'), ('>>', None)],
'cost':
0,
'visited_states':
8,
'queued_states':
15,
'traversed_arcs':
16,
'fitness':
1
}]
ranges = to_lock_align.compute_lock_range(tree, alignments, [])
expect_ranges = [{1: [[0, 5]], 2: [[2, 2]], 3: [[1, 4]], 5: [[1, 4]]}]
self.assertEqual(str(expect_ranges), str(ranges))
def test_range1(self):
tree = pt_utils.parse("->( a, b, c)")
pt_number.apply(tree, 'D', 1)
alignments = [{
'alignment': [('a', 'a'), ('b', 'b'), ('d', '>>'), ('c', 'c'),
('e', '>>')],
'cost':
10,
'visited_states':
6,
'queued_states':
11,
'traversed_arcs':
11,
'fitness':
0.6774193548387097
}]
ranges = to_lock_align.compute_lock_range(tree, alignments, [])
expect_ranges = [{1: [[0, 4]], 2: [[0, 0]], 3: [[1, 1]], 4: [[3, 3]]}]
self.assertEqual(str(expect_ranges), str(ranges))
def test_range3(self):
tree = pt_utils.parse("*( +( *(->( a, b), c, τ), d), X(e, f), τ)")
pt_number.apply(tree, 'D', 1)
alignments = [{
'alignment': [('>>', None), ('>>', '2_s'), ('>>', None),
('>>', '4_s'), ('a', 'a'), ('d', 'd'), ('b', 'b'),
('>>', '4_e'), ('>>', '7_s'), ('c', 'c'),
('>>', '7_e'), ('>>', '4_s'), ('a', 'a'), ('b', 'b'),
('>>', '4_e'), ('>>', None), ('>>', None),
('>>', '2_e'), ('>>', '10_s'), ('e', 'e'),
('>>', '10_e'), ('>>', '2_s'), ('>>', None),
('>>', '4_s'), ('a', 'a'), ('b', 'b'), ('>>', '4_e'),
('>>', None), ('d', 'd'), ('>>', None),
('>>', '2_e'), ('>>', None)],
'cost':
0,
'visited_states':
39,
'queued_states':
97,
'traversed_arcs':
99,
'fitness':
1
}]
ranges = to_lock_align.compute_lock_range(tree, alignments, [])
expect_ranges = [{
1: [[0, 31]],
2: [[1, 17], [21, 30]],
3: [[3, 14], [23, 26]],
4: [[3, 7], [11, 14], [23, 26]],
5: [[4, 4], [12, 12], [24, 24]],
6: [[6, 6], [13, 13], [25, 25]],
7: [[8, 10]],
9: [[5, 5], [28, 28]],
10: [[18, 20]],
11: [[19, 19]]
}]
self.assertEqual(str(ranges), str(expect_ranges))
'2: improved alignment repair with lock; ' \
'3: improved alignment repair Up to Down; '\
'default 3', metavar='version')
parser.add_argument('--o', nargs='?', default=1, type=int,
help='1: return the smallest changed scope; '
'2: return the subtree of the parent of the changed scope if ' \
'the parent of the smallest changed scope has loop operator; '
'default 1', metavar='option')
parser.add_argument('--s', nargs='?', default=False, type=bool,
help='indicate whether to write to file, ' \
'default=False', metavar='save', choices=[False, True])
args = parser.parse_args()
# print("start of plugin with arguments: ", args)
#
T1 = args.t1
T2 = args.t2
A1 = args.a1
paras = args.parameter
version = args.v
option = args.o
save_to_file = args.s
tree = pt_utils.parse(
"*( X( ->( b, c ), +( X( i, j ), X( g, h, ->( d, e, f ) ) ) ), a, τ )")
m_tree = pt_utils.parse(
"*( X( ->( b, c ), +( X( i, j ), X( g, h, ->( d, e, f, l ) ) ) ), a, τ )"
)
log = create_event_log("jfljgabc")
a1, a2 = apply(tree, m_tree, log, version, option=option)
print(a2)
def run_feature(row):
pt = pt_utils.parse(row['tree'])
m_pt = pt_utils.parse(row['m_tree'])
com_res = pt_compare.apply(pt, m_pt, 2)
# depth
depth1 = pt_mani_utils.pt_depth(str(com_res.subtree1))
depth2 = pt_mani_utils.pt_depth(str(com_res.subtree2))
depths = [
depth1 / pt_mani_utils.pt_depth(row['tree']),
depth2 / pt_mani_utils.pt_depth(row['m_tree'])
]
# depths = [depth1, pt_mani_utils.pt_depth(row['tree']), depth2, pt_mani_utils.pt_depth(row['m_tree'])]
# trace fit
t_l = set(re.findall("[a-z]", row['tree']))
st_l = set(re.findall("[a-z]", str(com_res.subtree1)))
nei_l = t_l - st_l
min_fit = 1
for trace in row['log'].strip().split(", "):
count = 0
for e in list(trace):
count = count + 1 if e in nei_l else count
min_fit = min(min_fit, count / len(trace))
# type of operators
ops = [pt.operator, com_res.subtree1.operator, com_res.subtree2.operator]
# number of operators
num_loop = len(re.findall(r'\*', row['tree'])) - len(
re.findall(r'\*', str(com_res.subtree1)))
num_xor = len(re.findall(r'X', row['tree'])) - len(
re.findall(r'X', str(com_res.subtree1)))
num_and = len(re.findall(r'\+', row['tree'])) - len(
re.findall(r'\+', str(com_res.subtree1)))
num_seq = len(re.findall(r'->', row['tree'])) - len(
re.findall(r'->', str(com_res.subtree1)))
total = num_loop + num_xor + num_seq + num_and
# rate = [num_loop, num_xor]
if total == 0:
rate = [
0, 0, 0, 0,
len(re.findall(r'\*', str(com_res.subtree1))),
len(re.findall(r'\*', str(com_res.subtree2)))
]
else:
rate = [
num_loop / total, num_xor / total, num_and / total,
num_seq / total,
len(re.findall(r'\*', str(com_res.subtree1))),
len(re.findall(r'\*', str(com_res.subtree2)))
]
# subtree parent loop
st = com_res.subtree1
num_loop, num_xor = 0, 0
while st.parent is not None:
if st.parent.operator == Operator.LOOP:
num_loop += 1
if st.parent.operator == Operator.XOR:
num_xor += 1
st = st.parent
return pd.Series([min_fit] + rate + ops + depths)
