def discover_petri_net_inductive(log, noise_threshold=0.0): """ Discovers a Petri net using the IMDFc algorithm Parameters -------------- log Event log_skeleton noise_threshold Noise threshold (default: 0.0) Returns -------------- petri_net Petri net initial_marking Initial marking final_marking Final marking """ from pm4py.algo.discovery.inductive import algorithm as inductive_miner if noise_threshold > 0.0: return inductive_miner.apply(log, variant=inductive_miner.Variants.IMf, parameters={ inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: noise_threshold}) else: return inductive_miner.apply(log, variant=inductive_miner.Variants.IM, parameters={ inductive_miner.Variants.IM.value.Parameters.NOISE_THRESHOLD: noise_threshold})
def discover_petri_net_inductive(log: Union[EventLog, pd.DataFrame], noise_threshold: float = 0.0) -> Tuple[ PetriNet, Marking, Marking]: """ Discovers a Petri net using the IMDFc algorithm Parameters -------------- log Event log noise_threshold Noise threshold (default: 0.0) Returns -------------- petri_net Petri net initial_marking Initial marking final_marking Final marking """ from pm4py.algo.discovery.inductive import algorithm as inductive_miner if noise_threshold > 0.0: return inductive_miner.apply(log, variant=inductive_miner.Variants.IMf, parameters={ inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: noise_threshold}) else: return inductive_miner.apply(log, variant=inductive_miner.Variants.IM_CLEAN, parameters={ inductive_miner.Variants.IM.value.Parameters.NOISE_THRESHOLD: noise_threshold})
def discover_process_model(): """ This function is responsible for mining the process model and in turn calling other functions to continue the simulation and provide additional functionality. Returns -------------- net The petri net generated from the event logs initial_marking The initial marking of the petri net generated from the event logs final_marking The final marking of the petri net generated from the event logs """ log = simulation_activity.verify_extension_and_import() parameters1 = { constants.PARAMETER_CONSTANT_CASEID_KEY: "concept:name", constants.PARAMETER_CONSTANT_ACTIVITY_KEY: "concept:name", constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: "time:timestamp" } print("Beginning Petri net mining. Please wait...") net, initial_marking, final_marking = inductive_miner.apply( log, parameters=parameters1) print("Petri Net creation successful") relevant_info_generator(net, initial_marking, final_marking, log) return net, initial_marking, final_marking
def test_58(self): import os from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.algo.discovery.inductive import algorithm as inductive_miner log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) net, initial_marking, final_marking = inductive_miner.apply(log) from pm4py.algo.conformance.alignments import algorithm as alignments model_cost_function = dict() sync_cost_function = dict() for t in net.transitions: # if the label is not None, we have a visible transition if t.label is not None: # associate cost 1000 to each move-on-model associated to visible transitions model_cost_function[t] = 1000 # associate cost 0 to each move-on-log sync_cost_function[t] = 0 else: # associate cost 1 to each move-on-model associated to hidden transitions model_cost_function[t] = 1 parameters = {} parameters[ alignments.Variants.VERSION_STATE_EQUATION_A_STAR.value.Parameters.PARAM_MODEL_COST_FUNCTION] = model_cost_function parameters[ alignments.Variants.VERSION_STATE_EQUATION_A_STAR.value.Parameters.PARAM_SYNC_COST_FUNCTION] = sync_cost_function alignments = alignments.apply_log(log, net, initial_marking, final_marking, parameters=parameters)
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 evaluate_logwithmodel(logpath): """ Calculate and return evaluation measurements like fitness, precision, simplicity and generalization, given the path of event log. Parameters: logpath (str): Path of event log Returns: fitness (float): Fitness value measured using pm4py precision (float): Precision value measured using pm4py simplicity (float): Simplicity value measured using pm4py generalization (float): Generalization value measured using pm4py """ xes_log = importer.apply(logpath) net, initial_marking, final_marking = inductive_miner.apply(xes_log) fitness = replay_fitness_evaluator.apply( xes_log, net, initial_marking, final_marking, variant=replay_fitness_evaluator.Variants.TOKEN_BASED) prec = precision_evaluator.apply( xes_log, net, initial_marking, final_marking, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN) simp = simplicity_evaluator.apply(net) gen = generalization_evaluator.apply(xes_log, net, initial_marking, final_marking) return round(fitness['log_fitness'], 3), round(prec, 3), round(simp, 3), round(gen, 3)
def execute_script(): # import the a32f0n00 log log = xes_importer.apply( os.path.join("..", "tests", "compressed_input_data", "09_a32f0n00.xes.gz")) # discover a model using the inductive miner net, im, fm = inductive_miner.apply(log) # apply the alignments decomposition with a maximal number of border disagreements set to 5 aa = time.time() aligned_traces = dec_align.apply( log, net, im, fm, parameters={ dec_align.Variants.RECOMPOS_MAXIMAL.value.Parameters.PARAM_THRESHOLD_BORDER_AGREEMENT: 5 }) bb = time.time() print(bb - aa) # print(aligned_traces) # calculate the fitness over the recomposed alignment (use the classical evaluation) fitness = rep_fit.evaluate(aligned_traces, variant=rep_fit.Variants.ALIGNMENT_BASED) print(fitness)
def execute_script(): log = pm4py.read_xes( os.path.join("..", "tests", "input_data", "receipt.xes")) net, im, fm = inductive_miner.apply( log, variant=inductive_miner.Variants.IM_CLEAN) idx = 0 # try to resolve the marking equation to find an heuristics and possible a vector of transitions # leading from im to fm sync_net, sync_im, sync_fm = pm4py.construct_synchronous_product_net( log[idx], net, im, fm) me_solver = marking_equation.build(sync_net, sync_im, sync_fm) h, x = me_solver.solve() firing_sequence, reach_fm1, explained_events = me_solver.get_firing_sequence( x) print("for trace at index " + str(idx) + ": marking equation h = ", h) print("x vector reaches fm = ", reach_fm1) print("firing sequence = ", firing_sequence) # it fails and the value of heuristics is low # # now let's try with extended marking equation to find the heuristics and the vector! eme_solver = extended_marking_equation.build(log[idx], sync_net, sync_im, sync_fm) h, x = eme_solver.solve() # the heuristics is much better firing_sequence, reach_fm2, explained_events = eme_solver.get_firing_sequence( x) print( "for trace at index " + str(idx) + ": extended marking equation h = ", h) print("x vector reaches fm = ", reach_fm2) print("firing sequence = ", firing_sequence)
def execute_script(): log = importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes")) net, im, fm = inductive_miner.apply(log) aligned_traces = alignments.apply(log, net, im, fm) gviz = visualizer.apply(log, aligned_traces, parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: "svg"}) visualizer.view(gviz)
def model_metrics(model_log_path, metric_log_path, gexp_name): start_time = time() model_log_csv = pd.read_csv(model_log_path, ',') metric_log_csv = pd.read_csv(metric_log_path, ',') parameters = {log_converter.Variants.TO_EVENT_LOG.value.Parameters.CASE_ID_KEY: 'number'} model_log = log_converter.apply(model_log_csv, parameters=parameters, variant=log_converter.Variants.TO_EVENT_LOG) metric_log = log_converter.apply(metric_log_csv, parameters=parameters, variant=log_converter.Variants.TO_EVENT_LOG) parameters = {inductive_miner.Variants.DFG_BASED.value.Parameters.CASE_ID_KEY: 'number', inductive_miner.Variants.DFG_BASED.value.Parameters.ACTIVITY_KEY: 'incident_state', inductive_miner.Variants.DFG_BASED.value.Parameters.TIMESTAMP_KEY: 'sys_updated_at', alignments.Variants.VERSION_STATE_EQUATION_A_STAR.value.Parameters.ACTIVITY_KEY: 'incident_state'} petrinet, initial_marking, final_marking = inductive_miner.apply(model_log, parameters=parameters) gviz = pn_visualizer.apply(petrinet, initial_marking, final_marking) #gviz.render('petrinets\\'+gexp_name+'\\petri_' + model_base + '.png') gviz.render('test_time\\test.png') pn_visualizer.view(gviz) alignments_res = alignments.apply_log(metric_log, petrinet, initial_marking, final_marking, parameters=parameters) fitness = replay_fitness.evaluate(alignments_res, variant=replay_fitness.Variants.ALIGNMENT_BASED, parameters=parameters) precision = calc_precision.apply(metric_log, petrinet, initial_marking, final_marking, parameters=parameters) generaliz = calc_generaliz.apply(metric_log, petrinet, initial_marking, final_marking, parameters=parameters) #generaliz = 0 simplic = calc_simplic.apply(petrinet) f_score = 2 * ((fitness['averageFitness'] * precision) / (fitness['averageFitness'] + precision)) end_time = time() m, s = divmod(end_time - start_time, 60) h, m = divmod(m, 60) print('Fin %02d:%02d:%02d' % (h, m, s)) print(' F:', '%.10f' % fitness['averageFitness'], ' P:', '%.10f' % precision, ' FS:', '%.10f' % f_score, ' G:', '%.10f' % generaliz, ' S:', '%.10f' % simplic, ' T:', '%02d:%02d:%02d' % (h, m, s)) #metrics = pd.Series([model_base, metric_base, '%.10f' % fitness['averageFitness'], # '%.10f' % precision, '%.10f' % f_score, '%.10f' % generaliz, '%.10f' % simplic, # '%02d:%02d:%02d' % (h, m, s)]) return model_base
def execute_script(): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) net, im, fm = inductive_miner.apply(log) # perform the Montecarlo simulation with the arrival rate inferred by the log (the simulation lasts 5 secs) parameters = {} parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value. Parameters.PARAM_ENABLE_DIAGNOSTICS] = False parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value. Parameters.PARAM_MAX_THREAD_EXECUTION_TIME] = 5 log, res = montecarlo_simulation.apply(log, net, im, fm, parameters=parameters) print( "\n(Montecarlo - Petri net) case arrival ratio inferred from the log") print(res["median_cases_ex_time"]) print(res["total_cases_time"]) # perform the Montecarlo simulation with the arrival rate specified (the simulation lasts 5 secs) parameters[montecarlo_simulation.Variants.PETRI_SEMAPH_FIFO.value. Parameters.PARAM_CASE_ARRIVAL_RATIO] = 60 log, res = montecarlo_simulation.apply(log, net, im, fm, parameters=parameters) print( "\n(Montecarlo - Petri net) case arrival ratio specified by the user") print(res["median_cases_ex_time"]) print(res["total_cases_time"])
def execute_script(): log = xes_importer.apply( os.path.join("..", "tests", "input_data", "running-example.xes")) net, im, fm = inductive_miner.apply(log) # perform the backwards token-based replay replayed_traces = tr.apply(log, net, im, fm, variant=tr.Variants.BACKWARDS) print(replayed_traces)
def check_model_quality(original_log, anonymized_log, result_path): anonymized_model, anonymized_initial_marking, anonymized_final_marking = inductive_miner.apply( anonymized_log) results = dict() fitness = replay_fitness_evaluator.apply( original_log, anonymized_model, anonymized_initial_marking, anonymized_final_marking, variant=replay_fitness_evaluator.Variants.TOKEN_BASED) print("Fitness: " + str(fitness)) results["fitness"] = fitness precision = precision_evaluator.apply( original_log, anonymized_model, anonymized_initial_marking, anonymized_final_marking, variant=precision_evaluator.Variants.ETCONFORMANCE_TOKEN) print("Precision: " + str(precision)) results["precision"] = precision gen = generalization_evaluator.apply(original_log, anonymized_model, anonymized_initial_marking, anonymized_final_marking) print("Generalization: " + str(gen)) results["generalization"] = gen simp = simplicity_evaluator.apply(anonymized_model) print("Simplicity: " + str(simp)) results["simplicity"] = simp with open(result_path, 'wb') as file: pickle.dump(results, file)
def test_evaluation_pm2(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) metrics = evaluation_alg.apply(log, net, marking, final_marking) del metrics
def test_emd_2(self): log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) lang_log = variants_get.get_language(log) net1, im1, fm1 = inductive_miner.apply(log) lang_model1 = variants_get.get_language( simulator.apply(net1, im1, fm1, variant=simulator.Variants.STOCHASTIC_PLAYOUT, parameters={simulator.Variants.STOCHASTIC_PLAYOUT.value.Parameters.LOG: log})) emd = earth_mover_distance.apply(lang_model1, lang_log)
def __init__(self, log, parameters=None): self.net, self.initial_marking, self.final_marking = \ inductive_miner.apply(log, parameters={Parameters.NOISE_THRESHOLD:0.5}, variant=inductive_miner.IMf)
def test_s_components(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 = inductive_miner.apply(log) s_comps = petri.utils.get_s_components_from_petri(net, im, fm) del s_comps
def test_running_example_inductive(self): path = os.path.join("input_data", "running-example.xes") log = xes_import.apply(path) net, i_m, f_m = inductive_miner.apply(log) self.assertTrue( woflan.apply(net, i_m, f_m, parameters={"print_diagnostics": 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", "running-example.xes")) net, im, fm = inductive_miner.apply(log) # we need to specify a decision point. In this case, the place p_10 is a suitable decision point clf, feature_names, classes = algorithm.get_decision_tree(log, net, im, fm, decision_point="p_10") # we can visualize the decision tree gviz = visualizer.apply(clf, feature_names, classes, parameters={visualizer.Variants.CLASSIC.value.Parameters.FORMAT: "svg"}) visualizer.view(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 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_55(self): from pm4py.objects.log.importer.xes import importer as xes_importer import os log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) from pm4py.algo.discovery.inductive import algorithm as inductive_miner net, initial_marking, final_marking = inductive_miner.apply(log) from pm4py.objects.petri import utils cycles = utils.get_cycles_petri_net_places(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_56(self): import os from pm4py.objects.log.importer.xes import importer as xes_importer from pm4py.algo.discovery.inductive import algorithm as inductive_miner log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) net, initial_marking, final_marking = inductive_miner.apply(log) from pm4py.algo.conformance.alignments import algorithm as alignments alignments = alignments.apply_log(log, net, initial_marking, final_marking)
def obtainPetriNetThroughImdf(self, log_name, variant=inductive_miner.DEFAULT_VARIANT): # 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) # apply dummily the test to all the available variants net, marking, final_marking = inductive_miner.apply( log, variant=inductive_miner.DFG_BASED) net, marking, final_marking = inductive_miner.apply(log, variant=variant) soundness = check_soundness.check_petri_wfnet_and_soundness(net) del soundness return log, net, marking, final_marking
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_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_54(self): from pm4py.objects.log.importer.xes import importer as xes_importer import os log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) from pm4py.algo.discovery.inductive import algorithm as inductive_miner net, initial_marking, final_marking = inductive_miner.apply(log) from pm4py.objects.petri import utils scc = utils.get_strongly_connected_subnets(net) from pm4py.visualization.petrinet import visualizer as pn_visualizer gviz = pn_visualizer.apply(scc[0][0], scc[0][1], scc[0][2])
def function_before_get(b_click): if b_click == 1: pn_visualizer.save(before_gviz, "clean_process.png") messagebox.showinfo("Message", "Downloaded in 'output' folder") else: before = self.before if self.a == 1: before = before[[ 'Case', 'Activity', "Timestamp", "Resource" ]] before.rename( columns={ "Case": "case:concept:name", "Activity": "concept:name", "Timestamp": "time:timestamp", "Resource": "Resource" }) before.columns = [ 'case:concept:name', 'concept:name', "time:timestamp", "Resource" ] elif self.a == 0 and self.b == 1: before = before[[ 'Case', 'Activity', "Timestamp", "System" ]] before.rename( columns={ "Case": "case:concept:name", "Activity": "concept:name", "Timestamp": "time:timestamp", "System": "Resource" }) before.columns = [ 'case:concept:name', 'concept:name', "time:timestamp", "Resource" ] before_log = log_converter.apply(before) b_net, b_initial_marking, b_final_marking = inductive_miner.apply( before_log) before_gviz = pn_visualizer.apply(b_net, b_initial_marking, b_final_marking) b_click = 1 pn_visualizer.save( before_gviz, "{}_clean_process.png".format(self.dat_name)) messagebox.showinfo("Message", "Downloaded in 'output' folder") return b_click
def test_47(self): log = self.load_running_example_xes() import os from pm4py.algo.discovery.inductive import algorithm as inductive_miner net, initial_marking, final_marking = inductive_miner.apply(log) from pm4py.visualization.petrinet import visualizer as pn_visualizer parameters = {pn_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "png"} gviz = pn_visualizer.apply(net, initial_marking, final_marking, parameters=parameters, variant=pn_visualizer.Variants.FREQUENCY, log=log) pn_visualizer.save(gviz, os.path.join("test_output_data", "inductive_frequency.png")) os.remove(os.path.join("test_output_data", "inductive_frequency.png"))