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 gerar_view_dfg_model(eventLog, dfg, metric_type='FREQUENCY', image_format='png'): gviz = None if metric_type == 'PERFORMANCE': parameters = { dfg_visualization.Variants.PERFORMANCE.value.Parameters.FORMAT: image_format } # Visualise gviz = dfg_visualization.apply( dfg, log=eventLog, variant=dfg_visualization.Variants.PERFORMANCE, parameters=parameters) elif metric_type == 'FREQUENCY': parameters = { dfg_visualization.Variants.FREQUENCY.value.Parameters.FORMAT: image_format } # Visualise gviz = dfg_visualization.apply( dfg, log=eventLog, variant=dfg_visualization.Variants.FREQUENCY, parameters=parameters) else: print("Invalid metric_type: " + metric_type) return gviz
def execute_script(): df = pd.read_csv("../tests/input_data/interval_event_log.csv") df = dataframe_utils.convert_timestamp_columns_in_df(df) act_count = dict(df["concept:name"].value_counts()) parameters = {} parameters[ constants.PARAMETER_CONSTANT_START_TIMESTAMP_KEY] = "start_timestamp" parameters[constants.PARAMETER_CONSTANT_TIMESTAMP_KEY] = "time:timestamp" parameters["format"] = "svg" start_activities = sa_get.get_start_activities(df, parameters=parameters) end_activities = ea_get.get_end_activities(df, parameters=parameters) parameters["start_activities"] = start_activities parameters["end_activities"] = end_activities soj_time = soj_time_get.apply(df, parameters=parameters) dfg, performance_dfg = correlation_miner.apply( df, variant=correlation_miner.Variants.CLASSIC, parameters=parameters) gviz_freq = dfg_vis.apply(dfg, activities_count=act_count, soj_time=soj_time, variant=dfg_vis.Variants.FREQUENCY, parameters=parameters) dfg_vis.view(gviz_freq) gviz_perf = dfg_vis.apply(performance_dfg, activities_count=act_count, soj_time=soj_time, variant=dfg_vis.Variants.PERFORMANCE, parameters=parameters) dfg_vis.view(gviz_perf)
def execute_script(): df = pd.read_csv("../tests/input_data/receipt.csv") df = dataframe_utils.convert_timestamp_columns_in_df(df) act_count = dict(df["concept:name"].value_counts()) dfg, performance_dfg = correlation_miner.apply(df, variant=correlation_miner.Variants.CLASSIC) gviz_freq = dfg_vis.apply(dfg, activities_count=act_count, variant=dfg_vis.Variants.FREQUENCY, parameters={"format": "svg"}) dfg_vis.view(gviz_freq) gviz_perf = dfg_vis.apply(performance_dfg, activities_count=act_count, variant=dfg_vis.Variants.PERFORMANCE, parameters={"format": "svg"}) dfg_vis.view(gviz_perf)
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "interval_event_log.csv") dataframe = pm4py.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 save_vis_dfg(dfg, start_activities, end_activities, file_path, log=None): """ Saves a DFG visualization to a file Parameters -------------- dfg DFG object start_activities Start activities end_activities End activities file_path Destination path """ format = file_path[file_path.index(".") + 1:].lower() from pm4py.visualization.dfg import visualizer as dfg_visualizer parameters = dfg_visualizer.Variants.FREQUENCY.value.Parameters gviz = dfg_visualizer.apply(dfg, log=log, variant=dfg_visualizer.Variants.FREQUENCY, parameters={ parameters.FORMAT: format, parameters.START_ACTIVITIES: start_activities, parameters.END_ACTIVITIES: end_activities }) dfg_visualizer.save(gviz, file_path)
def view_dfg(dfg, start_activities, end_activities, format="png", log=None): """ Views a (composite) DFG Parameters ------------- dfg DFG object start_activities Start activities end_activities End activities format Format of the output picture (default: png) """ from pm4py.visualization.dfg import visualizer as dfg_visualizer parameters = dfg_visualizer.Variants.FREQUENCY.value.Parameters gviz = dfg_visualizer.apply(dfg, log=log, variant=dfg_visualizer.Variants.FREQUENCY, parameters={ parameters.FORMAT: format, parameters.START_ACTIVITIES: start_activities, parameters.END_ACTIVITIES: end_activities }) dfg_visualizer.view(gviz)
def execute_script(): log_input_directory = "xesinput" all_logs_names = os.listdir(log_input_directory) all_logs_names = [log for log in all_logs_names if ".xe" in log] for logName in all_logs_names: # logPath = os.path.join("..", "tests", "inputData", logName) log_path = log_input_directory + "\\" + logName log = xes_importer.apply(log_path) print("\n\n") print("log loaded") print("Number of traces - ", len(log)) event_log = log_conversion.apply( log, variant=log_conversion.TO_EVENT_STREAM) print("Number of events - ", len(event_log)) print("Classifiers ", log.classifiers) exp_log_name = "xescert_exportlogs" + "\\" + "exp_" + logName print("exporting log", exp_log_name) xes_exporter.apply(log, exp_log_name) print("exported log", exp_log_name) log, classifier_attr_key = insert_classifier.search_act_class_attr(log) classifiers = list(log.classifiers.keys()) if classifier_attr_key is None and classifiers: try: print(classifiers) log, classifier_attr_key = insert_classifier.insert_activity_classifier_attribute( log, classifiers[0]) print(classifier_attr_key) except: print("exception in handling classifier") if classifier_attr_key is None: classifier_attr_key = "concept:name" if len(event_log) > 0 and classifier_attr_key in event_log[0]: parameters = { constants.PARAMETER_CONSTANT_ACTIVITY_KEY: classifier_attr_key } dfg = dfg_algorithm.apply(log, parameters=parameters) gviz = dfg_vis.apply(dfg, log=log, variant="frequency", parameters=parameters) # dfg_vis.view(gviz) dfg_vis.save(gviz, "xescert_images\\" + logName.replace("xes", "png")) print("Reimporting log file just exported - ", exp_log_name) log = xes_importer.apply(exp_log_name) print("log loaded", exp_log_name) print("Number of traces - ", len(log)) event_log = log_conversion.apply( log, variant=log_conversion.TO_EVENT_STREAM) print("Number of events - ", len(event_log)) print("Classifiers ", log.classifiers)
def execute_script(): # imports a XES event log log = pm4py.read_xes( os.path.join("..", "tests", "input_data", "receipt.xes")) # converts the log into a list of events (not anymore grouped in cases) event_stream = pm4py.convert_to_event_stream(log) # creates a live event stream (an object that distributes the messages to the algorithm) live_stream = LiveEventStream() # creates the streaming DFG discovery object stream_dfg_disc = dfg_discovery.apply() # register the discovery algorithm to the stream live_stream.register(stream_dfg_disc) # start the recording of events from the live event stream live_stream.start() # append each event of the original log to the live event stream # (so it is sent to the conformance checking algorithm) for event in event_stream: live_stream.append(event) # stops the live event stream live_stream.stop() # gets the DFG along with the start and end activities from the stream dfg, activities, start_activities, end_activities = stream_dfg_disc.get() # visualize the DFG gviz = dfg_visualizer.apply(dfg, variant=dfg_visualizer.Variants.FREQUENCY, activities_count=activities, parameters={ "format": "svg", "start_activities": start_activities, "end_activities": end_activities }) dfg_visualizer.view(gviz)
def view_dfg(dfg: dict, start_activities: dict, end_activities: dict, format: str = "png", log: Optional[EventLog] = None): """ Views a (composite) DFG Parameters ------------- dfg DFG object start_activities Start activities end_activities End activities format Format of the output picture (default: png) """ from pm4py.visualization.dfg import visualizer as dfg_visualizer dfg_parameters = dfg_visualizer.Variants.FREQUENCY.value.Parameters parameters = get_properties(log) parameters[dfg_parameters.FORMAT] = format parameters[dfg_parameters.START_ACTIVITIES] = start_activities parameters[dfg_parameters.END_ACTIVITIES] = end_activities gviz = dfg_visualizer.apply(dfg, log=log, variant=dfg_visualizer.Variants.FREQUENCY, parameters=parameters) dfg_visualizer.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 execute_script(): df = csv_import_adapter.import_dataframe_from_path( "../tests/input_data/receipt.csv") act_count = dict(df["concept:name"].value_counts()) dfg, performance_dfg = correlation_miner.apply( df, variant=correlation_miner.Variants.CLASSIC) gviz_freq = dfg_vis.apply(dfg, activities_count=act_count, variant=dfg_vis.Variants.FREQUENCY, parameters={"format": "svg"}) dfg_vis.view(gviz_freq) gviz_perf = dfg_vis.apply(performance_dfg, activities_count=act_count, variant=dfg_vis.Variants.PERFORMANCE, parameters={"format": "svg"}) dfg_vis.view(gviz_perf)
def save_full_dfg(log): dfg = dfg_discovery.apply(log) gviz = dfg_visualization.apply( dfg, log=log, variant=dfg_visualization.Variants.FREQUENCY) dfg_visualization.view(gviz) parameters = { dfg_visualization.Variants.PERFORMANCE.value.Parameters.FORMAT: "svg" } gviz = dfg_visualization.apply( dfg, log=log, variant=dfg_visualization.Variants.FREQUENCY, parameters=parameters) dfg_visualization.save(gviz, "dfg_full.svg") print('Full DFG saves as "dfg_full.svg"') return gviz
def test_44(self): import os from pm4py.objects.log.importer.xes import importer as xes_importer log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) from pm4py.algo.discovery.dfg import algorithm as dfg_discovery from pm4py.visualization.dfg import visualizer as dfg_visualization dfg = dfg_discovery.apply(log, variant=dfg_discovery.Variants.PERFORMANCE) gviz = dfg_visualization.apply(dfg, log=log, variant=dfg_visualization.Variants.PERFORMANCE)
def test_45(self): import os from pm4py.objects.log.importer.xes import importer as xes_importer log = xes_importer.apply(os.path.join("input_data", "running-example.xes")) from pm4py.algo.discovery.dfg import algorithm as dfg_discovery from pm4py.visualization.dfg import visualizer as dfg_visualization dfg = dfg_discovery.apply(log, variant=dfg_discovery.Variants.PERFORMANCE) parameters = {dfg_visualization.Variants.PERFORMANCE.value.Parameters.FORMAT: "svg"} gviz = dfg_visualization.apply(dfg, log=log, variant=dfg_visualization.Variants.PERFORMANCE, parameters=parameters) dfg_visualization.save(gviz, os.path.join("test_output_data", "dfg.svg")) os.remove(os.path.join("test_output_data", "dfg.svg"))
def execute_script(): log = pm4py.read_xes( os.path.join("..", "tests", "input_data", "receipt.xes")) print("number of cases", len(log)) print("number of events", sum(len(x) for x in log)) print("number of variants", len(pm4py.get_variants(log))) ac = get.get_attribute_values(log, "concept:name") dfg, sa, ea = pm4py.discover_dfg(log) perc = 0.5 dfg, sa, ea, ac = dfg_filtering.filter_dfg_on_activities_percentage( dfg, sa, ea, ac, perc) dfg, sa, ea, ac = dfg_filtering.filter_dfg_on_paths_percentage( dfg, sa, ea, ac, perc) aa = time.time() aligned_traces = dfg_alignment.apply(log, dfg, sa, ea) bb = time.time() net, im, fm = pm4py.convert_to_petri_net(dfg, sa, ea) for trace in aligned_traces: if trace["cost"] != trace["internal_cost"]: print(trace) pass print(bb - aa) print(sum(x["visited_states"] for x in aligned_traces)) print( sum(x["cost"] // align_utils.STD_MODEL_LOG_MOVE_COST for x in aligned_traces)) gviz = visualizer.apply(dfg, activities_count=ac, parameters={ "start_activities": sa, "end_activities": ea, "format": "svg" }) visualizer.view(gviz) cc = time.time() aligned_traces2 = petri_alignments.apply( log, net, im, fm, variant=petri_alignments.Variants.VERSION_DIJKSTRA_LESS_MEMORY) dd = time.time() print(dd - cc) print(sum(x["visited_states"] for x in aligned_traces2)) print( sum(x["cost"] // align_utils.STD_MODEL_LOG_MOVE_COST for x in aligned_traces2))
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_importer.apply(log_path) dfg = dfg_algorithm.apply(log) dfg_gv = dfg_vis_fact.apply( dfg, log, parameters={ dfg_vis_fact.Variants.FREQUENCY.value.Parameters.FORMAT: "svg" }) dfg_vis_fact.view(dfg_gv) net, im, fm = dfg_conv.apply(dfg) gviz = pn_vis.apply( net, im, fm, parameters={ pn_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg" }) pn_vis.view(gviz)
def create_directly_follows_graph(frame: DataFrame, output_format='svg'): """ Creates a Directly Follows Graph from the supplied DataFrame. :param frame: the DataFrame :param output_format: desired output format :return: object representing the created graph """ event_log = _convert_data_frame_to_event_log(frame) dfg = dfg_alg.apply(log=event_log, variant=DfgAlgVariants.FREQUENCY) apply = dfg_vis.apply( dfg, log=event_log, variant=DfgVisVariants.FREQUENCY, parameters={VisualisationParams.FORMAT: output_format}) saved_dfg = tempfile.NamedTemporaryFile(prefix='pm_', suffix=f'.{output_format}', delete=False) dfg_vis.save(apply, saved_dfg.name) # close here and delete after final use to work around access issues on # in case anybody tries to run this on windows saved_dfg.close() return saved_dfg
def execute_script(): log = pm4py.read_xes("../tests/input_data/receipt.xes") dfg, sa, ea = pm4py.discover_dfg(log) act_count = pm4py.get_attribute_values(log, "concept:name") # keep the specified amount of activities dfg, sa, ea, act_count = pm4py.objects.dfg.filtering.dfg_filtering.filter_dfg_on_activities_percentage( dfg, sa, ea, act_count, 0.3) # keep the specified amount of paths dfg, sa, ea, act_count = pm4py.objects.dfg.filtering.dfg_filtering.filter_dfg_on_paths_percentage( dfg, sa, ea, act_count, 0.3) # view the DFG gviz = dfg_visualizer.apply( dfg, activities_count=act_count, parameters={ dfg_visualizer.Variants.FREQUENCY.value.Parameters.START_ACTIVITIES: sa, dfg_visualizer.Variants.FREQUENCY.value.Parameters.END_ACTIVITIES: ea, dfg_visualizer.Variants.FREQUENCY.value.Parameters.FORMAT: "svg" }) dfg_visualizer.view(gviz)
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 DFG (using Pm4Py) dfg, start_activities, end_activities = pm4py.discover_directly_follows_graph( sub_log) parameters = { dfg_visualization.Variants.FREQUENCY.value.Parameters.START_ACTIVITIES: start_activities, dfg_visualization.Variants.FREQUENCY.value.Parameters.END_ACTIVITIES: end_activities } gviz = dfg_visualization.apply(dfg, log=sub_log, parameters=parameters) # dfg = dfg_discovery.apply(sub_log, variant=dfg_discovery.Variants.PERFORMANCE) # gviz = dfg_visualization.apply(dfg, log=sub_log, variant=dfg_visualization.Variants.PERFORMANCE) # save the process model if activity and activity != '': # adaptive approach generates models per activity output_filename = self.model_type_definitions.get_model_filename( event_data_original_name, w_count[activity]) else: # fixed approach generate the models based on the window size 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) gviz.save(filename=output_filename, directory=models_path) return gviz
def save_vis_dfg(dfg: dict, start_activities: dict, end_activities: dict, file_path: str, log: Optional[EventLog] = None): """ Saves a DFG visualization to a file Parameters -------------- dfg DFG object start_activities Start activities end_activities End activities file_path Destination path """ if log is not None: if type(log) not in [pd.DataFrame, EventLog, EventStream]: raise Exception( "the method can be applied only to a traditional event log!") format = os.path.splitext(file_path)[1][1:] from pm4py.visualization.dfg import visualizer as dfg_visualizer dfg_parameters = dfg_visualizer.Variants.FREQUENCY.value.Parameters parameters = get_properties(log) parameters[dfg_parameters.FORMAT] = format parameters[dfg_parameters.START_ACTIVITIES] = start_activities parameters[dfg_parameters.END_ACTIVITIES] = end_activities gviz = dfg_visualizer.apply(dfg, log=log, variant=dfg_visualizer.Variants.FREQUENCY, parameters=parameters) dfg_visualizer.save(gviz, file_path)
st.write("") st.write("Os movimentos estão no seguinte formato:") st.write("* CódigoNacionalCNJ:Descrição do Movimento") st.write("") st.write('Quando a métrica selecionada é o "Tempo" são utilizadas as seguintes unidades:' ) st.write('* D = Days/Dias' ) st.write('* MO = Months/Meses' ) st.write('* Y = Years/Anos' ) st.write('' ) st.write('Ex: 5D = 5 Dias, 2Y = 2 anos.' ) st.write("") sl_grafo_oj1 = st.empty() with st.spinner('Só mais 1 segundo...'): gviz_oj1 = dfg_visualization.apply(dfg_oj1, log=tracefilter_log_pos_oj1, variant=dfg_metrica, parameters=parameters) html = render_svg(gviz_oj1.pipe().decode('utf-8'), 1200, 500) sl_grafo_oj1.write(html, unsafe_allow_html=True) st.header(f"Órgão Julgador 2 - {sb_2_OJ}") with st.beta_expander("Ajuda"): st.write("Trib: "+sb_1_trib) st.write("Classes: "+sb_1_classes) st.write("Órgão: "+sb_2_OJ) st.write("") st.write("Os movimentos estão no seguinte formato:") st.write("* CódigoNacionalCNJ:Descrição do Movimento") st.write("") st.write('Quando a métrica selecionada é o "Tempo" são utilizadas as seguintes unidades:' ) st.write('* D = Days/Dias' )
def filter_for_periods(detect_result, event_counts): start_element1 = 0 if CHOSEN_PERIOD1 == 1 else detect_result[CHOSEN_PERIOD1 - 2] end_element1 = detect_result[CHOSEN_PERIOD1 - 1] start_element2 = 0 if CHOSEN_PERIOD2 == 1 else detect_result[CHOSEN_PERIOD2 - 2] end_element2 = detect_result[CHOSEN_PERIOD2 - 1] days = list(event_counts.keys()) #print(days[start_element1]) start_day1 = days[start_element1] end_day1 = days[end_element1 - 1] days_count1 = end_element1 - start_element1 start_day2 = days[start_element2] end_day2 = days[end_element2 - 1] days_count2 = end_element2 - start_element2 # Traces that are FULLY CONTAINED in the given timeframe period_1_log = timestamp_filter.filter_traces_contained( log, start_day1 + " 00:00:00", end_day1 + " 23:59:59") period_2_log = timestamp_filter.filter_traces_contained( log, start_day2 + " 00:00:00", end_day2 + " 23:59:59") # Traces that INTERSECT with the given timeframe # period_1_log = timestamp_filter.filter_traces_intersecting(log, start_day+" 00:00:00", end_day+" 23:59:59") dfg1 = dfg_discovery.apply(period_1_log) dfg2 = dfg_discovery.apply(period_2_log) gviz1 = dfg_visualization.apply( dfg1, log=period_1_log, variant=dfg_visualization.Variants.FREQUENCY) dfg_visualization.view(gviz1) # Saving the DFG parameters = { dfg_visualization.Variants.PERFORMANCE.value.Parameters.FORMAT: "svg" } gviz1 = dfg_visualization.apply( dfg1, log=period_1_log, variant=dfg_visualization.Variants.FREQUENCY, parameters=parameters) dfg_visualization.save(gviz1, "dfg1.svg") nodes_period1, edges_period1 = dot_to_df(gviz1) gviz2 = dfg_visualization.apply( dfg2, log=period_2_log, variant=dfg_visualization.Variants.FREQUENCY) dfg_visualization.view(gviz2) # Saving the DFG parameters = { dfg_visualization.Variants.PERFORMANCE.value.Parameters.FORMAT: "svg" } gviz2 = dfg_visualization.apply( dfg2, log=period_2_log, variant=dfg_visualization.Variants.FREQUENCY, parameters=parameters) dfg_visualization.save(gviz2, "dfg2.svg") return days_count1, days_count2, period_1_log, period_2_log, gviz1, gviz2
def dfg_discovery_frequency(log): # creatig the graph from log dfg = dfg_discovery.apply(log) gviz = dfg_visualization.apply( dfg, log=log, variant=dfg_visualization.Variants.FREQUENCY) return gviz, None
def dfg_discovery_active_time(log): # creatig the graph from log dfg = dfg_discovery.apply(log, variant=dfg_discovery.Variants.PERFORMANCE) gviz = dfg_visualization.apply( dfg, log=log, variant=dfg_visualization.Variants.PERFORMANCE) return gviz, None
def discover_process_models(log_path, log_name): custom_print('Importando log') log_complete = xes_importer.apply(log_path) log = variants_filter.filter_log_variants_percentage(log_complete, 0.9) #A_ACTIVATED, A_DECLINED, A_CANCELLED #log = attributes_filter.apply(log_complete, ["A_ACTIVATED"], parameters={attributes_filter.Parameters.ATTRIBUTE_KEY: "concept:name", attributes_filter.Parameters.POSITIVE: True}) custom_print('Log importado') if (1 == 2): #Inductive Miner custom_print('Iniciando Inductive Miner') parameters = { inductive_miner.Variants.IM.value.Parameters.CASE_ID_KEY: 'case:concept:name', inductive_miner.Variants.IM.value.Parameters.TIMESTAMP_KEY: 'time:timestamp' } variant = inductive_miner.Variants.IM petrinet = inductive_miner.apply(log, parameters=parameters, variant=variant) print_statistics(petrinet[0], 'IM') custom_print('Inductive Miner finalizado\n') if (1 == 2): #Inductive Miner Infrequent 0.2 custom_print('Iniciando Inductive Miner Infrequent 0.2') parameters = { inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: 0.2, inductive_miner.Variants.IMf.value.Parameters.CASE_ID_KEY: 'case:concept:name', inductive_miner.Variants.IMf.value.Parameters.TIMESTAMP_KEY: 'time:timestamp' } variant = inductive_miner.Variants.IMf petrinet = inductive_miner.apply(log, parameters=parameters, variant=variant) print_statistics(petrinet[0], 'IMf0.2') custom_print('Inductive Miner Infrequent 0.2 finalizado\n') if (1 == 1): #Inductive Miner Infrequent 0.5 custom_print('Iniciando Inductive Miner Infrequent 0.5') parameters = { inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: 0.5, inductive_miner.Variants.IMf.value.Parameters.CASE_ID_KEY: 'case:concept:name', inductive_miner.Variants.IMf.value.Parameters.TIMESTAMP_KEY: 'time:timestamp' } variant = inductive_miner.Variants.IMf petrinet, initial_marking, final_marking = inductive_miner.apply( log, parameters=parameters, variant=variant) print_statistics(petrinet, 'IMf0.5') custom_print('Inductive Miner Infrequent 0.5 finalizado\n') ts = reachability_graph.construct_reachability_graph( petrinet, initial_marking) gviz = ts_visualizer.apply( ts, parameters={ ts_visualizer.Variants.VIEW_BASED.value.Parameters.FORMAT: "png" }) gviz.render('petrinets/simple-reach', cleanup=True) pnml_exporter.apply(petrinet, initial_marking, "petrinets/simple-petri.pnml") if (1 == 2): #Inductive Miner Infrequent 0.8 custom_print('Iniciando Inductive Miner Infrequent 0.8') parameters = { inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: 0.8, inductive_miner.Variants.IMf.value.Parameters.CASE_ID_KEY: 'case:concept:name', inductive_miner.Variants.IMf.value.Parameters.TIMESTAMP_KEY: 'time:timestamp' } variant = inductive_miner.Variants.IMf petrinet = inductive_miner.apply(log, parameters=parameters, variant=variant) print_statistics(petrinet[0], 'IMf0.8') custom_print('Inductive Miner Infrequent 0.8 finalizado\n') if (1 == 2): #Inductive Miner Directly-Follows custom_print('Iniciando Inductive Miner Directly-Follows') parameters = { inductive_miner.Variants.IMd.value.Parameters.CASE_ID_KEY: 'case:concept:name', inductive_miner.Variants.IMd.value.Parameters.TIMESTAMP_KEY: 'time:timestamp' } variant = inductive_miner.Variants.IMd petrinet = inductive_miner.apply(log, parameters=parameters, variant=variant) print_statistics(petrinet[0], 'IMd') custom_print('Inductive Miner Infrequent Directly-Follows\n') if (1 == 2): #Alpha Miner custom_print('Iniciando Alpha Miner') parameters = {} variant = alpha_miner.Variants.ALPHA_VERSION_CLASSIC petrinet = alpha_miner.apply(log, parameters=parameters, variant=variant) print_statistics(petrinet[0], 'Alpha') custom_print('Alpha Miner finalizado\n') if (1 == 2): #Heuristic Miner 0.5 custom_print('Iniciando Heuristic Miner 0.5') parameters = { heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.5 } petrinet = heuristics_miner.apply(log, parameters=parameters) print_statistics(petrinet[0], 'HM0.5') custom_print('Heuristic Miner 0.5 finalizado\n') if (1 == 2): #Heuristic Miner 0.99 custom_print('Iniciando Heuristic Miner 0.99') parameters = { heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.99 } petrinet = heuristics_miner.apply(log, parameters=parameters) print_statistics(petrinet[0], 'HM0.99') custom_print('Heuristic Miner 0.99 finalizado\n') if (1 == 2): #Heuristic Miner 0.1 custom_print('Iniciando Heuristic Miner 0.1') parameters = { heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 0.1 } petrinet = heuristics_miner.apply(log, parameters=parameters) print_statistics(petrinet[0], 'HM0.1') custom_print('Heuristic Miner 0.1 finalizado\n') if (1 == 2): #Heuristic Miner 1.0 custom_print('Iniciando Heuristic Miner 1.0') parameters = { heuristics_miner.Variants.CLASSIC.value.Parameters.DEPENDENCY_THRESH: 1.0 } petrinet = heuristics_miner.apply(log, parameters=parameters) print_statistics(petrinet[0], 'HM1.0') custom_print('Heuristic Miner 1.0 finalizado\n') if (1 == 2): #DFG custom_print('Iniciando DFG') dfg = dfg_discovery.apply(log) parameters = { dfg_visualization.Variants.FREQUENCY.value.Parameters.FORMAT: 'png' } gviz = dfg_visualization.apply( dfg, log=log, variant=dfg_visualization.Variants.FREQUENCY, parameters=parameters) dfg_visualization.save(gviz, 'petrinets/simple-DFG.png') custom_print('DFG finalizado\n')
import pandas as pd # this part is required because the dataframe provided by PowerBI has strings dataset["time:timestamp"] = pd.to_datetime(dataset["time:timestamp"]) from pm4py.algo.discovery.dfg.adapters.pandas import df_statistics dfg = df_statistics.get_dfg_graph(dataset, measure="frequency") from pm4py.statistics.attributes.pandas import get as attributes_get activities_count = attributes_get.get_attribute_values(dataset, "concept:name") from pm4py.statistics.start_activities.pandas import get as sa_get start_activities = sa_get.get_start_activities(dataset) from pm4py.statistics.end_activities.pandas import get as ea_get end_activities = ea_get.get_end_activities(dataset) from pm4py.visualization.dfg import visualizer gviz = visualizer.apply(dfg, activities_count=activities_count, variant=visualizer.Variants.FREQUENCY, parameters={ "start_activities": start_activities, "end_activities": end_activities }) visualizer.matplotlib_view(gviz)
def apply_filter(req): sessions[req.session["id"]] = datetime.now() filters = { "time": True, "variants": True, "performance": True, "activities": True, "attribute": True } req.session.set_expiry(7200) #print(str(req.body)) o = json.loads(req.body) print(str(o)) custom_time_range = [] for pair in o["filter1"]: #custom_time_range.append((dateutil.parser.parse(pair[0]),dateutil.parser.parse(pair[1]))) custom_time_range.append((pair[0],pair[1])) if o["filter1"] == []: filters["time"] = False #print(o["filter1"][0]) #print(custom_time_range[0][0]) #print(custom_time_range) custom_path_range = [] for pair in o["filter2"]: custom_path_range.append((float(pair[0]),float(pair[1]))) if o["filter2"] == []: filters["variants"] = False #custom_path_range = [(0,1)] #filter2 custom_performance_range = [] for pair in o["filter3"]: custom_performance_range.append((float(pair[0]),float(pair[1]))) if o["filter3"] == []: filters["performance"] = False custom_activitiy_range = [] for pair in o["filter4"]: custom_activitiy_range.append((float(pair[0]),float(pair[1]))) if o["filter4"] == []: filters["activities"] = False #custom_activitiy_range = [(0,1)] #filter3 custom_attribute_range = [] for pair in o["filter5"]: custom_attribute_range.append((float(pair[0]),float(pair[1]))) if o["filter5"] == [] or o["filter5attribute"] == "Empty": filters["attribute"] = False additional_attribute = o["filter5attribute"] selected_viz = o["visualization"] calc_lev = o["distance"] #input_file = os.path.join("webapp","static", req.session["id"] + "_l0.xes") input_file = os.path.join("webapp","static", "sepsis.xes") input_log = xes_importer.apply(input_file) not_filtered_logs = {} flatten = lambda l: [item for sublist in l for item in sublist] time_timestamp_started = datetime.now() if filters["time"]: #TODO check overlapping for filter custom_time_range = sorted(custom_time_range, reverse=False) for i in range(0,len(custom_time_range)-1): if(custom_time_range[i][1] > custom_time_range[i+1][0]): response = HttpResponse(json.dumps({'error': "Wrong intervals for time filter"})) response.status_code = 200 return response #raise ValueError("Overlapping time ranges") logs = [] for (x,y) in custom_time_range: logs.append(timestamp_filter.filter_traces_contained(input_log, x, y)) #log = timestamp_filter.filter_traces_contained(input_log, custom_time_range[0][0], custom_time_range[0][1]) log = pm4py.objects.log.log.EventLog() for timeslice in logs: for trace in timeslice: log.append(trace) print(len(input_log)) print(len(log)) #l2 not_filtered_logs["timestamp_filter"] = pm4py.objects.log.log.EventLog() for trace in input_log: if trace not in log: not_filtered_logs["timestamp_filter"].append(trace) print(len(not_filtered_logs["timestamp_filter"])) else: log = input_log time_variants_started = datetime.now() # where should I start? if filters["variants"]: variants = variants_filter.get_variants(log) variants_count = case_statistics.get_variant_statistics(log) variants_count = sorted(variants_count, key=lambda x: x['count'], reverse=False) custom_path_range = sorted(custom_path_range, reverse=False) # check overlapping for i in range(0,len(custom_path_range)-1): if(custom_path_range[i][1] > custom_path_range[i+1][0]): response = HttpResponse(json.dumps({'error': "Wrong intervals for variants filter"})) response.status_code = 200 return response #raise ValueError("Overlapping variants ranges") nr_variants = len(variants_count) custom_path_range * nr_variants idx = [(math.floor(x*nr_variants), math.ceil(y*nr_variants)) for (x,y) in custom_path_range] variants_subset = [variants_count[x:y+1] for (x,y) in idx] variants_subset = flatten(variants_subset) filtered_variants = {k:v for k,v in variants.items() if k in [x["variant"] for x in variants_subset]} #l2 not_filtered_variants = {k:v for k,v in variants.items() if k not in [x["variant"] for x in variants_subset]} filtered_log = variants_filter.apply(log, filtered_variants) #l2 not_filtered_logs["variant_filter"] = variants_filter.apply(log, not_filtered_variants) else: filtered_log = log time_variants_finished = datetime.now() # note: incl log2 generation if filters["performance"]: custom_performance_range = sorted(custom_performance_range, reverse=False) # check overlapping for i in range(0,len(custom_performance_range)-1): if(custom_performance_range[i][1] > custom_performance_range[i+1][0]): response = HttpResponse(json.dumps({'error': "Wrong intervals for performance filter"})) response.status_code = 200 return response #raise ValueError("Overlapping performance ranges") #all_case_durations = case_statistics.get_all_casedurations(log, parameters={case_statistics.Parameters.TIMESTAMP_KEY: "time:timestamp"}) #case_filter.filter_case_performance(log, 86400, 864000) performances = [] for i in range(len(filtered_log)): filtered_log[i].attributes["throughput"] = (max([event["time:timestamp"]for event in filtered_log[i]])-min([event["time:timestamp"] for event in filtered_log[i]])).total_seconds() performances.append(filtered_log[i].attributes["throughput"]) nr_cases = len(filtered_log) performances = sorted(performances, reverse=False) idx = [(math.floor(x*nr_cases), math.ceil(y*nr_cases)) for (x,y) in custom_performance_range] perf_subset = [performances[x:y+1] for (x,y) in idx] perf_subset = flatten(perf_subset) performance_log = pm4py.objects.log.log.EventLog([trace for trace in filtered_log if trace.attributes["throughput"] in perf_subset]) #l2 not_filtered_logs["performance_filter"] = pm4py.objects.log.log.EventLog([trace for trace in filtered_log if trace.attributes["throughput"] not in perf_subset]) #print(str(len(not_filtered_logs["performance_filter"]))) else: performance_log = filtered_log time_performance_finished = datetime.now() if filters["activities"]: variants = variants_filter.get_variants(performance_log) variants_count = case_statistics.get_variant_statistics(performance_log) variants_count = sorted(variants_count, key=lambda x: x['count'], reverse=False) activities = dict() for variant in variants_count: for activity in variant["variant"].split(","): if (activity not in activities.keys()): activities[activity] = variant["count"] else: activities[activity] += variant["count"] sorted_activities = {k: v for k, v in sorted(activities.items(), key=lambda item: item[1])} activities_sorted_list = list(sorted_activities) custom_activitiy_range = sorted(custom_activitiy_range, reverse=False) # check overlapping for i in range(0,len(custom_activitiy_range)-1): if(custom_activitiy_range[i][1] > custom_activitiy_range[i+1][0]): response = HttpResponse(json.dumps({'error': "Wrong intervals for activities filter"})) response.status_code = 200 return response #raise ValueError("Overlapping activities ranges") nr_activities = len(activities_sorted_list) idx = [(math.floor(x*nr_activities), math.ceil(y*nr_activities)) for (x,y) in custom_activitiy_range] activities_to_keep = [activities_sorted_list[x:y+1] for (x,y) in idx] activities_to_keep = flatten(activities_to_keep) variants_idx = [] for i in range(len(variants_count)): for activity in activities_to_keep: if (activity in variants_count[i]["variant"].split(",") and (i not in variants_idx)): variants_idx.append(i) variants_subset = [variants_count[i] for i in variants_idx] filtered_variants = {k:v for k,v in variants.items() if k in [x["variant"] for x in variants_subset]} #l2 not_filtered_variants = {k:v for k,v in variants.items() if k not in [x["variant"] for x in variants_subset]} filtered_log = variants_filter.apply(performance_log, filtered_variants) #l2 not_filtered_logs["activities_filter"] = variants_filter.apply(performance_log, not_filtered_variants) new_log = pm4py.objects.log.log.EventLog() #not_filtered_logs["activities_filter_traces"] = pm4py.objects.log.log.EventLog() for trace in filtered_log: new_trace = pm4py.objects.log.log.Trace() not_new_trace = pm4py.objects.log.log.Trace() for event in trace: if(event['concept:name'] in activities_to_keep): new_trace.append(event) else: not_new_trace.append(event) if(len(new_trace)>0): new_log.append(new_trace) if(len(not_new_trace)>0): not_filtered_logs["activities_filter"].append(not_new_trace) else: new_log = performance_log time_activities_finished = datetime.now() if filters["attribute"]: custom_attribute_range = sorted(custom_attribute_range, reverse=False) # check overlapping for i in range(0,len(custom_attribute_range)-1): if(custom_attribute_range[i][1] > custom_attribute_range[i+1][0]): response = HttpResponse(json.dumps({'error': "Wrong intervals for additional attribute filter"})) response.status_code = 200 return response newest_log = pm4py.objects.log.log.EventLog() not_filtered_logs["additional_filter"] = pm4py.objects.log.log.EventLog() traces_with_attr = [] not_traces_with_attr = [] for trace in new_log: if additional_attribute in trace.attributes.keys(): traces_with_attr.append(trace) else: not_traces_with_attr.append(trace) #check if trace attribute if len(traces_with_attr)>0: #check if numeric if type(traces_with_attr[0].attributes[additional_attribute]) in [int, float]: for trace in traces_with_attr: if any([trace.attributes[additional_attribute] >= x and trace.attributes[additional_attribute] <= y for (x,y) in custom_attribute_range]): newest_log.append(trace) else: not_filtered_logs["additional_filter"].append(trace) for trace in not_traces_with_attr: not_filtered_logs["additional_filter"].append(trace) else: #string attribute_frequencies = dict() for trace in traces_with_attr: if trace.attributes[additional_attribute] not in attribute_frequencies.keys(): attribute_frequencies[trace.attributes[additional_attribute]] = 0 attribute_frequencies[trace.attributes[additional_attribute]] += 1 sorted_frequencies = {k: v for k, v in sorted(attribute_frequencies.items(), key=lambda item: item[1])} frequencies_sorted_list = list(sorted_frequencies) nr_values = len(frequencies_sorted_list) idx = [(math.floor(x*nr_values), math.ceil(y*nr_values)) for (x,y) in custom_attribute_range] values_to_keep = [frequencies_sorted_list[x:y+1] for (x,y) in idx] values_to_keep = flatten(values_to_keep) for trace in traces_with_attr: if trace.attributes[additional_attribute] in values_to_keep: newest_log.append(trace) else: not_filtered_logs["additional_filter"].append(trace) for trace in not_traces_with_attr: not_filtered_logs["additional_filter"].append(trace) else: #event attribute if [type(event[additional_attribute]) for trace in new_log for event in trace if additional_attribute in event.keys()][0] in [int, float]: for trace in new_log: new_trace = pm4py.objects.log.log.Trace() not_new_trace = pm4py.objects.log.log.Trace() for event in trace: if(additional_attribute in event.keys() and any([event[additional_attribute] >= x and event[additional_attribute] <= y for (x,y) in custom_attribute_range ])): new_trace.append(event) else: not_new_trace.append(event) if(len(new_trace)>0): newest_log.append(new_trace) if(len(not_new_trace)>0): not_filtered_logs["additional_filter"].append(not_new_trace) else: #string attribute_frequencies = dict() for trace in new_log: for event in trace: if additional_attribute in event.keys(): if event[additional_attribute] not in attribute_frequencies.keys(): attribute_frequencies[event[additional_attribute]] = 0 attribute_frequencies[event[additional_attribute]] += 1 sorted_frequencies = {k: v for k, v in sorted(attribute_frequencies.items(), key=lambda item: item[1])} frequencies_sorted_list = list(sorted_frequencies) nr_values = len(frequencies_sorted_list) idx = [(math.floor(x*nr_values), math.ceil(y*nr_values)) for (x,y) in custom_attribute_range] values_to_keep = [frequencies_sorted_list[x:y+1] for (x,y) in idx] values_to_keep = flatten(values_to_keep) for trace in new_log: new_trace = pm4py.objects.log.log.Trace() not_new_trace = pm4py.objects.log.log.Trace() for event in trace: if(additional_attribute in event.keys() and event[additional_attribute] in values_to_keep): new_trace.append(event) else: not_new_trace.append(event) if(len(new_trace)>0): newest_log.append(new_trace) if(len(not_new_trace)>0): not_filtered_logs["additional_filter"].append(not_new_trace) else: newest_log = new_log time_attribute_finished = datetime.now() if(selected_viz=="dfgf"): dfg = dfg_discovery.apply(newest_log) gviz = dfg_visualization.apply(dfg, log=newest_log, variant=dfg_visualization.Variants.FREQUENCY) dfg_visualization.save(gviz, os.path.join("webapp","static", req.session["id"] + "_l1.png")) elif(selected_viz=="dfgp"): dfg = dfg_discovery.apply(newest_log) gviz = dfg_visualization.apply(dfg, log=newest_log, variant=dfg_visualization.Variants.PERFORMANCE) dfg_visualization.save(gviz, os.path.join("webapp","static", req.session["id"] + "_l1.png")) else: heu_net = heuristics_miner.apply_heu(newest_log, parameters={"dependency_thresh": 0.99}) gviz = hn_vis_factory.apply(heu_net) hn_vis_factory.save(gviz, os.path.join("webapp","static", req.session["id"] + "_l1.png")) xes_exporter.apply(newest_log, os.path.join("webapp","static", req.session["id"] + "_l1.xes")) #l2 not_filtered_log = pm4py.objects.log.log.EventLog() for part in not_filtered_logs.keys(): for trace in not_filtered_logs[part]: not_filtered_log.append(trace) if(selected_viz=="dfgf"): dfg = dfg_discovery.apply(not_filtered_log) gviz = dfg_visualization.apply(dfg, log=not_filtered_log, variant=dfg_visualization.Variants.FREQUENCY) dfg_visualization.save(gviz, os.path.join("webapp","static", req.session["id"] + "_l2.png")) elif(selected_viz=="dfgp"): dfg = dfg_discovery.apply(not_filtered_log) gviz = dfg_visualization.apply(dfg, log=not_filtered_log, variant=dfg_visualization.Variants.PERFORMANCE) dfg_visualization.save(gviz, os.path.join("webapp","static", req.session["id"] + "_l2.png")) else: heu_net = heuristics_miner.apply_heu(not_filtered_log, parameters={"dependency_thresh": 0.99}) gviz = hn_vis_factory.apply(heu_net) hn_vis_factory.save(gviz, os.path.join("webapp","static", req.session["id"] + "_l2.png")) xes_exporter.apply(not_filtered_log, os.path.join("webapp","static", req.session["id"] + "_l2.xes")) if(calc_lev): lev_new = [0]*len(newest_log) for i in range(len(newest_log)): lev_new[i] = [hash(event['concept:name']) for event in newest_log[i]] lev_not = [0]*len(not_filtered_log) for i in range(len(not_filtered_log)): lev_not[i] = [hash(event['concept:name']) for event in not_filtered_log[i]] distances = [] for i in range(len(lev_new)): for j in range(len(lev_not)): distances.append(lev_dist(lev_new[i], lev_not[j])) lev_d = sum(distances)/len(distances) print("Levenshtein's distance: "+str(lev_d)) else: lev_d = "null" used_paths = 0 for lower, higher in custom_path_range: used_paths += round((higher-lower)*100) print(f"Using {used_paths}% of paths. {100-used_paths}% of paths are discarded.") print("Timestamp filter: {} seconds. \nVariants filter: {} seconds. \nPerformance filter: {} seconds. \nActivities filter: {} seconds. \nAttribute filter: {} seconds.".format((time_variants_started - time_timestamp_started).total_seconds(), (time_variants_finished - time_variants_started).total_seconds(), (time_performance_finished - time_variants_finished).total_seconds(), (time_activities_finished - time_performance_finished).total_seconds(), (time_attribute_finished - time_activities_finished).total_seconds())) response = HttpResponse(json.dumps({'time':(time_variants_started - time_timestamp_started).total_seconds(), 'variants':(time_variants_finished - time_variants_started).total_seconds(),'performance':(time_performance_finished - time_variants_finished).total_seconds(), 'activities':(time_activities_finished - time_performance_finished).total_seconds(), 'attribute':(time_attribute_finished - time_activities_finished).total_seconds(), 'traces':[len(newest_log), len(not_filtered_log)], 'distance':lev_d})) response.status_code = 200 return response
from pm4pydistr.remote_wrapper import factory as wrapper_factory from pm4py.visualization.dfg import visualizer as dfg_visualizer wrapper = wrapper_factory.apply("127.0.0.1", "5001", "hello", "receipt") dfg, performance_dfg, activities_counter = wrapper.correlation_miner(parameters={"min_act_freq": 100}) gviz = dfg_visualizer.apply(dfg, activities_count=activities_counter, parameters={"format": "svg"}) dfg_visualizer.view(gviz)
nx.draw_networkx_nodes(G, pos, partition.keys(), node_size=40, cmap=cmap, node_color=list(partition.values())) nx.draw_networkx_edges(G, pos, alpha=0.5) plt.show() community_louvain.modularity(partition, G) girvannewman = graphLearning.community_dection_graph(graph, mst=False) from pm4py.visualization.dfg import visualizer as dfg_visualization gviz = dfg_visualization.apply(dfg, log=ex1_personal_log_1_converted, variant=dfg_visualization.Variants.FREQUENCY) dfg_visualization.view(gviz) def fixDfg(dfg, activityList=[ 'Read_Labsheet', 'Read_Lecture_Note', 'Excercise', 'Check_solution' ]): result = {} transitionList = [] for i in activityList: for j in activityList: transitionList.append((i, j)) for t in transitionList: