def add_artficial_start_and_end(event_log, start='[start>', end='[end]', activity_key=xes_util.DEFAULT_NAME_KEY): for trace in event_log: trace.insert(0, log.Event({activity_key: start})) trace.append(log.Event({activity_key: end})) return event_log
def apply_from_variant(variant, petri_net, initial_marking, final_marking, parameters=None): """ Apply the alignments from the specification of a single variant Parameters ------------- variant Variant (as string delimited by the "variant_delimiter" parameter) petri_net Petri net initial_marking Initial marking final_marking Final marking parameters Parameters of the algorithm (same as 'apply' method, plus 'variant_delimiter' that is , by default) Returns ------------ dictionary: `dict` with keys **alignment**, **cost**, **visited_states**, **queued_states** """ if parameters is None: parameters = {} activity_key = DEFAULT_NAME_KEY if parameters is None or PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters else \ parameters[ pm4pyutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY] trace = log_implementation.Trace() variant_delimiter = exec_utils.get_param_value(Parameters.PARAMETER_VARIANT_DELIMITER, parameters, ",") variant_split = variant.split(variant_delimiter) if type(variant) is str else variant for i in range(len(variant_split)): trace.append(log_implementation.Event({activity_key: variant_split[i]})) return apply(trace, petri_net, initial_marking, final_marking, parameters=parameters)
def apply_playout(net, initial_marking, no_traces=100, max_trace_length=100, case_id_key=xes_constants.DEFAULT_TRACEID_KEY, activity_key=xes_constants.DEFAULT_NAME_KEY, timestamp_key=xes_constants.DEFAULT_TIMESTAMP_KEY, final_marking=None): """ Do the playout of a Petrinet generating a log Parameters ---------- net Petri net to play-out initial_marking Initial marking of the Petri net no_traces Number of traces to generate max_trace_length Maximum number of events per trace (do break) case_id_key Trace attribute that is the case ID activity_key Event attribute that corresponds to the activity timestamp_key Event attribute that corresponds to the timestamp final_marking If provided, the final marking of the Petri net """ # assigns to each event an increased timestamp from 1970 curr_timestamp = 10000000 log = log_instance.EventLog() for i in range(no_traces): trace = log_instance.Trace() trace.attributes[case_id_key] = str(i) marking = copy(initial_marking) while len(trace) < max_trace_length: if not semantics.enabled_transitions( net, marking): # supports nets with possible deadlocks break all_enabled_trans = semantics.enabled_transitions(net, marking) if final_marking is not None and marking == final_marking: trans = choice(list(all_enabled_trans.union({None}))) else: trans = choice(list(all_enabled_trans)) if trans is None: break if trans.label is not None: event = log_instance.Event() event[activity_key] = trans.label event[timestamp_key] = datetime.datetime.fromtimestamp( curr_timestamp) trace.append(event) # increases by 1 second curr_timestamp += 1 marking = semantics.execute(trans, net, marking) log.append(trace) return log
def apply_from_variants_list(var_list, petri_net, initial_marking, final_marking, parameters=None): """ Apply the alignments from the specification of a list of variants in the log Parameters ------------- var_list List of variants (for each item, the first entry is the variant itself, the second entry may be the number of cases) petri_net Petri net initial_marking Initial marking final_marking Final marking parameters Parameters of the algorithm (same as 'apply' method, plus 'variant_delimiter' that is , by default) Returns -------------- dictio_alignments Dictionary that assigns to each variant its alignment """ if parameters is None: parameters = {} activity_key = DEFAULT_NAME_KEY if parameters is None or PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters else \ parameters[ pm4pyutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY] variant_delimiter = exec_utils.get_param_value( Parameters.PARAMETER_VARIANT_DELIMITER, parameters, pm4pyutil.constants.DEFAULT_VARIANT_SEP) log = log_implementation.EventLog() dictio_alignments = {} for varitem in var_list: variant = varitem[0] trace = log_implementation.Trace() variant_split = variant.split( variant_delimiter) if type(variant) is str else variant for el in variant_split: trace.append(log_implementation.Event({activity_key: el})) log.append(trace) alignment = apply(log, petri_net, initial_marking, final_marking) for index, varitem in enumerate(var_list): variant = varitem[0] dictio_alignments[variant] = alignment[index] return dictio_alignments
def apply_from_variant(variant, petri_net, initial_marking, final_marking, parameters=None): if parameters is None: parameters = {} activity_key = DEFAULT_NAME_KEY if parameters is None or PARAMETER_CONSTANT_ACTIVITY_KEY not in parameters else \ parameters[ pm4pyutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY] trace = log_implementation.Trace() variant_delimiter = parameters[ PARAMETER_VARIANT_DELIMITER] if PARAMETER_VARIANT_DELIMITER in parameters else DEFAULT_VARIANT_DELIMITER variant_split = variant.split(variant_delimiter) if type(variant) is str else variant for i in range(len(variant_split)): trace.append(log_implementation.Event({activity_key: variant_split[i]})) return apply(trace, petri_net, initial_marking, final_marking, parameters=parameters)
def generate_pm4py_log(trace_frequencies): log = event_log.EventLog() trace_count = 0 for variant in trace_frequencies.items(): frequency=variant[1] activities=variant[0].split(EVENT_DELIMETER) for i in range (0,frequency): trace = event_log.Trace() trace.attributes["concept:name"] = trace_count trace_count = trace_count + 1 for activity in activities: if not TRACE_END in activity: event = event_log.Event() event["concept:name"] = str(activity) event["time:timestamp"] = datetime.datetime(1970, 1, 1, 0, 0, 0, tzinfo=tzutc()) trace.append(event) log.append(trace) return log
def apply_playout(net, initial_marking, no_traces=100, max_trace_length=100): """ Do the playout of a Petrinet generating a log Parameters ---------- net Petri net to play-out initial_marking Initial marking of the Petri net no_traces Number of traces to generate max_trace_length Maximum number of events per trace (do break) """ # assigns to each event an increased timestamp from 1970 curr_timestamp = 10000000 log = log_instance.EventLog() for i in range(no_traces): trace = log_instance.Trace() trace.attributes["concept:name"] = str(i) marking = copy(initial_marking) for j in range(100000): if not semantics.enabled_transitions(net, marking): break all_enabled_trans = semantics.enabled_transitions(net, marking) all_enabled_trans = list(all_enabled_trans) shuffle(all_enabled_trans) trans = all_enabled_trans[0] if trans.label is not None: event = log_instance.Event() event["concept:name"] = trans.label event["time:timestamp"] = datetime.datetime.fromtimestamp( curr_timestamp) trace.append(event) # increases by 1 second curr_timestamp = curr_timestamp + 1 marking = semantics.execute(trans, net, marking) if len(trace) > max_trace_length: break if len(trace) > 0: log.append(trace) return log
def generate_pm4py_log(df_relations, event_int_mapping): int_event_mapping = {value:key for key, value in event_int_mapping.items()} log = event_log.EventLog() size = df_relations.shape[0]-1 #print(np.sum(df_relations[0]),np.sum(df_relations,axis=0)[size]) trace_amount = min(np.sum(df_relations[0]),np.sum(df_relations,axis=0)[size]) possible_elements = list(range(0,size+1)) counter = 0 while(counter < trace_amount): empty_list=[0] next_trace = find_path(df_relations,possible_elements ,empty_list,0) #print("trace nr.: ",counter,next_trace) if len(next_trace) <= 1: print("All traces attached to log.") break trace = event_log.Trace() trace.attributes["concept:name"] = counter counter += 1 for i in range(len(next_trace)-1): #print(df_relations[next_trace[i],next_trace[i+1]]) #if df_relations[next_trace[i],next_trace[i+1]] > 0: # df_relations[next_trace[i],next_trace[i+1]] -= 1 if str(int_event_mapping[next_trace[i]]) == TRACE_START: continue event = event_log.Event() event["concept:name"] = str(int_event_mapping[next_trace[i]]) event["time:timestamp"] = datetime.datetime(1970, 1, 1, 0, 0, 0, tzinfo=tzutc()) trace.append(event) log.append(trace) return log
def apply_playout(net, initial_marking, no_traces=100, max_trace_length=100, case_id_key=xes_constants.DEFAULT_TRACEID_KEY, activity_key=xes_constants.DEFAULT_NAME_KEY, timestamp_key=xes_constants.DEFAULT_TIMESTAMP_KEY, final_marking=None, smap=None, log=None, return_visited_elements=False): """ Do the playout of a Petrinet generating a log Parameters ---------- net Petri net to play-out initial_marking Initial marking of the Petri net no_traces Number of traces to generate max_trace_length Maximum number of events per trace (do break) case_id_key Trace attribute that is the case ID activity_key Event attribute that corresponds to the activity timestamp_key Event attribute that corresponds to the timestamp final_marking If provided, the final marking of the Petri net smap Stochastic map log Log """ if final_marking is None: # infer the final marking from the net final_marking = final_marking_discovery.discover_final_marking(net) if smap is None: if log is None: raise Exception("please provide at least one between stochastic map and log") smap = replay.get_map_from_log_and_net(log, net, initial_marking, final_marking, parameters={Parameters.ACTIVITY_KEY: activity_key, Parameters.TIMESTAMP_KEY: timestamp_key}) # assigns to each event an increased timestamp from 1970 curr_timestamp = 10000000 all_visited_elements = [] for i in range(no_traces): visited_elements = [] visible_transitions_visited = [] marking = copy(initial_marking) while len(visible_transitions_visited) < max_trace_length: visited_elements.append(marking) if not semantics.enabled_transitions(net, marking): # supports nets with possible deadlocks break all_enabled_trans = semantics.enabled_transitions(net, marking) if final_marking is not None and marking == final_marking: en_t_list = list(all_enabled_trans.union({None})) else: en_t_list = list(all_enabled_trans) trans = stochastic_utils.pick_transition(en_t_list, smap) if trans is None: break visited_elements.append(trans) if trans.label is not None: visible_transitions_visited.append(trans) marking = semantics.execute(trans, net, marking) all_visited_elements.append(tuple(visited_elements)) if return_visited_elements: return all_visited_elements log = log_instance.EventLog() for index, visited_elements in enumerate(all_visited_elements): trace = log_instance.Trace() trace.attributes[case_id_key] = str(index) for element in visited_elements: if type(element) is PetriNet.Transition and element.label is not None: event = log_instance.Event() event[activity_key] = element.label event[timestamp_key] = datetime.datetime.fromtimestamp(curr_timestamp) trace.append(event) # increases by 1 second curr_timestamp += 1 log.append(trace) return log
def apply(net, initial_marking, final_marking=None, parameters=None): """ Do the playout of a Petrinet generating a log (extensive search; stop at the maximum trace length specified Parameters ----------- net Petri net to play-out initial_marking Initial marking of the Petri net final_marking If provided, the final marking of the Petri net parameters Parameters of the algorithm: Parameters.MAX_TRACE_LENGTH -> Maximum trace length """ if parameters is None: parameters = {} case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, xes_constants.DEFAULT_TRACEID_KEY) activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY) timestamp_key = exec_utils.get_param_value( Parameters.TIMESTAMP_KEY, parameters, xes_constants.DEFAULT_TIMESTAMP_KEY) max_trace_length = exec_utils.get_param_value(Parameters.MAX_TRACE_LENGTH, parameters, 10) # assigns to each event an increased timestamp from 1970 curr_timestamp = 10000000 log = log_instance.EventLog() to_visit = [(initial_marking, ())] visited = set() while len(to_visit) > 0: state = to_visit.pop(0) if state in visited: continue visited.add(state) m = state[POSITION_MARKING] trace = state[POSITION_TRACE] en_t = semantics.enabled_transitions(net, m) if (final_marking is not None and m == final_marking) or len(en_t) == 0: if len(trace) <= max_trace_length: log_trace = log_instance.Trace() log_trace.attributes[case_id_key] = str(len(log)) for act in trace: curr_timestamp = curr_timestamp + 1 log_trace.append( log_instance.Event({ activity_key: act, timestamp_key: datetime.datetime.fromtimestamp(curr_timestamp) })) log.append(log_trace) for t in en_t: new_m = semantics.weak_execute(t, m) if t.label is not None: new_trace = trace + (t.label, ) else: new_trace = trace new_state = (new_m, new_trace) if new_state in visited or len(new_trace) > max_trace_length: continue to_visit.append(new_state) return log
def apply(net, initial_marking, final_marking=None, parameters=None): """ Do the playout of a Petrinet generating a log (extensive search; stop at the maximum trace length specified Parameters ----------- net Petri net to play-out initial_marking Initial marking of the Petri net final_marking If provided, the final marking of the Petri net parameters Parameters of the algorithm: Parameters.MAX_TRACE_LENGTH -> Maximum trace length """ if parameters is None: parameters = {} case_id_key = exec_utils.get_param_value(Parameters.CASE_ID_KEY, parameters, xes_constants.DEFAULT_TRACEID_KEY) activity_key = exec_utils.get_param_value(Parameters.ACTIVITY_KEY, parameters, xes_constants.DEFAULT_NAME_KEY) timestamp_key = exec_utils.get_param_value( Parameters.TIMESTAMP_KEY, parameters, xes_constants.DEFAULT_TIMESTAMP_KEY) max_trace_length = exec_utils.get_param_value(Parameters.MAX_TRACE_LENGTH, parameters, 10) return_elements = exec_utils.get_param_value(Parameters.RETURN_ELEMENTS, parameters, False) max_marking_occ = exec_utils.get_param_value(Parameters.MAX_MARKING_OCC, parameters, sys.maxsize) # assigns to each event an increased timestamp from 1970 curr_timestamp = 10000000 feasible_elements = [] to_visit = [(initial_marking, (), ())] visited = set() while len(to_visit) > 0: state = to_visit.pop(0) m = state[POSITION_MARKING] trace = state[POSITION_TRACE] elements = state[POSITION_ELEMENTS] if (m, trace) in visited: continue visited.add((m, trace)) en_t = semantics.enabled_transitions(net, m) if (final_marking is not None and m == final_marking) or (final_marking is None and len(en_t) == 0): if len(trace) <= max_trace_length: feasible_elements.append(elements) for t in en_t: new_elements = elements + (m, ) new_elements = new_elements + (t, ) counter_elements = Counter(new_elements) if counter_elements[m] > max_marking_occ: continue new_m = semantics.weak_execute(t, m) if t.label is not None: new_trace = trace + (t.label, ) else: new_trace = trace new_state = (new_m, new_trace, new_elements) if new_state in visited or len(new_trace) > max_trace_length: continue to_visit.append(new_state) if return_elements: return feasible_elements log = log_instance.EventLog() for elements in feasible_elements: log_trace = log_instance.Trace() log_trace.attributes[case_id_key] = str(len(log)) activities = [ x.label for x in elements if type(x) is PetriNet.Transition and x.label is not None ] for act in activities: curr_timestamp = curr_timestamp + 1 log_trace.append( log_instance.Event({ activity_key: act, timestamp_key: datetime.datetime.fromtimestamp(curr_timestamp) })) log.append(log_trace) return log
def to_trace(list_act, cid): t = pm4py_log.Trace() t.attributes["concept:name"] = cid for act in list_act: t.append(pm4py_log.Event({"concept:name": act})) return t
thewriter = csv.writer(f) thewriter.writerow(['case_id', 'activity', 'time:timestamp']) curr_timestamp = datetime.now() log = log_instance.EventLog() trace = log_instance.Trace() trace.attributes[case_id_key] = str(case_num.replace('Case', '')) marking = copy(initial_marking) while True: if not semantics.enabled_transitions(net, marking): break all_enabled_trans = semantics.enabled_transitions(net, marking) all_enabled_trans = list(all_enabled_trans) shuffle(all_enabled_trans) trans = all_enabled_trans[0] if trans.label is not None: event = log_instance.Event() event[activity_key] = trans.label results.append([ case_num, event[activity_key], datetime.now() + timedelta(seconds=env.now) ]) yield env.process( getattr(case, str(trans.label).replace(" ", ""))()) event[timestamp_key] = curr_timestamp trace.append(event) marking = semantics.execute(trans, net, marking) if len(trace) > max_trace_length: break if len(trace) > 0: log.append(trace)
def generate_pm4py_log(df_relations, event_int_mapping,int_event_mapping, activity_list): #int_event_mapping = {value:key for key, value in event_int_mapping.items()} #print(int_event_mapping) log = event_log.EventLog() size = df_relations.shape[0]-1 print("START:",np.sum(df_relations[0]),np.sum(df_relations,axis=0)[size],"\n\n") trace_amount = min(np.sum(df_relations[0]),np.sum(df_relations,axis=0)[size]) possible_elements = list(range(0,size+1))#counter < trace_amount total_df_amount = df_relations.sum() deleted_df = np.zeros((len(int_event_mapping),len(int_event_mapping)), dtype=int) new_df_amount = df_relations.sum() #df = pd.DataFrame(data=df_relations, index=activity_list, columns=activity_list) #df.to_csv('df_relations_noised.csv',sep=',',columns=activity_list, header=activity_list) #print(tabulate(df, headers= activity_list,tablefmt = 'pretty')) #plt.matshow(df_relations,fignum=None,cmap='gray') #plt.savefig('df_relations.png',dpi=300) #print("hello?") #sys.exit() counter = 0 while(True): empty_list=[0] old_df_amount = new_df_amount next_trace = find_path(df_relations,deleted_df,activity_list,possible_elements ,empty_list,0) new_df_amount = df_relations.sum() #print("trace nr.: ",counter,next_trace,"lentgh:",len(next_trace)) #print("total dfs - current trace:", old_df_amount - new_df_amount) #if old_df_amount - new_df_amount != len(next_trace) -1: # print("weird deletion") #sys.exit() if len(next_trace) <= 1: print("All traces attached to log.", counter, "traces") break trace = event_log.Trace() trace.attributes["concept:name"] = counter counter += 1 for i in range(len(next_trace)-1): #print(df_relations[next_trace[i],next_trace[i+1]]) #if df_relations[next_trace[i],next_trace[i+1]] > 0: # df_relations[next_trace[i],next_trace[i+1]] -= 1 if str(int_event_mapping[next_trace[i]]) == TRACE_START: continue event = event_log.Event() event["concept:name"] = str(int_event_mapping[next_trace[i]]) event["time:timestamp"] = datetime.datetime(1970, 1, 1, 0, 0, 0, tzinfo=tzutc()) trace.append(event) log.append(trace) #print("appended:" ,counter, next_trace) #print(df_relations,"\n") #print("deleted df:\n",deleted_df,"\n") #df = pd.DataFrame(data=df_relations, index=activity_list, columns=activity_list) #df.to_csv('df_relation_end.csv',sep=',',columns=activity_list, header=activity_list) df_deletions = np.add(deleted_df,df_relations) #print(df_deletions,"\n") #df = pd.DataFrame(data=df_deletions, index=activity_list, columns=activity_list) #df.to_csv('df_deletions_end.csv',sep=',',columns=activity_list, header=activity_list) total_df_deleted = df_deletions.sum() print("total cases:",counter) print("Total df relations:",total_df_amount,"total deletions:",total_df_deleted," Percentage deleted =", total_df_deleted / total_df_amount) return log, counter, total_df_amount, total_df_deleted