def discover_petri_net_inductive(log, noise_threshold=0.0):
"""
Discovers a Petri net using the IMDFc algorithm
Parameters
--------------
log
Event log_skeleton
noise_threshold
Noise threshold (default: 0.0)
Returns
--------------
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
if noise_threshold > 0.0:
return inductive_miner.apply(log, variant=inductive_miner.Variants.IMf, parameters={
inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: noise_threshold})
else:
return inductive_miner.apply(log, variant=inductive_miner.Variants.IM, parameters={
inductive_miner.Variants.IM.value.Parameters.NOISE_THRESHOLD: noise_threshold})
def discover_petri_net_inductive(log: Union[EventLog, pd.DataFrame], noise_threshold: float = 0.0) -> Tuple[
PetriNet, Marking, Marking]:
"""
Discovers a Petri net using the IMDFc algorithm
Parameters
--------------
log
Event log
noise_threshold
Noise threshold (default: 0.0)
Returns
--------------
petri_net
Petri net
initial_marking
Initial marking
final_marking
Final marking
"""
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
if noise_threshold > 0.0:
return inductive_miner.apply(log, variant=inductive_miner.Variants.IMf, parameters={
inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: noise_threshold})
else:
return inductive_miner.apply(log, variant=inductive_miner.Variants.IM_CLEAN, parameters={
inductive_miner.Variants.IM.value.Parameters.NOISE_THRESHOLD: noise_threshold})
def discover_process_model():
"""
This function is responsible for mining the process model and in turn calling other functions to
continue the simulation and provide additional functionality.
Returns
--------------
net
The petri net generated from the event logs
initial_marking
The initial marking of the petri net generated from the event logs
final_marking
The final marking of the petri net generated from the event logs
"""
log = simulation_activity.verify_extension_and_import()
parameters1 = {
constants.PARAMETER_CONSTANT_CASEID_KEY: "concept:name",
constants.PARAMETER_CONSTANT_ACTIVITY_KEY: "concept:name",
constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: "time:timestamp"
}
print("Beginning Petri net mining. Please wait...")
net, initial_marking, final_marking = inductive_miner.apply(
log, parameters=parameters1)
print("Petri Net creation successful")
relevant_info_generator(net, initial_marking, final_marking, log)
return net, initial_marking, final_marking
def test_58(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.conformance.alignments import algorithm as alignments
model_cost_function = dict()
sync_cost_function = dict()
for t in net.transitions:
# if the label is not None, we have a visible transition
if t.label is not None:
# associate cost 1000 to each move-on-model associated to visible transitions
model_cost_function[t] = 1000
# associate cost 0 to each move-on-log
sync_cost_function[t] = 0
else:
# associate cost 1 to each move-on-model associated to hidden transitions
model_cost_function[t] = 1
parameters = {}
parameters[
alignments.Variants.VERSION_STATE_EQUATION_A_STAR.value.Parameters.PARAM_MODEL_COST_FUNCTION] = model_cost_function
parameters[
alignments.Variants.VERSION_STATE_EQUATION_A_STAR.value.Parameters.PARAM_SYNC_COST_FUNCTION] = sync_cost_function
alignments = alignments.apply_log(log, net, initial_marking, final_marking, parameters=parameters)
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 evaluate_logwithmodel(logpath):
"""
Calculate and return evaluation measurements like fitness, precision, simplicity and generalization, given the path
of event log.
Parameters:
logpath (str): Path of event log
Returns:
fitness (float): Fitness value measured using pm4py
precision (float): Precision value measured using pm4py
simplicity (float): Simplicity value measured using pm4py
generalization (float): Generalization value measured using pm4py
"""
xes_log = importer.apply(logpath)
net, initial_marking, final_marking = inductive_miner.apply(xes_log)
fitness = replay_fitness_evaluator.apply(
xes_log,
net,
initial_marking,
final_marking,
variant=replay_fitness_evaluator.Variants.TOKEN_BASED)
prec = precision_evaluator.apply(
xes_log,
net,
initial_marking,
final_marking,
variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN)
simp = simplicity_evaluator.apply(net)
gen = generalization_evaluator.apply(xes_log, net, initial_marking,
final_marking)
return round(fitness['log_fitness'],
3), round(prec, 3), round(simp, 3), round(gen, 3)
def execute_script():
# import the a32f0n00 log
log = xes_importer.apply(
os.path.join("..", "tests", "compressed_input_data",
"09_a32f0n00.xes.gz"))
# discover a model using the inductive miner
net, im, fm = inductive_miner.apply(log)
# apply the alignments decomposition with a maximal number of border disagreements set to 5
aa = time.time()
aligned_traces = dec_align.apply(
log,
net,
im,
fm,
parameters={
dec_align.Variants.RECOMPOS_MAXIMAL.value.Parameters.PARAM_THRESHOLD_BORDER_AGREEMENT:
5
})
bb = time.time()
print(bb - aa)
# print(aligned_traces)
# calculate the fitness over the recomposed alignment (use the classical evaluation)
fitness = rep_fit.evaluate(aligned_traces,
variant=rep_fit.Variants.ALIGNMENT_BASED)
print(fitness)
def execute_script():
log = pm4py.read_xes(
os.path.join("..", "tests", "input_data", "receipt.xes"))
net, im, fm = inductive_miner.apply(
log, variant=inductive_miner.Variants.IM_CLEAN)
idx = 0
# try to resolve the marking equation to find an heuristics and possible a vector of transitions
# leading from im to fm
sync_net, sync_im, sync_fm = pm4py.construct_synchronous_product_net(
log[idx], net, im, fm)
me_solver = marking_equation.build(sync_net, sync_im, sync_fm)
h, x = me_solver.solve()
firing_sequence, reach_fm1, explained_events = me_solver.get_firing_sequence(
x)
print("for trace at index " + str(idx) + ": marking equation h = ", h)
print("x vector reaches fm = ", reach_fm1)
print("firing sequence = ", firing_sequence)
# it fails and the value of heuristics is low
#
# now let's try with extended marking equation to find the heuristics and the vector!
eme_solver = extended_marking_equation.build(log[idx], sync_net, sync_im,
sync_fm)
h, x = eme_solver.solve()
# the heuristics is much better
firing_sequence, reach_fm2, explained_events = eme_solver.get_firing_sequence(
x)
print(
"for trace at index " + str(idx) + ": extended marking equation h = ",
h)
print("x vector reaches fm = ", reach_fm2)
print("firing sequence = ", firing_sequence)
def execute_script():
log = importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes"))
net, im, fm = inductive_miner.apply(log)
aligned_traces = alignments.apply(log, net, im, fm)
gviz = visualizer.apply(log, aligned_traces,
parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: "svg"})
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 execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "input_data", "running-example.xes"))
net, im, fm = inductive_miner.apply(log)
# perform the Montecarlo simulation with the arrival rate inferred by the log (the simulation lasts 5 secs)
parameters = {}
parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value.
Parameters.PARAM_ENABLE_DIAGNOSTICS] = False
parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value.
Parameters.PARAM_MAX_THREAD_EXECUTION_TIME] = 5
log, res = montecarlo_simulation.apply(log,
net,
im,
fm,
parameters=parameters)
print(
"\n(Montecarlo - Petri net) case arrival ratio inferred from the log")
print(res["median_cases_ex_time"])
print(res["total_cases_time"])
# perform the Montecarlo simulation with the arrival rate specified (the simulation lasts 5 secs)
parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value.
Parameters.PARAM_CASE_ARRIVAL_RATIO] = 60
log, res = montecarlo_simulation.apply(log,
net,
im,
fm,
parameters=parameters)
print(
"\n(Montecarlo - Petri net) case arrival ratio specified by the user")
print(res["median_cases_ex_time"])
print(res["total_cases_time"])
def execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "input_data", "running-example.xes"))
net, im, fm = inductive_miner.apply(log)
# perform the backwards token-based replay
replayed_traces = tr.apply(log, net, im, fm, variant=tr.Variants.BACKWARDS)
print(replayed_traces)
def check_model_quality(original_log, anonymized_log, result_path):
anonymized_model, anonymized_initial_marking, anonymized_final_marking = inductive_miner.apply(
anonymized_log)
results = dict()
fitness = replay_fitness_evaluator.apply(
original_log,
anonymized_model,
anonymized_initial_marking,
anonymized_final_marking,
variant=replay_fitness_evaluator.Variants.TOKEN_BASED)
print("Fitness: " + str(fitness))
results["fitness"] = fitness
precision = precision_evaluator.apply(
original_log,
anonymized_model,
anonymized_initial_marking,
anonymized_final_marking,
variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN)
print("Precision: " + str(precision))
results["precision"] = precision
gen = generalization_evaluator.apply(original_log, anonymized_model,
anonymized_initial_marking,
anonymized_final_marking)
print("Generalization: " + str(gen))
results["generalization"] = gen
simp = simplicity_evaluator.apply(anonymized_model)
print("Simplicity: " + str(simp))
results["simplicity"] = simp
with open(result_path, 'wb') as file:
pickle.dump(results, file)
def test_evaluation_pm2(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, marking, final_marking = inductive_miner.apply(log)
metrics = evaluation_alg.apply(log, net, marking, final_marking)
del metrics
def test_emd_2(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
lang_log = variants_get.get_language(log)
net1, im1, fm1 = inductive_miner.apply(log)
lang_model1 = variants_get.get_language(
simulator.apply(net1, im1, fm1, variant=simulator.Variants.STOCHASTIC_PLAYOUT,
parameters={simulator.Variants.STOCHASTIC_PLAYOUT.value.Parameters.LOG: log}))
emd = earth_mover_distance.apply(lang_model1, lang_log)
def __init__(self,
log,
parameters=None):
self.net, self.initial_marking, self.final_marking = \
inductive_miner.apply(log,
parameters={Parameters.NOISE_THRESHOLD:0.5},
variant=inductive_miner.IMf)
def test_s_components(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 = inductive_miner.apply(log)
s_comps = petri.utils.get_s_components_from_petri(net, im, fm)
del s_comps
def test_running_example_inductive(self):
path = os.path.join("input_data", "running-example.xes")
log = xes_import.apply(path)
net, i_m, f_m = inductive_miner.apply(log)
self.assertTrue(
woflan.apply(net,
i_m,
f_m,
parameters={"print_diagnostics": False}))
def execute_script():
# in this case, we obtain a decision tree by alignments on a specific decision point
log = xes_importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes"))
net, im, fm = inductive_miner.apply(log)
# we need to specify a decision point. In this case, the place p_10 is a suitable decision point
clf, feature_names, classes = algorithm.get_decision_tree(log, net, im, fm, decision_point="p_10")
# we can visualize the decision tree
gviz = visualizer.apply(clf, feature_names, classes,
parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: "svg"})
visualizer.view(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 test_inductiveminer_log(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
net, im, fm = inductive_miner.apply(log)
aligned_traces_tr = tr_alg.apply(log, net, im, fm)
aligned_traces_alignments = align_alg.apply(log, net, im, fm)
evaluation = eval_alg.apply(log, net, im, fm)
fitness = rp_fit.apply(log, net, im, fm)
precision = precision_evaluator.apply(log, net, im, fm)
gen = generalization.apply(log, net, im, fm)
sim = simplicity.apply(net)
def test_55(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
cycles = utils.get_cycles_petri_net_places(net)
def test_inductiveminer_df(self):
log = pd.read_csv(os.path.join("input_data", "running-example.csv"))
log = dataframe_utils.convert_timestamp_columns_in_df(log)
net, im, fm = inductive_miner.apply(log)
aligned_traces_tr = tr_alg.apply(log, net, im, fm)
aligned_traces_alignments = align_alg.apply(log, net, im, fm)
evaluation = eval_alg.apply(log, net, im, fm)
fitness = rp_fit.apply(log, net, im, fm)
precision = precision_evaluator.apply(log, net, im, fm)
gen = generalization.apply(log, net, im, fm)
sim = simplicity.apply(net)
def test_56(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.conformance.alignments import algorithm as alignments
alignments = alignments.apply_log(log, net, initial_marking, final_marking)
def obtainPetriNetThroughImdf(self,
log_name,
variant=inductive_miner.DEFAULT_VARIANT):
# 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"
if ".xes" in log_name:
log = xes_importer.apply(log_name)
else:
df = pd.read_csv(log_name)
df = dataframe_utils.convert_timestamp_columns_in_df(df)
log = log_conversion.apply(df)
# apply dummily the test to all the available variants
net, marking, final_marking = inductive_miner.apply(
log, variant=inductive_miner.DFG_BASED)
net, marking, final_marking = inductive_miner.apply(log,
variant=variant)
soundness = check_soundness.check_petri_wfnet_and_soundness(net)
del soundness
return log, net, marking, final_marking
def test_inductiveminer_stream(self):
df = pd.read_csv(os.path.join("input_data", "running-example.csv"))
df = dataframe_utils.convert_timestamp_columns_in_df(df)
stream = log_conversion.apply(df, variant=log_conversion.TO_EVENT_STREAM)
net, im, fm = inductive_miner.apply(stream)
aligned_traces_tr = tr_alg.apply(stream, net, im, fm)
aligned_traces_alignments = align_alg.apply(stream, net, im, fm)
evaluation = eval_alg.apply(stream, net, im, fm)
fitness = rp_fit.apply(stream, net, im, fm)
precision = precision_evaluator.apply(stream, net, im, fm)
gen = generalization.apply(stream, net, im, fm)
sim = simplicity.apply(net)
def test_etc1(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, marking, final_marking = inductive_miner.apply(log)
precision = etc_alg.apply(log,
net,
marking,
final_marking,
variant=etc_alg.ETCONFORMANCE_TOKEN)
del precision
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 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"))
