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 test_52(self):
# creating an empty Petri net
from pm4py.objects.petri.petrinet import PetriNet, Marking
net = PetriNet("new_petri_net")
# creating source, p_1 and sink place
source = PetriNet.Place("source")
sink = PetriNet.Place("sink")
p_1 = PetriNet.Place("p_1")
# add the places to the Petri Net
net.places.add(source)
net.places.add(sink)
net.places.add(p_1)
# Create transitions
t_1 = PetriNet.Transition("name_1", "label_1")
t_2 = PetriNet.Transition("name_2", "label_2")
# Add the transitions to the Petri Net
net.transitions.add(t_1)
net.transitions.add(t_2)
# Add arcs
from pm4py.objects.petri import utils
utils.add_arc_from_to(source, t_1, net)
utils.add_arc_from_to(t_1, p_1, net)
utils.add_arc_from_to(p_1, t_2, net)
utils.add_arc_from_to(t_2, sink, net)
# Adding tokens
initial_marking = Marking()
initial_marking[source] = 1
final_marking = Marking()
final_marking[sink] = 1
from pm4py.objects.petri.exporter import exporter as pnml_exporter
pnml_exporter.apply(net, initial_marking, "createdPetriNet1.pnml", final_marking=final_marking)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
gviz = pn_visualizer.apply(net, initial_marking, final_marking)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
parameters = {pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking, parameters=parameters)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
parameters = {pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking, parameters=parameters)
pn_visualizer.save(gviz, "alpha.svg")
os.remove("createdPetriNet1.pnml")
os.remove("alpha.svg")
def execute_script():
df = pm4py.read_csv("../tests/input_data/interval_event_log.csv")
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 view_petri_net(petri_net, initial_marking, final_marking, format="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.petrinet 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 model_metrics(model_log_path, metric_log_path, gexp_name):
start_time = time()
model_log_csv = pd.read_csv(model_log_path, ',')
metric_log_csv = pd.read_csv(metric_log_path, ',')
parameters = {log_converter.Variants.TO_EVENT_LOG.value.Parameters.CASE_ID_KEY: 'number'}
model_log = log_converter.apply(model_log_csv, parameters=parameters, variant=log_converter.Variants.TO_EVENT_LOG)
metric_log = log_converter.apply(metric_log_csv, parameters=parameters, variant=log_converter.Variants.TO_EVENT_LOG)
parameters = {inductive_miner.Variants.DFG_BASED.value.Parameters.CASE_ID_KEY: 'number',
inductive_miner.Variants.DFG_BASED.value.Parameters.ACTIVITY_KEY: 'incident_state',
inductive_miner.Variants.DFG_BASED.value.Parameters.TIMESTAMP_KEY: 'sys_updated_at',
alignments.Variants.VERSION_STATE_EQUATION_A_STAR.value.Parameters.ACTIVITY_KEY: 'incident_state'}
petrinet, initial_marking, final_marking = inductive_miner.apply(model_log, parameters=parameters)
gviz = pn_visualizer.apply(petrinet, initial_marking, final_marking)
#gviz.render('petrinets\\'+gexp_name+'\\petri_' + model_base + '.png')
gviz.render('test_time\\test.png')
pn_visualizer.view(gviz)
alignments_res = alignments.apply_log(metric_log, petrinet, initial_marking, final_marking, parameters=parameters)
fitness = replay_fitness.evaluate(alignments_res, variant=replay_fitness.Variants.ALIGNMENT_BASED,
parameters=parameters)
precision = calc_precision.apply(metric_log, petrinet, initial_marking, final_marking, parameters=parameters)
generaliz = calc_generaliz.apply(metric_log, petrinet, initial_marking, final_marking, parameters=parameters)
#generaliz = 0
simplic = calc_simplic.apply(petrinet)
f_score = 2 * ((fitness['averageFitness'] * precision) / (fitness['averageFitness'] + precision))
end_time = time()
m, s = divmod(end_time - start_time, 60)
h, m = divmod(m, 60)
print('Fin %02d:%02d:%02d' % (h, m, s))
print(' F:', '%.10f' % fitness['averageFitness'], ' P:', '%.10f' % precision,
' FS:', '%.10f' % f_score, ' G:', '%.10f' % generaliz, ' S:', '%.10f' % simplic, ' T:',
'%02d:%02d:%02d' % (h, m, s))
#metrics = pd.Series([model_base, metric_base, '%.10f' % fitness['averageFitness'],
# '%.10f' % precision, '%.10f' % f_score, '%.10f' % generaliz, '%.10f' % simplic,
# '%02d:%02d:%02d' % (h, m, s)])
return model_base
def save_vis_petri_net(petri_net, initial_marking, final_marking, file_path):
"""
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 = file_path[file_path.index(".") + 1:].lower()
from pm4py.visualization.petrinet 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 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)
return pt_util.fold(pt) if fold else pt
else:
if debug:
from pm4py.visualization.petrinet import visualizer as pn_viz
pn_viz.view(pn_viz.apply(grouped_net, parameters={"format": "svg"}))
raise ValueError('Parsing of WF-net Failed')
def test_51(self):
import os
from pm4py.objects.petri.importer import importer as pnml_importer
net, initial_marking, final_marking = pnml_importer.apply(
os.path.join("input_data", "running-example.pnml"))
from pm4py.visualization.petrinet import visualizer as pn_visualizer
gviz = pn_visualizer.apply(net, initial_marking, final_marking)
from pm4py.objects.petri.exporter import exporter as pnml_exporter
pnml_exporter.apply(net, initial_marking, "petri.pnml")
pnml_exporter.apply(net, initial_marking, "petri_final.pnml", final_marking=final_marking)
os.remove("petri.pnml")
os.remove("petri_final.pnml")
from pm4py.objects.petri import semantics
transitions = semantics.enabled_transitions(net, initial_marking)
places = net.places
transitions = net.transitions
arcs = net.arcs
for place in places:
stru = "\nPLACE: " + place.name
for arc in place.in_arcs:
stru = str(arc.source.name) + " " + str(arc.source.label)
def execute_script():
log_path = os.path.join("..", "tests", "input_data",
"interval_event_log.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["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
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 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 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", "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 petrinet_visualizer(net,
initial_marking,
final_marking,
parameters=
{pn_visualizer.Variants.WO_DECORATION.\
value.Parameters.FORMAT:"png"}):
gviz = pn_visualizer.apply(net,
initial_marking,
final_marking,
parameters=parameters)
pn_visualizer.view(gviz)
def visualization(log, C, petrinet=True, heu_net=False):
if petrinet:
# net, im, fm = inductive_miner.apply(variants_filter.apply(log, C))
net, im, fm = heuristics_miner.apply(variants_filter.apply(log, C))
gviz = pn_visualizer.apply(net, im, fm)
pn_visualizer.view(gviz)
if heu_net:
heu_net = inductive_miner.apply_heu(variants_filter.apply(log, C))
gviz = hn_vis_factory.apply(heu_net)
hn_vis_factory.view(gviz)
def svg(net_im_fm, kwargs0):
kwargs = copy(kwargs0)
gviz = pn_visualizer.apply(net_im_fm[0],
net_im_fm[1],
net_im_fm[2],
parameters={"format": "svg"})
temp_file = NamedTemporaryFile(suffix=".svg")
temp_file.close()
pn_visualizer.save(gviz, temp_file.name)
F = open(temp_file.name, "r")
content = F.read()
F.close()
return content
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_54(self):
from pm4py.objects.log.importer.xes import importer as xes_importer
import os
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
net, initial_marking, final_marking = inductive_miner.apply(log)
from pm4py.objects.petri import utils
scc = utils.get_strongly_connected_subnets(net)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
gviz = pn_visualizer.apply(scc[0][0], scc[0][1], scc[0][2])
def print_statistics(net, name):
gviz = pn_visualizer.apply(net)
gviz.render('petrinets/simple-' + name, cleanup=True, format='png')
places = net.places
transitions = net.transitions
arcs = net.arcs
print('Lugares:', len(places), 'Arcos:', len(arcs), 'Transições:',
len(transitions))
print('Transição Inputs Outputs')
for transition in transitions:
i = len(transition.in_arcs)
o = len(transition.out_arcs)
if (i < 1) or (o < 1):
print(transition.name, i, o)
sP = ''
for place in places:
if (sP != ''):
sP = sP + ','
sP = sP + place.name
sT = ''
for transition in transitions:
if (sT != ''):
sT = sT + ','
sT = sT + transition.name
sF = ''
for arc in arcs:
if (sF != ''):
sF = sF + ','
sF = sF + '(' + arc.source.name + ',' + arc.target.name + ')'
print('Definição')
print('P = {' + sP + '}')
print('T = {' + sT + '}')
print('F = {' + sF + '}')
def function_before_get(b_click):
if b_click == 1:
pn_visualizer.save(before_gviz, "clean_process.png")
messagebox.showinfo("Message", "Downloaded in 'output' folder")
else:
before = self.before
if self.a == 1:
before = before[[
'Case', 'Activity', "Timestamp", "Resource"
]]
before.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"Resource": "Resource"
})
before.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
elif self.a == 0 and self.b == 1:
before = before[[
'Case', 'Activity', "Timestamp", "System"
]]
before.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"System": "Resource"
})
before.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
before_log = log_converter.apply(before)
b_net, b_initial_marking, b_final_marking = inductive_miner.apply(
before_log)
before_gviz = pn_visualizer.apply(b_net, b_initial_marking,
b_final_marking)
b_click = 1
pn_visualizer.save(
before_gviz, "{}_clean_process.png".format(self.dat_name))
messagebox.showinfo("Message", "Downloaded in 'output' folder")
return b_click
def test_47(self):
log = self.load_running_example_xes()
import os
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
net, initial_marking, final_marking = inductive_miner.apply(log)
from pm4py.visualization.petrinet import visualizer as pn_visualizer
parameters = {pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "png"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking, parameters=parameters,
variant=pn_visualizer.Variants.FREQUENCY, log=log)
pn_visualizer.save(gviz, os.path.join("test_output_data", "inductive_frequency.png"))
os.remove(os.path.join("test_output_data", "inductive_frequency.png"))
def visualize_as_petri_net(net, initial_marking, final_marking, path=''):
if len(path) > 0:
parameters = {
pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"
}
gviz = pn_visualizer.apply(net,
initial_marking,
final_marking,
parameters=parameters)
pn_visualizer.save(gviz, path)
else:
gviz = pn_vis_factory.apply(net, initial_marking, final_marking)
pn_vis_factory.view(gviz)
return net, initial_marking, final_marking
def function_after_get(a_click):
if a_click == 1:
pn_visualizer.save(after_gviz, "anomaly_process.png")
messagebox.showinfo("Message", "Downloaded in 'output' folder")
else:
after = self.after
if self.a == 1:
after = after[[
'Case', 'Activity', "Timestamp", "Resource"
]]
after.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"Resource": "Resource"
})
after.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
elif self.a == 0 and self.b == 1:
after = after[['Case', 'Activity', "Timestamp", "System"]]
after.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"System": "Resource"
})
after.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
after_log = log_converter.apply(after)
a_net, a_initial_marking, a_final_marking = inductive_miner.apply(
after_log)
after_gviz = pn_visualizer.apply(a_net, a_initial_marking,
a_final_marking)
a_click = 1
pn_visualizer.save(
after_gviz, "{}_anomaly_process.png".format(self.dat_name))
messagebox.showinfo("Message", "Downloaded in 'output' folder")
return a_click
def execute_script():
log_path = os.path.join("..", "tests", "input_data",
"interval_event_log.csv")
dataframe = pm4py.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 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 function_before_see(b_click):
if b_click == 1:
before_gviz.view()
else:
before = self.before
if self.a == 1:
before = before[[
'Case', 'Activity', "Timestamp", "Resource"
]]
before.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"Resource": "Resource"
})
before.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
elif self.a == 0 and self.b == 1:
before = before[[
'Case', 'Activity', "Timestamp", "System"
]]
before.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"System": "Resource"
})
before.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
before_log = log_converter.apply(before)
b_net, b_initial_marking, b_final_marking = inductive_miner.apply(
before_log)
before_gviz = pn_visualizer.apply(b_net, b_initial_marking,
b_final_marking)
b_click = 1
before_gviz.view()
return b_click
def execute_script():
# import csv & create log
dataframe = csv_import_adapter.import_dataframe_from_path(
datasourceMockdata(), sep=";")
dataframe = dataframe.rename(columns={
'coID': 'case:concept:name',
'Activity': 'concept:name'
})
log = conversion_factory.apply(dataframe)
# option 1: Directly-Follows Graph, represent frequency or performance
parameters = {constants.PARAMETER_CONSTANT_ACTIVITY_KEY: "concept:name"}
variant = 'frequency'
dfg = dfg_factory.apply(log, variant=variant, parameters=parameters)
gviz1 = dfg_vis_factory.apply(dfg,
log=log,
variant=variant,
parameters=parameters)
dfg_vis_factory.view(gviz1)
# option 2: Heuristics Miner, acts on the Directly-Follows Graph, find common structures, output: Heuristic Net (.svg)
heu_net = heuristics_miner.apply_heu(
log,
parameters={
heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH:
0.00
})
gviz2 = hn_vis.apply(
heu_net,
parameters={hn_vis.Variants.PYDOTPLUS.value.Parameters.FORMAT: "svg"})
hn_vis.view(gviz2)
# option 3: Petri Net based on Heuristic Miner (.png)
net, im, fm = heuristics_miner.apply(
log,
parameters={
heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH:
0.00
})
gviz3 = petri_vis.apply(
net,
im,
fm,
parameters={
petri_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "png"
})
petri_vis.view(gviz3)
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_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)
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.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 function_after_see(a_click):
if a_click == 1:
after_gviz.view()
else:
after = self.after
if self.a == 1:
after = after[[
'Case', 'Activity', "Timestamp", "Resource"
]]
after.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"Resource": "Resource"
})
after.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
elif self.a == 0 and self.b == 1:
after = after[['Case', 'Activity', "Timestamp", "System"]]
after.rename(
columns={
"Case": "case:concept:name",
"Activity": "concept:name",
"Timestamp": "time:timestamp",
"System": "Resource"
})
after.columns = [
'case:concept:name', 'concept:name', "time:timestamp",
"Resource"
]
after_log = log_converter.apply(after)
a_net, a_initial_marking, a_final_marking = inductive_miner.apply(
after_log)
after_gviz = pn_visualizer.apply(a_net, a_initial_marking,
a_final_marking)
a_click = 1
after_gviz.view()
return a_click
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)
