def conformance_diagnostics_alignments(log: EventLog, *args, multi_processing: bool = False) -> List[Dict[str, Any]]: """ Apply the alignments algorithm between a log and a process model. The methods return the full alignment diagnostics. Parameters ------------- log Event log args Specification of the process model multi_processing Boolean value that enables the multiprocessing (default: False) Returns ------------- aligned_traces A list of alignments for each trace of the log (in the same order as the traces in the event log) """ if type(log) not in [pd.DataFrame, EventLog, EventStream]: raise Exception("the method can be applied only to a traditional event log!") if len(args) == 3: if type(args[0]) is PetriNet: # Petri net alignments from pm4py.algo.conformance.alignments.petri_net import algorithm as alignments if multi_processing: return alignments.apply_multiprocessing(log, args[0], args[1], args[2], parameters=get_properties(log)) else: return alignments.apply(log, args[0], args[1], args[2], parameters=get_properties(log)) elif type(args[0]) is dict or type(args[0]) is Counter: # DFG alignments from pm4py.algo.conformance.alignments.dfg import algorithm as dfg_alignment return dfg_alignment.apply(log, args[0], args[1], args[2], parameters=get_properties(log)) elif len(args) == 1: if type(args[0]) is ProcessTree: # process tree alignments from pm4py.algo.conformance.alignments.process_tree.variants import search_graph_pt if multi_processing: return search_graph_pt.apply_multiprocessing(log, args[0], parameters=get_properties(log)) else: return search_graph_pt.apply(log, args[0], parameters=get_properties(log)) # try to convert to Petri net import pm4py from pm4py.algo.conformance.alignments.petri_net import algorithm as alignments net, im, fm = pm4py.convert_to_petri_net(*args) if multi_processing: return alignments.apply_multiprocessing(log, net, im, fm, parameters=get_properties(log)) else: return alignments.apply(log, net, im, fm, parameters=get_properties(log))
def execute_script(): log = pm4py.read_xes("../tests/compressed_input_data/02_teleclaims.xes.gz") tree = pm4py.discover_process_tree_inductive(log, noise_threshold=0.3) net, im, fm = pm4py.convert_to_petri_net(tree) # reduce the log to one trace per variant log = filtering_utils.keep_one_trace_per_variant(log) for index, trace in enumerate(log): print(index) aa = time.time() check_tree = pm4py.check_is_fitting(trace, tree) bb = time.time() check_petri = pm4py.check_is_fitting(trace, net, im, fm) cc = time.time() print("check on tree: ", check_tree, "time", bb - aa) print("check on Petri net: ", check_petri, "time", cc - bb) print()
def execute_script(): log = pm4py.read_xes( os.path.join("..", "tests", "input_data", "receipt.xes")) print("number of cases", len(log)) print("number of events", sum(len(x) for x in log)) print("number of variants", len(pm4py.get_variants(log))) ac = get.get_attribute_values(log, "concept:name") dfg, sa, ea = pm4py.discover_dfg(log) perc = 0.5 dfg, sa, ea, ac = dfg_filtering.filter_dfg_on_activities_percentage( dfg, sa, ea, ac, perc) dfg, sa, ea, ac = dfg_filtering.filter_dfg_on_paths_percentage( dfg, sa, ea, ac, perc) aa = time.time() aligned_traces = dfg_alignment.apply(log, dfg, sa, ea) bb = time.time() net, im, fm = pm4py.convert_to_petri_net(dfg, sa, ea) for trace in aligned_traces: if trace["cost"] != trace["internal_cost"]: print(trace) pass print(bb - aa) print(sum(x["visited_states"] for x in aligned_traces)) print( sum(x["cost"] // align_utils.STD_MODEL_LOG_MOVE_COST for x in aligned_traces)) gviz = visualizer.apply(dfg, activities_count=ac, parameters={ "start_activities": sa, "end_activities": ea, "format": "svg" }) visualizer.view(gviz) cc = time.time() aligned_traces2 = petri_alignments.apply( log, net, im, fm, variant=petri_alignments.Variants.VERSION_DIJKSTRA_LESS_MEMORY) dd = time.time() print(dd - cc) print(sum(x["visited_states"] for x in aligned_traces2)) print( sum(x["cost"] // align_utils.STD_MODEL_LOG_MOVE_COST for x in aligned_traces2))
def conformance_diagnostics_alignments(log: EventLog, *args) -> List[Dict[str, Any]]: """ Apply the alignments algorithm between a log and a process model. The methods return the full alignment diagnostics. Parameters ------------- log Event log args Specification of the process model Returns ------------- aligned_traces A list of alignments for each trace of the log (in the same order as the traces in the event log) """ if len(args) == 3: if type(args[0]) is PetriNet: # Petri net alignments from pm4py.algo.conformance.alignments import algorithm as alignments return alignments.apply(log, args[0], args[1], args[2]) elif type(args[0]) is dict or type(args[0]) is Counter: # DFG alignments from pm4py.objects.dfg.utils import dfg_alignment return dfg_alignment.apply(log, args[0], args[1], args[2]) elif len(args) == 1: if type(args[0]) is ProcessTree: # process tree alignments from pm4py.algo.conformance.tree_alignments import algorithm as tree_alignments return tree_alignments.apply(log, args[0]) # try to convert to Petri net import pm4py from pm4py.algo.conformance.alignments import algorithm as alignments net, im, fm = pm4py.convert_to_petri_net(*args) return alignments.apply(log, net, im, fm)
def test_convert_to_net_from_heu(self): log = pm4py.read_xes("input_data/running-example.xes") heu_net = pm4py.discover_heuristics_net(log) net, im, fm = pm4py.convert_to_petri_net(heu_net) self.assertTrue(isinstance(net, PetriNet))
def test_convert_to_net_from_dfg(self): dfg, sa, ea = pm4py.read_dfg("input_data/running-example.dfg") net, im, fm = pm4py.convert_to_petri_net(dfg, sa, ea) self.assertTrue(isinstance(net, PetriNet))
def test_convert_to_net_from_bpmn(self): bpmn = pm4py.read_bpmn("input_data/running-example.bpmn") net, im, fm = pm4py.convert_to_petri_net(bpmn) self.assertTrue(isinstance(net, PetriNet))
def test_convert_to_net_from_tree(self): tree = pm4py.read_ptml("input_data/running-example.ptml") net, im, fm = pm4py.convert_to_petri_net(tree) self.assertTrue(isinstance(net, PetriNet))