def create_log(G, conn_comp, timestamps, max_comp_len=50, include_loops=False): log = EventLog() for i in range(len(conn_comp)): if len(conn_comp[i]) <= max_comp_len: trace = Trace() trace.attributes["concept:name"] = str(i) SG = G.subgraph(conn_comp[i]) SGG = networkx.DiGraph(SG) edges = list(SGG.edges) for e in edges: if e[0] == e[1]: SGG.remove_edge(e[0], e[1]) sorted_nodes = list(networkx.topological_sort(SGG)) for n in sorted_nodes: selfloop = 1 if (n, n) in SG.edges else 0 trace.append( Event({ 'time:timestamp': timestamps[n.split("=")[1]], 'concept:name': n.split("=")[0], 'value': n.split("=")[1], 'typevalue': n, 'selfloop': selfloop })) if include_loops and selfloop: trace.append( Event({ 'time:timestamp': timestamps[n.split("=")[1]], 'concept:name': n.split("=")[0], 'value': n.split("=")[1], 'typevalue': n, 'selfloop': selfloop })) log.append(trace) log = sorting.sort_timestamp_log(log, "time:timestamp") return log
def apply(log, list_activities, sample_size, parameters): """ Finds the performance spectrum provided a log and a list of activities Parameters ------------- log Log list_activities List of activities interesting for the performance spectrum (at least two) sample_size Size of the sample parameters Parameters of the algorithm, including the activity key and the timestamp key Returns ------------- points Points of the performance spectrum """ if parameters is None: parameters = {} activity_key = parameters[ constants. PARAMETER_CONSTANT_ACTIVITY_KEY] if constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY timestamp_key = parameters[ constants. PARAMETER_CONSTANT_TIMESTAMP_KEY] if constants.PARAMETER_CONSTANT_TIMESTAMP_KEY in parameters else xes.DEFAULT_TIMESTAMP_KEY log = sorting.sort_timestamp_log(log, timestamp_key=timestamp_key) parameters[constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY] = activity_key log = basic_filter.filter_log_events_attr(log, list_activities, parameters=parameters) points = [] for trace in log: for i in range(len(trace) - len(list_activities) + 1): acti_comb = [ event[activity_key] for event in trace[i:i + len(list_activities)] ] if acti_comb == list_activities: timest_comb = [ event[timestamp_key].timestamp() for event in trace[i:i + len(list_activities)] ] points.append(timest_comb) points = sorted(points, key=lambda x: x[0]) if len(points) > sample_size: points = points_subset.pick_chosen_points_list(sample_size, points) return points
def insert_time_from_previous(log, parameters=None): """ Inserts the time from the previous event, both in normal and business hours Parameters ------------- log Event log parameters Parameters of the algorithm Returns ------------- enriched_log Enriched log (with the time passed from the previous event) """ if parameters is None: parameters = {} timestamp_key = parameters[ constants. PARAMETER_CONSTANT_TIMESTAMP_KEY] if constants.PARAMETER_CONSTANT_TIMESTAMP_KEY in parameters else xes.DEFAULT_TIMESTAMP_KEY worktiming = parameters["worktiming"] if "worktiming" in parameters else [ 7, 17 ] weekends = parameters["weekends"] if "weekends" in parameters else [6, 7] if not type(log) is EventLog: log = log_converter.apply(log) log = sorting.sort_timestamp_log(log, timestamp_key) for trace in log: if trace: trace[0]["@@passed_time_from_previous"] = 0 trace[0]["@@approx_bh_passed_time_from_previous"] = 0 i = 1 while i < len(trace): trace[i]["@@passed_time_from_previous"] = ( trace[i][timestamp_key] - trace[i - 1][timestamp_key]).total_seconds() bh = BusinessHours( trace[i - 1][timestamp_key].replace(tzinfo=None), trace[i][timestamp_key].replace(tzinfo=None), worktiming=worktiming, weekends=weekends) trace[i][ "@@approx_bh_passed_time_from_previous"] = bh.getseconds() i = i + 1 return log
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 # 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()
def apply( log: EventLog, list_activities: List[str], sample_size: int, parameters: Optional[Dict[Union[str, Parameters], Any]] = None ) -> Dict[str, Any]: """ Finds the disconnected performance spectrum provided a log and a list of activities Parameters ------------- log Log list_activities List of activities interesting for the performance spectrum (at least two) sample_size Size of the sample parameters Parameters of the algorithm, including: - Parameters.ACTIVITY_KEY - Parameters.TIMESTAMP_KEY Returns ------------- points Points of the performance spectrum """ if parameters is None: parameters = {} sort_log_required = exec_utils.get_param_value( Parameters.SORT_LOG_REQUIRED, parameters, True) all_acti_combs = set( tuple(list_activities[j:j + i]) for i in range(2, len(list_activities) + 1) for j in range(0, len(list_activities) - i + 1)) two_acti_combs = set((list_activities[i], list_activities[i + 1]) for i in range(len(list_activities) - 1)) activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes.DEFAULT_NAME_KEY) timestamp_key = exec_utils.get_param_value(Parameters.TIMESTAMP_KEY, parameters, xes.DEFAULT_TIMESTAMP_KEY) case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, xes.DEFAULT_TRACEID_KEY) parameters[Parameters.ATTRIBUTE_KEY] = activity_key log = basic_filter.filter_log_events_attr(log, list_activities, parameters=parameters) if sort_log_required: log = sorting.sort_timestamp_log(log, timestamp_key=timestamp_key) points = [] for trace in log: matches = [(i, i + 1) for i in range(len(trace) - 1) if (trace[i][activity_key], trace[i + 1][activity_key]) in two_acti_combs] i = 0 while i < len(matches) - 1: matchAct = (trace[mi][activity_key] for mi in (matches[i] + matches[i + 1][1:])) if matches[i][-1] == matches[i + 1][0] and matchAct in all_acti_combs: matches[i] = matches[i] + matches[i + 1][1:] del matches[i + 1] i = 0 else: i += 1 if matches: matches = set(matches) timest_comb = [{ 'points': [(trace[i][activity_key], trace[i][timestamp_key].timestamp()) for i in match] } for match in matches] for p in timest_comb: p['case_id'] = trace.attributes[case_id_key] points += timest_comb points = sorted(points, key=lambda x: min(x['points'], key=lambda x: x[1])[1]) if len(points) > sample_size: points = points_subset.pick_chosen_points_list(sample_size, points) return points
def apply( log: EventLog, list_activities: List[str], sample_size: int, parameters: Optional[Dict[Union[str, Parameters], Any]] = None ) -> Dict[str, Any]: """ Finds the performance spectrum provided a log and a list of activities Parameters ------------- log Log list_activities List of activities interesting for the performance spectrum (at least two) sample_size Size of the sample parameters Parameters of the algorithm, including: - Parameters.ACTIVITY_KEY - Parameters.TIMESTAMP_KEY Returns ------------- points Points of the performance spectrum """ if parameters is None: parameters = {} activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes.DEFAULT_NAME_KEY) timestamp_key = exec_utils.get_param_value(Parameters.TIMESTAMP_KEY, parameters, xes.DEFAULT_TIMESTAMP_KEY) sort_log_required = exec_utils.get_param_value( Parameters.SORT_LOG_REQUIRED, parameters, True) parameters[Parameters.ATTRIBUTE_KEY] = activity_key log = basic_filter.filter_log_events_attr(log, list_activities, parameters=parameters) if sort_log_required: log = sorting.sort_timestamp_log(log, timestamp_key=timestamp_key) points = [] for trace in log: for i in range(len(trace) - len(list_activities) + 1): acti_comb = [ event[activity_key] for event in trace[i:i + len(list_activities)] ] if acti_comb == list_activities: timest_comb = [ event[timestamp_key].timestamp() for event in trace[i:i + len(list_activities)] ] points.append(timest_comb) points = sorted(points, key=lambda x: x[0]) if len(points) > sample_size: points = points_subset.pick_chosen_points_list(sample_size, points) return points