def apply_variants(variants, parameters=None):
"""
Apply the IMDF algorithm to a dictionary/list/set of variants obtaining a Petri net along with an initial and final marking
Parameters
-----------
variants
Dictionary/list/set of variants in the log
parameters
Parameters of the algorithm, including:
pmutil.constants.PARAMETER_CONSTANT_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 = {}
tree = apply_tree_variants(variants, parameters=parameters)
net, initial_marking, final_marking = tree_to_petri.apply(tree)
return net, initial_marking, final_marking
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 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_F 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 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 alignment_default_on_pt(tree, log):
net, initial_marking, final_marking = pt_to_net.apply(tree)
parameters = align_utils.alignment_parameters(net)
parameters['ret_tuple_as_trans_desc'] = True
alignments = align_factory.apply_log(log, net, initial_marking,
final_marking, parameters)
return alignments
def apply_dfg(dfg, parameters, activities=None, contains_empty_traces=False):
"""
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:
pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY -> attribute of the log 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 from which the DFG has been extracted contains empty traces
Returns
-----------
net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
tree = apply_tree_dfg(dfg, parameters, activities=activities, contains_empty_traces=contains_empty_traces)
net, initial_marking, final_marking = tree_to_petri.apply(tree)
return net, initial_marking, final_marking
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:
pmutil.constants.PARAMETER_CONSTANT_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 = {}
if pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters:
parameters[pmutil.constants.
PARAMETER_CONSTANT_ACTIVITY_KEY] = xes_util.DEFAULT_NAME_KEY
if pmutil.constants.PARAMETER_CONSTANT_TIMESTAMP_KEY not in parameters:
parameters[
pmutil.constants.
PARAMETER_CONSTANT_TIMESTAMP_KEY] = xes_util.DEFAULT_TIMESTAMP_KEY
if pmutil.constants.PARAMETER_CONSTANT_CASEID_KEY not in parameters:
parameters[
pmutil.constants.
PARAMETER_CONSTANT_CASEID_KEY] = pmutil.constants.CASE_ATTRIBUTE_GLUE
if type(log) is pd.DataFrame:
return apply_variants(variants_get.get_variants_set(
log, parameters=parameters),
parameters=parameters)
else:
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 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 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 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:
pmutil.constants.PARAMETER_CONSTANT_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 = {}
if pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters:
parameters[pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = xes_util.DEFAULT_NAME_KEY
if pmutil.constants.PARAMETER_CONSTANT_TIMESTAMP_KEY not in parameters:
parameters[pmutil.constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = xes_util.DEFAULT_TIMESTAMP_KEY
if pmutil.constants.PARAMETER_CONSTANT_CASEID_KEY not in parameters:
parameters[pmutil.constants.PARAMETER_CONSTANT_CASEID_KEY] = pmutil.constants.CASE_ATTRIBUTE_GLUE
if isinstance(log, pandas.core.frame.DataFrame):
dfg = df_statistics.get_dfg_graph(log, case_id_glue=parameters[pmutil.constants.PARAMETER_CONSTANT_CASEID_KEY],
activity_key=parameters[pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY],
timestamp_key=parameters[pmutil.constants.PARAMETER_CONSTANT_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, parameters[pmutil.constants.PARAMETER_CONSTANT_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 apply_infrequent_petrinet(tree):
return tree_to_petri.apply(tree)
def draw_normal_pn4pt(tree, parameters=None):
net, initial_marking, final_marking = pt_to_net.apply(tree, parameters)
gviz = pn_vis_factory.apply(net)
pn_vis_factory.view(gviz)
from pm4py.visualization.process_tree import factory as pt_viz
from pm4py.algo.simulation.tree_generator import factory as pt_gen
from pm4py.objects.process_tree import util as pt_util
from pm4py.objects.conversion.process_tree import factory as pt_conv
from pm4py.visualization.petrinet import factory as pn_viz
from pm4py.objects.petri import utils as pn_util
import time
if __name__ == "__main__":
pt = pt_gen.apply()
pt_viz.view(pt_viz.apply(pt, parameters={"format": "svg"}))
time.sleep(1)
pn, im, fm = pt_conv.apply(pt)
pn_viz.view(pn_viz.apply(pn, parameters={'format': 'svg'}))
time.sleep(1)
pt = pt_util.fold(pt)
pt_viz.view(pt_viz.apply(pt, parameters={"format": "svg"}))
from pm4py.algo.simulation.tree_generator import factory as pt_gen
from pm4py.objects.conversion.process_tree import factory as pt_conv
from pm4py.visualization.petrinet import factory as pn_viz
from pm4py.visualization.process_tree import factory as pt_viz
from pm4py.objects.process_tree import util as pt_util
from pm4py.objects.petri import utils as pn_util
import time
from pm4py.objects.petri.exporter import factory as pn_exp
if __name__ == '__main__':
pt = pt_gen.apply()
gviz = pt_viz.apply(pt, parameters={'format': 'svg'})
pt_viz.view(gviz)
time.sleep(1)
pt = pt_util.fold(pt)
gviz = pt_viz.apply(pt, parameters={'format': 'svg'})
pt_viz.view(gviz)
time.sleep(1)
pn, ini, fin = pt_conv.apply(pt)
gviz = pn_viz.apply(pn, ini, fin, parameters={"format": "svg"})
pn_viz.view(gviz)
time.sleep(1)
pn_exp.apply(pn,
ini,
'C:/Users/zelst/Desktop/translation_test.pnml',
final_marking=fin)
