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