def execute_script():
# import the log
log_path = os.path.join("..", "tests", "input_data", "receipt.xes")
log = xes_importer.apply(log_path)
# apply Inductive Miner
net, initial_marking, final_marking = inductive_miner.apply(log)
# get visualization
variant = pn_vis.Variants.PERFORMANCE
parameters_viz = {
pn_vis.Variants.PERFORMANCE.value.Parameters.AGGREGATION_MEASURE:
"mean",
pn_vis.Variants.PERFORMANCE.value.Parameters.FORMAT: "svg"
}
gviz = pn_vis.apply(net,
initial_marking,
final_marking,
log=log,
variant=variant,
parameters=parameters_viz)
pn_vis.view(gviz)
# do another visualization with frequency
variant = pn_vis.Variants.FREQUENCY
parameters_viz = {pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: "svg"}
gviz = pn_vis.apply(net,
initial_marking,
final_marking,
log=log,
variant=variant,
parameters=parameters_viz)
pn_vis.view(gviz)
def view_petri_net(petri_net: PetriNet,
initial_marking: Optional[Marking] = None,
final_marking: Optional[Marking] = None,
format: str = "png"):
"""
Views a (composite) Petri net
Parameters
-------------
petri_net
Petri net
initial_marking
Initial marking
final marking
Final marking
format
Format of the output picture (default: png)
"""
from pm4py.visualization.petri_net import visualizer as pn_visualizer
gviz = pn_visualizer.apply(
petri_net,
initial_marking,
final_marking,
parameters={
pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT:
format
})
pn_visualizer.view(gviz)
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "interval_event_log.xes")
#log_path = os.path.join("..", "tests", "input_data", "reviewing.xes")
log = xes_importer.apply(log_path)
parameters = {}
parameters[constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp"
parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp"
parameters[constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = "concept:name"
parameters["strict"] = False
parameters["format"] = "svg"
start_activities = sa_get.get_start_activities(log, parameters=parameters)
end_activities = ea_get.get_end_activities(log, parameters=parameters)
parameters["start_activities"] = start_activities
parameters["end_activities"] = end_activities
soj_time = soj_time_get.apply(log, parameters=parameters)
print("soj_time")
print(soj_time)
conc_act = conc_act_get.apply(log, parameters=parameters)
print("conc_act")
print(conc_act)
efg = efg_get.apply(log, parameters=parameters)
print("efg")
print(efg)
dfg_freq = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.FREQUENCY)
dfg_perf = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.PERFORMANCE)
dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, log=log, variant=dfg_vis_fact.Variants.FREQUENCY,
parameters=parameters)
dfg_vis_fact.view(dfg_gv_freq)
dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, log=log, variant=dfg_vis_fact.Variants.PERFORMANCE,
parameters=parameters)
dfg_vis_fact.view(dfg_gv_perf)
net, im, fm = dfg_conv.apply(dfg_freq)
gviz = pn_vis.apply(net, im, fm, parameters=parameters)
pn_vis.view(gviz)
def execute_script():
log = pm4py.read_xes("../tests/input_data/running-example.xes")
dfg, sa, ea = pm4py.discover_dfg(log)
tree = pm4py.discover_process_tree_inductive(log)
heu_net = pm4py.discover_heuristics_net(log)
net, im, fm = pm4py.discover_petri_net_alpha(log)
bpmn = pm4py.convert_to_bpmn(tree)
ts = ts_discovery.apply(log)
x_cases, y_cases = case_statistics.get_kde_caseduration(log)
gviz1 = dfg_visualizer.apply(dfg)
gviz2 = tree_visualizer.apply(tree)
gviz3 = hn_visualizer.apply(heu_net)
gviz4 = pn_visualizer.apply(net, im, fm)
gviz5 = bpmn_visualizer.apply(bpmn)
gviz6 = ts_visualizer.apply(ts)
gviz7 = graphs_visualizer.apply(x_cases, y_cases, variant=graphs_visualizer.Variants.CASES,
parameters={graphs_visualizer.Variants.CASES.value.Parameters.FORMAT: "svg"})
print("1", len(dfg_visualizer.serialize_dot(gviz1)))
print("1", len(dfg_visualizer.serialize(gviz1)))
print("2", len(tree_visualizer.serialize_dot(gviz2)))
print("2", len(tree_visualizer.serialize(gviz2)))
print("3", len(hn_visualizer.serialize(gviz3)))
print("4", len(pn_visualizer.serialize_dot(gviz4)))
print("4", len(pn_visualizer.serialize(gviz4)))
print("5", len(bpmn_visualizer.serialize_dot(gviz5)))
print("5", len(bpmn_visualizer.serialize(gviz5)))
print("6", len(ts_visualizer.serialize_dot(gviz6)))
print("6", len(ts_visualizer.serialize(gviz6)))
print("7", len(graphs_visualizer.serialize(gviz7)))
def save_vis_petri_net(petri_net: PetriNet, initial_marking: Marking,
final_marking: Marking, file_path: str):
"""
Saves a Petri net visualization to a file
Parameters
--------------
petri_net
Petri net
initial_marking
Initial marking
final marking
Final marking
file_path
Destination path
"""
format = os.path.splitext(file_path)[1][1:]
from pm4py.visualization.petri_net import visualizer as pn_visualizer
gviz = pn_visualizer.apply(
petri_net,
initial_marking,
final_marking,
parameters={
pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT:
format
})
pn_visualizer.save(gviz, file_path)
def test_petrinet_running_example(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.apply(os.path.join(INPUT_DATA_DIR, "running-example.xes"))
net, im, fm = heuristics_miner.apply(log)
gviz = pn_vis.apply(net, im, fm)
del gviz
def execute_script():
df = pd.read_csv("../tests/input_data/interval_event_log.csv")
df = pm4py.format_dataframe(df)
log = pm4py.read_xes("../tests/input_data/interval_event_log.xes")
heu_net = plusplus.apply_heu(
log, parameters={"heu_net_decoration": "performance"})
heu_net_2 = plusplus.apply_heu_pandas(
df, parameters={"heu_net_decoration": "performance"})
gviz = visualizer.apply(heu_net, parameters={"format": "svg"})
visualizer.view(gviz)
gviz2 = visualizer.apply(heu_net_2, parameters={"format": "svg"})
visualizer.view(gviz2)
net1, im1, fm1 = plusplus.apply(log)
net2, im2, fm2 = plusplus.apply(log)
gviz3 = pn_visualizer.apply(net1, im1, fm1, parameters={"format": "svg"})
pn_visualizer.view(gviz3)
gviz4 = pn_visualizer.apply(net2, im2, fm2, parameters={"format": "svg"})
pn_visualizer.view(gviz4)
def test_petrinet_receipt_df(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"
df = pd.read_csv(os.path.join(INPUT_DATA_DIR, "receipt.csv"))
df = dataframe_utils.convert_timestamp_columns_in_df(df)
net, im, fm = heuristics_miner.apply(df)
gviz = pn_vis.apply(net, im, fm)
del gviz
def execute_script():
log = xes_importer.apply(os.path.join("..", "tests", "input_data", "receipt.xes"))
log = sorting.sort_timestamp(log)
net, im, fm = inductive_miner.apply(log)
log1 = EventLog(log[:500])
log2 = EventLog(log[len(log) - 500:])
statistics = element_usage_comparison.compare_element_usage_two_logs(net, im, fm, log1, log2)
gviz = pn_vis.apply(net, im, fm, variant=pn_vis.Variants.FREQUENCY, aggregated_statistics=statistics,
parameters={pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: "svg"})
pn_vis.view(gviz)
def execute_script():
log = xes_importer.apply(os.path.join("..", "tests", "compressed_input_data", "09_a32f0n00.xes.gz"))
heu_net = heuristics_miner.apply_heu(log, parameters={
heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99})
gviz = hn_vis.apply(heu_net, parameters={hn_vis.Variants.PYDOTPLUS.value.Parameters.FORMAT: "svg"})
hn_vis.view(gviz)
net, im, fm = heuristics_miner.apply(log, parameters={
heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99})
gviz2 = petri_vis.apply(net, im, fm, parameters={petri_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"})
petri_vis.view(gviz2)
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_import.apply(log_path)
net, i_m, f_m = alpha_miner.apply(log)
gviz = pn_vis.apply(
net,
i_m,
f_m,
parameters={
pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg",
pn_vis.Variants.WO_DECORATION.value.Parameters.DEBUG: False
})
pn_vis.view(gviz)
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
net, marking, final_marking = inductive.apply(
log, variant=inductive.Variants.IM_CLEAN)
for place in marking:
print("initial marking " + place.name)
for place in final_marking:
print("final marking " + place.name)
gviz = pn_vis.apply(
net,
marking,
final_marking,
parameters={
pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg",
pn_vis.Variants.WO_DECORATION.value.Parameters.DEBUG: True
})
pn_vis.view(gviz)
if True:
fit_traces = []
for i in range(0, len(log)):
try:
print("\n", i, [x["concept:name"] for x in log[i]])
cf_result = pm4py.algo.conformance.alignments.petri_net.variants.state_equation_a_star.apply(
log[i], net, marking, final_marking)['alignment']
if cf_result is None:
print("alignment is none!")
else:
is_fit = True
for couple in cf_result:
print(couple)
if not (couple[0] == couple[1]
or couple[0] == ">>" and couple[1] is None):
is_fit = False
print("isFit = " + str(is_fit))
if is_fit:
fit_traces.append(log[i])
except TypeError:
print("EXCEPTION ", i)
traceback.print_exc()
print(fit_traces)
print(len(fit_traces))
def generate_process_model(self,
sub_log,
models_path,
event_data_original_name,
w_count,
activity=''):
# create the folder for saving the process map if does not exist
models_path = self.model_type_definitions.get_models_path(
models_path, event_data_original_name, activity)
if not os.path.exists(models_path):
os.makedirs(models_path)
# mine the petri net (using Pm4Py - Inductive Miner)
net, initial_marking, final_marking = inductive_miner.apply(sub_log)
gviz = pn_visualizer.apply(net, initial_marking, final_marking)
# save the process model
output_filename = self.model_type_definitions.get_model_filename(
event_data_original_name, w_count)
print(f'Saving {models_path} - {output_filename}')
Source.save(gviz, filename=output_filename, directory=models_path)
return PNModel(net, initial_marking, final_marking)
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)
ret = pt_util.fold(pt) if fold else pt
tree_sort(ret)
return ret
else:
if debug:
from pm4py.visualization.petri_net import visualizer as pn_viz
pn_viz.view(pn_viz.apply(grouped_net, parameters={"format":
"svg"}))
raise ValueError('Parsing of WF-net Failed')
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
net, marking, final_marking = alpha_miner.apply(log)
for place in marking:
print("initial marking " + place.name)
for place in final_marking:
print("final marking " + place.name)
gviz = pn_vis.apply(
net,
marking,
final_marking,
parameters={
pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"
})
pn_vis.view(gviz)
print("started token replay")
aligned_traces = token_replay.apply(log, net, marking, final_marking)
fit_traces = [x for x in aligned_traces if x['trace_is_fit']]
perc_fitness = 0.00
if len(aligned_traces) > 0:
perc_fitness = len(fit_traces) / len(aligned_traces)
print("perc_fitness=", perc_fitness)
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "interval_event_log.csv")
dataframe = pd.read_csv(log_path)
log_path = os.path.join("..", "tests", "input_data", "reviewing.xes")
log = pm4py.read_xes(log_path)
dataframe = pm4py.convert_to_dataframe(log)
parameters = {}
#parameters[constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp"
parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp"
parameters[constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = "concept:name"
parameters[constants.PARAMETER_CONSTANT_CASEID_KEY] = "case:concept:name"
parameters["strict"] = True
parameters["format"] = "svg"
start_activities = sa_get.get_start_activities(dataframe, parameters=parameters)
end_activities = ea_get.get_end_activities(dataframe, parameters=parameters)
att_count = att_get.get_attribute_values(dataframe, "concept:name", parameters=parameters)
parameters["start_activities"] = start_activities
parameters["end_activities"] = end_activities
soj_time = soj_time_get.apply(dataframe, parameters=parameters)
print("soj_time")
print(soj_time)
conc_act = conc_act_get.apply(dataframe, parameters=parameters)
print("conc_act")
print(conc_act)
efg = efg_get.apply(dataframe, parameters=parameters)
print("efg")
print(efg)
dfg_freq, dfg_perf = df_statistics.get_dfg_graph(dataframe, measure="both", start_timestamp_key="start_timestamp")
dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, activities_count=att_count, variant=dfg_vis_fact.Variants.FREQUENCY,
soj_time=soj_time, parameters=parameters)
dfg_vis_fact.view(dfg_gv_freq)
dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, activities_count=att_count, variant=dfg_vis_fact.Variants.PERFORMANCE,
soj_time=soj_time, parameters=parameters)
dfg_vis_fact.view(dfg_gv_perf)
net, im, fm = dfg_conv.apply(dfg_freq)
gviz = pn_vis.apply(net, im, fm, parameters=parameters)
pn_vis.view(gviz)
def display_petri_net(net=None):
"""
The function exports the Petri net in .SVG format and saves it in current directory
Parameter:
net (PetriNet) : Petri net model to be stored in .SVG format
Returns:
net_path (str): The path of the saved Petri net model in .SVG form
"""
if net == None:
net = settings.PETRI_NET
im = settings.I_MARKS_ORIG
fm = settings.F_MARKS_ORIG
parameters = {
pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "SVG"
}
gviz = pn_visualizer.apply(net, im, fm, parameters=parameters)
log_name = settings.EVENT_LOG_NAME
log_name = log_name.replace(" ", "")
image_path = os.path.join(settings.NET_PATH, f"{log_name}.SVG")
pn_visualizer.save(gviz, image_path)
return image_path
bpmn_output_path = bpmn_output_path.name
log_path = os.path.join(LOGS_FOLDER, log_name)
print("")
print(log_path)
log = pm4py.read_xes(log_path)
fp_log = pm4py.algo.discovery.footprints.log.variants.entire_event_log.apply(
log)
net, im, fm = pm4py.discover_petri_net_heuristics(log)
fitness0 = pm4py.evaluate_fitness_alignments(log, net, im, fm)
precision0 = pm4py.evaluate_precision_alignments(log, net, im, fm)
print("fitness 0", fitness0)
print("precision 0", precision0)
bpmn_graph = pm4py.objects.conversion.wf_net.variants.to_bpmn.apply(
net, im, fm)
bpmn_graph = layouter.apply(bpmn_graph)
exporter.apply(bpmn_graph, bpmn_output_path)
bpmn_graph = importer.apply(bpmn_output_path)
bpmn_graph = layouter.apply(bpmn_graph)
# gets the net back
net, im, fm = pm4py.objects.conversion.bpmn.variants.to_petri_net.apply(
bpmn_graph)
gviz = pn_visualizer.apply(net, im, fm)
pn_visualizer.view(gviz)
fitness1 = pm4py.evaluate_fitness_alignments(log, net, im, fm)
precision1 = pm4py.evaluate_precision_alignments(log, net, im, fm)
print("fitness 1", fitness1, fitness0 == fitness1)
print("precision 1", precision1, precision0 == precision1)
if not (fitness0 == fitness1 and precision0 == precision1):
print("ALERT")
input()
def test_heuplusplus_petri_log(self):
log = xes_importer.apply(os.path.join(INPUT_DATA_DIR, "interval_event_log.xes"))
net, im, fm = heuristics_miner.apply(log, variant=heuristics_miner.Variants.PLUSPLUS)
gviz = pn_vis.apply(net, im, fm)
str(time.time()) + " generalization_imdf for " + logName +
" succeeded! " + str(generalization_imdf[logName]))
simplicity_imdf[logName] = simplicity_evaluator.apply(
inductive_model, parameters=parameters)
print(
str(time.time()) + " simplicity_imdf for " + logName +
" succeeded! " + str(simplicity_imdf[logName]))
write_report()
if ENABLE_VISUALIZATIONS:
try:
alpha_vis = petri_vis.apply(
alpha_model,
alpha_initial_marking,
alpha_final_marking,
log=log,
parameters=parameters,
variant=petri_vis.Variants.FREQUENCY)
vis_save(
alpha_vis,
os.path.join(pngFolder, logNamePrefix + "_alpha.png"))
print(
str(time.time()) + " alpha visualization for " +
logName + " succeeded!")
except:
print(
str(time.time()) + " alpha visualization for " +
logName + " failed!")
traceback.print_exc()
def test_heuplusplus_petri_df(self):
df = pd.read_csv(os.path.join(INPUT_DATA_DIR, "interval_event_log.csv"))
df = dataframe_utils.convert_timestamp_columns_in_df(df)
net, im, fm = heuristics_miner.Variants.PLUSPLUS.value.apply_pandas(df)
gviz = pn_vis.apply(net, im, fm)
