def test_fourEeyesPrinciple_neg(self): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) filt_foureyes_neg = ltl_checker.four_eyes_principle( log, "check ticket", "pay compensation", parameters={"positive": False})
def test_AeventuallyB_neg(self): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) filt_A_ev_B_neg = ltl_checker.A_eventually_B( log, "check ticket", "pay compensation", parameters={"positive": False})
def test_AeventuallyB_pos(self): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) filt_A_ev_B_pos = ltl_checker.A_eventually_B( log, "check ticket", "pay compensation", parameters={ltl_checker.Parameters.POSITIVE: True})
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_importer.apply(log_path) # obtain Petri net through Alpha Miner net, initial_marking, final_marking = alpha_miner.apply(log) # obtain stochastic information for transitions in the model s_map = stochastic_map.get_map_from_log_and_net( log, net, initial_marking, final_marking, force_distribution="EXPONENTIAL") # export the current stochastic Petri net petri_exporter.export_net(net, initial_marking, "example.pnml", final_marking=final_marking, stochastic_map=s_map) # re-import the current stochastic Petri net from file net, initial_marking, final_marking, s_map = petri_importer.import_net( "example.pnml", return_stochastic_information=True) # remove temporary file os.remove("example.pnml") # gets the reachability graph from the Petri net reachab_graph = construct_reachability_graph(net, initial_marking) # get the tangible reachability graph from the reachability graph and the stochastic map tang_reach_graph = tangible_reachability.get_tangible_reachability_from_reachability( reachab_graph, s_map) # visualize the tangible reachability graph on the screen viz = ts_vis_factory.apply(tang_reach_graph, parameters={ "format": "svg", "show_labels": True, "show_names": True }) ts_vis_factory.view(viz) # gets the Q matrix assuming exponential distributions q_matrix = ctmc.get_q_matrix_from_tangible_exponential( tang_reach_graph, s_map) # pick a state to start from states = sorted(list(tang_reach_graph.states), key=lambda x: x.name) state = states[0] print("\n\nstarting from state = ", state.name) # do transient analysis after 1 day transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state( tang_reach_graph, q_matrix, state, 86400) print("\nprobability for each state after 1 day = ", transient_result) # do transient analysis after 10 days transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state( tang_reach_graph, q_matrix, state, 864000) print("\nprobability for each state after 10 days = ", transient_result) # do transient analysis after 100 days transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state( tang_reach_graph, q_matrix, state, 8640000) print("\nprobability for each state after 100 days = ", transient_result) steady_state = ctmc.steadystate_analysis_from_tangible_q_matrix( tang_reach_graph, q_matrix) print("\nsteady state = ", steady_state)
def test_AnextBnextC_pos(self): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) filt_A_next_B_next_C_pos = ltl_checker.A_next_B_next_C( log, "check ticket", "decide", "pay compensation", parameters={"positive": True})
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_importer.apply(log_path) dfg = dfg_factory.apply(log) dfg_gv = dfg_vis_fact.apply(dfg, log, parameters={"format": "svg"}) dfg_vis_fact.view(dfg_gv) net, im, fm = dfg_conv_factory.apply(dfg) gviz = pn_vis_factory.apply(net, im, fm, parameters={"format": "svg"}) pn_vis_factory.view(gviz)
def execute_script(): # loads the log log = xes_importer.apply( os.path.join("..", "tests", "input_data", "receipt.xes")) # apply the simple miner net, im, fm = simple_miner.apply(log, classic_output=True) # checks if the Petri net is a sound workflow net is_sound_wfnet = check_petri_wfnet_and_soundness(net) print("is_sound_wfnet = ", is_sound_wfnet)
def test_simple_execution_receipt(self): self.dummy = "dummy" log = xes_importer.apply(os.path.join(INPUT_DATA_DIR, "receipt.xes")) output_dictionary = simple_model_factory.apply(log) net, initial_marking, final_marking = simple_model_factory.apply(log, classic_output=True) del output_dictionary del net del initial_marking del final_marking
def test_performance_spectrum(self): log = xes_importer.apply( os.path.join("input_data", "running-example.xes")) from pm4py.statistics.performance_spectrum import factory as pspectrum ps = pspectrum.apply(log, ["register request", "decide"]) 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")) ps = pspectrum.apply(df, ["register request", "decide"])
def test_logCaseDurationPlotSemiLogx(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", "receipt.xes")) x, y = log_case_statistics.get_kde_caseduration(log) json = log_case_statistics.get_kde_caseduration_json(log) del json
def convert_xes_file_to_parquet(xes_input_path: str, parquet_output_path: str): """Converts a XES file at the given location to a parquet file (via pandas dataframes) Arguments: xes_input_path {str} -- The filepath the XES file should be read from parquet_output_path {str} -- The filepath the new parquet file should be written to """ log = xes_importer.apply(xes_input_path) parquet_exporter.apply(log, parquet_output_path)
def execute_script(): # import the log log = xes_importer.apply(os.path.join("..", "tests", "input_data", "receipt.xes"), variant="nonstandard") # execute the roles detection factory roles = roles_factory.apply(log) # print the results (grouped activities) on the screen print([x[0] for x in roles])
def xes_to_csv(file, file_to_write): log = xes_importer.apply(PATH + file) data = [] for trace in log: trace_act = "" for event in trace: trace_act += event[pm4py.objects.log.util.xes.DEFAULT_NAME_KEY] + ", " data.append(trace_act[:-2]) pd.DataFrame(data, columns=["trace"]).to_csv(PATH + file_to_write, index=False)
def xes_to_csv(xes_path, csv_path): """ Imports .xes given the xes_path, and converts and saves it to a .csv file Args: xes_path (str) : path of .xes compliant input event log csv_path (str) : path of .csv output event log """ log = xes_import_factory.apply(xes_path) csv_exporter.export(log, csv_path)
def test_logDateAttribute(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", "receipt.xes")) x, y = log_attributes_filter.get_kde_date_attribute(log) json = log_attributes_filter.get_kde_date_attribute_json(log) del json
def test_AnextBnextC_neg(self): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) filt_A_next_B_next_C_neg = ltl_checker.A_next_B_next_C( log, "check ticket", "decide", "pay compensation", parameters={ltl_checker.Parameters.POSITIVE: False})
def execute_script(): # in this case, we obtain a decision tree by alignments on a specific decision point log = xes_importer.apply(os.path.join("..", "tests", "input_data", "receipt.xes")) net, im, fm = inductive_miner.apply(log) # we need to specify a decision point. In this case, the place p_25 is a suitable decision point clf, feature_names, classes = algorithm.get_decision_tree(log, net, im, fm, decision_point="p_25") # we can visualize the decision tree gviz = visualizer.apply(clf, feature_names, classes, parameters={"format": "svg"}) visualizer.view(gviz)
def test_evaluation(self): log = xes_importer.apply( os.path.join("input_data", "running-example.xes")) from pm4py.algo.discovery.alpha import factory as alpha_miner net, im, fm = alpha_miner.apply(log) from pm4py.evaluation.simplicity import factory as simplicity simp = simplicity.apply(net) from pm4py.evaluation import factory as evaluation_method eval = evaluation_method.apply(log, net, im, fm)
def test_sna_log(self): # loads the log from XES file log_path = os.path.join("..", "tests", "input_data", "receipt.xes") log = xes_importer.apply(log_path) # calculates the Matrix Container object mco = sna_transformer.apply(log) # calculates the Handover of Work matrix hw_matrix = handover_of_work.apply(mco) # calculates the Similar Activities matrix sim_act_matrix = similar_activities.apply(mco)
def process_each(): clean_folder("./results") for filename in os.listdir(XES_PATH): label = filename.split(".")[0] filepath = os.path.join(XES_PATH, filename) log = xes_import_factory.apply(filepath) process_log(log, label)
def import_logs(path): l = [] for i, file in enumerate(os.listdir(path)): logging.debug("Importing: {}".format(file)) sublog = xes_import_factory.apply(os.path.join(path, file)) logging.debug("Sublog length: {}".format(len(sublog))) for item in sublog: l.append(item) return l
def main(logFile, dataVectors, index, threshold): log = xes_factory.apply(logFile) print("Detecting outliers") timeStart = time.time() outliers, distributions, means = outlierDetectionWithDistribution( log, dataVectors, threshold) timeEnd = time.time() print("Creating pairs") outlierPairs = createPairsFromOutliers(outliers, index, dataVectors, means) return outlierPairs, timeEnd - timeStart
def load_file(path: str) -> EventLog: """ Loads the input file and passes it to pm4py parser Args: path: Returns: """ return xes_import_factory.apply(path)
def test_serialization_stream(self): from pm4py.objects.log.serialization import factory as serialization_factory from pm4py.objects.log.deserialization import factory as deserialization_factory log = xes_importer.apply( os.path.join("input_data", "running-example.xes")) stream = log_conv_factory.apply( log, variant=log_conv_factory.TO_EVENT_STREAM) ser = serialization_factory.apply(stream) deser = deserialization_factory.apply(ser, variant="pyarrow_event_stream")
def test_heu_log(self): log = xes_importer.apply( os.path.join("input_data", "running-example.xes")) net, im, fm = heuristics_miner.apply(log) aligned_traces_tr = tr_factory.apply(log, net, im, fm) aligned_traces_alignments = align_factory.apply(log, net, im, fm) evaluation = eval_factory.apply(log, net, im, fm) fitness = rp_fit_factory.apply(log, net, im, fm) precision = precision_factory.apply(log, net, im, fm) generalization = generalization_factory.apply(log, net, im, fm) simplicity = simplicity_factory.apply(net)
def test_logNumericAttribute(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", "roadtraffic100traces.xes")) x, y = log_attributes_filter.get_kde_numeric_attribute(log, "amount") json = log_attributes_filter.get_kde_numeric_attribute_json( log, "amount") del json
def uselog(loginput): log = xes_import_factory.apply(loginput) log = sorting.sort_timestamp(log) # print(log) dfg = dfg_factory.apply(log) dfg_gv = dfg_vis_fact.apply(dfg, log, parameters={"format": "svg"}) this_data = dfg_to_g6.dfg_to_g6(dfg) # dfg_vis_fact.view(dfg_gv) return this_data '''grouplist = get_groups(log)
def test_decomp_alignment(self): log = xes_importer.apply( os.path.join("input_data", "running-example.xes")) from pm4py.algo.discovery.alpha import factory as alpha_miner net, im, fm = alpha_miner.apply(log) from pm4py.algo.conformance.decomp_alignments import factory as decomp_align aligned_traces = decomp_align.apply(log, net, im, fm, variant="recompos_maximal")
def execute_script(): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "receipt.xes")) # discovers the log skeleton with a minimal noise log_skeleton = lsk_factory.apply(log, parameters={"noise_threshold": 0.01}) print(log_skeleton) # applies conformance checking to it results = lsk_conf_factory.apply(log, log_skeleton) for i in range(min(len(results), 5)): # print the i-the conformance checking print(results[i])
def test_import_xes_data(filename): filename = os.path.basename(filename) file_path = global_util.get_full_path_test_file(filename) log = importer.apply(file_path) for case_index, case in enumerate(log): print("\n case index: %d case id: %s" % (case_index, case.attributes["concept:name"])) for event_index, event in enumerate(case): print("event index: %d event activity: %s" % (event_index, event["concept:name"]))