def test_alpha_miner_log(self): log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) from pm4py.algo.discovery.alpha import algorithm as alpha_miner net1, im1, fm1 = alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC) net2, im2, fm2 = alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS) from pm4py.algo.discovery.dfg import algorithm as dfg_discovery dfg = dfg_discovery.apply(log) net3, im3, fm3 = alpha_miner.apply_dfg(dfg, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC)
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 test_playout(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.simulation.playout import simulator log2 = simulator.apply(net, im, fm)
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)
def test_alpha_miner_dataframe(self): from pm4py.objects.log.adapters.pandas import csv_import_adapter df = csv_import_adapter.import_dataframe_from_path( os.path.join("input_data", "running-example.csv")) from pm4py.algo.discovery.alpha import algorithm as alpha_miner net, im, fm = alpha_miner.apply( df, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC)
def test_48(self): import os from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.algo.discovery.alpha import algorithm as alpha_miner log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) parameters = {alpha_miner.Variants.ALPHA_VERSION_CLASSIC.value.Parameters.ACTIVITY_KEY: "concept:name"} net, initial_marking, final_marking = alpha_miner.apply(log, parameters=parameters)
def test_conversion_pn_to_pt(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.objects.conversion.wf_net import converter as wf_net_converter tree = wf_net_converter.apply( net, im, fm, variant=wf_net_converter.Variants.TO_PROCESS_TREE)
def test_decomp_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.decomp_alignments import algorithm as decomp_align aligned_traces = decomp_align.apply( log, net, im, fm, variant=decomp_align.Variants.RECOMPOS_MAXIMAL)
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.algo.evaluation.simplicity import algorithm as simplicity simp = simplicity.apply(net) from pm4py.algo.evaluation import algorithm as evaluation_method eval = evaluation_method.apply(log, net, im, fm)
def test_running_example_alpha(self): path = os.path.join("input_data", "running-example.xes") log = xes_import.apply(path) net, i_m, f_m = alpha_miner.apply(log) self.assertTrue( woflan.apply(net, i_m, f_m, parameters={"print_diagnostics": False}))
def test_footprints_net(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.discovery.footprints import algorithm as footprints_discovery fp_log = footprints_discovery.apply(log) fp_net = footprints_discovery.apply(net, im) from pm4py.algo.conformance.footprints import algorithm as footprints_conformance conf = footprints_conformance.apply(fp_log, fp_net)
def gerar_orgaosjulgadores_modelfit_from_params(ramo_justica, codtribunal, atuacao, cluster, grau, codorgaoj, codnatureza, codclasse, dtinicio, dtfim, baixado=None, sensibility='60'): eventLog = gerar_log_eventos(ramo_justica, codtribunal, atuacao, cluster, grau, codorgaoj, codnatureza, codclasse, dtinicio, dtfim, baixado, sensibility) net, initial_marking, final_marking = alpha_miner.apply(eventLog) orgaos_model_fit = [] df = consultar_orgaosjulgadores_por_tribunal_e_atuacaovara( codtribunal, atuacao) with ThreadPoolExecutor(max_workers=15) as executor: future_to_row = { executor.submit(get_token_replayed_traces_from_params, net, initial_marking, final_marking, ramo_justica, codtribunal, atuacao, cluster, grau, str(row["cod"]), codnatureza, codclasse, dtinicio, dtfim, baixado, sensibility): row for index, row in df.iterrows() } for future in concurrent.futures.as_completed(future_to_row): row = future_to_row[future] try: replayed_traces = future.result() orgao_model_fit = { "cod": row["cod"], "descricao": row["descricao"], "traceFitness": str(replayed_traces[0]['trace_fitness'] * 100) + ' %', "traceIsFit": replayed_traces[0]['trace_is_fit'] } orgaos_model_fit.append(orgao_model_fit) except Exception as exc: print('%r generated an exception: %s' % (row, exc)) sorted_orgaos_model_fit = sorted(orgaos_model_fit, key=lambda i: i['traceFitness'], reverse=True) return sorted_orgaos_model_fit
def test_alphaminer_log(self): log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) 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_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_alphaminer_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 = alpha_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_50(self): import os from pm4py.objects.log.importer.xes import importer as xes_importer log = xes_importer.apply(os.path.join("input_data", "receipt.xes")) for trace in log: for event in trace: event["customClassifier"] = event["concept:name"] + event["lifecycle:transition"] from pm4py.algo.discovery.alpha import algorithm as alpha_miner parameters = {alpha_miner.Variants.ALPHA_VERSION_CLASSIC.value.Parameters.ACTIVITY_KEY: "customClassifier"} net, initial_marking, final_marking = alpha_miner.apply(log, parameters=parameters)
def test_49(self): import os from pm4py.objects.log.importer.xes import importer as xes_importer log = xes_importer.apply(os.path.join("input_data", "receipt.xes")) classifiers = log.classifiers from pm4py.objects.log.util import insert_classifier log, activity_key = insert_classifier.insert_activity_classifier_attribute(log, "Activity classifier") from pm4py.algo.discovery.alpha import algorithm as alpha_miner parameters = {alpha_miner.Variants.ALPHA_VERSION_CLASSIC.value.Parameters.ACTIVITY_KEY: activity_key} net, initial_marking, final_marking = alpha_miner.apply(log, parameters=parameters)
def execute_script(): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) net, im, fm = alpha_miner.apply(log) is_sound, diagn = woflan.apply(net, im, fm, parameters={ "print_diagnostics": True, "return_diagnostics": True }) print("is_sound", is_sound) print(diagn)
def obtainPetriNetThroughAlphaMiner(self, log_name): # 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) net, marking, fmarking = alpha_alg.apply(log) return log, net, marking, fmarking
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_import.apply(log_path) net, i_m, f_m = alpha_miner.apply(log) gviz = pn_vis.apply( net, i_m, f_m, parameters={ pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg", pn_vis.Variants.WO_DECORATION.value.Parameters.DEBUG: False }) pn_vis.view(gviz)
def test_footprints_net(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.discovery.footprints import algorithm as footprints_discovery fp_entire_log = footprints_discovery.apply(log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG) fp_trace_trace = footprints_discovery.apply(log) fp_net = footprints_discovery.apply(net, im) from pm4py.algo.conformance.footprints import algorithm as footprints_conformance conf1 = footprints_conformance.apply(fp_entire_log, fp_net) conf2 = footprints_conformance.apply(fp_trace_trace, fp_net) conf3 = footprints_conformance.apply(fp_entire_log, fp_net, variant=footprints_conformance.Variants.LOG_EXTENSIVE) conf4 = footprints_conformance.apply(fp_trace_trace, fp_net, variant=footprints_conformance.Variants.TRACE_EXTENSIVE)
def test_rep_log_petri_fitness(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")) pref_mat, var_mat, activities = prefix_matrix.get_prefix_variants_matrix( log) net, im, fm = alpha_miner.apply(log) net_matrix = project_net_on_matrix(net, activities) product_matrix = np.matmul(pref_mat, net_matrix) max_product_matrix = np.max(product_matrix) self.assertGreaterEqual(max_product_matrix, 0)
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_importer.apply(log_path) net, marking, final_marking = alpha_miner.apply(log) for place in marking: print("initial marking " + place.name) for place in final_marking: print("final marking " + place.name) gviz = pn_vis.apply(net, marking, final_marking, parameters={pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"}) pn_vis.view(gviz) print("started token replay") aligned_traces = token_replay.apply(log, net, marking, final_marking) fit_traces = [x for x in aligned_traces if x['trace_is_fit']] perc_fitness = 0.00 if len(aligned_traces) > 0: perc_fitness = len(fit_traces) / len(aligned_traces) print("perc_fitness=", perc_fitness)
def execute_script(): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) net, im, fm = alpha_miner.apply(log) # the alpha miner in this case returns a sound workflow net! # get the tangible reachability graph and the Q-matrix reach_graph, tang_reach_graph, stochastic_map, q_matrix = ctmc.get_tangible_reachability_and_q_matrix_from_log_net( log, net, im, fm) print(reach_graph.states) # pick the source state state = [ x for x in tang_reach_graph.states if x.name.startswith("registerrequest") or x.name.startswith("reinitiaterequest") ][0] # analyse the distribution over the states of the system starting from the source after 86400.0 seconds (1 day) transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state( tang_reach_graph, q_matrix, state, 86400.0) print(transient_result)
def discover_petri_net_alpha(log: EventLog) -> Tuple[PetriNet, Marking, Marking]: """ Discovers a Petri net using the Alpha Miner Parameters -------------- log Event log Returns -------------- petri_net Petri net initial_marking Initial marking final_marking Final marking """ from pm4py.algo.discovery.alpha import algorithm as alpha_miner return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_CLASSIC)
def discover_petri_net_alpha_plus(log): """ Discovers a Petri net using the Alpha+ algorithm Parameters -------------- log Event log_skeleton Returns -------------- petri_net Petri net initial_marking Initial marking final_marking Final marking """ from pm4py.algo.discovery.alpha import algorithm as alpha_miner return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS)
def discover_petri_net_alpha_plus(log: Union[EventLog, pd.DataFrame]) -> Tuple[PetriNet, Marking, Marking]: """ Discovers a Petri net using the Alpha+ algorithm Parameters -------------- log Event log Returns -------------- petri_net Petri net initial_marking Initial marking final_marking Final marking """ from pm4py.algo.discovery.alpha import algorithm as alpha_miner return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS)
def test_alignment_alpha(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, fmarking = alpha_alg.apply(log) final_marking = petri_net.obj.Marking() for p in net.places: if not p.out_arcs: final_marking[p] = 1 for trace in log: cf_result = \ align_alg.apply(trace, net, marking, final_marking, variant=align_alg.VERSION_DIJKSTRA_NO_HEURISTICS)[ 'alignment'] is_fit = True for couple in cf_result: if not (couple[0] == couple[1] or couple[0] == ">>" and couple[1] is None): is_fit = False if not is_fit: raise Exception("should be fit")
def discover_petri_net_alpha_plus(log: Union[EventLog, pd.DataFrame]) -> Tuple[PetriNet, Marking, Marking]: """ Discovers a Petri net using the Alpha+ algorithm Parameters -------------- log Event log Returns -------------- petri_net Petri net initial_marking Initial marking final_marking Final marking """ 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.discovery.alpha import algorithm as alpha_miner return alpha_miner.apply(log, variant=alpha_miner.Variants.ALPHA_VERSION_PLUS, parameters=get_properties(log))