def test_tokenreplay(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.tokenreplay import algorithm as token_replay
replayed_traces = token_replay.apply(
log, net, im, fm, variant=token_replay.Variants.TOKEN_REPLAY)
replayed_traces = token_replay.apply(
log, net, im, fm, variant=token_replay.Variants.BACKWARDS)
from pm4py.evaluation.replay_fitness import evaluator as rp_fitness_evaluator
fitness = rp_fitness_evaluator.apply(
log,
net,
im,
fm,
variant=rp_fitness_evaluator.Variants.TOKEN_BASED)
evaluation = rp_fitness_evaluator.evaluate(
replayed_traces, variant=rp_fitness_evaluator.Variants.TOKEN_BASED)
from pm4py.evaluation.precision import evaluator as precision_evaluator
precision = precision_evaluator.apply(
log,
net,
im,
fm,
variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN)
from pm4py.evaluation.generalization import evaluator as generalization_evaluation
generalization = generalization_evaluation.apply(
log,
net,
im,
fm,
variant=generalization_evaluation.Variants.GENERALIZATION_TOKEN)
def test_alignment(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import algorithm as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.alignments import algorithm as alignments
aligned_traces = alignments.apply(
log,
net,
im,
fm,
variant=alignments.Variants.VERSION_STATE_EQUATION_A_STAR)
aligned_traces = alignments.apply(
log,
net,
im,
fm,
variant=alignments.Variants.VERSION_DIJKSTRA_NO_HEURISTICS)
from pm4py.evaluation.replay_fitness import evaluator as rp_fitness_evaluator
fitness = rp_fitness_evaluator.apply(
log,
net,
im,
fm,
variant=rp_fitness_evaluator.Variants.ALIGNMENT_BASED)
evaluation = rp_fitness_evaluator.evaluate(
aligned_traces,
variant=rp_fitness_evaluator.Variants.ALIGNMENT_BASED)
from pm4py.evaluation.precision import evaluator as precision_evaluator
precision = precision_evaluator.apply(
log,
net,
im,
fm,
variant=rp_fitness_evaluator.Variants.ALIGNMENT_BASED)
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():
# 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 test_57(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"))
for trace in log:
for event in trace:
event["customClassifier"] = event["concept:name"] + event["concept:name"]
from pm4py.algo.conformance.alignments import algorithm as alignments
# define the activity key in the parameters
parameters = {inductive_miner.Variants.DFG_BASED.value.Parameters.ACTIVITY_KEY: "customClassifier",
alignments.Variants.VERSION_STATE_EQUATION_A_STAR.value.Parameters.ACTIVITY_KEY: "customClassifier"}
# calculate process model using the given classifier
net, initial_marking, final_marking = inductive_miner.apply(log, parameters=parameters)
alignments = alignments.apply_log(log, net, initial_marking, final_marking, parameters=parameters)
from pm4py.evaluation.replay_fitness import evaluator as replay_fitness
log_fitness = replay_fitness.evaluate(alignments, variant=replay_fitness.Variants.ALIGNMENT_BASED)
gviz = hn_visualizer.apply(heu_net)
#hn_visualizer.view(gviz)
from pm4py.algo.discovery.heuristics import algorithm as heuristics_miner
net, im, fm = heuristics_miner.apply(
log,
parameters={
heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH:
0.99
})
print("alignment start")
starttime = datetime.datetime.now()
print(starttime)
from pm4py.algo.conformance.alignments import algorithm as alignments
alignments = alignments.apply_log(log, net, im, fm)
endtime = datetime.datetime.now()
print(endtime)
print("alignments success")
from pm4py.evaluation.replay_fitness import evaluator as replay_fitness
log_fitness = replay_fitness.evaluate(
alignments, variant=replay_fitness.Variants.ALIGNMENT_BASED)
print(log_fitness)
print("system end")
final_time = endtime - starttime
print(final_time.seconds)