def split_real_life_data(file):
name = file.split(".")[0]
logs = pd.read_csv(PATH + file)["trace"].tolist()
# log_test = random.sample(logs, len(logs) // 2)
# pd.DataFrame(log_test, columns=["trace"]).to_csv(PATH + name + "_test.csv", index=False)
log_tree = logs[0: len(logs)//10]
pd.DataFrame(log_tree, columns=["trace"]).to_csv(PATH + name + "_tree.csv", index=False)
tree = inductive_miner.apply_tree(list_to_xes(log_tree))
m_trees = []
print(str(tree))
for i in range(1, 5):
log_part = logs[i*len(logs)//10: len(logs)//10*(i+1)]
pd.DataFrame(log_part, columns=["trace"]).to_csv(PATH + name + "_part" + str(i + 1) + ".csv", index=False)
m_tree = inductive_miner.apply_tree(list_to_xes(log_part))
m_trees.append(m_tree)
print(str(tree) == str(m_tree))
print(pt_compare.apply(tree, m_tree))
def test_tree_receipt(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"
log = xes_importer.import_log(
os.path.join(INPUT_DATA_DIR, "receipt.xes"))
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree)
del gviz
def SPIMDFbTree(context):
args = context.args
inputFile = os.path.join(args.inputData, os.listdir(args.inputData)[0])
log = xes_importer.import_log(inputFile)
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree)
pt_vis_factory.save(gviz,
os.path.join(args.outputData, "inductive-miner.png"))
return args.outputData
def result(file):
name = file.split(".")[0]
logs = pd.read_csv(PATH + file)["trace"].tolist()
for rd in range(1):
log = list_to_xes(random.sample(logs, len(logs)//10))
# log = pd.read_csv("../../../data/reallife_test.csv")["trace"].tolist()
tree_log = pd.read_csv(PATH + name + "_tree.csv")["trace"].tolist()
tree = inductive_miner.apply_tree(list_to_xes(tree_log))
print(ra_pt_utils.pt_depth(str(tree)))
m_trees = []
for i in range(4):
m_tree_log = pd.read_csv(PATH + name + "_part" + str(i + 1) + ".csv")["trace"].tolist()
m_tree = inductive_miner.apply_tree(list_to_xes(m_tree_log))
print(ra_pt_utils.pt_depth(str(m_tree)))
print(len(ra_pt_utils.parse_tree_to_a_bfs_sequence(m_tree)), "+")
m_trees.append(m_tree)
res_com = pt_compare.apply(tree, m_tree)
print(len(ra_pt_utils.parse_tree_to_a_bfs_sequence(res_com.subtree1)),
len(ra_pt_utils.parse_tree_to_a_bfs_sequence(res_com.subtree2)))
def test_tree_running_example_dfg_based_old(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"
log = xes_importer.import_log(
os.path.join(INPUT_DATA_DIR, "running-example.xes"))
tree = inductive_miner.apply_tree(
log, variant=inductive_miner.DFG_BASED_OLD_VERSION)
gviz = pt_vis_factory.apply(tree)
del gviz
# test log generation
log = pt_semantics.generate_log(tree)
del log
def run_inductive_and_evaluate(log_for_pd, log_for_eval):
'''
Given 2 event logs, it runs the inductive miner and evaluate the result of the process models
:param log_for_pd: logs that will be used to discover the process models (e.g., might be truncated)
:param log_for_eval: logs that will be replayed on top of the discovered process model (e.g., will not be truncated = ground truth)
:return: The evaluation of the process model in a dictionary.
'''
# Discover petri net from log
tree = inductive_miner.apply_tree(log_for_pd)
net, initial_marking, final_marking = pt_conv_factory.apply(tree, variant=pt_conv_factory.TO_PETRI_NET)
# Replay the log on top of the discovered process model
inductive_evaluation_result = evaluation_factory.apply(log_for_eval, net, initial_marking, final_marking)
inductive_evaluation_result.update(inductive_evaluation_result['fitness'])
inductive_evaluation_result['discovered_pt'] = str(tree)
del inductive_evaluation_result['fitness']
return inductive_evaluation_result
def execute_script():
# import a log
log = importer.apply(
os.path.join("..", "tests", "input_data", "receipt.xes"))
# found a filtered version of the log that is used to discover a process model
filtered_log = variants_filter.apply_auto_filter(deepcopy(log))
# discover a process tree using inductive miner
tree = inductive_miner.apply_tree(filtered_log)
print(tree)
# apply the conversion of a process tree into a Petri net
net, im, fm = converter.apply(tree)
# Footprints discovery: discover a list of footprints
# for all the cases of the log
fp_log = footprints_discovery.apply(log)
# discover the footpritns from the process tree
fp_tree = footprints_discovery.apply(tree)
# discover the footpritns from the Petri net
fp_net = footprints_discovery.apply(net, im)
print(len(fp_tree["sequence"]), len(fp_tree["parallel"]),
len(fp_net["sequence"]), len(fp_net["parallel"]))
print(fp_tree["sequence"] == fp_net["sequence"]
and fp_tree["parallel"] == fp_net["parallel"])
# apply the footprints conformance checking
conf = footprints_conformance.apply(fp_log, fp_net)
for trace_an in conf:
if trace_an:
# print the first anomalous trace (containing deviations
# that are contained in the trace but not allowed by the model)
print(trace_an)
break
# finds the footprints for the entire log (not case-by-case, but taking
# the relations that appear inside the entire log)
fp_log_entire = footprints_discovery.apply(
log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG)
# visualize the footprint table
gviz = fp_visualizer.apply(fp_log_entire,
fp_net,
parameters={"format": "svg"})
fp_visualizer.view(gviz)
pnml_exporter.export_net(heu_model,
heu_initial_marking,
os.path.join(
pnmlFolder,
logNamePrefix + "_alpha.pnml"),
final_marking=heu_final_marking)
t2 = time.time()
print("time interlapsed for calculating Heuristics Model",
(t2 - t1))
print(
"heuristics is_sound_wfnet",
check_soundness.check_petri_wfnet_and_soundness(heu_model,
debug=True))
t1 = time.time()
tree = inductive.apply_tree(log, parameters=parameters_discovery)
inductive_model, inductive_im, inductive_fm = inductive.apply(
log, parameters=parameters_discovery)
pnml_exporter.export_net(inductive_model,
inductive_im,
os.path.join(
pnmlFolder,
logNamePrefix + "_inductive.pnml"),
final_marking=inductive_fm)
generated_log = pt_semantics.generate_log(tree)
print("first trace of log",
[x["concept:name"] for x in generated_log[0]])
t2 = time.time()
print("time interlapsed for calculating Inductive Model",
(t2 - t1))
print(
def model(request, log_id, cube_id):
values = request.GET.get("values")
if (values == None):
values = "{}"
values = json.loads(values)
def convert(value, dtype):
if (dtype == 'float'):
return float(value)
elif (dtype == 'int'):
return int(value)
elif (dtype == 'date'):
return convert_date(value)
elif (dtype == 'bool'):
return bool(value)
else:
return value
def convert_date(value):
# Construct datetime object to filter with pymongo
time_format = "%Y-%m-%dT%H:%M:%S.%f"
time_format = "%Y-%m-%d %H:%M:%S.%f"
if ("." not in value):
time_format = time_format[:-3]
return datetime.strptime(value, time_format)
algo = request.GET.get("algorithm")
values_ = {}
# Convert to attribute id to name like it is in the events.
values_ = {}
for key in values:
if (key != 'log'):
attribute = Attribute.objects.get(pk=key)
if (":" in attribute.parent):
parent = attribute.parent.split(':')[0]
d_name = attribute.parent.split(':')[1]
name = attribute.name
# Query for elements of dictionary
queryname = parent + ":" + d_name + ".children." + name
else:
queryname = attribute.name
if (attribute.parent == "trace"):
queryname = 'trace:' + queryname
if ("to" in values[key]):
lower = values[key].split("to")[0].strip()
upper = values[key].split('to')[1].strip()
lower = convert(lower, attribute.dtype)
upper = convert(upper, attribute.dtype)
values_[queryname] = {'$gt': lower, '$lt': upper}
else:
value = convert(values[key], attribute.dtype)
values_[queryname] = value
values_['log'] = log_id
values = values_
client = MongoClient(host=DATABASES['default']['HOST'])
db = client[DATABASES['default']['NAME']]
trace_collection = db['traces']
event_collection = db['events']
t1 = time()
all_events = event_collection.find(values)
t2 = time()
print("Time to get events: {}".format(t2 - t1))
t1 = time()
traces = groupby(all_events, key=lambda e: e['trace:_id'])
t2 = time()
print("Time to get traces: {}".format(t2 - t1))
t1 = time()
traces = [log_lib.log.Trace(g) for k, g in traces]
t2 = time()
print("Time to make list: {}".format(t2 - t1))
# log_list = [log_lib.log.Trace([log_lib.log.Event(t_e) for t_e in all_events if t_e['trace:_id'] == db_trace['_id']]) for db_trace in db_traces]
t1 = time()
log = log_lib.log.EventLog(traces)
t2 = time()
print("Time to make event log: {}".format(t2 - t1))
# for db_trace in db_traces:
# pm4py_trace = log_lib.log.Trace([log_lib.log.Event(t_e) for t_e in all_events if t_e['trace:_id'] == db_trace['_id']])
# log.append(pm4py_trace)
# print(len(log))
# pm_events = []
# traces = {str(e['trace:_id']): log_lib.log.Trace() for e in events}
# for event in events:
# trace = trace_collection.find_one({"_id": event['trace:_id']})
# t = traces[str(event['trace:_id'])]
# del event['_id']
# del event['trace:_id']
# e = log_lib.log.Event(event)
# t.append(e)
# log.append(traces.items())
# for trace in traces:
# log.append(traces[trace])
parameters = {"format": "svg"}
event_log = EventLog.objects.get(pk=log_id)
filename = str(event_log.pk) + algo + ".svg"
t1 = time()
if (algo == "alpha"):
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
parameters=parameters)
pn_vis_factory.save(gviz, filename)
elif (algo == "inductive"):
mine_tree = request.GET.get("mine_tree")
if (mine_tree == 'true'):
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree, parameters=parameters)
pt_vis_factory.save(gviz, filename)
else:
net, initial_marking, final_marking = inductive_miner.apply(log)
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
parameters=parameters)
pn_vis_factory.save(gviz, filename)
elif (algo == "heuristic"):
dependency_thresh = float(request.GET.get("dependency_thresh"))
and_measure_thresh = float(request.GET.get("and_measure_thresh"))
min_act_count = float(request.GET.get("min_act_count"))
min_dfg_occurrences = float(request.GET.get("min_dfg_occurrences"))
dfg_pre_cleaning_noise_thresh = float(
request.GET.get("dfg_pre_cleaning_noise_thresh"))
h_params = {
'dependency_thresh': dependency_thresh,
'and_measure_thresh': and_measure_thresh,
'min_act_count': min_act_count,
'min_dfg_occurrences': min_dfg_occurrences,
'dfg_pre_cleaning_noise_thresh': dfg_pre_cleaning_noise_thresh,
}
net, im, fm = heuristics_miner.apply(log, parameters=h_params)
gviz = pn_vis_factory.apply(net, im, fm, parameters=parameters)
pn_vis_factory.save(gviz, filename)
t2 = time()
print("Time pm4py: {}".format(t2 - t1))
svg = open(filename, "rb")
svg_content = svg.read()
svg.close()
# Tdelete file, it's not required anymore
os.remove(svg.name)
return HttpResponse(svg_content, content_type="image/svg+xml")
weak_dfg_fixed_percentage = percentageFixDFG(weak_dfg_fixed)
excellent_average = averagePerPersonFixDFG(
excellent_dfg_fixed, len(ex1_personal_log_1['org:resource'].unique()))
weak_average = averagePerPersonFixDFG(
weak_dfg_fixed, len(ex1_personal_log_2['org:resource'].unique()))
diff_absolute = diffTwoMatrix(excellent_average, weak_average)
dfg_miner_time_diff_absolute = diffTwoMatrix(dfg_miner_excellent_dfg,
dfg_miner_weak_dfg)
#Inductive Miner
from pm4py.algo.discovery.inductive import factory as inductive_miner
tree = inductive_miner.apply_tree(ex1_personal_log_1_converted)
from pm4py.visualization.process_tree import factory as pt_vis_factory
gviz = pt_vis_factory.apply(tree)
pt_vis_factory.view(gviz)
from pm4py.algo.discovery.inductive import factory as inductive_miner
net, initial_marking, final_marking = inductive_miner.apply(
ex1_personal_log_1_converted)
from pm4py.visualization.petrinet import factory as pn_vis_factory
gviz = pn_vis_factory.apply(net, initial_marking, final_marking)
pn_vis_factory.view(gviz)
log_start = start_activities_filter.get_start_activities(sorted_log)
filtered_log = start_activities_filter.apply(sorted_log, ["A"])
# print(rrr)
# from pm4py.algo.discovery.simple.model.log import factory as simple_algorithm
# net, initial_marking, final_marking = simple_algorithm.apply(conv_log, classic_output=True, parameters={"max_no_variants": 20})
# gviz = pn_vis_factory.apply(net, im, fm)
# pn_vis_factory.view(gviz)
# print(ooo)
from pm4py.algo.discovery.alpha import factory as alpha_miner
# the same exact discovery technique can be applied directly to Pandas dataframes! :)
from pm4py.algo.discovery.inductive import factory as inductive_miner
# discovers an accepting Petri net
net, im, fm = inductive_miner.apply(filtered_log)
tree = inductive_miner.apply_tree(filtered_log)
# print(tree)
from pm4py.visualization.process_tree import factory as pt_vis_factory
##########################################################
# gviz = pt_vis_factory.apply(tree)
# pt_vis_factory.view(gviz)
# print(net,im,fm)
# perform a visualization of the Petri net that is discovered
from pm4py.visualization.petrinet import factory as pn_vis_factory
# gviz = pn_vis_factory.apply(net, im, fm)
# pn_vis_factory.view(gviz)
# ############################################
def inductive_to_petri_net(log):
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree)
pt_vis_factory.view(gviz)
return tree
