def apply(tree, no, prob, has_empty_trace=False):
"""
Returns non-fitting EventLog with fixed traces randomly created by the process tree.
Parameters
-----------
tree
Process Tree
no
Number of traces that will be in the event log
prob
Randomness of the traces
has_empty_trace
True, when the event log has empty trace
Returns
------------
EventLog
Non-fitting event log
"""
log, non_fit_traces = generate_log(tree, no), list()
label_num = pt_mani_utils.non_none_leaves_number(tree)
traces = list(map(lambda t: t, log))
while len(traces) > 0:
trace = traces.pop()
non_fit_t = Trace(attributes=log.attributes)
for event in trace:
if random.random() < prob:
index = random.randint(0, 2)
if index == 1: # add a new event
non_fit_t.append(event)
new_event = Event()
new_event[
xes.DEFAULT_NAME_KEY] = pt_gene_utils.get_cur_label(
label_num + 1)
non_fit_t.append(new_event)
elif index == 2: # replace with other event
new_event = Event()
new_event[
xes.DEFAULT_NAME_KEY] = pt_gene_utils.get_cur_label(
random.randint(1, label_num))
non_fit_t.append(new_event)
else:
non_fit_t.append(event)
if not has_empty_trace and len(non_fit_t) == 0:
traces.append(generate_log(tree, 1)[0])
else:
non_fit_traces.append(non_fit_t)
return EventLog(non_fit_traces,
attributes=log.attributes,
classifiers=log.classifiers,
omni_present=log.omni_present,
extensions=log.extensions)
def apply(
tree: ProcessTree,
parameters: Optional[Dict[Union[str, Parameters],
Any]] = None) -> EventLog:
"""
Generate a log by a playout operation
Parameters
---------------
tree
Process tree
parameters
Parameters of the algorithm, including:
- Parameters.NO_TRACES: number of traces of the playout
Returns
--------------
log
Simulated log
"""
if parameters is None:
parameters = {}
no_traces = exec_utils.get_param_value(Parameters.NO_TRACES, parameters,
1000)
log = semantics.generate_log(tree, no_traces=no_traces)
return log
def test_tree_parsing(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
tree = pt_util.parse("->(X('a', 'b', tau), +('c', 'd'))")
# test log generation
log = pt_semantics.generate_log(tree)
def apply(tree, parameters=None):
"""
Generate a log_skeleton by a playout operation
Parameters
---------------
tree
Process tree
parameters
Parameters of the algorithm, including:
- Parameters.NO_TRACES: number of traces of the playout
Returns
--------------
log_skeleton
Simulated log_skeleton
"""
if parameters is None:
parameters = {}
no_traces = exec_utils.get_param_value(Parameters.NO_TRACES, parameters, 1000)
log = semantics.generate_log(tree, no_traces=no_traces)
return log
def test_tree_receipt(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
log = xes_importer.import_log(os.path.join(INPUT_DATA_DIR, "receipt.xes"))
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree)
del gviz
# test log generation
log = pt_semantics.generate_log(tree)
del log
def test_tree_running_example_dfg_based(self):
# to avoid static method warnings in tests,
# that by construction of the unittest package have to be expressed in such way
self.dummy_variable = "dummy_value"
log = xes_importer.apply(os.path.join(INPUT_DATA_DIR, "running-example.xes"))
tree = inductive_miner.apply_tree(log, variant=inductive_miner.DFG_BASED)
gviz = pt_vis.apply(tree)
del gviz
# test log generation
log = pt_semantics.generate_log(tree)
del log
def start_experiments(number_process_trees=1, number_traces_per_tree=1,
input_data: List[Tuple[ProcessTree, EventLog]] = None):
logging.disable(logging.CRITICAL)
results_per_tree = {}
processed_trees: List[ProcessTree] = []
futures: Dict[ProcessTree, List[concurrent.futures]] = {}
if input_data is None:
input_data = []
for i in range(number_process_trees):
parameters = {"min": 20, "mode": 35, "max": 50, "duplicate": 0.25, "silent": .25}
tree = tree_gen_factory.apply(parameters=parameters)
tree = process_tree_to_binary_process_tree(tree)
log = semantics.generate_log(tree, no_traces=number_traces_per_tree)
log = __introduce_deviations_in_log(log)
input_data.append((tree, log))
with concurrent.futures.ProcessPoolExecutor() as executor:
for i in range(len(input_data)):
print("process tree ", i + 1, "/", number_process_trees)
tree = input_data[i][0]
log = input_data[i][1]
results_per_tree[tree] = {}
processed_trees.append(tree)
results_per_tree[tree]["log"] = log
start_time = datetime.now()
a_sets, sa_sets, ea_sets, tau_sets = initialize_a_sa_ea_tau_sets(tree)
end_time = datetime.now()
results_per_tree[tree]["calculation_time_of_a_sa_ea_tau_sets"] = (end_time - start_time).total_seconds()
results_per_tree[tree]["alignments"] = []
futures[tree] = []
for j, trace in enumerate(log):
futures[tree].append(
executor.submit(__calculate_approx_and_opt_align, trace, tree, a_sets, sa_sets, ea_sets,
tau_sets))
for i, tree in enumerate(processed_trees):
print("Waiting for process tree ", i + 1, "/", len(processed_trees))
results_per_tree[tree]["alignments"] = []
for j, f in enumerate(futures[tree]):
print("Waiting for trace ", j + 1, "/", len(futures[tree]))
results_per_tree[tree]["alignments"].append(f.result())
__save_obj_to_file("results_per_tree_", results_per_tree)
print(
"heuristics is_sound_wfnet",
check_soundness.check_petri_wfnet_and_soundness(heu_model,
debug=True))
t1 = time.time()
tree = inductive.apply_tree(log, parameters=parameters_discovery)
inductive_model, inductive_im, inductive_fm = inductive.apply(
log, parameters=parameters_discovery)
pnml_exporter.export_net(inductive_model,
inductive_im,
os.path.join(
pnmlFolder,
logNamePrefix + "_inductive.pnml"),
final_marking=inductive_fm)
generated_log = pt_semantics.generate_log(tree)
print("first trace of log",
[x["concept:name"] for x in generated_log[0]])
t2 = time.time()
print("time interlapsed for calculating Inductive Model",
(t2 - t1))
print(
"inductive is_sound_wfnet",
check_soundness.check_petri_wfnet_and_soundness(
inductive_model, debug=True))
parameters = {
pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key,
pmutil.constants.PARAMETER_CONSTANT_ATTRIBUTE_KEY:
activity_key,
"format": "png"
net, initial_marking, final_marking = pt_conv_factory.apply(tree, variant=pt_conv_factory.TO_PETRI_NET)
# Replay the log on top of the discovered process model
inductive_evaluation_result = evaluation_factory.apply(log_for_eval, net, initial_marking, final_marking)
inductive_evaluation_result.update(inductive_evaluation_result['fitness'])
inductive_evaluation_result['discovered_pt'] = str(tree)
del inductive_evaluation_result['fitness']
return inductive_evaluation_result
number_of_experiment_to_run = 100
results = []
for _ in range(number_of_experiment_to_run):
# Generate a random process tree and get traces from the process tree
tree = tree_gen_factory.apply()
log = semantics.generate_log(tree, no_traces=1000)
size_tree, leafs = rec_node([tree], [])
leafs = set(leafs).union(set('τ'))
tree = {
'tree': str(tree),
'tree_size': size_tree
}
csv_exporter.export(log, 'temp.csv')
original_df = pd.read_csv('temp.csv')
os.remove('temp.csv')
log_for_eval = copy.deepcopy(log)
# Try different level of noise
for noise_ratio in np.arange(0, 1.01, 0.05):
noise_ratio = round(noise_ratio,2)
