def evaluate_precision_alignments(log: EventLog, petri_net: PetriNet, initial_marking: Marking, final_marking: Marking) -> float: warnings.warn('evaluate_precision_alignments is deprecated, use precision_alignments', DeprecationWarning) """ Calculates the precision using alignments Parameters -------------- log Event log petri_net Petri net object initial_marking Initial marking final_marking Final marking Returns -------------- precision float representing the precision value """ if type(log) not in [pd.DataFrame, EventLog, EventStream]: raise Exception("the method can be applied only to a traditional event log!") from pm4py.algo.evaluation.precision import algorithm as precision_evaluator return precision_evaluator.apply(log, petri_net, initial_marking, final_marking, variant=precision_evaluator.Variants.ALIGN_ETCONFORMANCE, parameters=get_properties(log))
def precision_token_based_replay(log: EventLog, petri_net: PetriNet, initial_marking: Marking, final_marking: Marking) -> float: """ Calculates the precision precision using token-based replay Parameters -------------- log Event log petri_net Petri net object initial_marking Initial marking final_marking Final marking Returns -------------- precision float representing the precision value """ if type(log) not in [pd.DataFrame, EventLog, EventStream]: raise Exception("the method can be applied only to a traditional event log!") from pm4py.algo.evaluation.precision import algorithm as precision_evaluator return precision_evaluator.apply(log, petri_net, initial_marking, final_marking, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN, parameters=get_properties(log))
def precision_alignments(log: EventLog, petri_net: PetriNet, initial_marking: Marking, final_marking: Marking, multi_processing: bool = False) -> float: """ Calculates the precision of the model w.r.t. the event log using alignments Parameters -------------- log Event log petri_net Petri net object initial_marking Initial marking final_marking Final marking multi_processing Boolean value that enables the multiprocessing (default: False) Returns -------------- precision float representing the precision value """ if type(log) not in [pd.DataFrame, EventLog, EventStream]: raise Exception("the method can be applied only to a traditional event log!") from pm4py.algo.evaluation.precision import algorithm as precision_evaluator parameters = get_properties(log) parameters["multiprocessing"] = multi_processing return precision_evaluator.apply(log, petri_net, initial_marking, final_marking, variant=precision_evaluator.Variants.ALIGN_ETCONFORMANCE, parameters=parameters)
def evaluate_precision_alignments(log: EventLog, petri_net: PetriNet, initial_marking: Marking, final_marking: Marking) -> float: warnings.warn('evaluate_precision_alignments is deprecated, use precision_alignments', DeprecationWarning) """ Calculates the precision using alignments Parameters -------------- log Event log petri_net Petri net object initial_marking Initial marking final_marking Final marking Returns -------------- precision float representing the precision value """ from pm4py.algo.evaluation.precision import algorithm as precision_evaluator return precision_evaluator.apply(log, petri_net, initial_marking, final_marking, variant=precision_evaluator.Variants.ALIGN_ETCONFORMANCE)
def precision_alignments(log: EventLog, petri_net: PetriNet, initial_marking: Marking, final_marking: Marking, multi_processing: bool = False) -> float: """ Calculates the precision of the model w.r.t. the event log using alignments Parameters -------------- log Event log petri_net Petri net object initial_marking Initial marking final_marking Final marking multi_processing Boolean value that enables the multiprocessing (default: False) Returns -------------- precision float representing the precision value """ from pm4py.algo.evaluation.precision import algorithm as precision_evaluator return precision_evaluator.apply(log, petri_net, initial_marking, final_marking, variant=precision_evaluator.Variants.ALIGN_ETCONFORMANCE, parameters={"multiprocessing": multi_processing})
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_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_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_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.petri_net 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.algo.evaluation.replay_fitness import algorithm 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.algo.evaluation.precision import algorithm as precision_evaluator precision = precision_evaluator.apply(log, net, im, fm, variant=rp_fitness_evaluator.Variants.ALIGNMENT_BASED)
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_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.algo.evaluation.replay_fitness import algorithm 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.algo.evaluation.precision import algorithm as precision_evaluator precision = precision_evaluator.apply(log, net, im, fm, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN) from pm4py.algo.evaluation.generalization import algorithm as generalization_evaluation generalization = generalization_evaluation.apply(log, net, im, fm, variant=generalization_evaluation.Variants.GENERALIZATION_TOKEN)
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 get_precision(pn_net, im, fm): """ Returns the precision of the model. Parameter: net (PetriNet): Generated Petri net of the log im (Marking) : Initial marking of the generated Petri net fm (Marking) : Final marking of the generated Petri net Return: Precision (float) : Precision value measured using pm4py """ log = settings.EVENT_LOG #prec = precision_evaluator.apply(log, pn_net, im, fm, variant=precision_evaluator.Variants.ALIGN_ETCONFORMANCE) prec = precision_evaluator.apply( log, pn_net, im, fm, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN) return prec
def precision_token_based_replay(log: EventLog, petri_net: PetriNet, initial_marking: Marking, final_marking: Marking) -> float: """ Calculates the precision precision using token-based replay Parameters -------------- log Event log petri_net Petri net object initial_marking Initial marking final_marking Final marking Returns -------------- precision float representing the precision value """ from pm4py.algo.evaluation.precision import algorithm as precision_evaluator return precision_evaluator.apply(log, petri_net, initial_marking, final_marking, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN)
t1 = time.time() fitness_align_imdf[logName] = \ fitness_evaluator.apply(log, inductive_model, inductive_im, inductive_fm, variant=fitness_evaluator.Variants.ALIGNMENT_BASED, parameters=parameters)[ 'percFitTraces'] print( str(time.time()) + " fitness_token_align for " + logName + " succeeded! " + str(fitness_align_imdf[logName])) t2 = time.time() 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)