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 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 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 test_evaluation(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.evaluation.simplicity import evaluator as simplicity
simp = simplicity.apply(net)
from pm4py.evaluation import evaluator as evaluation_method
eval = evaluation_method.apply(log, net, im, fm)
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_alphaminer_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 = alpha_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_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_evaluation_pm1(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)
fitness = fitness_alg.apply(log, net, marking, final_marking)
precision = precision_alg.apply(log, net, marking, final_marking)
generalization = generalization_alg.apply(log, net, marking,
final_marking)
simplicity = simplicity_alg.apply(net)
del fitness
del precision
del generalization
del simplicity
def evaluation_w_hm(log):
# print("evaluation_w_hm() called")
net, im, fm = heuristics_miner.apply(log)
# print("herusitic miner performed with the given log")
# net, im, fm = inductive_miner.apply(log)
fitness = replay_fitness_evaluator.apply(
log, net, im, fm, variant=replay_fitness_evaluator.Variants.TOKEN_BASED)['log_fitness']
# print("fitness", fitness)
prec = precision_evaluator.apply(
log, net, im, fm, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN)
# print("pecision", prec)
gen = generalization_evaluator.apply(log, net, im, fm)
# print('generality',gen)
simp = simplicity_evaluator.apply(net)
# print('simplicity',simp)
return [len(log), fitness, prec, gen, simp]
def extract_metrics(log, net, im, fm):
"""
Extracts model quality criteria: fitness, precision, generalization, simplicity
Also records time spent in each metric
"""
start_time = time.time()
fitness = replay_fitness_evaluator.apply(
log,
net,
im,
fm,
variant=replay_fitness_evaluator.Variants.TOKEN_BASED)
fitness_time = time.time() - start_time
start_time = time.time()
precision = precision_evaluator.apply(
log,
net,
im,
fm,
variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN)
precision_time = time.time() - start_time
start_time = time.time()
generalization = generalization_evaluator.apply(log, net, im, fm)
generalization_time = time.time() - start_time
start_time = time.time()
simplicity = simplicity_evaluator.apply(net)
simplicity_time = time.time() - start_time
return [
fitness_time,
precision_time,
generalization_time,
simplicity_time,
*fitness.values(),
precision,
generalization,
simplicity,
]
times_alignments_imdf[logName] = t2 - t1
if ENABLE_PRECISION:
precision_alpha[logName] = precision_evaluator.apply(log, alpha_model, alpha_initial_marking,
alpha_final_marking,
variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN,
parameters=parameters)
else:
precision_alpha[logName] = 0.0
print(str(time.time()) + " precision_alpha for " + logName + " succeeded! " + str(precision_alpha[logName]))
generalization_alpha[logName] = generalization_evaluator.apply(log, alpha_model, alpha_initial_marking,
alpha_final_marking, parameters=parameters)
print(str(time.time()) + " generalization_alpha for " + logName + " succeeded! " + str(
generalization_alpha[logName]))
simplicity_alpha[logName] = simplicity_evaluator.apply(alpha_model, parameters=parameters)
print(
str(time.time()) + " simplicity_alpha for " + logName + " succeeded! " + str(simplicity_alpha[logName]))
if ENABLE_PRECISION:
precision_imdf[logName] = precision_evaluator.apply(log, inductive_model, inductive_im,
inductive_fm, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN,
parameters=parameters)
else:
precision_imdf[logName] = 0.0
print(str(time.time()) + " precision_imdf for " + logName + " succeeded! " + str(precision_imdf[logName]))
generalization_imdf[logName] = generalization_evaluator.apply(log, inductive_model, inductive_im,
inductive_fm, parameters=parameters)
print(str(time.time()) + " generalization_imdf for " + logName + " succeeded! " + str(
generalization_imdf[logName]))
log_converter.Variants.TO_EVENT_LOG.value.Parameters.CASE_ID_KEY: 'number'
}
log = log_converter.apply(log, parameters=parameters)
parameters = {
inductive_miner.Variants.DFG_BASED.value.Parameters.CASE_ID_KEY: 'number',
inductive_miner.Variants.DFG_BASED.value.Parameters.ACTIVITY_KEY:
'activity',
}
petrinet_res = inductive_miner.apply(log, parameters=parameters)
#fitness = calc_fitness.apply(log, *petrinet_res, parameters=parameters)
#print('Conformidade',round(fitness['average_trace_fitness'],4))
precision = calc_precision.apply(log, *petrinet_res, parameters=parameters)
print('Precisao', round(precision, 4))
simplic = calc_simplic.apply(petrinet_res[0], parameters=parameters)
print('Simplicidade', round(simplic, 4))
generaliz = calc_generaliz.apply(log, *petrinet_res, parameters=parameters)
print('Generalização', round(generaliz, 4))
# Precisao 0.1023
# Simplicidade 0.5802
# Generalização 0.575
# ----------------------------------------------------------------------------
# Metrics for kmeans
# Generate a csv file with the metrics for all the kmeans results
def attributes_selection(filename):
if 'specialist' in filename:
def calc_and_time_simplic():
start_time = time.time()
simplic = calc_simplic.apply(petrinet_res)
calc_duration = time.time() - start_time
return round(simplic, 4), calc_duration
sub = ['3', '4', '15', '65', '92']
for s in sub:
# Modello Rete
net, initial_marking, final_marking = pnml_importer.apply(
'../patterns_file/reti_Fahland/repaired_' + s + '_adjusted.pnml')
print("\nValutazione rete sub_" + s + ":")
fitness = replay_evaluator.apply(
log,
net,
initial_marking,
final_marking,
variant=replay_evaluator.Variants.ALIGNMENT_BASED)
print("Fitness: ", fitness)
precision = precision_evaluator.apply(
log,
net,
initial_marking,
final_marking,
variant=precision_evaluator.Variants.ALIGN_ETCONFORMANCE)
print("Precision: ", precision)
generalization = generalization_evaluator.apply(log, net, initial_marking,
final_marking)
print("Generalization: ", generalization)
simplicity = simplicity_evaluator.apply(net)
print("Simplicity: ", simplicity)
with open(
'C:/Users/user/Desktop/ΔΙΠΛΩΜΑΤΙΚΗ/ΔΙΠΛΩΜΑΤΙΚΗ_2/pretty_allignment.txt',
'w') as f:
with redirect_stdout(f):
pretty_print_alignments(alignments)
f.close()
"""
SIMPLICITY για Alpha-Miner, Inductive-Miner, Heuristic-Miner και Heuristic-Miner-With-Parameters.
RESULTS:
simplicity_alpha= 1.0
simplicity_inductive= 0.6274509803921569
simplicity_heuristic= 0.5186721991701245
simplicity_heuristic_with_params= 0.5146443514644352
"""
simplicity_alpha = simplicity_factory.apply(alpha_petri)
simplicity_inductive = simplicity_factory.apply(inductive_petri)
simplicity_heuristic = simplicity_factory.apply(heuristic_petri)
simplicity_heuristic_with_params = simplicity_factory.apply(
heuristic_with_params_petri)
print("simplicity_alpha=", simplicity_alpha)
print("simplicity_inductive=", simplicity_inductive)
print("simplicity_heuristic=", simplicity_heuristic)
print("simplicity_heuristic_with_params=", simplicity_heuristic_with_params)
"""
FITNESS για Alpha-Miner και Inductive-Miner.
"""
fitness_alpha = fitness_evaluator.apply(log, alpha_petri, initial_marking,
final_marking)
