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.import_log(log_path) print("\n\n") print("log loaded") print("Number of traces - ", len(log)) event_log = log_conv_fact.apply(log, variant=log_conv_fact.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.export_log(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_factory.apply(log, parameters=parameters) gviz = dfg_vis_factory.apply(dfg, log=log, variant="frequency", parameters=parameters) # dfg_vis_factory.view(gviz) dfg_vis_factory.save( gviz, "xescert_images\\" + logName.replace("xes", "png")) print("Reimporting log file just exported - ", exp_log_name) log = xes_importer.import_log(exp_log_name) print("log loaded", exp_log_name) print("Number of traces - ", len(log)) event_log = log_conv_fact.apply(log, variant=log_conv_fact.TO_EVENT_STREAM) print("Number of events - ", len(event_log)) print("Classifiers ", log.classifiers)
def build_from_path(self, path, parameters=None): """ Builds the handler from the specified path to XES file Parameters ------------- path Path to the log file parameters Parameters of the algorithm """ if parameters is None: parameters = {} try: # try faster non standard importer self.log = xes_importer.apply(path, variant="nonstandard") if len(self.log) == 0: # non standard imported failed self.log = xes_importer.apply(path) except: # revert to classic importer self.log = xes_importer.apply(path) self.log, classifier_key = insert_classifier.search_act_class_attr( self.log, force_activity_transition_insertion=True) self.activity_key = xes.DEFAULT_NAME_KEY if classifier_key is not None: self.activity_key = classifier_key self.build_variants() self.calculate_variants_number() self.calculate_cases_number() self.calculate_events_number()
def build_from_path(self, path, parameters=None): """ Builds the handler from the specified path to XES file Parameters ------------- path Path to the log file parameters Parameters of the algorithm """ if parameters is None: parameters = {} self.log = xes_importer.apply(path) self.log, classifier_key = insert_classifier.search_act_class_attr(self.log, force_activity_transition_insertion=True) self.activity_key = xes.DEFAULT_NAME_KEY if classifier_key is not None: self.activity_key = classifier_key # sorts the traces and the events in the log #self.log = sorting.sort_timestamp_log(self.log) self.build_variants() self.calculate_variants_number() self.calculate_cases_number() self.calculate_events_number() # inserts the event and the case index attributes self.insert_event_index()
f.write("\t") f.write(get_elonged_float(simplicity_imdf[this_logname])) f.write("\n") f.write("\n") f.close() 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") log, classifier_key = insert_classifier.search_act_class_attr(log) print("loaded log") activity_key = "concept:name" if classifier_key is not None: activity_key = classifier_key parameters_discovery = { pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key, pmutil.constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY: activity_key } t1 = time.time() alpha_model, alpha_initial_marking, alpha_final_marking = alpha.apply( log, parameters=parameters_discovery) pnml_exporter.export_net(alpha_model,
def apply(log, parameters=None, classic_output=False): """ Gets a simple model out of a log Parameters ------------- log Trace log parameters Parameters of the algorithm, including: maximum_number_activities -> Maximum number of activities to keep discovery_algorithm -> Discovery algorithm to use (alpha, inductive) desidered_output -> Desidered output of the algorithm (default: Petri) include_filtered_log -> Include the filtered log in the output include_dfg_frequency -> Include the DFG of frequencies in the output include_dfg_performance -> Include the DFG of performance in the output include_filtered_dfg_frequency -> Include the filtered DFG of frequencies in the output include_filtered_dfg_performance -> Include the filtered DFG of performance in the output classic_output Determine if the output shall contains directly the objects (e.g. net, initial_marking, final_marking) or can return a more detailed dictionary """ if parameters is None: parameters = {} returned_dictionary = {} net = None initial_marking = None final_marking = None bpmn_graph = None dfg_frequency = None dfg_performance = None filtered_dfg_frequency = None filtered_dfg_performance = None maximum_number_activities = parameters[ "maximum_number_activities"] if "maximum_number_activities" in parameters else 20 discovery_algorithm = parameters["discovery_algorithm"] if "discovery_algorithm" in parameters else "alpha" desidered_output = parameters["desidered_output"] if "desidered_output" in parameters else "petri" include_filtered_log = parameters["include_filtered_log"] if "include_filtered_log" in parameters else True include_dfg_frequency = parameters["include_dfg_frequency"] if "include_dfg_frequency" in parameters else True include_dfg_performance = parameters[ "include_dfg_performance"] if "include_dfg_performance" in parameters else False include_filtered_dfg_frequency = parameters[ "include_filtered_dfg_frequency"] if "include_filtered_dfg_frequency" in parameters else True include_filtered_dfg_performance = parameters[ "include_filtered_dfg_performance"] if "include_filtered_dfg_performance" in parameters else False if PARAMETER_CONSTANT_ATTRIBUTE_KEY in parameters: activity_key = parameters[ PARAMETER_CONSTANT_ATTRIBUTE_KEY] if PARAMETER_CONSTANT_ATTRIBUTE_KEY in parameters else DEFAULT_NAME_KEY parameters[PARAMETER_CONSTANT_ATTRIBUTE_KEY] = activity_key else: log, activity_key = insert_classifier.search_act_class_attr(log) if activity_key is None: activity_key = DEFAULT_NAME_KEY parameters[PARAMETER_CONSTANT_ATTRIBUTE_KEY] = activity_key if PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters: parameters[PARAMETER_CONSTANT_ACTIVITY_KEY] = parameters[PARAMETER_CONSTANT_ATTRIBUTE_KEY] activities_count_dictio = attributes_filter.get_attribute_values(log, activity_key) activities_count_list = [] for activity in activities_count_dictio: activities_count_list.append([activity, activities_count_dictio[activity]]) activities_count_list = sorted(activities_count_list, key=lambda x: x[1], reverse=True) activities_count_list = activities_count_list[:min(len(activities_count_list), maximum_number_activities)] activities_keep_list = [x[0] for x in activities_count_list] log = attributes_filter.apply(log, activities_keep_list, parameters=parameters) filtered_log = None if "alpha" in discovery_algorithm: # parameters_sa = deepcopy(parameters) # parameters_sa["decreasingFactor"] = 1.0 filtered_log = start_activities_filter.apply_auto_filter(log, parameters=parameters) filtered_log = end_activities_filter.apply_auto_filter(filtered_log, parameters=parameters) filtered_log = filter_topvariants_soundmodel.apply(filtered_log, parameters=parameters) elif "dfg_mining" in discovery_algorithm: filtered_log = start_activities_filter.apply_auto_filter(log, parameters=parameters) filtered_log = end_activities_filter.apply_auto_filter(filtered_log, parameters=parameters) filtered_log = auto_filter.apply_auto_filter(filtered_log, parameters=parameters) if include_dfg_frequency or "dfg_mining" in discovery_algorithm: dfg_frequency = dfg_factory.apply(log, parameters=parameters, variant="frequency") if include_dfg_performance: dfg_performance = dfg_factory.apply(log, parameters=parameters, variant="performance") if include_filtered_dfg_frequency: filtered_dfg_frequency = dfg_factory.apply(filtered_log, parameters=parameters, variant="frequency") if include_filtered_dfg_performance: filtered_dfg_performance = dfg_factory.apply(filtered_log, parameters=parameters, variant="performance") if "alpha" in discovery_algorithm: net, initial_marking, final_marking = alpha_miner.apply(filtered_log, parameters=parameters) elif "dfg_mining" in discovery_algorithm: start_activities = start_activities_filter.get_start_activities(filtered_log, parameters=parameters) end_activities = end_activities_filter.get_end_activities(filtered_log, parameters=parameters) parameters_conv = {} parameters_conv["start_activities"] = start_activities parameters_conv["end_activities"] = end_activities net, initial_marking, final_marking = dfg_conv_factory.apply(dfg_frequency, parameters=parameters_conv) if filtered_log is not None and include_filtered_log: returned_dictionary["filtered_log"] = filtered_log if net is not None and desidered_output == "petri": returned_dictionary["net"] = net if initial_marking is not None and desidered_output == "petri": returned_dictionary["initial_marking"] = initial_marking if final_marking is not None and desidered_output == "petri": returned_dictionary["final_marking"] = final_marking if bpmn_graph is not None and desidered_output == "bpmn": returned_dictionary["bpmn_graph"] = bpmn_graph if dfg_frequency is not None and include_dfg_frequency: returned_dictionary["dfg_frequency"] = dfg_frequency if dfg_performance is not None and include_dfg_performance: returned_dictionary["dfg_performance"] = dfg_performance if filtered_dfg_frequency is not None and include_filtered_dfg_frequency: returned_dictionary["filtered_dfg_frequency"] = filtered_dfg_frequency if filtered_dfg_performance is not None and include_filtered_dfg_performance: returned_dictionary["filtered_dfg_performance"] = filtered_dfg_performance if classic_output: if net is not None and desidered_output == "petri": return net, initial_marking, final_marking return returned_dictionary
f.write("\n") f.close() for logName in os.listdir(logFolder): if "." in logName: logNamePrefix = logName.split(".")[0] logExtension = logName[len(logNamePrefix) + 1:] print("\nelaborating " + logName) logPath = os.path.join(logFolder, logName) if "xes" in logExtension: log = xes_importer.apply(logPath, variant=xes_importer.Variants.ITERPARSE) log, classifier_key = insert_classifier.search_act_class_attr(log, force_activity_transition_insertion=True) print("loaded log") activity_key = "concept:name" if classifier_key is not None: activity_key = classifier_key parameters_discovery = {pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key, pmutil.constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY: activity_key} t1 = time.time() alpha_model, alpha_initial_marking, alpha_final_marking = alpha.apply(log, parameters=parameters_discovery) if ENABLE_PETRI_EXPORTING: pnml_exporter.export_net(alpha_model, alpha_initial_marking, os.path.join(pnmlFolder, logNamePrefix + "_alpha.pnml"), final_marking=alpha_final_marking)