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
