def discover_tree_inductive(log, noise_threshold=0.0):
"""
Discovers a process tree using the IMDFc algorithm
Parameters
--------------
log
Event log
noise_threshold
Noise threshold (default: 0.0)
Returns
--------------
process_tree
Process tree object
"""
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
if noise_threshold > 0.0:
return inductive_miner.apply_tree(
log,
variant=inductive_miner.Variants.IMf,
parameters={
inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD:
noise_threshold
})
else:
return inductive_miner.apply_tree(
log,
variant=inductive_miner.Variants.IM,
parameters={
inductive_miner.Variants.IM.value.Parameters.NOISE_THRESHOLD:
noise_threshold
})
def discover_process_tree_inductive(
log: Union[EventLog, pd.DataFrame],
noise_threshold: float = 0.0) -> ProcessTree:
"""
Discovers a process tree using the IM algorithm
Parameters
--------------
log
Event log
noise_threshold
Noise threshold (default: 0.0)
Returns
--------------
process_tree
Process tree object
"""
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
if noise_threshold > 0:
return inductive_miner.apply_tree(
log,
variant=inductive_miner.Variants.IMf,
parameters={
inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD:
noise_threshold
})
else:
return inductive_miner.apply_tree(
log,
variant=inductive_miner.Variants.IM_CLEAN,
parameters={
inductive_miner.Variants.IM_CLEAN.value.Parameters.NOISE_THRESHOLD:
noise_threshold
})
def execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "input_data", "running-example.xes"))
tree = inductive_miner.apply_tree(log)
new_log_1 = tree_playout.apply(tree)
print(len(new_log_1))
new_tree_1 = inductive_miner.apply_tree(new_log_1)
print(new_tree_1)
new_log_2 = tree_playout.apply(tree,
variant=tree_playout.Variants.EXTENSIVE)
print(len(new_log_2))
new_tree_2 = inductive_miner.apply_tree(new_log_2)
print(new_tree_2)
def execute_script():
log = importer.apply(os.path.join("..", "tests", "input_data", "running-example.xes"))
tree = inductive_miner.apply_tree(log)
gviz1 = pt_vis_factory.apply(tree, parameters={"format": "svg"})
# pt_vis_factory.view(gviz1)
gviz2 = pt_visualizer.apply(tree, parameters={pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"})
pt_visualizer.view(gviz2)
def test_playout_tree_basic(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
tree = inductive_miner.apply_tree(log)
from pm4py.simulation.tree_playout import algorithm as tree_playout
new_log = tree_playout.apply(tree)
def test_playout_tree_extensive(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
tree = inductive_miner.apply_tree(log)
from pm4py.algo.simulation.playout.process_tree import algorithm as tree_playout
new_log = tree_playout.apply(tree,
variant=tree_playout.Variants.EXTENSIVE)
def test_tree_receipt_log_infrequent_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, "receipt.xes"))
tree = inductive_miner.apply_tree(log, variant=inductive_miner.IMf)
gviz = pt_vis.apply(tree)
del gviz
del log
def execute_script():
log_path = os.path.join(
os.path.join("..", "tests", "input_data", "running-example.xes"))
log = xes_import.apply(log_path)
ptree = inductive_miner.apply_tree(log)
bpmn = pt_converter.apply(ptree, variant=pt_converter.Variants.TO_BPMN)
#bpmn = bpmn_layouter.apply(bpmn)
bpmn_exporter.apply(bpmn, "stru.bpmn")
os.remove("stru.bpmn")
def test_footprints_tree(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
tree = inductive_miner.apply_tree(log)
from pm4py.algo.discovery.footprints import algorithm as footprints_discovery
fp_log = footprints_discovery.apply(log)
fp_tree = footprints_discovery.apply(tree)
from pm4py.algo.conformance.footprints import algorithm as footprints_conformance
conf = footprints_conformance.apply(fp_log, fp_tree)
def test_footprints_tree_df(self):
df = csv_import_adapter.import_dataframe_from_path(
os.path.join("input_data", "running-example.csv"))
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
log = converter.apply(df)
tree = inductive_miner.apply_tree(log)
from pm4py.algo.discovery.footprints import algorithm as footprints_discovery
fp_df = footprints_discovery.apply(df)
fp_tree = footprints_discovery.apply(tree)
from pm4py.algo.conformance.footprints import algorithm as footprints_conformance
conf = footprints_conformance.apply(fp_df, fp_tree)
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 test_footprints_tree_df(self):
df = pd.read_csv(os.path.join("input_data", "running-example.csv"))
df = dataframe_utils.convert_timestamp_columns_in_df(df)
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
log = converter.apply(df)
tree = inductive_miner.apply_tree(log)
from pm4py.algo.discovery.footprints import algorithm as footprints_discovery
fp_df = footprints_discovery.apply(df)
fp_tree = footprints_discovery.apply(tree)
from pm4py.algo.conformance.footprints import algorithm as footprints_conformance
conf = footprints_conformance.apply(fp_df, fp_tree)
def execute_script():
log_path = os.path.join("/Users/Julian/Documents/HiWi/PADS/EventLogs/BPI_Challenge_2012.xes")
log = xes_import.apply(log_path)
#log = keep_one_trace_per_variant(log)
#log = log[15:30]
ptree = ind_miner.apply_tree(log, parameters={Parameters.NOISE_THRESHOLD: 0.5}, variant=ind_miner.Variants.IMf)
gviz = pt_vis.apply(ptree,
parameters={pt_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"})
net, im, fm = converter.apply(ptree)
pt_vis.view(gviz)
def inductive_miner_petri_net(log):
# create the process tree
tree = inductive_miner.apply_tree(log)
# convert the process tree to a petri net
net, initial_marking, final_marking = pt_converter.apply(tree)
find_fitness('induct', log, net, initial_marking, final_marking)
parameters = {
pn_visualizer.Variants.FREQUENCY.value.Parameters.FORMAT: "png"}
gviz = pn_visualizer.apply(net, initial_marking, final_marking,
parameters=parameters,
variant=pn_visualizer.Variants.FREQUENCY,
log=log)
return gviz, None
def discover_process_tree(log):
"""
Given an event log, the function discovers the process tree using inductive miner algorithm.
Parameters:
log (EventLog): Given event log
Returns:
tree (ProcessTree): The generated Process tree from the log
"""
tree = inductive_miner.apply_tree(log)
settings.PROCESS_TREE = tree
return tree
def test_footprints_tree(self):
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
tree = inductive_miner.apply_tree(log)
from pm4py.algo.discovery.footprints import algorithm as footprints_discovery
fp_entire_log = footprints_discovery.apply(log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG)
fp_trace_trace = footprints_discovery.apply(log)
fp_tree = footprints_discovery.apply(tree)
from pm4py.algo.conformance.footprints import algorithm as footprints_conformance
conf1 = footprints_conformance.apply(fp_entire_log, fp_tree)
conf2 = footprints_conformance.apply(fp_trace_trace, fp_tree)
conf3 = footprints_conformance.apply(fp_entire_log, fp_tree,
variant=footprints_conformance.Variants.LOG_EXTENSIVE)
conf4 = footprints_conformance.apply(fp_trace_trace, fp_tree,
variant=footprints_conformance.Variants.TRACE_EXTENSIVE)
def discover_tree_inductive(log: EventLog, noise_threshold: float = 0.0) -> ProcessTree:
warnings.warn('discover_tree_inductive is deprecated, use discover_process_tree_inductive', DeprecationWarning)
"""
Discovers a process tree using the IMDFc algorithm
Parameters
--------------
log
Event log
noise_threshold
Noise threshold (default: 0.0)
Returns
--------------
process_tree
Process tree object
"""
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
if noise_threshold > 0.0:
return inductive_miner.apply_tree(log, variant=inductive_miner.Variants.IMf, parameters={
inductive_miner.Variants.IMf.value.Parameters.NOISE_THRESHOLD: noise_threshold})
else:
return inductive_miner.apply_tree(log, variant=inductive_miner.Variants.IM, parameters={
inductive_miner.Variants.IM.value.Parameters.NOISE_THRESHOLD: noise_threshold})
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
tree: ProcessTree = inductive.apply_tree(log)
gviz = pt_vis.apply(
tree,
parameters={
pt_vis.Variants.WO_DECORATION.value.Parameters.FORMAT: "svg"
})
pt_vis.view(gviz)
print("start calculate approximated alignments")
approx_alignments = align_approx.apply(log, tree)
pretty_print_alignments(approx_alignments)
def test_41(self):
import os
from pm4py.objects.log.importer.xes import importer as xes_importer
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
log = xes_importer.apply(os.path.join("input_data", "running-example.xes"))
net, initial_marking, final_marking = inductive_miner.apply(log)
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
from pm4py.visualization.process_tree import visualizer as pt_visualizer
tree = inductive_miner.apply_tree(log)
gviz = pt_visualizer.apply(tree)
from pm4py.objects.conversion.process_tree import converter as pt_converter
net, initial_marking, final_marking = pt_converter.apply(tree, variant=pt_converter.Variants.TO_PETRI_NET)
def execute_script():
# import a log
log = importer.apply(
os.path.join("..", "tests", "input_data", "receipt.xes"))
# found a filtered version of the log that is used to discover a process model
filtered_log = variants_filter.apply_auto_filter(deepcopy(log))
# discover a process tree using inductive miner
tree = inductive_miner.apply_tree(filtered_log)
print(tree)
# apply the conversion of a process tree into a Petri net
net, im, fm = converter.apply(tree)
# Footprints discovery: discover a list of footprints
# for all the cases of the log
fp_log = footprints_discovery.apply(log)
# discover the footpritns from the process tree
fp_tree = footprints_discovery.apply(tree)
# discover the footpritns from the Petri net
fp_net = footprints_discovery.apply(net, im)
print(len(fp_tree["sequence"]), len(fp_tree["parallel"]),
len(fp_net["sequence"]), len(fp_net["parallel"]))
print(fp_tree["sequence"] == fp_net["sequence"]
and fp_tree["parallel"] == fp_net["parallel"])
# apply the footprints conformance checking
conf = footprints_conformance.apply(fp_log, fp_net)
for trace_an in conf:
if trace_an:
# print the first anomalous trace (containing deviations
# that are contained in the trace but not allowed by the model)
print(trace_an)
break
# finds the footprints for the entire log (not case-by-case, but taking
# the relations that appear inside the entire log)
fp_log_entire = footprints_discovery.apply(
log, variant=footprints_discovery.Variants.ENTIRE_EVENT_LOG)
# visualize the footprint table
gviz = fp_visualizer.apply(fp_log_entire,
fp_net,
parameters={"format": "svg"})
fp_visualizer.view(gviz)
def discover_process_tree_inductive(log: Union[EventLog, pd.DataFrame], noise_threshold: float = 0.0) -> ProcessTree:
"""
Discovers a process tree using the IM algorithm
Parameters
--------------
log
Event log
noise_threshold
Noise threshold (default: 0.0)
Returns
--------------
process_tree
Process tree object
"""
if type(log) not in [pd.DataFrame, EventLog, EventStream]: raise Exception("the method can be applied only to a traditional event log!")
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
parameters = get_properties(log)
parameters[inductive_miner.Variants.IM_CLEAN.value.Parameters.NOISE_THRESHOLD] = noise_threshold
return inductive_miner.apply_tree(log, variant=inductive_miner.Variants.IM_CLEAN, parameters=parameters)
except:
if ENABLE_PETRI_EXPORTING_DEBUG:
exce = traceback.format_exc()
pnml_exporter.export_net(
heu_model,
heu_initial_marking,
os.path.join(pnmlFolder,
logNamePrefix + "_heuristics.pnml"),
final_marking=heu_final_marking)
F = open(logNamePrefix + "_heuristics.txt", "w")
F.write(exce)
F.close()
t1 = time.time()
tree = inductive.apply_tree(log,
parameters=parameters_discovery,
variant=INDUCTIVE_MINER_VARIANT)
# print(tree)
inductive_model, inductive_im, inductive_fm = pt_converter.apply(
tree, variant=pt_converter.Variants.TO_PETRI_NET)
"""inductive_model, inductive_im, inductive_fm = inductive.apply(log, parameters=parameters_discovery,
variant=INDUCTIVE_MINER_VARIANT)"""
if ENABLE_PETRI_EXPORTING:
pnml_exporter.export_net(
inductive_model,
inductive_im,
os.path.join(pnmlFolder,
logNamePrefix + "_inductive.pnml"),
final_marking=inductive_fm)
"""
def apply(df0, classifier_function=None, parameters=None):
if parameters is None:
parameters = {}
if classifier_function is None:
classifier_function = lambda x: x["event_activity"]
min_acti_freq = parameters[
"min_acti_freq"] if "min_acti_freq" in parameters else 0
min_edge_freq = parameters[
"min_edge_freq"] if "min_edge_freq" in parameters else 0
df = df0.copy()
df = general.preprocess(df, parameters=parameters)
df = clean_frequency.apply(df, min_acti_freq=min_acti_freq)
df = clean_arc_frequency.apply(df, min_freq=min_edge_freq)
models = {}
obj_types = [x for x in df.columns if not x.startswith("event_")]
activities = set()
activities_repeated = Counter()
edges = Counter()
start_activities = dict()
end_activities = dict()
acti_spec = Counter()
for ot in obj_types:
start_activities[ot] = set()
end_activities[ot] = set()
new_df = df[["event_id", "event_activity", "event_timestamp",
ot]].dropna(subset=[ot])
new_df = new_df.sort_values("event_timestamp")
new_df = new_df.rename(columns={
ot: "case:concept:name",
"event_timestamp": "time:timestamp"
})
log = new_df.to_dict("r")
for ev in log:
ev["event_objtype"] = ot
ev["concept:name"] = classifier_function(ev)
del ev["event_objtype"]
del ev["event_activity"]
activities.add((ev["event_id"], ev["concept:name"]))
log = EventStream(log)
this_activities = set(x["concept:name"] for x in log)
for act in this_activities:
activities_repeated[act] += 1
log = log_conv_factory.apply(log,
variant=log_conv_factory.TO_EVENT_LOG)
log = sorting.sort_timestamp(log, "time:timestamp")
for trace in log:
if trace:
start_activities[ot].add(trace[0]["concept:name"])
end_activities[ot].add(trace[-1]["concept:name"])
for i in range(len(trace) - 1):
ev0 = trace[i]
ev1 = trace[i + 1]
edges[(ot, ev0["concept:name"], ev1["concept:name"],
ev0["event_id"], ev1["event_id"],
trace.attributes["concept:name"],
ev0["time:timestamp"], ev1["time:timestamp"])] += 1
acti_spec[(ot, trace[i]["concept:name"],
trace[i]["event_id"],
trace.attributes["concept:name"],
trace[i]["time:timestamp"])] += 1
if len(trace) > 0:
acti_spec[(ot, trace[-1]["concept:name"],
trace[-1]["event_id"],
trace.attributes["concept:name"],
trace[-1]["time:timestamp"])] += 1
models[ot] = inductive_miner.apply_tree(log, parameters=parameters)
activities = dict(Counter(list(x[1] for x in activities)))
activities_repeated = set(x for x in activities_repeated
if activities_repeated[x] > 1)
return {
"type": "ptree",
"models": models,
"activities": activities,
"activities_repeated": activities_repeated,
"edges": edges,
"acti_spec": acti_spec
}
def inductive_miner_tree(log):
# create the process tree
tree = inductive_miner.apply_tree(log)
gviz = pt_visualizer.apply(tree)
return gviz, None
for ele2 in sample:
chooselist.append(
(ele2[0], pre + (ele2[1] / dominator)))
pre += (ele2[1] / dominator)
r = random.random()
for i in range(len(chooselist) - 1):
if chooselist[i][1] <= r and chooselist[i + 1][1] >= r:
simrestrace.append(chooselist[i + 1][0])
print(event[logname], chooselist[i + 1][0])
simreslog.append(simrestrace)
return simreslog
tree = inductive_miner.apply_tree(log)
list0 = []
notdoact(tree, list0)
actrescount = getactivityresourcecount(log, list0, "concept:name", "org:group")
#print(actrescount,"actrescount")
roles = roles_discovery.apply(
log, variant=None, parameters={rpd.Parameters.RESOURCE_KEY: "org:group"})
#rescluster = getresoucecluster(log,roles,"concept:name","org:resource")
print(roles, "roles")
resourcesimulation = simulateresource(log, actrescount, roles, "concept:name",
"org:group")
print(resourcesimulation, "resourcesimulation")
#join activity but nothing different to the last segment.
#ja_values = sna.apply(log, variant=sna.Variants.JOINTACTIVITIES_LOG)
#gviz_ja_py = sna_visualizer.apply(ja_values, variant=sna_visualizer.Variants.PYVIS)
#sna_visualizer.view(gviz_ja_py, variant=sna_visualizer.Variants.PYVIS)
if True:
# ignore this part in true PowerBI executions
from pm4py.objects.log.adapters.pandas import csv_import_adapter
dataset = csv_import_adapter.import_dataframe_from_path("C:/running-example.csv")
import pandas as pd
# this part is required because the dataframe provided by PowerBI has strings
dataset["time:timestamp"] = pd.to_datetime(dataset["time:timestamp"])
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
tree = inductive_miner.apply_tree(dataset)
from pm4py.visualization.process_tree import visualizer
gviz = visualizer.apply(tree)
visualizer.matplotlib_view(gviz)
t1 = time.time()
heu_model, heu_initial_marking, heu_final_marking = heuristics_miner.apply(log,
parameters=parameters_discovery)
if ENABLE_PETRI_EXPORTING:
pnml_exporter.export_net(heu_model, heu_initial_marking,
os.path.join(pnmlFolder, logNamePrefix + "_alpha.pnml"),
final_marking=heu_final_marking)
t2 = time.time()
print("time interlapsed for calculating Heuristics Model", (t2 - t1))
if CHECK_SOUNDNESS:
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)
print(tree)
inductive_model, inductive_im, inductive_fm = inductive.apply(log, parameters=parameters_discovery)
if ENABLE_PETRI_EXPORTING:
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))
if CHECK_SOUNDNESS:
print("inductive is_sound_wfnet",
check_soundness.check_petri_wfnet_and_soundness(inductive_model, debug=True))
def execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "input_data", "receipt.xes"))
throughput_time = case_statistics.get_median_caseduration(log)
variants, variants_times = variants_filter.get_variants_along_with_case_durations(
log)
dfg = dfg_discovery.apply(log)
filtered_log = variants_filter.apply_auto_filter(deepcopy(log))
# filtered_log = log
tree = inductive_miner.apply_tree(filtered_log)
fp_log = fp_discovery.apply(log,
variant=fp_discovery.Variants.ENTIRE_EVENT_LOG)
fp_model = fp_discovery.apply(tree)
conf = fp_conformance.apply(fp_log, fp_model)
conf_occ = sorted([(x, dfg[x]) for x in conf],
key=lambda y: (y[1], y[0][0], y[0][1]),
reverse=True)
print(
"source activity\t\ttarget activity\t\toccurrences\t\tthroughput time log\t\tthroughput time traces with path"
)
for i in range(min(10, len(conf_occ))):
path = conf_occ[i][0]
occ = conf_occ[i][1]
red_log = paths_filter.apply(log, [path])
red_throughput_time = case_statistics.get_median_caseduration(red_log)
print("%s\t\t%s\t\t%d\t\t%s\t\t%s" %
(path[0], path[1], occ, human_readable_stat(throughput_time),
human_readable_stat(red_throughput_time)))
variants_length = sorted([(x, len(variants[x])) for x in variants.keys()],
key=lambda y: (y[1], y[0]),
reverse=True)
print(
"\nvariant\t\toccurrences\t\tthroughput time log\t\tthroughput time traces with path"
)
for i in range(min(10, len(variants_length))):
var = variants_length[i][0]
vark = str(var)
if len(vark) > 10:
vark = vark[:10]
occ = variants_length[i][1]
fp_log_var = fp_discovery.apply(
variants[var], variant=fp_discovery.Variants.ENTIRE_EVENT_LOG)
conf_var = fp_conformance.apply(fp_log_var, fp_model)
is_fit = str(len(conf_var) == 0)
var_throughput = case_statistics.get_median_caseduration(variants[var])
print("%s\t\t%d\t\t%s\t\t%s\t\t%s" %
(vark, occ, is_fit, throughput_time,
human_readable_stat(var_throughput)))
# print(conf_occ)
conf_colors = tree_visualization.apply(tree, conf)
if True:
gviz = pt_visualizer.apply(
tree,
parameters={
"format":
"svg",
pt_visualizer.Variants.WO_DECORATION.value.Parameters.COLOR_MAP:
conf_colors,
pt_visualizer.Variants.WO_DECORATION.value.Parameters.ENABLE_DEEPCOPY:
False
})
pt_visualizer.view(gviz)
from pm4py.objects.process_tree import semantics
import pm4py
from pm4py.objects.log.importer.xes import importer
from pm4py.simulation.tree_playout.variants import extensive
#log = pm4py.read_xes("BPI_Challenge_2012_APP.xes")
from pm4py.simulation.tree_playout import algorithm as tree_playout
playout_variant = tree_playout.Variants.EXTENSIVE
param = tree_playout.Variants.EXTENSIVE.value.Parameters
#treelist = "+( ->( 'B', 'C', 'D', 'E' ), 'A', 'G' )"
#treelist1 = treelist.split(" ")
#log0 = importer.apply('/Users/jiao.shuai.1998.12.01outlook.com/code/07.01.2021/DES1/testfile/test.xes')
log0 = importer.apply(
'/Users/jiao.shuai.1998.12.01outlook.com/code/07.01.2021/DES1/testfile/test.xes'
)
tree = inductive_miner.apply_tree(log0)
#tree = infra.recieve_and_convert_log.convertptree(treelist1,None,0)
#tree = pm4py.discover_process_tree_inductive(log)
sim_log = extensive.apply(tree, parameters={param.MAX_LIMIT_NUM_TRACES: 100})
print('The generated traces are shown as follow:')
for trace in sim_log:
print(trace, '~~~~~~~~~')
tree1 = inductive_miner.apply_tree(sim_log)
print('The previous tree:', tree, '\n', "The new tree:", tree1)
#sim_variants = pm4py.get_variants(sim_log)
'''
log0 = xes_importer.apply('/Users/jiao.shuai.1998.12.01outlook.com/code/07.01.2021/DES1/testfile/test.xes')
log1 = xes_importer.apply('/Users/jiao.shuai.1998.12.01outlook.com/code/07.01.2021/DES1/testfile/evalunew.xes')
log2 = xes_importer.apply('/Users/jiao.shuai.1998.12.01outlook.com/code/07.01.2021/DES1/testfile/evaluold.xes')
