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 execute_script():
log = pm4py.read_xes("../tests/input_data/running-example.xes")
dfg, sa, ea = pm4py.discover_dfg(log)
tree = pm4py.discover_process_tree_inductive(log)
heu_net = pm4py.discover_heuristics_net(log)
net, im, fm = pm4py.discover_petri_net_alpha(log)
bpmn = pm4py.convert_to_bpmn(tree)
ts = ts_discovery.apply(log)
x_cases, y_cases = case_statistics.get_kde_caseduration(log)
gviz1 = dfg_visualizer.apply(dfg)
gviz2 = tree_visualizer.apply(tree)
gviz3 = hn_visualizer.apply(heu_net)
gviz4 = pn_visualizer.apply(net, im, fm)
gviz5 = bpmn_visualizer.apply(bpmn)
gviz6 = ts_visualizer.apply(ts)
gviz7 = graphs_visualizer.apply(x_cases, y_cases, variant=graphs_visualizer.Variants.CASES,
parameters={graphs_visualizer.Variants.CASES.value.Parameters.FORMAT: "svg"})
print("1", len(dfg_visualizer.serialize_dot(gviz1)))
print("1", len(dfg_visualizer.serialize(gviz1)))
print("2", len(tree_visualizer.serialize_dot(gviz2)))
print("2", len(tree_visualizer.serialize(gviz2)))
print("3", len(hn_visualizer.serialize(gviz3)))
print("4", len(pn_visualizer.serialize_dot(gviz4)))
print("4", len(pn_visualizer.serialize(gviz4)))
print("5", len(bpmn_visualizer.serialize_dot(gviz5)))
print("5", len(bpmn_visualizer.serialize(gviz5)))
print("6", len(ts_visualizer.serialize_dot(gviz6)))
print("6", len(ts_visualizer.serialize(gviz6)))
print("7", len(graphs_visualizer.serialize(gviz7)))
def changeptree(request):
print('here is changeptree~~~~~~~~~~~~~~~~~~~~~')
global ADRESS
global ProcessTree
global inputname
global ConvertTree
inputname = uploadview.getlogname()
logadr = './media/log/input_log'
ADRESS = logadr
log = infra.recieve_and_convert_log.convert_log(logadr, logname, logtime,
logtran, logstart,
logcompl, logreso, logid,
inputname[-3:])
#ptree = infra.recieve_and_convert_log.get_processtree(log)
ptree = request.POST.get('ptree')
#print(ptree,'here is ptree')
k = 0
for i, ele in enumerate(ptree):
if i < k:
#print(i,k,"ik")
continue
if ele == "'":
#print("left")
for j, ele in enumerate(ptree[i + 1:]):
#print(ele,"ele")
if ele == "'":
#print("right")
k = i + j + 2
#print(k,ptree[k],"line49")
break
if ele == " ":
#print("space")
b = list(ptree)
b[i + j + 1] = '$'
ptree = ''.join(b)
treelist = ptree.split(" ")
treelist1 = []
for ele in treelist:
ele1 = ele.replace('$', ' ')
treelist1.append(ele1)
processtree = infra.recieve_and_convert_log.convertptree(
treelist1, None, 0)
gviz = pt_visualizer.apply(
processtree,
parameters={
pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "png"
})
ConvertTree = 1
ProcessTree = processtree
pt_visualizer.save(gviz, "DES1/static/ptree.gv.png")
window = 1
return render(request, 'processtree.html', {
'gviz': gviz,
'ptree': ProcessTree,
'window': window
})
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 display_process_tree():
parameters = {
pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "SVG"
}
gviz = pt_visualizer.apply(settings.PROCESS_TREE, parameters=parameters)
log_name = settings.EVENT_LOG_NAME
log_name = log_name.replace(" ", "")
tree_path = os.path.join(settings.TREE_PATH, f"{log_name}.SVG")
pt_visualizer.save(gviz, tree_path)
return tree_path
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 execute_script():
log = pm4py.read_xes(
os.path.join("..", "tests", "input_data", "receipt.xes"))
tree = pm4py.discover_process_tree_inductive(log)
aligned_traces = pm4py.conformance_diagnostics_alignments(log, tree)
tree = search_graph_pt_frequency_annotation.apply(tree, aligned_traces)
gviz = pt_visualizer.apply(
tree,
parameters={"format": "svg"},
variant=pt_visualizer.Variants.FREQUENCY_ANNOTATION)
pt_visualizer.view(gviz)
def test_59(self):
from pm4py.simulation.tree_generator import simulator as tree_gen
parameters = {}
tree = tree_gen.apply(parameters=parameters)
from pm4py.objects.process_tree import semantics
log = semantics.generate_log(tree, no_traces=100)
from pm4py.objects.conversion.process_tree import converter as pt_converter
net, im, fm = pt_converter.apply(tree)
from pm4py.visualization.process_tree import visualizer as pt_visualizer
gviz = pt_visualizer.apply(tree, parameters={pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "png"})
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 view_process_tree(tree, format="png"):
"""
Views a process tree
Parameters
---------------
tree
Process tree
format
Format of the visualization (default: png)
"""
from pm4py.visualization.process_tree import visualizer as pt_visualizer
parameters = pt_visualizer.Variants.WO_DECORATION.value.Parameters
gviz = pt_visualizer.apply(tree, parameters={parameters.FORMAT: format})
pt_visualizer.view(gviz)
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 save_vis_process_tree(tree, file_path):
"""
Saves the visualization of a process tree
Parameters
---------------
tree
Process tree
file_path
Destination path
"""
format = file_path[file_path.index(".") + 1:].lower()
from pm4py.visualization.process_tree import visualizer as pt_visualizer
parameters = pt_visualizer.Variants.WO_DECORATION.value.Parameters
gviz = pt_visualizer.apply(tree, parameters={parameters.FORMAT: format})
pt_visualizer.save(gviz, file_path)
def save_vis_process_tree(tree: ProcessTree, file_path: str):
"""
Saves the visualization of a process tree
Parameters
---------------
tree
Process tree
file_path
Destination path
"""
format = os.path.splitext(file_path)[1][1:]
from pm4py.visualization.process_tree import visualizer as pt_visualizer
parameters = pt_visualizer.Variants.WO_DECORATION.value.Parameters
gviz = pt_visualizer.apply(tree, parameters={parameters.FORMAT: format})
pt_visualizer.save(gviz, file_path)
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 processtree(request):
print('here is processtree~~~~~~~~~~~~~~~~~~~~~')
global ADRESS
logadr = ADRESS
gviz = pt_visualizer.apply(
ProcessTree,
parameters={
pt_visualizer.Variants.WO_DECORATION.value.Parameters.FORMAT: "png"
})
Evaluation = infra.recieve_and_convert_log.gettreeinfo()[0]
Loopdict = infra.recieve_and_convert_log.gettreeinfo()[1]
pt_visualizer.save(gviz, "DES1/static/ptree.gv.png")
window = 0
return render(
request, 'processtree.html', {
'gviz': gviz,
'ptree': ProcessTree,
'evaluation': Evaluation,
'loopdict': Loopdict,
'window': window
})
def inductive_miner_tree(log):
# create the process tree
tree = inductive_miner.apply_tree(log)
gviz = pt_visualizer.apply(tree)
return gviz, None
from pm4py.algo.discovery.inductive import algorithm as inductive_miner
log = xes_importer.apply(os.path.join('E:/data/pm/running-example.xes'))
net, initial_marking, final_marking = inductive_miner.apply(log)
net
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)
import os
os.environ["PATH"] += os.pathsep + 'c:/Program Files (x86)/Graphviz2.38/bin/'
import graphviz
from subprocess import call
call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])
gviz = pt_visualizer.apply(tree)
pt_visualizer.view(gviz)
#
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)
#heuristic Miner
from pm4py.objects.log.importer.xes import importer as xes_importer
import os
#log_path = os.path.join("tests", "compressed_input_data", "09_a32f0n00.xes.gz")
log_path = os.path.join('E:/data/pm/running-example.xes')
log = xes_importer.apply(log_path)
from pm4py.algo.discovery.heuristics import algorithm as heuristics_miner
"""
import pandas as pd
import pm4py
'''
def import_csv(file_path):
event_log = pandas.read_csv(file_path, sep=';')
event_log = pm4py.format_dataframe(event_log, case_id='case_id', activity_key='activity', timestamp_key='timestamp')
start_activities = pm4py.get_start_activities(event_log)
end_activities = pm4py.get_end_activities(event_log)
print("Start activities: {}\nEnd activities: {}".format(start_activities, end_activities))
'''
file_path = r'file'
log = pm4py.format_dataframe(pd.read_csv(file_path, sep=';'),
case_id='case_id',
activity_key='activity',
timestamp_key='timestamp')
#log = log[log['@@index']< 40]
process_tree = pm4py.discover_tree_inductive(log)
bpmn_model = pm4py.convert_to_bpmn(process_tree)
pm4py.view_bpmn(bpmn_model)
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)
pt_visualizer.view(gviz)
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)
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)