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 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 calculate_process_schema_from_df(dataframe, path_frequency,
path_performance):
activities_count = attributes_filter.get_attribute_values(
dataframe, attribute_key=ACTIVITY_KEY)
[dfg_frequency, dfg_performance
] = df_statistics.get_dfg_graph(dataframe,
measure="both",
perf_aggregation_key="median",
case_id_glue=CASEID_GLUE,
activity_key=ACTIVITY_KEY,
timestamp_key=TIMEST_KEY,
sort_caseid_required=False)
net, initial_marking, final_marking = inductive_factory.apply_dfg(
dfg_frequency)
spaths = vis_trans_shortest_paths.get_shortest_paths(net)
aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount(
net, dfg_frequency, spaths, activities_count, variant="frequency")
parameters_viz = {"format": "svg"}
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
variant="frequency",
aggregated_statistics=aggregated_statistics,
parameters=parameters_viz)
pn_vis_factory.save(gviz, path_frequency)
aggregated_statistics = vis_trans_shortest_paths.get_decorations_from_dfg_spaths_acticount(
net, dfg_performance, spaths, activities_count, variant="performance")
parameters_viz = {"format": "svg"}
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
variant="performance",
aggregated_statistics=aggregated_statistics,
parameters=parameters_viz)
pn_vis_factory.save(gviz, path_performance)
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):
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 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 SPIMDFb(context):
args = context.args
inputFile = os.path.join(args.inputData, os.listdir(args.inputData)[0])
log = xes_importer.import_log(inputFile)
net, initial_marking, final_marking = inductive_miner.apply(log)
gviz = pn_vis_factory.apply(net, initial_marking, final_marking)
pn_vis_factory.save(gviz, os.path.join(args.outputData, "inductive-miner.png"))
return args.outputData
def inductive_miner_petrinet_no_decor(log_file):
net, i_m, f_m = inductive_miner.apply(log_file)
gviz = pn_vis_factory.apply(net,
i_m,
f_m,
parameters={
"format": "png",
"debug": False
})
pn_vis_factory.save(gviz, "static/inductive_miner_petnet_no_decor.png")
return net, i_m, f_m
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 inductive_miner_petrinet_frequency(log_file):
net, i_m, f_m = inductive_miner.apply(log_file)
gviz = pn_vis_factory.apply(net,
i_m,
f_m,
parameters={
"format": "png",
"debug": False
},
variant="frequency",
log=log_file)
pn_vis_factory.save(gviz, "static/inductive_miner_petnet_frequency.png")
return "success!"
def explore_process(name, csv, miner, miner_name):
event_log = csv_importer.import_log_from_string(csv)
net, initial_marking, final_marking = miner.apply(event_log)
gviz = pn_vis_factory.apply(net, initial_marking, final_marking)
pn_vis_factory.save(gviz, join('solutions', name + '_' + miner_name + '_petri_net.png'))
pn_vis_factory.save(gviz, join('solutions', name + '_' + miner_name + '_petri_net.pdf'))
bpmn_graph, elements_correspondence, inv_elements_correspondence, el_corr_keys_map = bpmn_converter.apply(net, initial_marking, final_marking)
bpmn_exporter.export_bpmn(bpmn_graph, join('solutions', name + '_' + miner_name + '.bpmn'))
bpmn_figure = bpmn_vis_factory.apply(bpmn_graph)
bpmn_vis_factory.save(bpmn_figure, join('solutions', name + '_' + miner_name + '_bpmn.png'))
bpmn_vis_factory.save(bpmn_figure, join('solutions', name + '_' + miner_name + '_bpmn.pdf'))
def bot_hm(chat_id, dependency_threshold=0.99):
log = get_current_log(chat_id)
heu_net = heuristics_miner.apply_heu(
log, parameters={"dependency_thresh": dependency_threshold})
gviz = hn_vis_factory.apply(heu_net)
new_file, filename = tempfile.mkstemp(suffix="png")
hn_vis_factory.save(gviz, filename)
net, im, fm = heuristics_miner.apply(
log, parameters={"dependency_thresh": dependency_threshold})
gviz = pn_vis_factory.apply(net, im, fm)
new_file2, filename2 = tempfile.mkstemp(suffix="png")
pn_vis_factory.save(gviz, filename2)
return [filename, filename2]
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 generate_petri_net_visual(net, initial_marking, final_marking, xes_log):
try:
# visualizing the petri net using graphviz library, by passing net initial and final marking and viewing it
parameters = {"format": "png"}
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
parameters=parameters,
variant="frequency",
log=xes_log)
pn_vis_factory.view(gviz)
print("By what name do you want to save the petri net image?")
filename = str(input())
pn_vis_factory.save(gviz, filename + ".png")
except TypeError:
print("Please check input values")
def SPHeuristicsMiner(context):
args = context.args
inputFile = os.path.join(args.inputData, os.listdir(args.inputData)[0])
log = xes_importer.import_log(inputFile)
net, im, fm = heuristics_miner.apply(
log,
parameters={
"dependency_thresh": args.dependencyThresh,
"and_measure_thresh": args.andMeasureThresh,
"min_act_count": args.minActCount,
"min_dfg_occurrences": args.minDfgOccurrences,
"dfg_pre_cleaning_noise_thresh": args.dfgPreCleaningNoiseThresh,
},
)
gviz = pn_vis_factory.apply(net, im, fm)
pn_vis_factory.save(gviz,
os.path.join(args.outputData, "heuristics-miner.png"))
return args.outputData
def _create_image(self, gviz, img_name, verbose=False):
"""
Create image file of the generated diagram (DFG,BPMN,Petr net)
:param gviz: image file generated by pm4py
:param img_name: name of the image to be saved
:param verbose: display log while generating images
"""
try:
img_path = os.path.join(self.discovery_path, f'{self.filename}_{img_name}.pdf')
if "alpha_miner" in img_name:
vis_factory.save(gviz, img_path)
elif "heuristic_miner" in img_name:
hn_vis_factory.save(gviz, img_path)
elif "petri_net" in img_name:
pn_vis_factory.save(gviz, img_path)
elif "DFG" in img_name:
dfg_vis_factory.save(gviz, img_path)
# elif "BPMN" in img_name:
# bpmn_vis_factory.save(gviz, img_path)
if verbose:
self.status_queue.put(f"[PROCESS MINING] Generated {img_name} in {img_path}")
except PermissionError as e:
print(f"[PROCESS MINING] Could not save image because of permission error: {e}")
print(f"Trying to save image on desktop")
img_path = os.path.join(utils.utils.DESKTOP, f'{self.filename}_{img_name}.pdf')
if "alpha_miner" in img_name:
vis_factory.save(gviz, img_path)
elif "heuristic_miner" in img_name:
hn_vis_factory.save(gviz, img_path)
elif "petri_net" in img_name:
pn_vis_factory.save(gviz, img_path)
elif "DFG" in img_name:
dfg_vis_factory.save(gviz, img_path)
# elif "BPMN" in img_name:
# bpmn_vis_factory.save(gviz, img_path)
except Exception as e:
print(f"[PROCESS MINING] Could not save image: {e}")
def directly_follows_graphs_freq(log_file):
dfg = dfg_factory.apply(log_file)
gviz = dfg_vis_factory.apply(dfg, log=log_file, variant="frequency")
pn_vis_factory.save(gviz, "static/dag_frequency.png")
return "success!"
def directly_follows_graphs_perf(log_file):
dfg = dfg_factory.apply(log_file)
gviz = dfg_vis_factory.apply(dfg, log=log_file, variant="performance")
pn_vis_factory.save(gviz, "static/dag_performance.png")
return "success!"
##### alpha miner ##########
from pm4py.algo.discovery.alpha import factory as alpha_miner
########### inductive mining #######
from pm4py.visualization.petrinet import factory as pn_vis_factory
parameters = {"format": "png"}
net, initial_marking, final_marking = alpha_miner.apply(conv_log)
parameters = {"format": "png"}
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
parameters=parameters,
variant="frequency",
log=conv_log)
pn_vis_factory.save(gviz, "inductive_frequency_invoice.png")
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
parameters=parameters,
variant="performance",
log=conv_log)
pn_vis_factory.save(gviz, "inductive_performance_invoice.png")
#########################################
##### inducive miner ###################
from pm4py.algo.discovery.inductive import factory as inductive_miner
# discovers an accepting Petri net
net, im, fm = inductive_miner.apply(df)
logging.debug("Creating process model...")
if DISCOVER:
main_model, main_im, main_fm = create_model(log_main)
#save_heuristics_net(log_main)
else:
# reference model can also be imported instead of using process discovery
main_model, main_im, main_fm = convert_bpmn(
os.path.join("datasets", "bpmn_models", "1.bpmn"))
# visualize
gviz = pn_vis_factory.apply(main_model,
main_im,
main_fm,
parameters={"format": "png"})
logging.debug("Saving micro-cluster model")
pn_vis_factory.save(gviz, "results/rm.png")
# introducing recurring drifts with specific inter-drift distance
log, gt = shuffle_log(log, SUB_LOG_SIZE, switch=SWITCH)
#logging.debug("Number of traces in whole log: {}".format(len(log)))
logging.debug("Saved micro-cluster model")
logging.debug("Creating networkx graph...")
nx_graph, inv_dict = create_networkx_graph(main_model, main_im, main_fm)
# only work on largest connected component
nx_graph = nx_graph.subgraph(max(nx.connected_components(nx_graph), key=len))
inv_dict = {
list(inv_dict.keys())[list(inv_dict.values()).index(v)]: v
for v in nx_graph.nodes
}
def show(model, tel, file_name, parameters):
'''
Show model and its quality measures
:param model: model type (transition system, state based region, DFG miner, alpha miner)
:param tel: input log
:param file_name: img file name to show model
:param parameters: parmater for transition system (afreq, sfreq)
:return:
'''
tel_flag = False
if isinstance(tel[0][0], tel_event):
tel_flag = True
if model in ['ts', 'sbr']:
if tel_flag:
output_file_path = os.path.join(
"static", "images", file_name[:file_name.find('.')] + '_' +
model + '_' + str(parameters['afreq_thresh']) + '_' +
str(parameters['sfreq_thresh']) + ".png")
else:
output_file_path = os.path.join(
"static", "images",
"2" + "_" + file_name[:file_name.find('.')] + '_' + model +
'_' + str(parameters[PARAM_KEY_DIRECTION]) + '_' +
str(parameters[PARAM_KEY_WINDOW]) + "_" +
str(parameters[PARAM_KEY_VIEW]) + ".png")
auto = utils.discover_annotated_automaton(tel, parameters=parameters)
max_thresh = {}
max_afreq = 0
max_sfreq = 0
if tel_flag:
for trans in auto.transitions:
max_afreq = max(max_afreq, trans.afreq)
for state in auto.states:
max_sfreq = max(max_sfreq, state.sfreq)
max_thresh['afreq'] = max_afreq
max_thresh['sfreq'] = max_sfreq
if model == 'ts':
result = {}
gviz = vis_factory.apply(auto)
vis_factory.save(gviz, output_file_path)
result['num of transitions'] = len(auto.transitions)
result['num of states'] = len(auto.states)
else:
net, im, fm = sb.petri_net_synthesis(auto)
gviz = petri_vis_factory.apply(net, im, fm)
petri_vis_factory.save(gviz, output_file_path)
result = evaluation(net, im, fm, tel)
else:
if tel_flag:
output_file_path = os.path.join(
"static", "images",
file_name[:file_name.find('.')] + '_' + model + '_' + ".png")
else:
output_file_path = os.path.join(
"static", "images", "2" + file_name[:file_name.find('.')] +
'_' + model + '_' + ".png")
if model == 'alpha':
if isinstance(tel[0][0], Event):
net, im, fm = trans_alpha(tel)
else:
net, im, fm = alpha_miner.apply(tel)
gviz = petri_vis_factory.apply(net, im, fm)
petri_vis_factory.save(gviz, output_file_path)
result = evaluation(net, im, fm, tel)
else:
dfg = dfg_factory.apply(tel)
if tel_flag:
dfg_tel = inductive_revise.get_dfg_graph_trans(tel)
#dfg = dfg_tel + dfg
dfg = dfg_tel
gviz = dfg_vis_factory.apply(dfg, log=tel)
dfg_vis_factory.save(gviz, output_file_path)
result = dict(
sorted(dfg.items(), key=operator.itemgetter(1), reverse=True))
max_thresh = None
return output_file_path, result, max_thresh
pnmlFolder = "simple_pnml"
pngFolder = "simple_png"
for logName in os.listdir(logFolder):
if "." in logName:
logNamePrefix = logName.split(".")[0]
print("\nelaborating " + logName)
logPath = os.path.join(logFolder, logName)
log = xes_factory.import_log(logPath, variant="iterparse")
net, initial_marking, final_marking = simple_model_factory.apply(
log, classic_output=True)
pnml_exporter.export_net(net,
initial_marking,
os.path.join(pnmlFolder, logNamePrefix) +
".pnml",
final_marking=final_marking)
gviz = petri_vis_factory.apply(net,
initial_marking,
final_marking,
log=log,
variant="frequency")
petri_vis_factory.save(
gviz,
os.path.join(pngFolder, logNamePrefix) + ".png")
def export_petri_net(path, output):
net, i_m, f_m = output
viz_params = {"format": "svg", "debug": True}
gviz = pn_vis_factory.apply(net, i_m, f_m, parameters=viz_params)
pn_vis_factory.save(gviz, path)
from pm4py.algo.discovery.alpha import factory as alpha_miner
from pm4py.objects.log.importer.xes import factory as xes_importer
from pm4py.visualization.petrinet import factory as vis_factory
log = xes_importer.import_log('/tmp/input/example.xes')
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = vis_factory.apply(net, initial_marking, final_marking)
vis_factory.save(gviz,'/data/output.png')
def model(request, log_id, cube_id):
values = request.GET.get("values")
if (values == None):
values = "{}"
values = json.loads(values)
def convert(value, dtype):
if (dtype == 'float'):
return float(value)
elif (dtype == 'int'):
return int(value)
elif (dtype == 'date'):
return convert_date(value)
elif (dtype == 'bool'):
return bool(value)
else:
return value
def convert_date(value):
# Construct datetime object to filter with pymongo
time_format = "%Y-%m-%dT%H:%M:%S.%f"
time_format = "%Y-%m-%d %H:%M:%S.%f"
if ("." not in value):
time_format = time_format[:-3]
return datetime.strptime(value, time_format)
algo = request.GET.get("algorithm")
values_ = {}
# Convert to attribute id to name like it is in the events.
values_ = {}
for key in values:
if (key != 'log'):
attribute = Attribute.objects.get(pk=key)
if (":" in attribute.parent):
parent = attribute.parent.split(':')[0]
d_name = attribute.parent.split(':')[1]
name = attribute.name
# Query for elements of dictionary
queryname = parent + ":" + d_name + ".children." + name
else:
queryname = attribute.name
if (attribute.parent == "trace"):
queryname = 'trace:' + queryname
if ("to" in values[key]):
lower = values[key].split("to")[0].strip()
upper = values[key].split('to')[1].strip()
lower = convert(lower, attribute.dtype)
upper = convert(upper, attribute.dtype)
values_[queryname] = {'$gt': lower, '$lt': upper}
else:
value = convert(values[key], attribute.dtype)
values_[queryname] = value
values_['log'] = log_id
values = values_
client = MongoClient(host=DATABASES['default']['HOST'])
db = client[DATABASES['default']['NAME']]
trace_collection = db['traces']
event_collection = db['events']
t1 = time()
all_events = event_collection.find(values)
t2 = time()
print("Time to get events: {}".format(t2 - t1))
t1 = time()
traces = groupby(all_events, key=lambda e: e['trace:_id'])
t2 = time()
print("Time to get traces: {}".format(t2 - t1))
t1 = time()
traces = [log_lib.log.Trace(g) for k, g in traces]
t2 = time()
print("Time to make list: {}".format(t2 - t1))
# log_list = [log_lib.log.Trace([log_lib.log.Event(t_e) for t_e in all_events if t_e['trace:_id'] == db_trace['_id']]) for db_trace in db_traces]
t1 = time()
log = log_lib.log.EventLog(traces)
t2 = time()
print("Time to make event log: {}".format(t2 - t1))
# for db_trace in db_traces:
# pm4py_trace = log_lib.log.Trace([log_lib.log.Event(t_e) for t_e in all_events if t_e['trace:_id'] == db_trace['_id']])
# log.append(pm4py_trace)
# print(len(log))
# pm_events = []
# traces = {str(e['trace:_id']): log_lib.log.Trace() for e in events}
# for event in events:
# trace = trace_collection.find_one({"_id": event['trace:_id']})
# t = traces[str(event['trace:_id'])]
# del event['_id']
# del event['trace:_id']
# e = log_lib.log.Event(event)
# t.append(e)
# log.append(traces.items())
# for trace in traces:
# log.append(traces[trace])
parameters = {"format": "svg"}
event_log = EventLog.objects.get(pk=log_id)
filename = str(event_log.pk) + algo + ".svg"
t1 = time()
if (algo == "alpha"):
net, initial_marking, final_marking = alpha_miner.apply(log)
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
parameters=parameters)
pn_vis_factory.save(gviz, filename)
elif (algo == "inductive"):
mine_tree = request.GET.get("mine_tree")
if (mine_tree == 'true'):
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree, parameters=parameters)
pt_vis_factory.save(gviz, filename)
else:
net, initial_marking, final_marking = inductive_miner.apply(log)
gviz = pn_vis_factory.apply(net,
initial_marking,
final_marking,
parameters=parameters)
pn_vis_factory.save(gviz, filename)
elif (algo == "heuristic"):
dependency_thresh = float(request.GET.get("dependency_thresh"))
and_measure_thresh = float(request.GET.get("and_measure_thresh"))
min_act_count = float(request.GET.get("min_act_count"))
min_dfg_occurrences = float(request.GET.get("min_dfg_occurrences"))
dfg_pre_cleaning_noise_thresh = float(
request.GET.get("dfg_pre_cleaning_noise_thresh"))
h_params = {
'dependency_thresh': dependency_thresh,
'and_measure_thresh': and_measure_thresh,
'min_act_count': min_act_count,
'min_dfg_occurrences': min_dfg_occurrences,
'dfg_pre_cleaning_noise_thresh': dfg_pre_cleaning_noise_thresh,
}
net, im, fm = heuristics_miner.apply(log, parameters=h_params)
gviz = pn_vis_factory.apply(net, im, fm, parameters=parameters)
pn_vis_factory.save(gviz, filename)
t2 = time()
print("Time pm4py: {}".format(t2 - t1))
svg = open(filename, "rb")
svg_content = svg.read()
svg.close()
# Tdelete file, it's not required anymore
os.remove(svg.name)
return HttpResponse(svg_content, content_type="image/svg+xml")
