def execute_script(): # import the log log_path = os.path.join("..", "tests", "input_data", "receipt.xes") log = xes_importer.apply(log_path) # apply Inductive Miner net, initial_marking, final_marking = inductive_miner.apply(log) # get visualization variant = pn_vis.Variants.PERFORMANCE parameters_viz = { pn_vis.Variants.PERFORMANCE.value.Parameters.AGGREGATION_MEASURE: "mean", pn_vis.Variants.PERFORMANCE.value.Parameters.FORMAT: "svg" } gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant, parameters=parameters_viz) pn_vis.view(gviz) # do another visualization with frequency variant = pn_vis.Variants.FREQUENCY parameters_viz = {pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: "svg"} gviz = pn_vis.apply(net, initial_marking, final_marking, log=log, variant=variant, parameters=parameters_viz) pn_vis.view(gviz)
def view_petri_net(petri_net: PetriNet, initial_marking: Optional[Marking] = None, final_marking: Optional[Marking] = None, format: str = "png"): """ Views a (composite) Petri net Parameters ------------- petri_net Petri net initial_marking Initial marking final marking Final marking format Format of the output picture (default: png) """ from pm4py.visualization.petri_net import visualizer as pn_visualizer gviz = pn_visualizer.apply( petri_net, initial_marking, final_marking, parameters={ pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: format }) pn_visualizer.view(gviz)
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "interval_event_log.xes") #log_path = os.path.join("..", "tests", "input_data", "reviewing.xes") log = xes_importer.apply(log_path) parameters = {} parameters[constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp" parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp" parameters[constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = "concept:name" parameters["strict"] = False parameters["format"] = "svg" start_activities = sa_get.get_start_activities(log, parameters=parameters) end_activities = ea_get.get_end_activities(log, parameters=parameters) parameters["start_activities"] = start_activities parameters["end_activities"] = end_activities soj_time = soj_time_get.apply(log, parameters=parameters) print("soj_time") print(soj_time) conc_act = conc_act_get.apply(log, parameters=parameters) print("conc_act") print(conc_act) efg = efg_get.apply(log, parameters=parameters) print("efg") print(efg) dfg_freq = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.FREQUENCY) dfg_perf = dfg_algorithm.apply(log, parameters=parameters, variant=dfg_algorithm.Variants.PERFORMANCE) dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, log=log, variant=dfg_vis_fact.Variants.FREQUENCY, parameters=parameters) dfg_vis_fact.view(dfg_gv_freq) dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, log=log, variant=dfg_vis_fact.Variants.PERFORMANCE, parameters=parameters) dfg_vis_fact.view(dfg_gv_perf) net, im, fm = dfg_conv.apply(dfg_freq) gviz = pn_vis.apply(net, im, fm, parameters=parameters) pn_vis.view(gviz)
def execute_script(): log = pm4py.read_xes("../tests/input_data/running-example.xes") dfg, sa, ea = pm4py.discover_dfg(log) tree = pm4py.discover_process_tree_inductive(log) heu_net = pm4py.discover_heuristics_net(log) net, im, fm = pm4py.discover_petri_net_alpha(log) bpmn = pm4py.convert_to_bpmn(tree) ts = ts_discovery.apply(log) x_cases, y_cases = case_statistics.get_kde_caseduration(log) gviz1 = dfg_visualizer.apply(dfg) gviz2 = tree_visualizer.apply(tree) gviz3 = hn_visualizer.apply(heu_net) gviz4 = pn_visualizer.apply(net, im, fm) gviz5 = bpmn_visualizer.apply(bpmn) gviz6 = ts_visualizer.apply(ts) gviz7 = graphs_visualizer.apply(x_cases, y_cases, variant=graphs_visualizer.Variants.CASES, parameters={graphs_visualizer.Variants.CASES.value.Parameters.FORMAT: "svg"}) print("1", len(dfg_visualizer.serialize_dot(gviz1))) print("1", len(dfg_visualizer.serialize(gviz1))) print("2", len(tree_visualizer.serialize_dot(gviz2))) print("2", len(tree_visualizer.serialize(gviz2))) print("3", len(hn_visualizer.serialize(gviz3))) print("4", len(pn_visualizer.serialize_dot(gviz4))) print("4", len(pn_visualizer.serialize(gviz4))) print("5", len(bpmn_visualizer.serialize_dot(gviz5))) print("5", len(bpmn_visualizer.serialize(gviz5))) print("6", len(ts_visualizer.serialize_dot(gviz6))) print("6", len(ts_visualizer.serialize(gviz6))) print("7", len(graphs_visualizer.serialize(gviz7)))
def save_vis_petri_net(petri_net: PetriNet, initial_marking: Marking, final_marking: Marking, file_path: str): """ Saves a Petri net visualization to a file Parameters -------------- petri_net Petri net initial_marking Initial marking final marking Final marking file_path Destination path """ format = os.path.splitext(file_path)[1][1:] from pm4py.visualization.petri_net import visualizer as pn_visualizer gviz = pn_visualizer.apply( petri_net, initial_marking, final_marking, parameters={ pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: format }) pn_visualizer.save(gviz, file_path)
def test_petrinet_running_example(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, im, fm = heuristics_miner.apply(log) gviz = pn_vis.apply(net, im, fm) del gviz
def execute_script(): df = pd.read_csv("../tests/input_data/interval_event_log.csv") df = pm4py.format_dataframe(df) log = pm4py.read_xes("../tests/input_data/interval_event_log.xes") heu_net = plusplus.apply_heu( log, parameters={"heu_net_decoration": "performance"}) heu_net_2 = plusplus.apply_heu_pandas( df, parameters={"heu_net_decoration": "performance"}) gviz = visualizer.apply(heu_net, parameters={"format": "svg"}) visualizer.view(gviz) gviz2 = visualizer.apply(heu_net_2, parameters={"format": "svg"}) visualizer.view(gviz2) net1, im1, fm1 = plusplus.apply(log) net2, im2, fm2 = plusplus.apply(log) gviz3 = pn_visualizer.apply(net1, im1, fm1, parameters={"format": "svg"}) pn_visualizer.view(gviz3) gviz4 = pn_visualizer.apply(net2, im2, fm2, parameters={"format": "svg"}) pn_visualizer.view(gviz4)
def test_petrinet_receipt_df(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" df = pd.read_csv(os.path.join(INPUT_DATA_DIR, "receipt.csv")) df = dataframe_utils.convert_timestamp_columns_in_df(df) net, im, fm = heuristics_miner.apply(df) gviz = pn_vis.apply(net, im, fm) del gviz
def execute_script(): log = xes_importer.apply(os.path.join("..", "tests", "input_data", "receipt.xes")) log = sorting.sort_timestamp(log) net, im, fm = inductive_miner.apply(log) log1 = EventLog(log[:500]) log2 = EventLog(log[len(log) - 500:]) statistics = element_usage_comparison.compare_element_usage_two_logs(net, im, fm, log1, log2) gviz = pn_vis.apply(net, im, fm, variant=pn_vis.Variants.FREQUENCY, aggregated_statistics=statistics, parameters={pn_vis.Variants.FREQUENCY.value.Parameters.FORMAT: "svg"}) pn_vis.view(gviz)
def execute_script(): log = xes_importer.apply(os.path.join("..", "tests", "compressed_input_data", "09_a32f0n00.xes.gz")) heu_net = heuristics_miner.apply_heu(log, parameters={ heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99}) gviz = hn_vis.apply(heu_net, parameters={hn_vis.Variants.PYDOTPLUS.value.Parameters.FORMAT: "svg"}) hn_vis.view(gviz) net, im, fm = heuristics_miner.apply(log, parameters={ heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99}) gviz2 = petri_vis.apply(net, im, fm, parameters={petri_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"}) petri_vis.view(gviz2)
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 execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_importer.apply(log_path) net, marking, final_marking = inductive.apply( log, variant=inductive.Variants.IM_CLEAN) 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.Variants.WO_DECORATION.value.Parameters.DEBUG: True }) pn_vis.view(gviz) if True: fit_traces = [] for i in range(0, len(log)): try: print("\n", i, [x["concept:name"] for x in log[i]]) cf_result = pm4py.algo.conformance.alignments.petri_net.variants.state_equation_a_star.apply( log[i], net, marking, final_marking)['alignment'] if cf_result is None: print("alignment is none!") else: is_fit = True for couple in cf_result: print(couple) if not (couple[0] == couple[1] or couple[0] == ">>" and couple[1] is None): is_fit = False print("isFit = " + str(is_fit)) if is_fit: fit_traces.append(log[i]) except TypeError: print("EXCEPTION ", i) traceback.print_exc() print(fit_traces) print(len(fit_traces))
def generate_process_model(self, sub_log, models_path, event_data_original_name, w_count, activity=''): # create the folder for saving the process map if does not exist models_path = self.model_type_definitions.get_models_path( models_path, event_data_original_name, activity) if not os.path.exists(models_path): os.makedirs(models_path) # mine the petri net (using Pm4Py - Inductive Miner) net, initial_marking, final_marking = inductive_miner.apply(sub_log) gviz = pn_visualizer.apply(net, initial_marking, final_marking) # save the process model output_filename = self.model_type_definitions.get_model_filename( event_data_original_name, w_count) print(f'Saving {models_path} - {output_filename}') Source.save(gviz, filename=output_filename, directory=models_path) return PNModel(net, initial_marking, final_marking)
def apply(net, im, fm, parameters=None): """ Transforms a WF-net to a process tree Parameters ------------- net Petri net im Initial marking fm Final marking Returns ------------- tree Process tree """ if parameters is None: parameters = {} debug = exec_utils.get_param_value(Parameters.DEBUG, parameters, False) fold = exec_utils.get_param_value(Parameters.FOLD, parameters, True) grouped_net = group_blocks_in_net(net, parameters=parameters) if len(grouped_net.transitions) == 1: pt_str = list(grouped_net.transitions)[0].label pt = pt_util.parse(pt_str) ret = pt_util.fold(pt) if fold else pt tree_sort(ret) return ret else: if debug: from pm4py.visualization.petri_net import visualizer as pn_viz pn_viz.view(pn_viz.apply(grouped_net, parameters={"format": "svg"})) raise ValueError('Parsing of WF-net Failed')
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_path = os.path.join("..", "tests", "input_data", "interval_event_log.csv") dataframe = pd.read_csv(log_path) log_path = os.path.join("..", "tests", "input_data", "reviewing.xes") log = pm4py.read_xes(log_path) dataframe = pm4py.convert_to_dataframe(log) parameters = {} #parameters[constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp" parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp" parameters[constants.PARAMETER_CONSTANT_ACTIVITY_KEY] = "concept:name" parameters[constants.PARAMETER_CONSTANT_CASEID_KEY] = "case:concept:name" parameters["strict"] = True parameters["format"] = "svg" start_activities = sa_get.get_start_activities(dataframe, parameters=parameters) end_activities = ea_get.get_end_activities(dataframe, parameters=parameters) att_count = att_get.get_attribute_values(dataframe, "concept:name", parameters=parameters) parameters["start_activities"] = start_activities parameters["end_activities"] = end_activities soj_time = soj_time_get.apply(dataframe, parameters=parameters) print("soj_time") print(soj_time) conc_act = conc_act_get.apply(dataframe, parameters=parameters) print("conc_act") print(conc_act) efg = efg_get.apply(dataframe, parameters=parameters) print("efg") print(efg) dfg_freq, dfg_perf = df_statistics.get_dfg_graph(dataframe, measure="both", start_timestamp_key="start_timestamp") dfg_gv_freq = dfg_vis_fact.apply(dfg_freq, activities_count=att_count, variant=dfg_vis_fact.Variants.FREQUENCY, soj_time=soj_time, parameters=parameters) dfg_vis_fact.view(dfg_gv_freq) dfg_gv_perf = dfg_vis_fact.apply(dfg_perf, activities_count=att_count, variant=dfg_vis_fact.Variants.PERFORMANCE, soj_time=soj_time, parameters=parameters) dfg_vis_fact.view(dfg_gv_perf) net, im, fm = dfg_conv.apply(dfg_freq) gviz = pn_vis.apply(net, im, fm, parameters=parameters) pn_vis.view(gviz)
def display_petri_net(net=None): """ The function exports the Petri net in .SVG format and saves it in current directory Parameter: net (PetriNet) : Petri net model to be stored in .SVG format Returns: net_path (str): The path of the saved Petri net model in .SVG form """ if net == None: net = settings.PETRI_NET im = settings.I_MARKS_ORIG fm = settings.F_MARKS_ORIG parameters = { pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "SVG" } gviz = pn_visualizer.apply(net, im, fm, parameters=parameters) log_name = settings.EVENT_LOG_NAME log_name = log_name.replace(" ", "") image_path = os.path.join(settings.NET_PATH, f"{log_name}.SVG") pn_visualizer.save(gviz, image_path) return image_path
bpmn_output_path = bpmn_output_path.name log_path = os.path.join(LOGS_FOLDER, log_name) print("") print(log_path) log = pm4py.read_xes(log_path) fp_log = pm4py.algo.discovery.footprints.log.variants.entire_event_log.apply( log) net, im, fm = pm4py.discover_petri_net_heuristics(log) fitness0 = pm4py.evaluate_fitness_alignments(log, net, im, fm) precision0 = pm4py.evaluate_precision_alignments(log, net, im, fm) print("fitness 0", fitness0) print("precision 0", precision0) bpmn_graph = pm4py.objects.conversion.wf_net.variants.to_bpmn.apply( net, im, fm) bpmn_graph = layouter.apply(bpmn_graph) exporter.apply(bpmn_graph, bpmn_output_path) bpmn_graph = importer.apply(bpmn_output_path) bpmn_graph = layouter.apply(bpmn_graph) # gets the net back net, im, fm = pm4py.objects.conversion.bpmn.variants.to_petri_net.apply( bpmn_graph) gviz = pn_visualizer.apply(net, im, fm) pn_visualizer.view(gviz) fitness1 = pm4py.evaluate_fitness_alignments(log, net, im, fm) precision1 = pm4py.evaluate_precision_alignments(log, net, im, fm) print("fitness 1", fitness1, fitness0 == fitness1) print("precision 1", precision1, precision0 == precision1) if not (fitness0 == fitness1 and precision0 == precision1): print("ALERT") input()
def test_heuplusplus_petri_log(self): log = xes_importer.apply(os.path.join(INPUT_DATA_DIR, "interval_event_log.xes")) net, im, fm = heuristics_miner.apply(log, variant=heuristics_miner.Variants.PLUSPLUS) gviz = pn_vis.apply(net, im, fm)
str(time.time()) + " generalization_imdf for " + logName + " succeeded! " + str(generalization_imdf[logName])) simplicity_imdf[logName] = simplicity_evaluator.apply( inductive_model, parameters=parameters) print( str(time.time()) + " simplicity_imdf for " + logName + " succeeded! " + str(simplicity_imdf[logName])) write_report() if ENABLE_VISUALIZATIONS: try: alpha_vis = petri_vis.apply( alpha_model, alpha_initial_marking, alpha_final_marking, log=log, parameters=parameters, variant=petri_vis.Variants.FREQUENCY) vis_save( alpha_vis, os.path.join(pngFolder, logNamePrefix + "_alpha.png")) print( str(time.time()) + " alpha visualization for " + logName + " succeeded!") except: print( str(time.time()) + " alpha visualization for " + logName + " failed!") traceback.print_exc()
def test_heuplusplus_petri_df(self): df = pd.read_csv(os.path.join(INPUT_DATA_DIR, "interval_event_log.csv")) df = dataframe_utils.convert_timestamp_columns_in_df(df) net, im, fm = heuristics_miner.Variants.PLUSPLUS.value.apply_pandas(df) gviz = pn_vis.apply(net, im, fm)