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_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
def SPIMDFbTree(context):
args = context.args
inputFile = os.path.join(args.inputData, os.listdir(args.inputData)[0])
log = xes_importer.import_log(inputFile)
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree)
pt_vis_factory.save(gviz,
os.path.join(args.outputData, "inductive-miner.png"))
return args.outputData
def start_experiments_for_ptml_files(path, file_names_pt, file_name_log, sample_size=None):
logging.disable(logging.CRITICAL)
input_data = []
print("load log")
log = import_log(path + file_name_log)
print("finish loading log")
variants = variants_filter.get_variants(log)
log_variants = EventLog()
for v in variants:
log_variants.append(variants[v][0])
if sample_size:
log_variants = random.sample(log_variants, sample_size)
for ptml_file_name in file_names_pt:
with open(path + ptml_file_name, "rb") as input_file:
pt = pickle.load(input_file)
pt_vis.view(pt_vis.apply(pt, parameters={"format": "svg"}))
pt = process_tree_to_binary_process_tree(pt)
pt_vis.view(pt_vis.apply(pt, parameters={"format": "svg"}))
input_data.append((pt, log_variants))
start_experiments(input_data=input_data)
def test_tree_running_example_dfg_based_old(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"))
tree = inductive_miner.apply_tree(
log, variant=inductive_miner.DFG_BASED_OLD_VERSION)
gviz = pt_vis_factory.apply(tree)
del gviz
# test log generation
log = pt_semantics.generate_log(tree)
del log
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")
import os
from tests.translucent_event_log.objects.tel.importer.xes.iterparse_tel import import_tel
import tests.translucent_event_log_new.objects.tel.tel as tel
from tests.translucent_event_log_new.objects.tel.importer.xes.utils import log_to_tel
from pm4py.algo.discovery.inductive import factory as inductive_miner
from pm4py.objects.log.importer.xes import factory as xes_importer
from pm4py.visualization.process_tree import factory as vis_factory
from tests.translucent_event_log.objects.tel.importer.xes.iterparse_tel import import_tel
import os
from tests.translucent_event_log_new.objects.tel.importer.xes.utils import log_to_tel
from pm4py.algo.discovery.alpha import factory as alpha_miner
from tests.translucent_event_log_new.objects.tel.utils import tel_set_enabled
from tests.translucent_event_log_new.algo.discover_automaton import utils
from datetime import timedelta
input_file_path = os.path.join("input_data", "running-example_tel.xes")
log = import_tel(input_file_path)
tel = tel_set_enabled(log)
logg = xes_importer.apply(input_file_path)
nett= inductive_miner.apply(tel)
net= inductive_miner.apply(logg)
gviz = vis_factory.apply(nett)
vis_factory.view(gviz)
gviz = vis_factory.apply(net)
vis_factory.view(gviz)
def apply(log, parameters=None):
"""
Gets the process tree using Inductive Miner Directly-Follows
Parameters
------------
log
Log
parameters
Parameters of the algorithm
Returns
------------
base64
Base64 of an SVG representing the model
model
Text representation of the model
format
Format of the model
"""
if parameters is None:
parameters = {}
decreasingFactor = parameters[
"decreasingFactor"] if "decreasingFactor" in parameters else constants.DEFAULT_DEC_FACTOR
activity_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_ACTIVITY_KEY] if pm4_constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
log = attributes_filter.filter_log_on_max_no_activities(
log,
max_no_activities=constants.MAX_NO_ACTIVITIES,
parameters=parameters)
filtered_log = auto_filter.apply_auto_filter(log, parameters=parameters)
activities_count = attributes_filter.get_attribute_values(
filtered_log, activity_key)
activities = list(activities_count.keys())
start_activities = list(
start_activities_filter.get_start_activities(
filtered_log, parameters=parameters).keys())
end_activities = list(
end_activities_filter.get_end_activities(filtered_log,
parameters=parameters).keys())
dfg = dfg_factory.apply(filtered_log, parameters=parameters)
dfg = clean_dfg_based_on_noise_thresh(
dfg,
activities,
decreasingFactor * constants.DEFAULT_DFG_CLEAN_MULTIPLIER,
parameters=parameters)
tree = inductive_miner.apply_tree_dfg(dfg,
parameters=parameters,
activities=activities,
start_activities=start_activities,
end_activities=end_activities)
parameters["format"] = "svg"
gviz = pt_vis_factory.apply(tree, parameters=parameters)
gviz_base64 = base64.b64encode(str(gviz).encode('utf-8'))
return get_base64_from_gviz(gviz), None, "", "xes", activities, start_activities, end_activities, gviz_base64, [], "tree", "freq", None, "", activity_key
weak_average = averagePerPersonFixDFG(
weak_dfg_fixed, len(ex1_personal_log_2['org:resource'].unique()))
diff_absolute = diffTwoMatrix(excellent_average, weak_average)
dfg_miner_time_diff_absolute = diffTwoMatrix(dfg_miner_excellent_dfg,
dfg_miner_weak_dfg)
#Inductive Miner
from pm4py.algo.discovery.inductive import factory as inductive_miner
tree = inductive_miner.apply_tree(ex1_personal_log_1_converted)
from pm4py.visualization.process_tree import factory as pt_vis_factory
gviz = pt_vis_factory.apply(tree)
pt_vis_factory.view(gviz)
from pm4py.algo.discovery.inductive import factory as inductive_miner
net, initial_marking, final_marking = inductive_miner.apply(
ex1_personal_log_1_converted)
from pm4py.visualization.petrinet import factory as pn_vis_factory
gviz = pn_vis_factory.apply(net, initial_marking, final_marking)
pn_vis_factory.view(gviz)
#variant
from pm4py.statistics.traces.log import case_statistics
def draw_process_tree(tree):
gvis = pt_vis_factory.apply(tree)
pt_vis_factory.view(gvis)
from pm4py.visualization.process_tree import factory as pt_viz
from pm4py.algo.simulation.tree_generator import factory as pt_gen
from pm4py.objects.process_tree import util as pt_util
from pm4py.objects.conversion.process_tree import factory as pt_conv
from pm4py.visualization.petrinet import factory as pn_viz
from pm4py.objects.petri import utils as pn_util
import time
if __name__ == "__main__":
pt = pt_gen.apply()
pt_viz.view(pt_viz.apply(pt, parameters={"format": "svg"}))
time.sleep(1)
pn, im, fm = pt_conv.apply(pt)
pn_viz.view(pn_viz.apply(pn, parameters={'format': 'svg'}))
time.sleep(1)
pt = pt_util.fold(pt)
pt_viz.view(pt_viz.apply(pt, parameters={"format": "svg"}))
from pm4py.algo.simulation.tree_generator import factory as pt_gen
from pm4py.objects.conversion.process_tree import factory as pt_conv
from pm4py.visualization.petrinet import factory as pn_viz
from pm4py.visualization.process_tree import factory as pt_viz
from pm4py.objects.process_tree import util as pt_util
from pm4py.objects.petri import utils as pn_util
import time
from pm4py.objects.petri.exporter import factory as pn_exp
if __name__ == '__main__':
pt = pt_gen.apply()
gviz = pt_viz.apply(pt, parameters={'format': 'svg'})
pt_viz.view(gviz)
time.sleep(1)
pt = pt_util.fold(pt)
gviz = pt_viz.apply(pt, parameters={'format': 'svg'})
pt_viz.view(gviz)
time.sleep(1)
pn, ini, fin = pt_conv.apply(pt)
gviz = pn_viz.apply(pn, ini, fin, parameters={"format": "svg"})
pn_viz.view(gviz)
time.sleep(1)
pn_exp.apply(pn,
ini,
'C:/Users/zelst/Desktop/translation_test.pnml',
final_marking=fin)
def apply(dataframe, parameters=None):
"""
Gets the process tree using Inductive Miner Directly-Follows
Parameters
------------
dataframe
Dataframe
parameters
Parameters of the algorithm
Returns
------------
base64
Base64 of an SVG representing the model
model
Text representation of the model
format
Format of the model
"""
if parameters is None:
parameters = {}
decreasingFactor = parameters[
"decreasingFactor"] if "decreasingFactor" in parameters else constants.DEFAULT_DEC_FACTOR
activity_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_ACTIVITY_KEY] if pm4_constants.PARAMETER_CONSTANT_ACTIVITY_KEY in parameters else xes.DEFAULT_NAME_KEY
timestamp_key = parameters[
pm4_constants.
PARAMETER_CONSTANT_TIMESTAMP_KEY] if pm4_constants.PARAMETER_CONSTANT_TIMESTAMP_KEY in parameters else xes.DEFAULT_TIMESTAMP_KEY
case_id_glue = parameters[
pm4_constants.
PARAMETER_CONSTANT_CASEID_KEY] if pm4_constants.PARAMETER_CONSTANT_CASEID_KEY in parameters else CASE_CONCEPT_NAME
parameters[pm4_constants.RETURN_EA_COUNT_DICT_AUTOFILTER] = True
dataframe = attributes_filter.filter_df_keeping_spno_activities(
dataframe,
activity_key=activity_key,
max_no_activities=constants.MAX_NO_ACTIVITIES)
dataframe, end_activities = auto_filter.apply_auto_filter(
dataframe, parameters=parameters)
end_activities = list(end_activities.keys())
activities_count = attributes_filter.get_attribute_values(
dataframe, activity_key, parameters=parameters)
activities = list(activities_count.keys())
start_activities = list(
start_activities_filter.get_start_activities(
dataframe, parameters=parameters).keys())
dfg = df_statistics.get_dfg_graph(dataframe,
activity_key=activity_key,
timestamp_key=timestamp_key,
case_id_glue=case_id_glue,
sort_caseid_required=False,
sort_timestamp_along_case_id=False)
dfg = clean_dfg_based_on_noise_thresh(
dfg,
activities,
decreasingFactor * constants.DEFAULT_DFG_CLEAN_MULTIPLIER,
parameters=parameters)
tree = inductive_miner.apply_tree_dfg(dfg,
parameters,
activities=activities,
start_activities=start_activities,
end_activities=end_activities)
gviz = pt_vis_factory.apply(tree, parameters={"format": "svg"})
gviz_base64 = base64.b64encode(str(gviz).encode('utf-8'))
return get_base64_from_gviz(gviz), None, "", "parquet", activities, start_activities, end_activities, gviz_base64, [], "tree", "freq", None, "", activity_key
def inductive_to_petri_net(log):
tree = inductive_miner.apply_tree(log)
gviz = pt_vis_factory.apply(tree)
pt_vis_factory.view(gviz)
return tree