def execute_script():
log = pm4py.read_xes(
os.path.join("..", "tests", "input_data", "receipt.xes"))
activities = pm4py.get_attribute_values(log, "concept:name")
dfg, sa, ea = pm4py.discover_dfg(log)
# filters the DFG to make a simpler one
perc = 0.5
dfg, sa, ea, activities = dfg_filtering.filter_dfg_on_activities_percentage(
dfg, sa, ea, activities, perc)
dfg, sa, ea, activities = dfg_filtering.filter_dfg_on_paths_percentage(
dfg, sa, ea, activities, perc)
# creates the simulated log
simulated_log = dfg_playout.apply(dfg, sa, ea)
print(simulated_log)
print(len(simulated_log))
print(sum(x.attributes["probability"] for x in simulated_log))
# shows the two DFGs to show that they are identical
pm4py.view_dfg(dfg, sa, ea, log=log, format="svg")
new_dfg, new_sa, new_ea = pm4py.discover_dfg(simulated_log)
pm4py.view_dfg(new_dfg, new_sa, new_ea, log=simulated_log, format="svg")
for trace in simulated_log:
print(list(x["concept:name"] for x in trace))
print(trace.attributes["probability"],
dfg_playout.get_trace_probability(trace, dfg, sa, ea))
break
dfg, sa, ea = pm4py.discover_dfg(log)
variants = pm4py.get_variants(log)
sum_prob_log_variants = 0.0
for var in variants:
sum_prob_log_variants += dfg_playout.get_trace_probability(
variants[var][0], dfg, sa, ea)
print(
"percentage of behavior allowed from DFG that is in the log (from 0.0 to 1.0): ",
sum_prob_log_variants)
def bkpfGetDfg():
parameters = request.args.get("parameters")
parameters = __process_parameters(parameters)
db_type = parameters["db_type"] if "db_type" in parameters else "sqlite"
db_con_args = parameters[
"db_con_args"] if "db_con_args" in parameters else {
"path": "sap.sqlite"
}
c = database_factory.apply(db_type, db_con_args)
from sapextractor.algo.ap_ar import graph_retrieval_util
dfg, act_count, sa, ea = graph_retrieval_util.extract_dfg_apar(c)
dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_paths_percentage(
dfg, sa, ea, act_count, 0.2, keep_all_activities=False)
gviz = pm4py.visualization.dfg.visualizer.apply(dfg,
activities_count=act_count,
parameters={
"format": "svg",
"start_activities": sa,
"end_activities": ea
})
ser = pm4py.visualization.dfg.visualizer.serialize(gviz).decode("utf-8")
dfg = sorted([[x[0], x[1], y] for x, y in dfg.items()],
key=lambda x: x[1],
reverse=True)
act_count = sorted([(x, y) for x, y in act_count.items()],
key=lambda x: x[1],
reverse=True)
return jsonify({"dfg": dfg, "act_count": act_count, "ser": ser})
def test_dfg_align(self):
import pm4py
from pm4py.objects.dfg.filtering import dfg_filtering
from pm4py.objects.dfg.utils import dfg_alignment
log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"))
dfg, sa, ea = pm4py.discover_dfg(log)
act_count = pm4py.get_attribute_values(log, "concept:name")
dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_activities_percentage(dfg, sa, ea, act_count, 0.5)
dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_paths_percentage(dfg, sa, ea, act_count, 0.5)
aligned_traces = dfg_alignment.apply(log, dfg, sa, ea)
def get_process_svg():
parameters = request.args.get("parameters")
parameters = __process_parameters(parameters)
log = __prepare_event_log(parameters)
ext_type = parameters[
"ext_type"] if "ext_type" in parameters else "document_flow_log"
log_type = __get_log_type_from_ext_type(ext_type)
if log_type == 0:
log.type = "succint"
from pm4pymdl.algo.mvp.gen_framework import algorithm as discovery
from pm4pymdl.visualization.mvp.gen_framework import visualizer as vis_factory
model = discovery.apply(log,
model_type_variant="model3",
node_freq_variant="type31",
edge_freq_variant="type11")
gviz = vis_factory.apply(model, parameters={"format": "svg"})
elif log_type == 1 or log_type == 2:
import pandas as pd
if type(log) is pd.DataFrame:
from pm4py.objects.dfg.retrieval.pandas import get_dfg_graph
dfg = get_dfg_graph(log)
from pm4py.statistics.start_activities.pandas import get as pd_sa_get
from pm4py.statistics.end_activities.pandas import get as pd_ea_get
sa = pd_sa_get.get_start_activities(log)
ea = pd_ea_get.get_end_activities(log)
else:
dfg, sa, ea = pm4py.discover_dfg(log)
act_count = pm4py.get_attribute_values(log, "concept:name")
dfg, sa, ea, act_count = dfg_filtering.filter_dfg_on_paths_percentage(
dfg, sa, ea, act_count, 0.2, keep_all_activities=True)
gviz = pm4py.visualization.dfg.visualizer.apply(
dfg,
activities_count=act_count,
parameters={
"format": "svg",
"start_activities": sa,
"end_activities": ea
})
ser = pm4py.visualization.dfg.visualizer.serialize(gviz).decode("utf-8")
return ser
def execute_script():
log = pm4py.read_xes(
os.path.join("..", "tests", "input_data", "receipt.xes"))
print("number of cases", len(log))
print("number of events", sum(len(x) for x in log))
print("number of variants", len(pm4py.get_variants(log)))
ac = get.get_attribute_values(log, "concept:name")
dfg, sa, ea = pm4py.discover_dfg(log)
perc = 0.5
dfg, sa, ea, ac = dfg_filtering.filter_dfg_on_activities_percentage(
dfg, sa, ea, ac, perc)
dfg, sa, ea, ac = dfg_filtering.filter_dfg_on_paths_percentage(
dfg, sa, ea, ac, perc)
aa = time.time()
aligned_traces = dfg_alignment.apply(log, dfg, sa, ea)
bb = time.time()
net, im, fm = pm4py.convert_to_petri_net(dfg, sa, ea)
for trace in aligned_traces:
if trace["cost"] != trace["internal_cost"]:
print(trace)
pass
print(bb - aa)
print(sum(x["visited_states"] for x in aligned_traces))
print(sum(x["cost"] // 10000 for x in aligned_traces))
gviz = visualizer.apply(dfg,
activities_count=ac,
parameters={
"start_activities": sa,
"end_activities": ea,
"format": "svg"
})
visualizer.view(gviz)
cc = time.time()
aligned_traces2 = petri_alignments.apply(
log,
net,
im,
fm,
variant=petri_alignments.Variants.VERSION_DIJKSTRA_LESS_MEMORY)
dd = time.time()
print(dd - cc)
print(sum(x["visited_states"] for x in aligned_traces2))
print(sum(x["cost"] // 10000 for x in aligned_traces2))