def apply(log, parameters=None, variant=DEFAULT_VARIANT): """ Find transition system given log Parameters ----------- log Log parameters Possible parameters of the algorithm, including: Parameters.PARAM_KEY_VIEW Parameters.PARAM_KEY_WINDOW Parameters.PARAM_KEY_DIRECTION variant Variant of the algorithm to use, including: Variants.VIEW_BASED Returns ---------- ts Transition system """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(log_conversion.apply( log, parameters, log_conversion.TO_EVENT_LOG), parameters=parameters)
def apply(df, activity, variant=Variants.PRE, parameters=None): """ Gets statistics on execution times of the paths to/from the activity Parameters ------------ df Dataframe activity Activity variant Variant: - Variants.PRE - Variants.POST - Variants.PREPOST parameters Possible parameters of the algorithm Returns ----------- dictio Dictio containing the times from/to the activity """ return exec_utils.get_variant(variant).apply(df, activity, parameters=parameters)
def apply(obj, pt, variant=DEFAULT_VARIANT, parameters=None): """ Align an event log or a trace with a process tree Parameters -------------- obj Log / Trace pt Process tree variant Variant parameters Variant-specific parameters Returns -------------- alignments Alignments """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(obj, pt, parameters=parameters)
def apply_variants(variants, parameters=None, variant=DEFAULT_VARIANT_VARIANTS): """ Apply the chosen IM algorithm to a dictionary/list/set of variants obtaining a Petri net along with an initial and final marking Parameters ----------- variants Dictionary/list/set of variants in the log variant Variant of the algorithm to apply, possible values: - Variants.IMd parameters Parameters of the algorithm, including: Parameters.ACTIVITY_KEY -> attribute of the log to use as activity name (default concept:name) Returns ----------- net Petri net initial_marking Initial marking final_marking Final marking """ return exec_utils.get_variant(variant).apply_variants( variants, parameters=parameters)
def apply_heu(log, parameters=None, variant=CLASSIC): """ Discovers an Heuristics Net using Heuristics Miner Parameters ------------ log Event log parameters Possible parameters of the algorithm, including: - Parameters.ACTIVITY_KEY - Parameters.TIMESTAMP_KEY - Parameters.CASE_ID_KEY - Parameters.DEPENDENCY_THRESH - Parameters.AND_MEASURE_THRESH - Parameters.MIN_ACT_COUNT - Parameters.MIN_DFG_OCCURRENCES - Parameters.DFG_PRE_CLEANING_NOISE_THRESH - Parameters.LOOP_LENGTH_TWO_THRESH variant Variant of the algorithm: - Variants.CLASSIC Returns ------------ net Petri net im Initial marking fm Final marking """ return exec_utils.get_variant(variant).apply_heu(log, parameters=parameters)
def apply(log: Union[EventLog, EventStream, pd.DataFrame], net: PetriNet, initial_marking: Marking, final_marking: Marking, parameters: Optional[Dict[Any, Any]] = None, variant=DEFAULT_VARIANT) -> typing.ListAlignments: """ Method to apply token-based replay Parameters ----------- log Log net Petri net initial_marking Initial marking final_marking Final marking parameters Parameters of the algorithm, including: Parameters.ACTIVITY_KEY -> Activity key variant Variant of the algorithm to use: - Variants.TOKEN_REPLAY - Variants.BACKWARDS """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(log_converter.apply(log, variant=log_converter.TO_EVENT_LOG, parameters=parameters), net, initial_marking, final_marking, parameters=parameters)
def apply( log_footprints: Union[Dict[str, Any], List[Dict[str, Any]]], model_footprints: Dict[str, Any], variant=Variants.LOG_MODEL, parameters: Optional[Dict[Any, Any]] = None ) -> Union[List[Dict[str, Any]], Dict[str, Any]]: """ Apply footprints conformance between a log footprints object and a model footprints object Parameters ----------------- log_footprints Footprints of the log model_footprints Footprints of the model parameters Parameters of the algorithm, including: - Parameters.STRICT => strict check of the footprints Returns ------------------ violations Set/dictionary of all the violations between the log footprints and the model footprints, OR list of case-per-case violations """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(log_footprints, model_footprints, parameters=parameters)
def apply(lang1, lang2, variant=Variants.PYEMD, parameters=None): """ Gets the EMD language between the two languages Parameters ------------- lang1 First language lang2 Second language variant Variants of the algorithm parameters Parameters variants Variants of the algorithm, including: - Variants.PYEMD: pyemd based distance Returns ------------- dist EMD distance """ return exec_utils.get_variant(variant).apply(lang1, lang2, parameters=parameters)
def apply(log, variant=DEFAULT_VARIANT, parameters=None): """ Applies the Correlation Miner to the event stream (a log is converted to a stream) The approach is described in: Pourmirza, Shaya, Remco Dijkman, and Paul Grefen. "Correlation miner: mining business process models and event correlations without case identifiers." International Journal of Cooperative Information Systems 26.02 (2017): 1742002. Parameters ------------- log Log object variant Variant of the algorithm to use parameters Parameters of the algorithm Returns -------------- dfg Directly-follows graph performance_dfg Performance DFG (containing the estimated performance for the arcs) """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(log, parameters=parameters)
def apply(log: Union[EventLog, pd.DataFrame], net: PetriNet, im: Marking, fm: Marking, variant=Variants.RECOMPOS_MAXIMAL, parameters: Optional[Dict[Any, Any]] = None) -> typing.ListAlignments: """ Apply the recomposition alignment approach to a log and a Petri net performing decomposition Parameters -------------- log Event log net Petri net im Initial marking fm Final marking variant Variant of the algorithm, possible values: - Variants.RECOMPOS_MAXIMAL parameters Parameters of the algorithm Returns -------------- aligned_traces For each trace, return its alignment """ return exec_utils.get_variant(variant).apply(log, net, im, fm, parameters=parameters)
def apply(log, net, initial_marking, final_marking, parameters=None, variant=DEFAULT_VARIANT): """ Method to apply token-based replay Parameters ----------- log Log net Petri net initial_marking Initial marking final_marking Final marking parameters Parameters of the algorithm, including: Parameters.ACTIVITY_KEY -> Activity key variant Variant of the algorithm to use: - Variants.TOKEN_REPLAY - Variants.BACKWARDS """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(log_converter.apply(log, parameters, log_converter.TO_EVENT_LOG), net, initial_marking, final_marking, parameters=parameters)
def apply( log: Union[pd.DataFrame, EventLog, EventStream], variant=Variants.DATAFRAME, parameters: Optional[Dict[Any, Any]] = None ) -> Dict[Tuple[str, str], Dict[str, Any]]: """ Performs the network analysis on the provided event log Parameters ---------------- log Event log parameters Version-specific parameters Returns ---------------- network_analysis Edges of the network analysis (first key: edge; second key: type; value: number of occurrences) """ return exec_utils.get_variant(variant).apply(log_converter.apply( log, variant=log_converter.Variants.TO_DATA_FRAME, parameters=parameters), parameters=parameters)
def get_diagnostics_dataframe(log, tbr_output, variant=DEFAULT_VARIANT, parameters=None): """ Gets the results of token-based replay in a dataframe Parameters -------------- log Event log tbr_output Output of the token-based replay technique variant Variant of the algorithm to use: - Variants.TOKEN_REPLAY - Variants.BACKWARDS Returns -------------- dataframe Diagnostics dataframe """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).get_diagnostics_dataframe( log, tbr_output, parameters=parameters)
def apply(dfg, log=None, activities_count=None, parameters=None, variant=DEFAULT_VARIANT): return exec_utils.get_variant(variant).apply( dfg, log=log, activities_count=activities_count, parameters=parameters)
def apply_dfg(dfg, parameters=None, variant=ALPHA_VERSION_CLASSIC): """ Apply Alpha Miner directly on top of a DFG graph Parameters ----------- dfg Directly-Follows graph variant Variant of the algorithm to use (classic) parameters Possible parameters of the algorithm, including: activity key -> Name of the attribute that contains the activity Returns ----------- net Petri net marking Initial marking final_marking Final marking """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply_dfg(dfg, parameters)
def import_log(path, parameters=None, variant=DEFAULT_VARIANT_LOG): """ Import a Parquet file Parameters ------------- path Path of the file to import parameters Parameters of the algorithm, possible values: Parameters.COLUMNS -> columns to import from the Parquet file variant Variant of the algorithm, possible values: - Variants.PYARROW Returns ------------- df Pandas dataframe """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).import_log(path, parameters=parameters)
def apply(log, net, im, fm, variant=Variants.RECOMPOS_MAXIMAL, parameters=None): """ Apply the recomposition alignment approach to a log_skeleton and a Petri net performing decomposition Parameters -------------- log Event log_skeleton net Petri net im Initial marking fm Final marking variant Variant of the algorithm, possible values: - Variants.RECOMPOS_MAXIMAL parameters Parameters of the algorithm Returns -------------- aligned_traces For each trace, return its alignment """ return exec_utils.get_variant(variant).apply(log, net, im, fm, parameters=parameters)
def import_minimal_log(path, parameters=None, variant=DEFAULT_VARIANT_LOG): """ Import a Parquet file (as a minimal log with only the essential columns) Parameters ------------- path Path of the file to import parameters Parameters of the algorithm, possible values: Parameters.COLUMNS -> columns to import from the Parquet file variant Variant of the algorithm, possible values: - Variants.PYARROW Returns ------------- df Pandas dataframe """ if parameters is None: parameters = {} parameters[COLUMNS] = [ constants.CASE_CONCEPT_NAME, xes.DEFAULT_NAME_KEY, xes.DEFAULT_TIMESTAMP_KEY ] return exec_utils.get_variant(variant).import_log(path, parameters=parameters)
def apply(net, initial_marking, output_filename, final_marking=None, variant=PNML, parameters=None): """ Export a Petri net along with an initial marking (and possibly a final marking) to an output file Parameters ------------ net Petri net initial_marking Initial marking output_filename Output filename final_marking Final marking variant Variant of the algorithm, possible values: - Variants.PNML parameters Parameters of the exporter """ return exec_utils.get_variant(variant).export_net( net, initial_marking, output_filename, final_marking=final_marking, parameters=parameters)
def apply(clf, feature_names, classes, parameters=None, variant=DEFAULT_VARIANT): """ Method to apply the visualization of the decision tree Parameters ------------ clf Decision tree feature_names Names of the provided features classes Names of the target classes parameters Possible parameters of the algorithm, including: Parameters.FORMAT -> Image format (pdf, svg, png ...) variant Variant of the algorithm: - Variants.CLASSIC Returns ------------ gviz GraphViz object """ return exec_utils.get_variant(variant).apply(clf, feature_names, classes, parameters=parameters)
def apply( log1: EventLog, log2: EventLog, variant=Variants.EDIT_DISTANCE, parameters: Optional[Dict[str, Any]] = None) -> typing.ListAlignments: """ Aligns each trace of the first log against the second log Parameters -------------- log1 First log log2 Second log variant Variant of the algorithm, possible values: - Variants.EDIT_DISTANCE: minimizes the edit distance parameters Parameters of the algorithm Returns --------------- aligned_traces List that contains, for each trace of the first log, the corresponding alignment """ return exec_utils.get_variant(variant).apply(log1, log2, parameters=parameters)
def apply(net, initial_marking, final_marking=None, parameters=None, variant=DEFAULT_VARIANT): """ Do the playout of a Petrinet generating a log Parameters ----------- net Petri net to play-out initial_marking Initial marking of the Petri net final_marking (if provided) Final marking of the Petri net parameters Parameters of the algorithm: Parameters.NO_TRACES -> Number of traces of the log to generate Parameters.MAX_TRACE_LENGTH -> Maximum trace length variant Variant of the algorithm to use: - Variants.BASIC_PLAYOUT """ return exec_utils.get_variant(variant).apply(net, initial_marking, final_marking=final_marking, parameters=parameters)
def apply_dfg(dfg, parameters=None, variant=DEFAULT_VARIANT_DFG): """ Apply the chosen IM algorithm to a DFG graph obtaining a Petri net along with an initial and final marking Parameters ----------- dfg Directly-Follows graph variant Variant of the algorithm to apply, possible values: - Variants.IMd parameters Parameters of the algorithm, including: Parameters.ACTIVITY_KEY -> attribute of the log to use as activity name (default concept:name) Returns ----------- net Petri net initial_marking Initial marking final_marking Final marking """ return exec_utils.get_variant(variant).apply_dfg(dfg, parameters=parameters)
def apply(net, initial_marking, final_marking=None, parameters=None, variant=DEFAULT_VARIANT): """ Do the playout of a Petrinet generating a log_skeleton Parameters ----------- net Petri net to play-out initial_marking Initial marking of the Petri net final_marking (if provided) Final marking of the Petri net parameters Parameters of the algorithm variant Variant of the algorithm to use: - Variants.BASIC_PLAYOUT: selects random traces from the model, without looking at the frequency of the transitions - Variants.STOCHASTIC_PLAYOUT: selects random traces from the model, looking at the stochastic frequency of the transitions. Requires the provision of the stochastic map or the log_skeleton. - Variants.EXTENSIVE: gets all the traces from the model. can be expensive """ return exec_utils.get_variant(variant).apply(net, initial_marking, final_marking=final_marking, parameters=parameters)
def apply( log: Union[EventLog, pd.DataFrame, EventStream], variant: Any = Variants.TRACE_BASED, parameters: Optional[Dict[Any, Any]] = None) -> Tuple[Any, List[str]]: """ Extracts the features from a log object Parameters --------------- log Event log variant Variant of the feature extraction to use: - Variants.EVENT_BASED => (default) extracts, for each trace, a list of numerical vectors containing for each event the corresponding features - Variants.TRACE_BASED => extracts for each trace a single numerical vector containing the features of the trace Returns --------------- data Data to provide for decision tree learning feature_names Names of the features, in order """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(log, parameters=parameters)
def apply_semilogx(x, y, parameters=None, variant=DEFAULT_VARIANT): """ Method to plot (semi-logarithmic way) the graph with axis values contained in x and y Parameters ------------ x Values for x-axis y Values for y-axis parameters Parameters of the algorithm, including: Parameters.FORMAT -> Format of the target image Parameters.TITLE -> Title of the image variant Variant of the algorithm to apply, including: - Variants.CASES - Variants.ATTRIBUTES - Variants.DATES Returns ------------ temp_file_name Representation temporary file name """ return exec_utils.get_variant(variant).apply_semilogx(x, y, parameters=parameters)
def apply(file_path: str, objects_path: str = None, variant=Variants.PANDAS, parameters: Optional[Dict[Any, Any]] = None) -> OCEL: """ Imports an object-centric event log from a CSV file Parameters ----------------- file_path Path to the object-centric event log objects_path Optional path to a CSV file containing the objects dataframe variant Variant of the algorithm that should be used, possible values: - Variants.PANDAS parameters Parameters of the algorithm Returns ------------------ ocel Object-centric event log """ return exec_utils.get_variant(variant).apply(file_path, objects_path, parameters)
def build(net: PetriNet, im: Marking, fm: Marking, variant=Variants.CLASSIC, parameters: Optional[Dict[Any, Any]] = None) -> Any: """ Builds the marking equation out of a Petri net Parameters --------------- net Petri net im Initial marking fm Final marking variant Variant of the algorithm to use, possible values: - Variants.CLASSIC parameters Parameters of the algorithm, including: - Parameters.CASE_ID_KEY => attribute to use as case identifier - Parameters.ACTIVITY_KEY => attribute to use as activity - Parameters.COSTS => (if provided) the cost function (otherwise the default cost function is applied) - Parameters.INCIDENCE_MATRIX => (if provided) the incidence matrix of the Petri net - Parameters.A => (if provided) the A numpy matrix of the incidence matrix - Parameters.FULL_BOOTSTRAP_REQUIRED => The preset/postset of places/transitions need to be inserted """ return exec_utils.get_variant(variant).build(net, im, fm, parameters=parameters)
def apply(log: Union[EventLog, EventStream, pd.DataFrame], variant=Variants.CLASSIC, parameters: Optional[Dict[Any, Any]] = None) -> pd.DataFrame: """ Applies a link analysis algorithm on the provided log object. Parameters ----------------- log Event log variant Variant of the algorithm to consider parameters Variant-specific parameters Returns ----------------- link_analysis_dataframe Link analysis dataframe """ if parameters is None: parameters = {} return exec_utils.get_variant(variant).apply(converter.apply( log, variant=converter.Variants.TO_DATA_FRAME, parameters=parameters), parameters=parameters)
def apply(tree, parameters=None, variant=Variants.TO_PETRI_NET): """ Method for converting from Process Tree to Petri net Parameters ----------- tree Process tree parameters Parameters of the algorithm variant Chosen variant of the algorithm: - Variants.TO_PETRI_NET - Variants.TO_PETRI_NET_TRANSITION_BORDERED Returns ----------- net Petri net initial_marking Initial marking final_marking Final marking """ return exec_utils.get_variant(variant).apply(tree, parameters=parameters)