def test_importingExportingPetri(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" imported_petri1, marking1, fmarking1 = petri_importer.import_net( os.path.join(INPUT_DATA_DIR, "running-example.pnml")) soundness = check_soundness.check_petri_wfnet_and_soundness( imported_petri1) del soundness petri_exporter.export_net( imported_petri1, marking1, os.path.join(OUTPUT_DATA_DIR, "running-example.pnml")) imported_petri2, marking2, fmarking2 = petri_importer.import_net( os.path.join(OUTPUT_DATA_DIR, "running-example.pnml")) soundness = check_soundness.check_petri_wfnet_and_soundness( imported_petri2) del soundness self.assertEqual(sorted([x.name for x in imported_petri1.places]), sorted([x.name for x in imported_petri2.places])) self.assertEqual(sorted([x.name for x in imported_petri1.transitions]), sorted([x.name for x in imported_petri2.transitions])) self.assertEqual( sorted( [x.source.name + x.target.name for x in imported_petri1.arcs]), sorted( [x.source.name + x.target.name for x in imported_petri2.arcs])) self.assertEqual([x.name for x in marking1], [x.name for x in marking2]) os.remove(os.path.join(OUTPUT_DATA_DIR, "running-example.pnml"))
def __init__(self, path): """ :param path: path to directory storing process model file """ self.net, self.initial_marking, self.final_marking = pnml_importer.import_net( path)
def test_importingPetriLogAlignment(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" imported_petri1, marking1, fmarking1 = petri_importer.import_net( os.path.join(INPUT_DATA_DIR, "running-example.pnml")) soundness = check_soundness.check_petri_wfnet_and_soundness( imported_petri1) del soundness log = xes_importer.import_log( os.path.join(INPUT_DATA_DIR, "running-example.xes")) final_marking = petri.petrinet.Marking() for p in imported_petri1.places: if not p.out_arcs: final_marking[p] = 1 for trace in log: cf_result = state_equation_a_star.apply(trace, imported_petri1, marking1, final_marking)['alignment'] is_fit = True for couple in cf_result: if not (couple[0] == couple[1] or couple[0] == ">>" and couple[1] is None): is_fit = False if not is_fit: raise Exception("should be fit")
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") log = xes_importer.apply(log_path) # obtain Petri net through Alpha Miner net, initial_marking, final_marking = alpha_miner.apply(log) # obtain stochastic information for transitions in the model s_map = stochastic_map.get_map_from_log_and_net( log, net, initial_marking, final_marking, force_distribution="EXPONENTIAL") # export the current stochastic Petri net petri_exporter.export_net(net, initial_marking, "example.pnml", final_marking=final_marking, stochastic_map=s_map) # re-import the current stochastic Petri net from file net, initial_marking, final_marking, s_map = petri_importer.import_net( "example.pnml", return_stochastic_information=True) # remove temporary file os.remove("example.pnml") # gets the reachability graph from the Petri net reachab_graph = construct_reachability_graph(net, initial_marking) # get the tangible reachability graph from the reachability graph and the stochastic map tang_reach_graph = tangible_reachability.get_tangible_reachability_from_reachability( reachab_graph, s_map) # visualize the tangible reachability graph on the screen viz = ts_vis_factory.apply(tang_reach_graph, parameters={ "format": "svg", "show_labels": True, "show_names": True }) ts_vis_factory.view(viz) # gets the Q matrix assuming exponential distributions q_matrix = ctmc.get_q_matrix_from_tangible_exponential( tang_reach_graph, s_map) # pick a state to start from states = sorted(list(tang_reach_graph.states), key=lambda x: x.name) state = states[0] print("\n\nstarting from state = ", state.name) # do transient analysis after 1 day transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state( tang_reach_graph, q_matrix, state, 86400) print("\nprobability for each state after 1 day = ", transient_result) # do transient analysis after 10 days transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state( tang_reach_graph, q_matrix, state, 864000) print("\nprobability for each state after 10 days = ", transient_result) # do transient analysis after 100 days transient_result = ctmc.transient_analysis_from_tangible_q_matrix_and_single_state( tang_reach_graph, q_matrix, state, 8640000) print("\nprobability for each state after 100 days = ", transient_result) steady_state = ctmc.steadystate_analysis_from_tangible_q_matrix( tang_reach_graph, q_matrix) print("\nsteady state = ", steady_state)
def test_importingPetriLogTokenReplay(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" imported_petri1, marking1, fmarking1 = petri_importer.import_net( os.path.join(INPUT_DATA_DIR, "running-example.pnml")) trace_log = xes_importer.import_log(os.path.join(INPUT_DATA_DIR, "running-example.xes")) aligned_traces = token_replay.apply_log(trace_log, imported_petri1, marking1, fmarking1) del aligned_traces
def test_importingExportingStochasticNet(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" imported_petri1, marking1, fmarking1, stochastic_info1 = petri_importer.import_net( os.path.join(INPUT_DATA_DIR, "stochastic_running_example.pnml")) petri_exporter.export_net(imported_petri1, marking1, os.path.join(OUTPUT_DATA_DIR, "stochastic_running_example.pnml"), final_marking=fmarking1) os.remove(os.path.join(OUTPUT_DATA_DIR, "stochastic_running_example.pnml"))
def execute_script(): log_path = os.path.join("..", "tests", "input_data", "running-example.xes") pnml_path = os.path.join("..", "tests", "input_data", "running-example.pnml") # log_path = 'C:/Users/bas/Documents/tue/svn/private/logs/a32_logs/a32f0n05.xes' # pnml_path = 'C:/Users/bas/Documents/tue/svn/private/logs/a32_logs/a32.pnml' log = xes_importer.import_log(log_path) net, marking, fmarking = import_net(pnml_path) model_cost_function = dict() sync_cost_function = dict() for t in net.transitions: if t.label is not None: model_cost_function[t] = 1000 sync_cost_function[t] = 0 else: model_cost_function[t] = 1 alignments = ali.factory.apply(log, net, marking, fmarking) print(alignments) pretty_print_alignments(alignments)
if __name__ == '__main__': logger.info("Start script...") start_all = time.time() configs_df = experiment_configs2df(EXPERIMENT_CONFIGS) logger.info(f"Experiment configuration: \n{configs_df}") results_dirname = get_results_dirname(EXPERIMENT_CONFIGS) results_dir = os.path.join(RESULT_DIR, results_dirname) os.makedirs(results_dir) time_dict = dict() logger.info("Importing data...") start_import = time.time() net, init_marking, final_marking = pnml_importer.import_net(MODEL_FP) net_orig, init_marking_orig, final_marking_orig = pnml_importer.import_net( MODEL_FP) event_df = pd.read_csv(DATA_FP) took_import = time.time() - start_import time_dict[TIME_IMPORT_DATA] = took_import logger.info(f"Importing data took: {took_import:.3f}s") logger.info(f"Event df shape: {event_df.shape}") logger.info('Mapping activity to integer labels...') obs2int = event_df[[ACTIVITY, ACTIVITY_ID]].set_index(ACTIVITY) obs2int = obs2int.to_dict()[ACTIVITY_ID] int2obs = {key: val for key, val in obs2int.items()} obs2int_df = pd.DataFrame(list(obs2int.items()), columns=['activity', 'activity_int'])
import os from pm4py.objects.petri.importer import pnml as pnml_importer net, initial_marking, final_marking = pnml_importer.import_net( os.path.join("tests", "input_data", "new net.pnml")) 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) from pm4py.objects.petri import semantics transitions = semantics.enabled_transitions(net, initial_marking) print(transitions)
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) with open("timedstatesamples.json", 'w') as fp: json.dump(tss_json, fp) algo = NAP(tss_train_file="timedstatesamples.json",
def cpn_to_petrinet(input_file_path): ''' Convert cpn file into petri net Parameters ---------- input_file_path Input File path (must be cpn file) ''' doc = ET.parse(input_file_path) root = doc.getroot() #load cpn file (xml file) for child in root.iter("generator"): root.remove(child) root.tag = "pnml" #change tag to pnml n = 0 for i in range(len(root[0])): tag = root[0][n].tag if tag == "page": n +=1 else: root[0].remove(root[0][n]) #remove tags that are of no use root[0].set("id", "net1") root[0].set("type", "http://www.pnml.org/version-2009/grammar/pnmlcoremodel") #set pnml type for place in root.iter("place"): n = 0 l = len(place) for i in range(l): tag = place[n].tag if tag == "text": n+=1 else: place.remove(place[n]) # remove place's child tags that are of no use for trans in root.iter("trans"): n = 0 l = len(trans) for i in range(l): tag = trans[n].tag if tag == "text": n+=1 else: trans.remove(trans[n]) # remove trans's child tags that are of no use trans.tag = "transition" for arc in root.iter("arc"): n = 0 l = len(arc) for i in range(l): tag = arc[n].tag if tag == "transend" or tag == "placeend": n+=1 else: arc.remove(arc[n]) #remove arc's child tags that are of no use for arc in root.iter("arc"): if arc.attrib['orientation'] == 'PtoT': arc.set("source", arc.find('placeend').attrib['idref']) arc.set("target", arc.find('transend').attrib['idref']) else: arc.set("source", arc.find('transend').attrib['idref']) arc.set("target", arc.find('placeend').attrib['idref']) #change arc into right pnml arc for text in root.iter("text"): text.tag = "name" for name in root.iter("name"): text = ET.SubElement(name, "text") text.text = name.text name.text = None out_file = input_file_path[:-3] out_file += "pnml" doc.write(out_file, encoding="utf-8", xml_declaration=True) net, initial_marking, final_marking = pnml_importer.import_net(out_file) #get petrinet object return net, initial_marking, final_marking
def import_net(net_fname): net_fp = os.path.join(MODEL_DIR, net_fname) net, init_marking, final_marking = pnml_importer.import_net(net_fp) return net, init_marking, final_marking
def main(system, miner): if DATA_PATH is None: log = xes_importer.import_log( os.path.join(WORK_PATH, "data", "variants", str(system) + "_train.xes")) else: log = xes_importer.import_log( os.path.join(DATA_PATH, "variants", str(system) + "_train.xes")) bestmodel = None bestfit = None bestPrec = None bestGen = 0 bestfittraces = 0 gen_bestmodel = None gen_bestfit = None gen_bestPrec = None gen_bestGen = 0 if DATA_PATH is None: dir = os.listdir(os.path.join(WORK_PATH, "data", "pns", str(system))) else: dir = os.listdir(os.path.join(DATA_PATH, "pns", str(system))) for file in dir: if system in file and miner in file: if DATA_PATH is None: path = os.path.join(WORK_PATH, "data", "pns", str(system), file) else: path = os.path.join(DATA_PATH, "pns", str(system), file) print("Checking conformance of file:", path) net, initial_marking, final_marking = pnml_importer.import_net( path) fitness = replay_factory.apply(log, net, initial_marking, final_marking) precision = precision_factory.apply(log, net, initial_marking, final_marking) generalization = generalization_factory.apply( log, net, initial_marking, final_marking) if fitness['perc_fit_traces'] > bestfittraces: bestfittraces = fitness['perc_fit_traces'] bestmodel = path bestfit = fitness bestPrec = precision bestGen = generalization elif generalization > bestGen and fitness[ 'perc_fit_traces'] == bestfittraces: bestmodel = path bestfit = fitness bestPrec = precision bestGen = generalization if generalization > gen_bestGen: gen_bestmodel = path gen_bestfit = fitness gen_bestPrec = precision gen_bestGen = generalization net, initial_marking, final_marking = pnml_importer.import_net( gen_bestmodel) try: align_fitness = replay_factory.apply(log, net, initial_marking, final_marking, variant="alignments") except: align_fitness = {"averageFitness": "N/A"} try: align_precision = precision_factory.apply( log, net, initial_marking, final_marking, variant="align_etconformance") except: align_precision = "N/A" print("") print("") print( "*********** Petri net w/ highest ratio of fitting traces and high generalization *************** " ) print("Petri net file:", gen_bestmodel) print("Token-based Fitness=", gen_bestfit['average_trace_fitness']) print("Token-based Precision=", gen_bestPrec) print("Alignment-based Fitness=", align_fitness['averageFitness']) print("Alignment-based Precision=", align_precision) print("Generalization=", gen_bestGen) net, initial_marking, final_marking = pnml_importer.import_net(bestmodel) try: align_fitness = replay_factory.apply(log, net, initial_marking, final_marking, variant="alignments") except: align_fitness = {"averageFitness": "N/A"} try: align_precision = precision_factory.apply( log, net, initial_marking, final_marking, variant="align_etconformance") except: align_precision = "N/A" print("") print( "*********** Petri net w/ highest ratio of fitting traces and high generalization *************** " ) print("Petri net file:", bestmodel) print("Token-based Fitness=", bestfit['average_trace_fitness']) print("Token-based Precision=", bestPrec) print("Alignment-based Fitness=", align_fitness['averageFitness']) print("Alignment-based Precision=", align_precision) print("Generalization=", bestGen)
f_out = os.path.join(DATA_PATH, "variants", pn + ".txt") f_pn = os.path.join(DATA_PATH, "pns", system, pn) seq_len = getMaxVariantLength(f_pop) n_decimal = 8 if eval_only: print("*** Variant Evaluation of " + system + " using " + pn + " ***") else: print("*** Playout Variants of " + system + " and Evaluation using " + pn + " ***") print("Maximum Variant Length is:", str(seq_len)) if not eval_only: net, initial_marking, final_marking = pnml_importer.import_net(f_pn) out = playout.apply(net, initial_marking, parameters={ "noTraces": n_traces, "maxTraceLength": seq_len - 1 }) writeToFile(f_out, out) train = readVariantFile(f_train, unique=True) test = readVariantFile(f_test, unique=True) pop = readVariantFile(f_pop, unique=True) gen = readVariantFile(f_out, unique=True) new_train = [] for i in train: