def apply(tree, no, prob, has_empty_trace=False): """ Returns non-fitting EventLog with fixed traces randomly created by the process tree. Parameters ----------- tree Process Tree no Number of traces that will be in the event log prob Randomness of the traces has_empty_trace True, when the event log has empty trace Returns ------------ EventLog Non-fitting event log """ log, non_fit_traces = generate_log(tree, no), list() label_num = pt_mani_utils.non_none_leaves_number(tree) traces = list(map(lambda t: t, log)) while len(traces) > 0: trace = traces.pop() non_fit_t = Trace(attributes=log.attributes) for event in trace: if random.random() < prob: index = random.randint(0, 2) if index == 1: # add a new event non_fit_t.append(event) new_event = Event() new_event[ xes.DEFAULT_NAME_KEY] = pt_gene_utils.get_cur_label( label_num + 1) non_fit_t.append(new_event) elif index == 2: # replace with other event new_event = Event() new_event[ xes.DEFAULT_NAME_KEY] = pt_gene_utils.get_cur_label( random.randint(1, label_num)) non_fit_t.append(new_event) else: non_fit_t.append(event) if not has_empty_trace and len(non_fit_t) == 0: traces.append(generate_log(tree, 1)[0]) else: non_fit_traces.append(non_fit_t) return EventLog(non_fit_traces, attributes=log.attributes, classifiers=log.classifiers, omni_present=log.omni_present, extensions=log.extensions)
def apply( tree: ProcessTree, parameters: Optional[Dict[Union[str, Parameters], Any]] = None) -> EventLog: """ Generate a log by a playout operation Parameters --------------- tree Process tree parameters Parameters of the algorithm, including: - Parameters.NO_TRACES: number of traces of the playout Returns -------------- log Simulated log """ if parameters is None: parameters = {} no_traces = exec_utils.get_param_value(Parameters.NO_TRACES, parameters, 1000) log = semantics.generate_log(tree, no_traces=no_traces) return log
def test_tree_parsing(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" tree = pt_util.parse("->(X('a', 'b', tau), +('c', 'd'))") # test log generation log = pt_semantics.generate_log(tree)
def apply(tree, parameters=None): """ Generate a log_skeleton by a playout operation Parameters --------------- tree Process tree parameters Parameters of the algorithm, including: - Parameters.NO_TRACES: number of traces of the playout Returns -------------- log_skeleton Simulated log_skeleton """ if parameters is None: parameters = {} no_traces = exec_utils.get_param_value(Parameters.NO_TRACES, parameters, 1000) log = semantics.generate_log(tree, no_traces=no_traces) return log
def test_tree_receipt(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.import_log(os.path.join(INPUT_DATA_DIR, "receipt.xes")) tree = inductive_miner.apply_tree(log) gviz = pt_vis_factory.apply(tree) del gviz # test log generation log = pt_semantics.generate_log(tree) del log
def test_tree_running_example_dfg_based(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")) tree = inductive_miner.apply_tree(log, variant=inductive_miner.DFG_BASED) gviz = pt_vis.apply(tree) del gviz # test log generation log = pt_semantics.generate_log(tree) del log
def start_experiments(number_process_trees=1, number_traces_per_tree=1, input_data: List[Tuple[ProcessTree, EventLog]] = None): logging.disable(logging.CRITICAL) results_per_tree = {} processed_trees: List[ProcessTree] = [] futures: Dict[ProcessTree, List[concurrent.futures]] = {} if input_data is None: input_data = [] for i in range(number_process_trees): parameters = {"min": 20, "mode": 35, "max": 50, "duplicate": 0.25, "silent": .25} tree = tree_gen_factory.apply(parameters=parameters) tree = process_tree_to_binary_process_tree(tree) log = semantics.generate_log(tree, no_traces=number_traces_per_tree) log = __introduce_deviations_in_log(log) input_data.append((tree, log)) with concurrent.futures.ProcessPoolExecutor() as executor: for i in range(len(input_data)): print("process tree ", i + 1, "/", number_process_trees) tree = input_data[i][0] log = input_data[i][1] results_per_tree[tree] = {} processed_trees.append(tree) results_per_tree[tree]["log"] = log start_time = datetime.now() a_sets, sa_sets, ea_sets, tau_sets = initialize_a_sa_ea_tau_sets(tree) end_time = datetime.now() results_per_tree[tree]["calculation_time_of_a_sa_ea_tau_sets"] = (end_time - start_time).total_seconds() results_per_tree[tree]["alignments"] = [] futures[tree] = [] for j, trace in enumerate(log): futures[tree].append( executor.submit(__calculate_approx_and_opt_align, trace, tree, a_sets, sa_sets, ea_sets, tau_sets)) for i, tree in enumerate(processed_trees): print("Waiting for process tree ", i + 1, "/", len(processed_trees)) results_per_tree[tree]["alignments"] = [] for j, f in enumerate(futures[tree]): print("Waiting for trace ", j + 1, "/", len(futures[tree])) results_per_tree[tree]["alignments"].append(f.result()) __save_obj_to_file("results_per_tree_", results_per_tree)
print( "heuristics is_sound_wfnet", check_soundness.check_petri_wfnet_and_soundness(heu_model, debug=True)) t1 = time.time() tree = inductive.apply_tree(log, parameters=parameters_discovery) inductive_model, inductive_im, inductive_fm = inductive.apply( log, parameters=parameters_discovery) pnml_exporter.export_net(inductive_model, inductive_im, os.path.join( pnmlFolder, logNamePrefix + "_inductive.pnml"), final_marking=inductive_fm) generated_log = pt_semantics.generate_log(tree) print("first trace of log", [x["concept:name"] for x in generated_log[0]]) t2 = time.time() print("time interlapsed for calculating Inductive Model", (t2 - t1)) print( "inductive is_sound_wfnet", check_soundness.check_petri_wfnet_and_soundness( inductive_model, debug=True)) parameters = { pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key, pmutil.constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY: activity_key, "format": "png"
net, initial_marking, final_marking = pt_conv_factory.apply(tree, variant=pt_conv_factory.TO_PETRI_NET) # Replay the log on top of the discovered process model inductive_evaluation_result = evaluation_factory.apply(log_for_eval, net, initial_marking, final_marking) inductive_evaluation_result.update(inductive_evaluation_result['fitness']) inductive_evaluation_result['discovered_pt'] = str(tree) del inductive_evaluation_result['fitness'] return inductive_evaluation_result number_of_experiment_to_run = 100 results = [] for _ in range(number_of_experiment_to_run): # Generate a random process tree and get traces from the process tree tree = tree_gen_factory.apply() log = semantics.generate_log(tree, no_traces=1000) size_tree, leafs = rec_node([tree], []) leafs = set(leafs).union(set('τ')) tree = { 'tree': str(tree), 'tree_size': size_tree } csv_exporter.export(log, 'temp.csv') original_df = pd.read_csv('temp.csv') os.remove('temp.csv') log_for_eval = copy.deepcopy(log) # Try different level of noise for noise_ratio in np.arange(0, 1.01, 0.05): noise_ratio = round(noise_ratio,2)