def handle_uploaded_file(f, algorithm):
logPath2 = '/home/pm4py_test/logs/log.xes'
logPath1 = '/home/pm4py_test/media/log.xes'
# os.remove('static/proc/model.png')
fs = FileSystemStorage()
fs.save('log.xes', f)
move_file(logPath1, logPath2)
log = xes_importer.import_log(logPath2)
if algorithm == "alpha":
print(algorithm)
net, initial_marking, final_marking = heuristics_miner.apply(log)
elif algorithm == "inductive":
print(algorithm)
net, initial_marking, final_marking = inductive_miner.apply(log)
elif algorithm == "heuristics":
print(algorithm)
net, initial_marking, final_marking = heuristics_miner.apply(log)
else:
print('error !!!')
print(algorithm)
return
gviz = vis_factory.apply(net, initial_marking, final_marking)
vis_factory.view(gviz)
pngUris = glob.glob('/home/pm4py_test/*.png')
gvUris = glob.glob('/home/pm4py_test/*.gv')
modelUri = '/home/pm4py_test/proc/static/proc/model.png'
print(pngUris)
print(gvUris)
os.remove(gvUris[0])
move_file(pngUris[0], modelUri)
def test_petrinet_receipt_df(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"
df = csv_import_adapter.import_dataframe_from_path(
os.path.join(INPUT_DATA_DIR, "running-example.csv"))
net, im, fm = heuristics_miner.apply(df)
gviz = pn_vis_factory.apply(net, im, fm)
del gviz
def test_petrinet_running_example(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"))
net, im, fm = heuristics_miner.apply(log)
gviz = pn_vis_factory.apply(net, im, fm)
del gviz
def test_heu_log(self):
log = xes_importer.apply(
os.path.join("input_data", "running-example.xes"))
net, im, fm = heuristics_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_heuristic(log, label, activity_key, parameters={}):
from pm4py.algo.discovery.heuristics import factory as heuristics_miner
miner_params = {
PARAMETER_CONSTANT_TIMESTAMP_KEY: "time",
PARAMETER_CONSTANT_ACTIVITY_KEY: activity_key
}
for key in parameters:
miner_params[key] = parameters[key]
return heuristics_miner.apply(log, parameters=miner_params)
def execute_script():
log = xes_importer.apply(
os.path.join("..", "tests", "compressed_input_data",
"09_a32f0n00.xes.gz"))
heu_net = heuristics_miner.apply_heu(
log, parameters={"dependency_thresh": 0.99})
gviz = hn_vis_factory.apply(heu_net, parameters={"format": "svg"})
hn_vis_factory.view(gviz)
net, im, fm = heuristics_miner.apply(
log, parameters={"dependency_thresh": 0.99})
gviz2 = petri_vis_factory.apply(net, im, fm, parameters={"format": "svg"})
petri_vis_factory.view(gviz2)
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 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
log, parameters=parameters_discovery)
pnml_exporter.export_net(alpha_model,
alpha_initial_marking,
os.path.join(
pnmlFolder,
logNamePrefix + "_alpha.pnml"),
final_marking=alpha_final_marking)
t2 = time.time()
print("time interlapsed for calculating Alpha Model", (t2 - t1))
print(
"alpha is_sound_wfnet",
check_soundness.check_petri_wfnet_and_soundness(alpha_model,
debug=True))
t1 = time.time()
heu_model, heu_initial_marking, heu_final_marking = heuristics_miner.apply(
log, parameters=parameters_discovery)
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))
print(
"heuristics is_sound_wfnet",
check_soundness.check_petri_wfnet_and_soundness(heu_model,
debug=True))
t1 = time.time()
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")
def run_heuristic_miner(log,parameters={"dependency_thresh": 0.99}):
net, initial_marking, final_marking = heuristics_miner.apply(log, parameters)
#gviz = vis_petri.apply(net, initial_marking, final_marking)
#vis_petri.view(gviz)
return net, initial_marking, final_marking
def generate_heuristics_petri_net(xes_log):
try:
heu_net, im, fm = heuristics_miner.apply(xes_log)
return {'heu_net': heu_net, 'initial_marking': im, 'final_marking': fm}
except AttributeError:
print("Please check your input values")
def create_model(log, params={"dependency_thresh": DEP_THRESH}):
model, initial_marking, final_marking = heuristics_miner.apply(
log, parameters=params)
#model, initial_marking, final_marking = alpha_miner.apply(log)
#model, initial_marking, final_marking = inductive_miner.apply(log)
return model, initial_marking, final_marking
import json
from pm4py.objects.log.importer.xes import factory as xes_import_factory
from pm4py.objects.petri.exporter import pnml as pnml_exporter
from pm4py.objects.petri.importer import pnml as pnml_importer
from pm4py.algo.discovery.heuristics import factory as heuristics_miner
from pydream.LogWrapper import LogWrapper
from pydream.EnhancedPN import EnhancedPN
from pydream.predictive.nap.NAP import NAP
from pydream.util.TimedStateSamples import loadTimedStateSamples
if __name__ == "__main__":
log = xes_import_factory.apply('YOUR_EVENTLOG.xes')
net, im, fm = heuristics_miner.apply(
log, parameters={"dependency_thresh": 0.99})
pnml_exporter.export_net(net, im, "discovered_pn.pnml")
net, initial_marking, final_marking = pnml_importer.import_net(
"discovered_pn.pnml")
log_wrapper = LogWrapper(log)
enhanced_pn = EnhancedPN(net, initial_marking)
enhanced_pn.enhance(log_wrapper)
enhanced_pn.saveToFile("enhanced_discovered_pn.json")
enhanced_pn = EnhancedPN(net,
initial_marking,
decay_function_file="enhanced_discovered_pn.json")
tss_json, tss_objs = enhanced_pn.decay_replay(log_wrapper=log_wrapper)
print(model)
tree = 5
tree_num = 0
tree_avg = 0
print(tree)
for sam in range(1, 11):
print(sam)
input_file_path = os.path.join("input_data", "df_complete_logs",
"%d_1000_%d.xes" % (tree, sam))
log = xes_importer.apply(input_file_path)
dfg_org = dfg_factory.apply(log)
start_act = set(get_start_activities(log).keys())
end_act = set(get_end_activities(log).keys())
#make petri net for simulation
net, im, fm = heu_factory.apply(log)
num = len(dfg_org.keys())
sim_log = sim_factory.apply(net,
im,
parameters={
'maxTraceLength': 20,
'noTraces': 1000
})
dfg_algo = dfg_factory.apply(log)
start_act_algo = set(get_start_activities(sim_log).keys())
end_act_algo = set(get_end_activities(sim_log).keys())
score = 0
su = 0
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 from pm4py.algo.discovery.inductive import factory as inductive_miner from pm4py.algo.discovery.heuristics import factory as heuristics_miner logPath = '../logs/Chapter_1/running-example-just-two-cases.xes' logPath2 = '' log = xes_importer.import_log(logPath) net, initial_marking, final_marking = heuristics_miner.apply(log) gviz = vis_factory.apply(net, initial_marking, final_marking) vis_factory.view(gviz)