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)
