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)