def apply(log, parameters):
"""
Apply the IM_F algorithm to a log obtaining a Petri net along with an initial and final marking
Parameters
-----------
log
Log
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> attribute of the log to use as activity name
(default concept:name)
Returns
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
if pkgutil.find_loader("pandas"):
import pandas as pd
from pm4py.statistics.variants.pandas import get as variants_get
if type(log) is pd.DataFrame:
vars = variants_get.get_variants_count(log, parameters=parameters)
return apply_variants(vars, parameters=parameters)
log = converter.apply(log, parameters=parameters)
net, initial_marking, final_marking = tree_to_petri.apply(apply_tree(log, parameters))
return net, initial_marking, final_marking
def apply(log, parameters=None):
"""
Apply the IM algorithm to a log obtaining a Petri net along with an initial and final marking
Parameters
-----------
log
Log
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> attribute of the log to use as activity name
(default concept:name)
Returns
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
if type(log) is pd.DataFrame:
vars = variants_get.get_variants_count(log, parameters=parameters)
return apply_variants(vars, parameters=parameters)
else:
log = converter.apply(log, parameters=parameters)
net, initial_marking, final_marking = tree_to_petri.apply(
apply_tree(log, parameters))
return net, initial_marking, final_marking
def apply_variants(variants, parameters=None):
"""
Apply the IM algorithm to a dictionary of variants, obtaining a Petri net along with an initial and final marking
Parameters
-----------
variants
Variants
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> attribute of the log_skeleton to use as activity name
(default concept:name)
Returns
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
net, im, fm = tree_to_petri.apply(
apply_tree_variants(variants, parameters=parameters))
return net, im, fm
def execute_script():
log = pm4py.read_xes(
os.path.join("..", "tests", "input_data", "running-example.xes"))
alpha_petri_net, alpha_im, alpha_fm = pm4py.discover_petri_net_alpha(log)
heuristics_petri_net, heuristics_im, heuristics_fm = pm4py.discover_petri_net_heuristics(
log)
tree = pm4py.discover_tree_inductive(log)
print("tree discovered by inductive miner=")
print(tree)
inductive_petri_net, inductive_im, inductive_fm = pt_converter.apply(tree)
print("is_wf_net alpha", is_wf_net.apply(alpha_petri_net))
print("is_wf_net heuristics", is_wf_net.apply(heuristics_petri_net))
print("is_wf_net inductive", is_wf_net.apply(inductive_petri_net))
print(
"woflan alpha",
woflan.apply(alpha_petri_net,
alpha_im,
alpha_fm,
parameters={
woflan.Parameters.RETURN_ASAP_WHEN_NOT_SOUND: True,
woflan.Parameters.PRINT_DIAGNOSTICS: False
}))
print(
"woflan heuristics",
woflan.apply(heuristics_petri_net,
heuristics_im,
heuristics_fm,
parameters={
woflan.Parameters.RETURN_ASAP_WHEN_NOT_SOUND: True,
woflan.Parameters.PRINT_DIAGNOSTICS: False
}))
print(
"woflan inductive",
woflan.apply(inductive_petri_net,
inductive_im,
inductive_fm,
parameters={
woflan.Parameters.RETURN_ASAP_WHEN_NOT_SOUND: True,
woflan.Parameters.PRINT_DIAGNOSTICS: False
}))
try:
tree_alpha = wf_net_converter.apply(alpha_petri_net, alpha_im,
alpha_fm)
print(tree_alpha)
except:
traceback.print_exc()
try:
tree_heuristics = wf_net_converter.apply(heuristics_petri_net,
heuristics_im, heuristics_fm)
print(tree_heuristics)
except:
traceback.print_exc()
try:
tree_inductive = wf_net_converter.apply(inductive_petri_net,
inductive_im, inductive_fm)
print(tree_inductive)
pm4py.view_process_tree(tree_inductive, format="svg")
except:
traceback.print_exc()
def execute_script():
log_path = os.path.join(
os.path.join("..", "tests", "input_data", "running-example.xes"))
log = xes_import.apply(log_path)
ptree = inductive_miner.apply_tree(log)
bpmn = pt_converter.apply(ptree, variant=pt_converter.Variants.TO_BPMN)
#bpmn = bpmn_layouter.apply(bpmn)
bpmn_exporter.apply(bpmn, "stru.bpmn")
os.remove("stru.bpmn")
def apply_variants(variants, parameters=None):
if parameters is None:
parameters = {}
tree = apply_tree_variants(variants, parameters=parameters)
net, im, fm = tree_converter.apply(
tree,
variant=tree_converter.Variants.TO_PETRI_NET,
parameters=parameters)
return net, im, fm
def apply(
event_log: Union[pd.DataFrame, EventLog, EventStream],
parameters: Optional[Dict[Union[str, Parameters], Any]] = None
) -> Tuple[PetriNet, Marking, Marking]:
if parameters is None:
parameters = {}
tree = apply_tree(event_log, parameters=parameters)
net, im, fm = tree_converter.apply(
tree,
variant=tree_converter.Variants.TO_PETRI_NET,
parameters=parameters)
return net, im, fm
def apply(log, parameters=None):
"""
Apply the IMDF algorithm to a log obtaining a Petri net along with an initial and final marking
Parameters
-----------
log
Log
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> attribute of the log to use as activity name
(default concept:name)
Returns
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
if parameters is None:
parameters = {}
case_id_glue = exec_utils.get_param_value(
Parameters.CASE_ID_KEY, parameters, pmutil.constants.CASE_CONCEPT_NAME)
activity_key = exec_utils.get_param_value(
Parameters.ACTIVITY_KEY, parameters,
pmutil.xes_constants.DEFAULT_NAME_KEY)
timestamp_key = exec_utils.get_param_value(
Parameters.TIMESTAMP_KEY, parameters,
pmutil.xes_constants.DEFAULT_TIMESTAMP_KEY)
if isinstance(log, pandas.core.frame.DataFrame):
dfg = df_statistics.get_dfg_graph(log,
case_id_glue=case_id_glue,
activity_key=activity_key,
timestamp_key=timestamp_key)
start_activities = pd_start_act_stats.get_start_activities(
log, parameters=parameters)
end_activities = pd_end_act_stats.get_end_activities(
log, parameters=parameters)
activities = pd_attributes_stats.get_attribute_values(
log, activity_key, parameters=parameters)
return apply_dfg(dfg,
activities=activities,
start_activities=start_activities,
end_activities=end_activities,
parameters=parameters)
log = log_conversion.apply(log, parameters, log_conversion.TO_EVENT_LOG)
tree = apply_tree(log, parameters=parameters)
net, initial_marking, final_marking = tree_to_petri.apply(tree)
return net, initial_marking, final_marking
def execute_script():
log_path = os.path.join("/Users/Julian/Documents/HiWi/PADS/EventLogs/BPI_Challenge_2012.xes")
log = xes_import.apply(log_path)
#log = keep_one_trace_per_variant(log)
#log = log[15:30]
ptree = ind_miner.apply_tree(log, parameters={Parameters.NOISE_THRESHOLD: 0.5}, variant=ind_miner.Variants.IMf)
gviz = pt_vis.apply(ptree,
parameters={pt_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"})
net, im, fm = converter.apply(ptree)
pt_vis.view(gviz)
def inductive_miner_petri_net(log):
# create the process tree
tree = inductive_miner.apply_tree(log)
# convert the process tree to a petri net
net, initial_marking, final_marking = pt_converter.apply(tree)
find_fitness('induct', log, net, initial_marking, final_marking)
parameters = {
pn_visualizer.Variants.FREQUENCY.value.Parameters.FORMAT: "png"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking,
parameters=parameters,
variant=pn_visualizer.Variants.FREQUENCY,
log=log)
return gviz, None
def test_59(self):
from pm4py.simulation.tree_generator import simulator as tree_gen
parameters = {}
tree = tree_gen.apply(parameters=parameters)
from pm4py.objects.process_tree import semantics
log = semantics.generate_log(tree, no_traces=100)
from pm4py.objects.conversion.process_tree import converter as pt_converter
net, im, fm = pt_converter.apply(tree)
from pm4py.visualization.process_tree import visualizer as pt_visualizer
gviz = pt_visualizer.apply(tree, parameters={pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "png"})
def apply_dfg(dfg,
parameters=None,
activities=None,
contains_empty_traces=False,
start_activities=None,
end_activities=None):
"""
Apply the IMDF algorithm to a DFG graph obtaining a Petri net along with an initial and final marking
Parameters
-----------
dfg
Directly-Follows graph
parameters
Parameters of the algorithm, including:
Parameters.ACTIVITY_KEY -> attribute of the log_skeleton to use as activity name
(default concept:name)
activities
Activities of the process (default None)
contains_empty_traces
Boolean value that is True if the event log_skeleton from which the DFG has been extracted contains empty traces
start_activities
If provided, the start activities of the log_skeleton
end_activities
If provided, the end activities of the log_skeleton
Returns
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
if parameters is None:
parameters = {}
tree = apply_tree_dfg(dfg,
parameters=parameters,
activities=activities,
contains_empty_traces=contains_empty_traces,
start_activities=start_activities,
end_activities=end_activities)
net, initial_marking, final_marking = tree_to_petri.apply(tree)
return net, initial_marking, final_marking
def test_41(self):
import os
from pm4py.objects.log.importer.xes import importer as xes_importer
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
net, initial_marking, final_marking = inductive_miner.apply(log)
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
from pm4py.visualization.process_tree import visualizer as pt_visualizer
tree = inductive_miner.apply_tree(log)
gviz = pt_visualizer.apply(tree)
from pm4py.objects.conversion.process_tree import converter as pt_converter
net, initial_marking, final_marking = pt_converter.apply(tree, variant=pt_converter.Variants.TO_PETRI_NET)
def calculate_optimal_alignment(pt: ProcessTree,
trace: Trace,
parameters=None):
if parameters is None:
parameters = {}
align_variant = exec_utils.get_param_value(
Parameters.CLASSIC_ALIGNMENTS_VARIANT, parameters,
Variants.VERSION_STATE_EQUATION_A_STAR)
conversion_version = exec_utils.get_param_value(
Parameters.CONVERSION_VERSION, parameters,
pt_converter.Variants.TO_PETRI_NET_TRANSITION_BORDERED)
parent = pt.parent
pt.parent = None
net, im, fm = pt_converter.apply(pt, variant=conversion_version)
# in this way, also the other parameters are passed to alignments
alignment_parameters = copy(parameters)
alignment_parameters[
AlignParameters.PARAM_ALIGNMENT_RESULT_IS_SYNC_PROD_AWARE] = True
alignment = get_alignment(trace,
net,
im,
fm,
variant=align_variant,
parameters=alignment_parameters)
pt.parent = parent
res = []
# if the alignment has terminated prematurely due to time constraints, raise an Exception
if alignment is None:
raise AlignmentNoneException("alignment terminated prematurely")
if conversion_version == pt_converter.Variants.TO_PETRI_NET_TRANSITION_BORDERED or conversion_version == pt_converter.Variants.TO_PETRI_NET_TRANSITION_BORDERED.value:
# remove invisible model moves from alignment steps that do not belong to a silent model move in the process tree
# this is possible only if the TO_PETRI_NET_TRANSITION_BORDERED variant is used
for a in alignment["alignment"]:
if not (a[0][0] == SKIP and not a[0][1].isdigit()):
res.append(a[1])
else:
for a in alignment["alignment"]:
res.append(a[1])
return res
def apply_dfg(dfg: Dict[Tuple[str, str], int],
start_activities: Dict[str, int],
end_activities: Dict[str, int],
activities: Dict[str, int],
parameters=None):
if parameters is None:
parameters = {}
tree = apply_tree_dfg(dfg,
start_activities,
end_activities,
activities,
parameters=parameters)
net, im, fm = tree_converter.apply(
tree,
variant=tree_converter.Variants.TO_PETRI_NET,
parameters=parameters)
return net, im, fm
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)
heu_model,
heu_initial_marking,
os.path.join(pnmlFolder,
logNamePrefix + "_heuristics.pnml"),
final_marking=heu_final_marking)
F = open(logNamePrefix + "_heuristics.txt", "w")
F.write(exce)
F.close()
t1 = time.time()
tree = inductive.apply_tree(log,
parameters=parameters_discovery,
variant=INDUCTIVE_MINER_VARIANT)
# print(tree)
inductive_model, inductive_im, inductive_fm = pt_converter.apply(
tree, variant=pt_converter.Variants.TO_PETRI_NET)
"""inductive_model, inductive_im, inductive_fm = inductive.apply(log, parameters=parameters_discovery,
variant=INDUCTIVE_MINER_VARIANT)"""
if ENABLE_PETRI_EXPORTING:
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",
def apply_infrequent_petrinet(tree):
return tree_to_petri.apply(tree)
def get_im_net_im_fm_from_variants(self, parameters=None):
tree = self.get_im_tree_from_variants(parameters=parameters)
net, im, fm = converter.apply(tree, parameters=parameters)
return net, im, fm
def get_imd_net_im_fm_from_dfg(self, parameters=None):
tree = self.get_imd_tree_from_dfg(parameters=parameters)
net, im, fm = converter.apply(tree, parameters=parameters)
return net, im, fm
def test_bpmn_layouting(self):
log = pm4py.read_xes(os.path.join("input_data", "running-example.xes"))
tree = pm4py.discover_tree_inductive(log)
bpmn_graph = tree_converter.apply(tree, variant=tree_converter.Variants.TO_BPMN)
bpmn_graph = bpmn_layouter.apply(bpmn_graph)
def calculate_get_best_worst_cost(tree: ProcessTree,
conversion_version) -> int:
net, im, fm = pt_converter.apply(tree, variant=conversion_version)
return get_best_worst_cost(net, im, fm)
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
from pm4py.visualization.process_tree import visualizer as pt_visualizer
tree = inductive_miner.apply_tree(log)
import os
os.environ["PATH"] += os.pathsep + 'c:/Program Files (x86)/Graphviz2.38/bin/'
import graphviz
from subprocess import call
call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])
gviz = pt_visualizer.apply(tree)
pt_visualizer.view(gviz)
#
from pm4py.objects.conversion.process_tree import converter as pt_converter
net, initial_marking, final_marking = pt_converter.apply(tree, variant=pt_converter.Variants.TO_PETRI_NET)
#heuristic Miner
from pm4py.objects.log.importer.xes import importer as xes_importer
import os
#log_path = os.path.join("tests", "compressed_input_data", "09_a32f0n00.xes.gz")
log_path = os.path.join('E:/data/pm/running-example.xes')
log = xes_importer.apply(log_path)
from pm4py.algo.discovery.heuristics import algorithm as heuristics_miner
heu_net = heuristics_miner.apply_heu(log, parameters= {heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99})
from pm4py.visualization.heuristics_net import visualizer as hn_visualizer
gviz = hn_visualizer.apply(heu_net)
hn_visualizer.view(gviz)
