def import_xes_data(filename): if not os.path.abspath(filename): # 修改日志文件路径 file_path = global_util.get_full_path_input_file(filename) else: file_path = filename filename = os.path.basename(filename) # 导入日志文件名 parameters = {"timestamp_sort": True} log = importer.apply(file_path, variant="nonstandard", parameters=parameters) # 矿工应用日志文件 net, initial_marking, final_marking = alpha_miner.apply(log) # 可视化界面应用分析结果 gviz = visualizer.apply(net, initial_marking, final_marking) # 生成输出文件名 file, _ = os.path.splitext(filename) output_full_name = "output_" + file + ".png" # 生成输出文件全路径 output_file = global_util.get_full_path_output_file(output_full_name) # 保存文件 visualizer.save(gviz, output_file) # 返回输出文件名 return output_full_name
def import_xes_data(filename): if not os.path.abspath(filename): # modify the path of file file_path = global_util.get_full_path_input_file(filename) else: file_path = filename filename = os.path.basename(filename) # import the name of log parameters = {"timestamp_sort": True} log = importer.apply(file_path, variant="nonstandard", parameters=parameters) # apply miner net, initial_marking, final_marking = alpha_miner.apply(log) # apply visualizer gviz = visualizer.apply(net, initial_marking, final_marking) # generate the name of the file file, _ = os.path.splitext(filename) output_full_name = "output_" + file + ".png" # generate the path of all generated files output_file = global_util.get_full_path_output_file(output_full_name) # save file visualizer.save(gviz, output_file) # return the name of the file return output_full_name
def calculate_process_schema_from_df(dataframe, path_frequency, path_performance): activities_count = attributes_filter.get_attribute_values( dataframe, attribute_key=ACTIVITY_KEY) [dfg_frequency, dfg_performance ] = df_statistics.get_dfg_graph(dataframe, measure="both", perf_aggregation_key="median", case_id_glue=CASEID_GLUE, activity_key=ACTIVITY_KEY, timestamp_key=TIMEST_KEY, sort_caseid_required=False) net, initial_marking, final_marking = inductive_factory.apply_dfg( dfg_frequency) spaths = vis_trans_shortest_paths.get_shortest_paths(net) aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount( net, dfg_frequency, spaths, activities_count, variant="frequency") parameters_viz = {"format": "svg"} gviz = pn_vis_factory.apply(net, initial_marking, final_marking, variant="frequency", aggregated_statistics=aggregated_statistics, parameters=parameters_viz) pn_vis_factory.save(gviz, path_frequency) aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount( net, dfg_performance, spaths, activities_count, variant="performance") parameters_viz = {"format": "svg"} gviz = pn_vis_factory.apply(net, initial_marking, final_marking, variant="performance", aggregated_statistics=aggregated_statistics, parameters=parameters_viz) pn_vis_factory.save(gviz, path_performance)
def import_xes_data(filename): if not os.path.abspath(filename): file_path = global_util.get_full_path_input_file(filename) else: file_path = filename filename = os.path.basename(filename) # import the name of log parameters = {"timestamp_sort": True} log = importer.apply(file_path, variant="nonstandard", parameters=parameters) print(log) # file of miner application log net, initial_marking, final_marking = alpha_miner.apply(log) # Visual interface application analysis results gviz = visualizer.apply(net, initial_marking, final_marking) # Generate output file name file, _ = os.path.splitext(filename) output_full_name = "output_" + file + ".png" # Generate the full path of the output file output_file = global_util.get_full_path_output_file(output_full_name) # save document visualizer.save(gviz, output_file) # Returns the output file name return output_full_name
def bot_alpha_miner(chat_id): log = get_current_log(chat_id) net, initial_marking, final_marking = alpha_miner.apply(log) gviz = vis_factory.apply(net, initial_marking, final_marking) new_file, filename = tempfile.mkstemp(suffix="png") vis_factory.save(gviz, filename) return filename
def import_xes_data(filename): if not os.path.abspath(filename): file_path = global_util.get_full_path_input_file(filename) else: file_path = filename filename = os.path.basename(filename) parameters = {"timestamp_sort": True} log = importer.apply(file_path, variant="nonstandard", parameters=parameters) print(log) net, initial_marking, final_marking = alpha_miner.apply(log) gviz = visualizer.apply(net, initial_marking, final_marking) file, _ = os.path.splitext(filename) output_full_name = "output_" + file + ".png" output_file = global_util.get_full_path_output_file(output_full_name) visualizer.save(gviz, output_file) return output_full_name
def Alphaminer(file): log = xes_importer.import_log(file) net, initial_marking, final_marking = alpha_miner.apply(log) gviz = vis_factory.apply(net, initial_marking, final_marking) location = "/mnt/c/Users/harim/Downloads/alphaminer.png" vis_factory.save(gviz, location) #vis_factory.view(gviz) return location
def SPIMDFb(context): args = context.args inputFile = os.path.join(args.inputData, os.listdir(args.inputData)[0]) log = xes_importer.import_log(inputFile) net, initial_marking, final_marking = inductive_miner.apply(log) gviz = pn_vis_factory.apply(net, initial_marking, final_marking) pn_vis_factory.save(gviz, os.path.join(args.outputData, "inductive-miner.png")) return args.outputData
def inductive_miner_petrinet_no_decor(log_file): net, i_m, f_m = inductive_miner.apply(log_file) gviz = pn_vis_factory.apply(net, i_m, f_m, parameters={ "format": "png", "debug": False }) pn_vis_factory.save(gviz, "static/inductive_miner_petnet_no_decor.png") return net, i_m, f_m
def SPAlphaMiner(context): args = context.args log = convert_df_pm_format(args.inputData) net, initial_marking, final_marking = alpha_miner.apply(log) gviz = pn_vis_factory.apply(net, initial_marking, final_marking) pn_vis_factory.save(gviz, os.path.join(args.outputData, "alpha-miner.png")) pnml_exporter.export_net( net, initial_marking, os.path.join(args.outputData, "petri_final.pnml"), final_marking=final_marking, ) return args.outputData
def inductive_miner_petrinet_frequency(log_file): net, i_m, f_m = inductive_miner.apply(log_file) gviz = pn_vis_factory.apply(net, i_m, f_m, parameters={ "format": "png", "debug": False }, variant="frequency", log=log_file) pn_vis_factory.save(gviz, "static/inductive_miner_petnet_frequency.png") return "success!"
def explore_process(name, csv, miner, miner_name): event_log = csv_importer.import_log_from_string(csv) net, initial_marking, final_marking = miner.apply(event_log) gviz = pn_vis_factory.apply(net, initial_marking, final_marking) pn_vis_factory.save(gviz, join('solutions', name + '_' + miner_name + '_petri_net.png')) pn_vis_factory.save(gviz, join('solutions', name + '_' + miner_name + '_petri_net.pdf')) bpmn_graph, elements_correspondence, inv_elements_correspondence, el_corr_keys_map = bpmn_converter.apply(net, initial_marking, final_marking) bpmn_exporter.export_bpmn(bpmn_graph, join('solutions', name + '_' + miner_name + '.bpmn')) bpmn_figure = bpmn_vis_factory.apply(bpmn_graph) bpmn_vis_factory.save(bpmn_figure, join('solutions', name + '_' + miner_name + '_bpmn.png')) bpmn_vis_factory.save(bpmn_figure, join('solutions', name + '_' + miner_name + '_bpmn.pdf'))
def bot_hm(chat_id, dependency_threshold=0.99): log = get_current_log(chat_id) heu_net = heuristics_miner.apply_heu( log, parameters={"dependency_thresh": dependency_threshold}) gviz = hn_vis_factory.apply(heu_net) new_file, filename = tempfile.mkstemp(suffix="png") hn_vis_factory.save(gviz, filename) net, im, fm = heuristics_miner.apply( log, parameters={"dependency_thresh": dependency_threshold}) gviz = pn_vis_factory.apply(net, im, fm) new_file2, filename2 = tempfile.mkstemp(suffix="png") pn_vis_factory.save(gviz, filename2) return [filename, filename2]
def show_log(self, log): # Miner application log file net, initial_marking, final_marking = alpha_miner.apply(log) # Visual interface application analysis results gviz = visualizer.apply(net, initial_marking, final_marking) file, _ = os.path.splitext(os.path.basename(self.fileName)) output_full_name = "output_time_filtered_" + file + ".png" output_file = global_util.get_full_path_output_file(output_full_name) print(output_file) visualizer.save(gviz, output_file) return output_full_name
def generate_petri_net_visual(net, initial_marking, final_marking, xes_log): try: # visualizing the petri net using graphviz library, by passing net initial and final marking and viewing it parameters = {"format": "png"} gviz = pn_vis_factory.apply(net, initial_marking, final_marking, parameters=parameters, variant="frequency", log=xes_log) pn_vis_factory.view(gviz) print("By what name do you want to save the petri net image?") filename = str(input()) pn_vis_factory.save(gviz, filename + ".png") except TypeError: print("Please check input values")
def SPHeuristicsMiner(context): args = context.args inputFile = os.path.join(args.inputData, os.listdir(args.inputData)[0]) log = xes_importer.import_log(inputFile) net, im, fm = heuristics_miner.apply( log, parameters={ "dependency_thresh": args.dependencyThresh, "and_measure_thresh": args.andMeasureThresh, "min_act_count": args.minActCount, "min_dfg_occurrences": args.minDfgOccurrences, "dfg_pre_cleaning_noise_thresh": args.dfgPreCleaningNoiseThresh, }, ) gviz = pn_vis_factory.apply(net, im, fm) pn_vis_factory.save(gviz, os.path.join(args.outputData, "heuristics-miner.png")) return args.outputData
def _create_image(self, gviz, img_name, verbose=False): """ Create image file of the generated diagram (DFG,BPMN,Petr net) :param gviz: image file generated by pm4py :param img_name: name of the image to be saved :param verbose: display log while generating images """ try: img_path = os.path.join(self.discovery_path, f'{self.filename}_{img_name}.pdf') if "alpha_miner" in img_name: vis_factory.save(gviz, img_path) elif "heuristic_miner" in img_name: hn_vis_factory.save(gviz, img_path) elif "petri_net" in img_name: pn_vis_factory.save(gviz, img_path) elif "DFG" in img_name: dfg_vis_factory.save(gviz, img_path) # elif "BPMN" in img_name: # bpmn_vis_factory.save(gviz, img_path) if verbose: self.status_queue.put(f"[PROCESS MINING] Generated {img_name} in {img_path}") except PermissionError as e: print(f"[PROCESS MINING] Could not save image because of permission error: {e}") print(f"Trying to save image on desktop") img_path = os.path.join(utils.utils.DESKTOP, f'{self.filename}_{img_name}.pdf') if "alpha_miner" in img_name: vis_factory.save(gviz, img_path) elif "heuristic_miner" in img_name: hn_vis_factory.save(gviz, img_path) elif "petri_net" in img_name: pn_vis_factory.save(gviz, img_path) elif "DFG" in img_name: dfg_vis_factory.save(gviz, img_path) # elif "BPMN" in img_name: # bpmn_vis_factory.save(gviz, img_path) except Exception as e: print(f"[PROCESS MINING] Could not save image: {e}")
def directly_follows_graphs_freq(log_file): dfg = dfg_factory.apply(log_file) gviz = dfg_vis_factory.apply(dfg, log=log_file, variant="frequency") pn_vis_factory.save(gviz, "static/dag_frequency.png") return "success!"
def directly_follows_graphs_perf(log_file): dfg = dfg_factory.apply(log_file) gviz = dfg_vis_factory.apply(dfg, log=log_file, variant="performance") pn_vis_factory.save(gviz, "static/dag_performance.png") return "success!"
##### alpha miner ########## from pm4py.algo.discovery.alpha import factory as alpha_miner ########### inductive mining ####### from pm4py.visualization.petrinet import factory as pn_vis_factory parameters = {"format": "png"} net, initial_marking, final_marking = alpha_miner.apply(conv_log) parameters = {"format": "png"} gviz = pn_vis_factory.apply(net, initial_marking, final_marking, parameters=parameters, variant="frequency", log=conv_log) pn_vis_factory.save(gviz, "inductive_frequency_invoice.png") gviz = pn_vis_factory.apply(net, initial_marking, final_marking, parameters=parameters, variant="performance", log=conv_log) pn_vis_factory.save(gviz, "inductive_performance_invoice.png") ######################################### ##### inducive miner ################### from pm4py.algo.discovery.inductive import factory as inductive_miner # discovers an accepting Petri net net, im, fm = inductive_miner.apply(df)
logging.debug("Creating process model...") if DISCOVER: main_model, main_im, main_fm = create_model(log_main) #save_heuristics_net(log_main) else: # reference model can also be imported instead of using process discovery main_model, main_im, main_fm = convert_bpmn( os.path.join("datasets", "bpmn_models", "1.bpmn")) # visualize gviz = pn_vis_factory.apply(main_model, main_im, main_fm, parameters={"format": "png"}) logging.debug("Saving micro-cluster model") pn_vis_factory.save(gviz, "results/rm.png") # introducing recurring drifts with specific inter-drift distance log, gt = shuffle_log(log, SUB_LOG_SIZE, switch=SWITCH) #logging.debug("Number of traces in whole log: {}".format(len(log))) logging.debug("Saved micro-cluster model") logging.debug("Creating networkx graph...") nx_graph, inv_dict = create_networkx_graph(main_model, main_im, main_fm) # only work on largest connected component nx_graph = nx_graph.subgraph(max(nx.connected_components(nx_graph), key=len)) inv_dict = { list(inv_dict.keys())[list(inv_dict.values()).index(v)]: v for v in nx_graph.nodes }
def show(model, tel, file_name, parameters): ''' Show model and its quality measures :param model: model type (transition system, state based region, DFG miner, alpha miner) :param tel: input log :param file_name: img file name to show model :param parameters: parmater for transition system (afreq, sfreq) :return: ''' tel_flag = False if isinstance(tel[0][0], tel_event): tel_flag = True if model in ['ts', 'sbr']: if tel_flag: output_file_path = os.path.join( "static", "images", file_name[:file_name.find('.')] + '_' + model + '_' + str(parameters['afreq_thresh']) + '_' + str(parameters['sfreq_thresh']) + ".png") else: output_file_path = os.path.join( "static", "images", "2" + "_" + file_name[:file_name.find('.')] + '_' + model + '_' + str(parameters[PARAM_KEY_DIRECTION]) + '_' + str(parameters[PARAM_KEY_WINDOW]) + "_" + str(parameters[PARAM_KEY_VIEW]) + ".png") auto = utils.discover_annotated_automaton(tel, parameters=parameters) max_thresh = {} max_afreq = 0 max_sfreq = 0 if tel_flag: for trans in auto.transitions: max_afreq = max(max_afreq, trans.afreq) for state in auto.states: max_sfreq = max(max_sfreq, state.sfreq) max_thresh['afreq'] = max_afreq max_thresh['sfreq'] = max_sfreq if model == 'ts': result = {} gviz = vis_factory.apply(auto) vis_factory.save(gviz, output_file_path) result['num of transitions'] = len(auto.transitions) result['num of states'] = len(auto.states) else: net, im, fm = sb.petri_net_synthesis(auto) gviz = petri_vis_factory.apply(net, im, fm) petri_vis_factory.save(gviz, output_file_path) result = evaluation(net, im, fm, tel) else: if tel_flag: output_file_path = os.path.join( "static", "images", file_name[:file_name.find('.')] + '_' + model + '_' + ".png") else: output_file_path = os.path.join( "static", "images", "2" + file_name[:file_name.find('.')] + '_' + model + '_' + ".png") if model == 'alpha': if isinstance(tel[0][0], Event): net, im, fm = trans_alpha(tel) else: net, im, fm = alpha_miner.apply(tel) gviz = petri_vis_factory.apply(net, im, fm) petri_vis_factory.save(gviz, output_file_path) result = evaluation(net, im, fm, tel) else: dfg = dfg_factory.apply(tel) if tel_flag: dfg_tel = inductive_revise.get_dfg_graph_trans(tel) #dfg = dfg_tel + dfg dfg = dfg_tel gviz = dfg_vis_factory.apply(dfg, log=tel) dfg_vis_factory.save(gviz, output_file_path) result = dict( sorted(dfg.items(), key=operator.itemgetter(1), reverse=True)) max_thresh = None return output_file_path, result, max_thresh
pnmlFolder = "simple_pnml" pngFolder = "simple_png" for logName in os.listdir(logFolder): if "." in logName: logNamePrefix = logName.split(".")[0] print("\nelaborating " + logName) logPath = os.path.join(logFolder, logName) log = xes_factory.import_log(logPath, variant="iterparse") net, initial_marking, final_marking = simple_model_factory.apply( log, classic_output=True) pnml_exporter.export_net(net, initial_marking, os.path.join(pnmlFolder, logNamePrefix) + ".pnml", final_marking=final_marking) gviz = petri_vis_factory.apply(net, initial_marking, final_marking, log=log, variant="frequency") petri_vis_factory.save( gviz, os.path.join(pngFolder, logNamePrefix) + ".png")
def export_petri_net(path, output): net, i_m, f_m = output viz_params = {"format": "svg", "debug": True} gviz = pn_vis_factory.apply(net, i_m, f_m, parameters=viz_params) pn_vis_factory.save(gviz, path)
from pm4py.algo.discovery.alpha import factory as alpha_miner from pm4py.objects.log.importer.xes import factory as xes_importer from pm4py.visualization.petrinet import factory as vis_factory log = xes_importer.import_log('/tmp/input/example.xes') net, initial_marking, final_marking = alpha_miner.apply(log) gviz = vis_factory.apply(net, initial_marking, final_marking) vis_factory.save(gviz,'/data/output.png')
def model(request, log_id, cube_id): values = request.GET.get("values") if (values == None): values = "{}" values = json.loads(values) def convert(value, dtype): if (dtype == 'float'): return float(value) elif (dtype == 'int'): return int(value) elif (dtype == 'date'): return convert_date(value) elif (dtype == 'bool'): return bool(value) else: return value def convert_date(value): # Construct datetime object to filter with pymongo time_format = "%Y-%m-%dT%H:%M:%S.%f" time_format = "%Y-%m-%d %H:%M:%S.%f" if ("." not in value): time_format = time_format[:-3] return datetime.strptime(value, time_format) algo = request.GET.get("algorithm") values_ = {} # Convert to attribute id to name like it is in the events. values_ = {} for key in values: if (key != 'log'): attribute = Attribute.objects.get(pk=key) if (":" in attribute.parent): parent = attribute.parent.split(':')[0] d_name = attribute.parent.split(':')[1] name = attribute.name # Query for elements of dictionary queryname = parent + ":" + d_name + ".children." + name else: queryname = attribute.name if (attribute.parent == "trace"): queryname = 'trace:' + queryname if ("to" in values[key]): lower = values[key].split("to")[0].strip() upper = values[key].split('to')[1].strip() lower = convert(lower, attribute.dtype) upper = convert(upper, attribute.dtype) values_[queryname] = {'$gt': lower, '$lt': upper} else: value = convert(values[key], attribute.dtype) values_[queryname] = value values_['log'] = log_id values = values_ client = MongoClient(host=DATABASES['default']['HOST']) db = client[DATABASES['default']['NAME']] trace_collection = db['traces'] event_collection = db['events'] t1 = time() all_events = event_collection.find(values) t2 = time() print("Time to get events: {}".format(t2 - t1)) t1 = time() traces = groupby(all_events, key=lambda e: e['trace:_id']) t2 = time() print("Time to get traces: {}".format(t2 - t1)) t1 = time() traces = [log_lib.log.Trace(g) for k, g in traces] t2 = time() print("Time to make list: {}".format(t2 - t1)) # log_list = [log_lib.log.Trace([log_lib.log.Event(t_e) for t_e in all_events if t_e['trace:_id'] == db_trace['_id']]) for db_trace in db_traces] t1 = time() log = log_lib.log.EventLog(traces) t2 = time() print("Time to make event log: {}".format(t2 - t1)) # for db_trace in db_traces: # pm4py_trace = log_lib.log.Trace([log_lib.log.Event(t_e) for t_e in all_events if t_e['trace:_id'] == db_trace['_id']]) # log.append(pm4py_trace) # print(len(log)) # pm_events = [] # traces = {str(e['trace:_id']): log_lib.log.Trace() for e in events} # for event in events: # trace = trace_collection.find_one({"_id": event['trace:_id']}) # t = traces[str(event['trace:_id'])] # del event['_id'] # del event['trace:_id'] # e = log_lib.log.Event(event) # t.append(e) # log.append(traces.items()) # for trace in traces: # log.append(traces[trace]) parameters = {"format": "svg"} event_log = EventLog.objects.get(pk=log_id) filename = str(event_log.pk) + algo + ".svg" t1 = time() if (algo == "alpha"): net, initial_marking, final_marking = alpha_miner.apply(log) gviz = pn_vis_factory.apply(net, initial_marking, final_marking, parameters=parameters) pn_vis_factory.save(gviz, filename) elif (algo == "inductive"): mine_tree = request.GET.get("mine_tree") if (mine_tree == 'true'): tree = inductive_miner.apply_tree(log) gviz = pt_vis_factory.apply(tree, parameters=parameters) pt_vis_factory.save(gviz, filename) else: net, initial_marking, final_marking = inductive_miner.apply(log) gviz = pn_vis_factory.apply(net, initial_marking, final_marking, parameters=parameters) pn_vis_factory.save(gviz, filename) elif (algo == "heuristic"): dependency_thresh = float(request.GET.get("dependency_thresh")) and_measure_thresh = float(request.GET.get("and_measure_thresh")) min_act_count = float(request.GET.get("min_act_count")) min_dfg_occurrences = float(request.GET.get("min_dfg_occurrences")) dfg_pre_cleaning_noise_thresh = float( request.GET.get("dfg_pre_cleaning_noise_thresh")) h_params = { 'dependency_thresh': dependency_thresh, 'and_measure_thresh': and_measure_thresh, 'min_act_count': min_act_count, 'min_dfg_occurrences': min_dfg_occurrences, 'dfg_pre_cleaning_noise_thresh': dfg_pre_cleaning_noise_thresh, } net, im, fm = heuristics_miner.apply(log, parameters=h_params) gviz = pn_vis_factory.apply(net, im, fm, parameters=parameters) pn_vis_factory.save(gviz, filename) t2 = time() print("Time pm4py: {}".format(t2 - t1)) svg = open(filename, "rb") svg_content = svg.read() svg.close() # Tdelete file, it's not required anymore os.remove(svg.name) return HttpResponse(svg_content, content_type="image/svg+xml")