def test_alpha_miner_log(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net1, im1, fm1 = alpha_miner.apply(
log, variant=alpha_miner.ALPHA_VERSION_CLASSIC)
net2, im2, fm2 = alpha_miner.apply(
log, variant=alpha_miner.ALPHA_VERSION_PLUS)
from pm4py.algo.discovery.dfg import factory as dfg_discovery
dfg = dfg_discovery.apply(log)
net3, im3, fm3 = alpha_miner.apply_dfg(
dfg, variant=alpha_miner.ALPHA_VERSION_CLASSIC)
def import_xes_data(filename):
if not os.path.abspath(filename):
# 修改日志文件路径
file_path = global_util.get_full_path_input_file(filename)
else:
file_path = filename
filename = os.path.basename(filename)
# 导入日志文件名
parameters = {"timestamp_sort": True}
log = importer.apply(file_path, variant="nonstandard", parameters=parameters)
# 矿工应用日志文件
net, initial_marking, final_marking = alpha_miner.apply(log)
# 可视化界面应用分析结果
gviz = visualizer.apply(net, initial_marking, final_marking)
# 生成输出文件名
file, _ = os.path.splitext(filename)
output_full_name = "output_" + file + ".png"
# 生成输出文件全路径
output_file = global_util.get_full_path_output_file(output_full_name)
# 保存文件
visualizer.save(gviz, output_file)
# 返回输出文件名
return output_full_name
def test_tokenreplay(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.tokenreplay import factory as token_replay
replayed_traces = token_replay.apply(log,
net,
im,
fm,
variant="token_replay")
replayed_traces = token_replay.apply(log,
net,
im,
fm,
variant="backwards")
from pm4py.evaluation.replay_fitness import factory as rp_fitness_evaluator
fitness = rp_fitness_evaluator.apply(
log, net, im, fm, variant=rp_fitness_evaluator.TOKEN_BASED)
evaluation = rp_fitness_evaluator.evaluate(
replayed_traces, variant=rp_fitness_evaluator.TOKEN_BASED)
from pm4py.evaluation.precision import factory as precision_evaluator
precision = precision_evaluator.apply(
log, net, im, fm, variant=precision_evaluator.ETCONFORMANCE_TOKEN)
from pm4py.evaluation.generalization import factory as generalization_evaluation
generalization = generalization_evaluation.apply(
log,
net,
im,
fm,
variant=generalization_evaluation.GENERALIZATION_TOKEN)
def test_alpha_miner_dataframe(self):
from pm4py.objects.log.adapters.pandas import csv_import_adapter
df = csv_import_adapter.import_dataframe_from_path(
os.path.join("input_data", "running-example.csv"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, im, fm = alpha_miner.apply(
df, variant=alpha_miner.ALPHA_VERSION_CLASSIC)
def import_xes_data(filename):
if not os.path.abspath(filename):
file_path = global_util.get_full_path_input_file(filename)
else:
file_path = filename
filename = os.path.basename(filename)
parameters = {"timestamp_sort": True}
log = importer.apply(file_path,
variant="nonstandard",
parameters=parameters)
print(log)
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = visualizer.apply(net, initial_marking, final_marking)
file, _ = os.path.splitext(filename)
output_full_name = "output_" + file + ".png"
output_file = global_util.get_full_path_output_file(output_full_name)
visualizer.save(gviz, output_file)
return output_full_name
def test_playout(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.simulation.playout import factory as simulator
log2 = simulator.apply(net, im, fm)
def test_tangiblereachabilitygraph_calc(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"
input_log = os.path.join(INPUT_DATA_DIR, "running-example.xes")
log = xes_importer.import_log(input_log)
net, initial_marking, final_marking = alpha_miner.apply(log)
s_map = stochastic_map.get_map_from_log_and_net(log, net, initial_marking, final_marking)
reachab_graph = construct_reachability_graph(net, initial_marking)
tang_reach_graph = tangible_reachability.get_tangible_reachability_from_reachability(reachab_graph,
s_map)
viz = ts_vis_factory.apply(tang_reach_graph, parameters={"format": "svg", "show_labels": True})
del viz
# gets the Q matrix assuming exponential distributions
q_matrix = ctmc.get_q_matrix_from_tangible_exponential(tang_reach_graph, s_map)
# pick a state to start from
states = sorted(list(tang_reach_graph.states), key=lambda x: x.name)
state = states[0]
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(tang_reach_graph, q_matrix,
state, 86400)
del transient_result
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(tang_reach_graph, q_matrix,
state, 864000)
del transient_result
steady_state = ctmc.steadystate_analysis_from_tangible_q_matrix(tang_reach_graph, q_matrix)
del steady_state
def import_xes_data(filename):
if not os.path.abspath(filename):
file_path = global_util.get_full_path_input_file(filename)
else:
file_path = filename
filename = os.path.basename(filename)
# import the name of log
parameters = {"timestamp_sort": True}
log = importer.apply(file_path,
variant="nonstandard",
parameters=parameters)
print(log)
# file of miner application log
net, initial_marking, final_marking = alpha_miner.apply(log)
# Visual interface application analysis results
gviz = visualizer.apply(net, initial_marking, final_marking)
# Generate output file name
file, _ = os.path.splitext(filename)
output_full_name = "output_" + file + ".png"
# Generate the full path of the output file
output_file = global_util.get_full_path_output_file(output_full_name)
# save document
visualizer.save(gviz, output_file)
# Returns the output file name
return output_full_name
def bot_alpha_miner(chat_id):
log = get_current_log(chat_id)
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = vis_factory.apply(net, initial_marking, final_marking)
new_file, filename = tempfile.mkstemp(suffix="png")
vis_factory.save(gviz, filename)
return filename
def import_xes_data(filename):
if not os.path.abspath(filename):
# modify the path of file
file_path = global_util.get_full_path_input_file(filename)
else:
file_path = filename
filename = os.path.basename(filename)
# import the name of log
parameters = {"timestamp_sort": True}
log = importer.apply(file_path,
variant="nonstandard",
parameters=parameters)
# apply miner
net, initial_marking, final_marking = alpha_miner.apply(log)
# apply visualizer
gviz = visualizer.apply(net, initial_marking, final_marking)
# generate the name of the file
file, _ = os.path.splitext(filename)
output_full_name = "output_" + file + ".png"
# generate the path of all generated files
output_file = global_util.get_full_path_output_file(output_full_name)
# save file
visualizer.save(gviz, output_file)
# return the name of the file
return output_full_name
def mine(self, log: EventLog) -> Tuple[PetriNet, Marking, Marking]:
params = {
PARAMETER_CONSTANT_CASEID_KEY: log.case_id_attr,
PARAMETER_CONSTANT_ACTIVITY_KEY: log.activity_attr
}
res_tpl = alpha_miner.apply(log, parameters=params)
return res_tpl
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_import.apply(log_path)
net, i_m, f_m = alpha_miner.apply(log)
gviz = pn_vis_factory.apply(net, i_m, f_m, parameters={"format": "svg", "debug": True})
pn_vis_factory.view(gviz)
def Alphaminer(file):
log = xes_importer.import_log(file)
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = vis_factory.apply(net, initial_marking, final_marking)
location = "/mnt/c/Users/harim/Downloads/alphaminer.png"
vis_factory.save(gviz, location)
#vis_factory.view(gviz)
return location
def execute_script():
log_path = os.path.join("..", "tests", "input_data", "running-example.xes")
log = xes_importer.apply(log_path)
# obtain Petri net through Alpha Miner
net, initial_marking, final_marking = alpha_miner.apply(log)
# obtain stochastic information for transitions in the model
s_map = stochastic_map.get_map_from_log_and_net(
log,
net,
initial_marking,
final_marking,
force_distribution="EXPONENTIAL")
# export the current stochastic Petri net
petri_exporter.export_net(net,
initial_marking,
"example.pnml",
final_marking=final_marking,
stochastic_map=s_map)
# re-import the current stochastic Petri net from file
net, initial_marking, final_marking, s_map = petri_importer.import_net(
"example.pnml", return_stochastic_information=True)
# remove temporary file
os.remove("example.pnml")
# gets the reachability graph from the Petri net
reachab_graph = construct_reachability_graph(net, initial_marking)
# get the tangible reachability graph from the reachability graph and the stochastic map
tang_reach_graph = tangible_reachability.get_tangible_reachability_from_reachability(
reachab_graph, s_map)
# visualize the tangible reachability graph on the screen
viz = ts_vis_factory.apply(tang_reach_graph,
parameters={
"format": "svg",
"show_labels": True,
"show_names": True
})
ts_vis_factory.view(viz)
# gets the Q matrix assuming exponential distributions
q_matrix = ctmc.get_q_matrix_from_tangible_exponential(
tang_reach_graph, s_map)
# pick a state to start from
states = sorted(list(tang_reach_graph.states), key=lambda x: x.name)
state = states[0]
print("\n\nstarting from state = ", state.name)
# do transient analysis after 1 day
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(
tang_reach_graph, q_matrix, state, 86400)
print("\nprobability for each state after 1 day = ", transient_result)
# do transient analysis after 10 days
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(
tang_reach_graph, q_matrix, state, 864000)
print("\nprobability for each state after 10 days = ", transient_result)
# do transient analysis after 100 days
transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state(
tang_reach_graph, q_matrix, state, 8640000)
print("\nprobability for each state after 100 days = ", transient_result)
steady_state = ctmc.steadystate_analysis_from_tangible_q_matrix(
tang_reach_graph, q_matrix)
print("\nsteady state = ", steady_state)
def test_evaluation(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.evaluation.simplicity import factory as simplicity
simp = simplicity.apply(net)
from pm4py.evaluation import factory as evaluation_method
eval = evaluation_method.apply(log, net, im, fm)
def generate_alpha_net(xes_log):
try:
alpha_net, initial_marking, final_marking = alpha_miner.apply(xes_log)
return {
'alpha_net': alpha_net,
'initial_marking': initial_marking,
'final_marking': final_marking
}
except AttributeError:
print("Please check input values")
def test_decomp_alignment(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, im, fm = alpha_miner.apply(log)
from pm4py.algo.conformance.decomp_alignments import factory as decomp_align
aligned_traces = decomp_align.apply(log,
net,
im,
fm,
variant="recompos_maximal")
def test_alphaminer_df(self):
log = csv_import_adapter.import_dataframe_from_path(
os.path.join("input_data", "running-example.csv"))
net, im, fm = alpha_miner.apply(log)
aligned_traces_tr = tr_factory.apply(log, net, im, fm)
aligned_traces_alignments = align_factory.apply(log, net, im, fm)
evaluation = eval_factory.apply(log, net, im, fm)
fitness = rp_fit_factory.apply(log, net, im, fm)
precision = precision_factory.apply(log, net, im, fm)
generalization = generalization_factory.apply(log, net, im, fm)
simplicity = simplicity_factory.apply(net)
def run_alpha(log, label, activity_key, variant="classic"):
from pm4py.algo.discovery.alpha import factory as alpha_miner
miner_params = {
PARAMETER_CONSTANT_TIMESTAMP_KEY: "time",
PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key
}
return alpha_miner.apply(copy.deepcopy(log),
parameters=miner_params,
variant=variant)
def test_alphaminer_stream(self):
stream = csv_importer.apply(
os.path.join("input_data", "running-example.csv"))
net, im, fm = alpha_miner.apply(stream)
aligned_traces_tr = tr_factory.apply(stream, net, im, fm)
aligned_traces_alignments = align_factory.apply(stream, net, im, fm)
evaluation = eval_factory.apply(stream, net, im, fm)
fitness = rp_fit_factory.apply(stream, net, im, fm)
precision = precision_factory.apply(stream, net, im, fm)
generalization = generalization_factory.apply(stream, net, im, fm)
simplicity = simplicity_factory.apply(net)
def test_docmeasures11(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"
from pm4py.objects.log.importer.xes import factory as xes_importer
log = xes_importer.import_log(os.path.join("input_data",
"receipt.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
from pm4py.algo.discovery.inductive import factory as inductive_miner
alpha_petri, alpha_initial_marking, alpha_final_marking = alpha_miner.apply(
log)
inductive_petri, inductive_initial_marking, inductive_final_marking = inductive_miner.apply(
log)
from pm4py.evaluation.replay_fitness import factory as replay_factory
fitness_alpha = replay_factory.apply(log, alpha_petri,
alpha_initial_marking,
alpha_final_marking)
fitness_inductive = replay_factory.apply(log, inductive_petri,
inductive_initial_marking,
inductive_final_marking)
del fitness_alpha
del fitness_inductive
from pm4py.evaluation.precision import factory as precision_factory
precision_alpha = precision_factory.apply(log, alpha_petri,
alpha_initial_marking,
alpha_final_marking)
precision_inductive = precision_factory.apply(
log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
del precision_alpha
del precision_inductive
from pm4py.evaluation.generalization import factory as generalization_factory
generalization_alpha = generalization_factory.apply(
log, alpha_petri, alpha_initial_marking, alpha_final_marking)
generalization_inductive = generalization_factory.apply(
log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
del generalization_alpha
del generalization_inductive
from pm4py.evaluation.simplicity import factory as simplicity_factory
simplicity_alpha = simplicity_factory.apply(alpha_petri)
simplicity_inductive = simplicity_factory.apply(inductive_petri)
del simplicity_alpha
del simplicity_inductive
from pm4py.evaluation import factory as evaluation_factory
alpha_evaluation_result = evaluation_factory.apply(
log, alpha_petri, alpha_initial_marking, alpha_final_marking)
inductive_evaluation_result = evaluation_factory.apply(
log, inductive_petri, inductive_initial_marking,
inductive_final_marking)
del alpha_evaluation_result
del inductive_evaluation_result
def obtainPetriNetThroughAlphaMiner(self, log_name):
# 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"
if ".xes" in log_name:
trace_log = xes_importer.import_log(log_name)
else:
event_log = csv_importer.import_log(log_name)
trace_log = log_transform.transform_event_log_to_trace_log(
event_log)
net, marking, fmarking = alpha_factory.apply(trace_log)
return trace_log, net, marking, fmarking
def test_classifiers1documentation(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"
from pm4py.objects.log.importer.xes import factory as xes_importer
log = xes_importer.import_log(os.path.join("input_data",
"receipt.xes"))
# print(log.classifiers)
from pm4py.objects.log.util import insert_classifier
log, activity_key = insert_classifier.insert_activity_classifier_attribute(
log, "Activity classifier")
# print(activity_key)
from pm4py.algo.discovery.alpha import factory as alpha_miner
parameters = {
pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key
}
net, initial_marking, final_marking = alpha_miner.apply(
log, parameters=parameters)
del net
del initial_marking
del final_marking
from pm4py.objects.log.importer.xes import factory as xes_importer
log = xes_importer.import_log(os.path.join("input_data",
"receipt.xes"))
for trace in log:
for event in trace:
event["customClassifier"] = event["concept:name"] + event[
"lifecycle:transition"]
from pm4py.algo.discovery.alpha import factory as alpha_miner
parameters = {
pmutil.constants.PARAMETER_CONSTANT_ACTIVITY_KEY:
"customClassifier"
}
net, initial_marking, final_marking = alpha_miner.apply(
log, parameters=parameters)
del net
del initial_marking
del final_marking
def SPAlphaMiner(context):
args = context.args
log = convert_df_pm_format(args.inputData)
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = pn_vis_factory.apply(net, initial_marking, final_marking)
pn_vis_factory.save(gviz, os.path.join(args.outputData, "alpha-miner.png"))
pnml_exporter.export_net(
net,
initial_marking,
os.path.join(args.outputData, "petri_final.pnml"),
final_marking=final_marking,
)
return args.outputData
def obtainPetriNetThroughAlphaMiner(self, log_name):
# 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"
if ".xes" in log_name:
log = xes_importer.import_log(log_name)
else:
event_log = csv_importer.import_event_stream(log_name)
log = log_transform.transform_event_stream_to_event_log(event_log)
net, marking, fmarking = alpha_factory.apply(log)
soundness = check_soundness.check_petri_wfnet_and_soundness(net)
del soundness
return log, net, marking, fmarking
def test_alphadoc1(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"
from pm4py.objects.log.importer.xes import factory as xes_importer
log = xes_importer.import_log(
os.path.join("input_data", "running-example.xes"))
from pm4py.algo.discovery.alpha import factory as alpha_miner
net, initial_marking, final_marking = alpha_miner.apply(log)
from pm4py.visualization.petrinet.common import visualize as pn_viz
gviz = pn_viz.graphviz_visualization(net,
initial_marking=initial_marking,
final_marking=final_marking)
del gviz
def make_enabledlog_alphaminer(log_file_path, output_file_name):
'''
Convert XES to XES++ based on alpha miner (event log with enabled activities)
(for test)
Parameters
----------
log_file_path
log's file path to be changed into XES++
output_file_name
output file (XES++)'s name
'''
log = xes_importer.import_log(log_file_path)
net, initial_marking, final_marking = alpha_miner.apply(log)
doc = ET.parse(log_file_path)
root = doc.getroot()
for glob in root.iter("global"):
if glob.attrib["scope"] == "event":
enabled = ET.SubElement(glob, "string")
enabled.set("key", "enabled")
enabled.set("value", "enabled")
for trace in root.iter("trace"):
m = ini.discover_initial_marking(net)
for event in trace.iter("event"):
for string in event.iter("string"):
if string.attrib["key"] == "concept:name":
act = string.attrib["value"] # act: current activity in the event log
break
for trans in net.transitions:
if act == trans.label:
t = trans
break
en = semantics.enabled_transitions(net, m)
enabled = ET.SubElement(event, "string")
enabled.set("key", "enabled")
enabled.set("value", en) #write on the XES file
if m == final_marking:
break
m = semantics.execute(t, net, m)
doc.write(output_file_name, encoding="utf-8", xml_declaration=True)
def show_log(self, log):
# Miner application log file
net, initial_marking, final_marking = alpha_miner.apply(log)
# Visual interface application analysis results
gviz = visualizer.apply(net, initial_marking, final_marking)
file, _ = os.path.splitext(os.path.basename(self.fileName))
output_full_name = "output_time_filtered_" + file + ".png"
output_file = global_util.get_full_path_output_file(output_full_name)
print(output_file)
visualizer.save(gviz, output_file)
return output_full_name
def import_csv_file(filename):
filename = os.path.basename(filename)
file_path = global_util.get_full_path_input_file(filename)
event_stream = csv_importer.import_event_stream(file_path)
# dataframe = csv_import_adapter.import_dataframe_from_path(file_path, sep=",")
log = conversion_factory.apply(
event_stream,
parameters={constants.PARAMETER_CONSTANT_TIMESTAMP_KEY: "日期和时间"})
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = visualizer.apply(net, initial_marking, final_marking)
visualizer.view(gviz)
def test_rep_log_petri_fitness(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, "running-example.xes"))
pref_mat, var_mat, activities = prefix_matrix.get_prefix_variants_matrix(
log)
net, im, fm = alpha_miner.apply(log)
net_matrix = project_net_on_matrix(net, activities)
product_matrix = np.matmul(pref_mat, net_matrix)
max_product_matrix = np.max(product_matrix)
self.assertGreaterEqual(max_product_matrix, 0)
