Ebi analyse all-traces
Ebi analyse all-traces
Short alias: Ebi ana all.
List all traces of a stohastic model. Models containing loops and unbounded models are not supported and the computation will run forever.
Parameters:
| <FILE> |
Any object with deterministic stochastic semantics.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
- slang (finite stochastic language)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
- finite stochastic language (.slang)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_all_traces.
Ebi analyse completeness
Ebi analyse completeness
Short alias: Ebi ana comp.
Estimate the completeness of an event log using species discovery.
More information is available in the
PDF manual.
Parameters:
| <FILE> |
An event log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_completeness.
Ebi analyse coverage
Ebi analyse coverage
Short alias: Ebi ana cov.
Find the most-likely traces that together cover the given minimum probability.
Will return a finite stochastic language with the extracted traces.
The computation may not terminate if the model has non-decreasing livelocks, or if the model is unbounded and this unboundedness can be triggered using silent transitions, or if the model has livelocks.
Parameters:
| <FILE> |
Any object with deterministic stochastic semantics.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <MINIMUM_COVERAGE> |
The minimum probability that a trace should have to be included.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
- slang (finite stochastic language)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
- finite stochastic language (.slang)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_coverage.
Ebi analyse directly-follows-edge-difference
Ebi analyse directly-follows-edge-difference
Short alias: Ebi ana dfgedi.
The number of edges that differ between two directly follows graphs.
Parameters:
| <DFG_1> |
A directly follows graph.
Accepted values:- directly follows graph (.dfg)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <DFG_2> |
A directly follows graph.
Accepted values:- directly follows graph (.dfg)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_directly_follows_edge_difference.
Ebi analyse medoid
Ebi analyse medoid
Short alias: Ebi ana med.
Find the traces with the lowest average normalised Levenshtein distance to the other traces.
If there are more than one such trace, an arbitrary one is returned.
Parameters:
| <FILE> |
Any object with a finite stochastic language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
The number of traces that should be extracted.
Accepted values:
Mandatory: no. If no value is provided, a default of 1 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_medoid.
Ebi analyse minimum-probability-traces
Ebi analyse minimum-probability-traces
Short alias: Ebi ana minprob.
Find all traces that have a given minimum probability.
Will return a finate stochastic language with the extracted traces.
Will return an error if there are no such traces.
The computation may not terminate if the model is unbounded and this unboundedness can be triggered using silent transitions.
Parameters:
| <FILE> |
Any object with deterministic stochastic semantics.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <MINIMUM_PROBABILITY> |
The minimum probability that a trace should have to be included.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
- slang (finite stochastic language)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
- finite stochastic language (.slang)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_minimum_probability_traces.
Ebi analyse mode
Ebi analyse mode
Find the trace with the highest probability.
If there is more than one trace with the highest probability, an arbitrary choice is made which one to return.
The computation may run forever if the model is unbounded.
Equivalent to `Ebi evaluate mostlikely 1`.
Computation is more efficient for a model with a finite stochastic language.
Parameters:
| <FILE> |
Any object with deterministic stochastic semantics.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
- slang (finite stochastic language)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
- finite stochastic language (.slang)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_mode.
Ebi analyse most-likely-traces
Ebi analyse most-likely-traces
Short alias: Ebi ana mostlikely.
Find the given number of traces with the highest probabilities.
If there are more than one trace with the same probability, an arbitrary choice is made which one to return.
The computation may run forever if the model is unbounded.
Computation is more efficient for an object with a finite stochastic language.
Parameters:
| <FILE> |
Any object with deterministic stochastic semantics.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
The number of traces that should be extracted.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
- slang (finite stochastic language)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
- finite stochastic language (.slang)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_most_likely_traces.
Ebi analyse variety
Ebi analyse variety
Short alias: Ebi ana var.
Compute the variety of a stochastic language. That is, the average distance between two arbitrary traces in the language.
Parameters:
| <FILE> |
An event log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_variety.
Ebi analyse-non-stochastic activities
Ebi analyse-non-stochastic activities
Short alias: Ebi anans act.
Shows the activities that are declared in the object.
Parameters:
| <FILE> |
Any object with activities.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- language of alignments (.ali)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic language of alignments (.sali)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_activities.
Ebi analyse-non-stochastic any-traces
Ebi analyse-non-stochastic any-traces
Short alias: Ebi anans at.
Compute whether the model has any traces.
Reasons for a model not to have any traces could be if the initial state is part of a livelock, or if there is no initial state.
'true' means that the model has traces, 'false' means that the model has no traces.
The computation may not terminate if the model is unbounded.
Parameters:
| <MODEL> |
The model.
Accepted values:- Petri net markup language (.pnml)
- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- labelled Petri net (.lpn)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The boolean file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of boolean (.bool).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_any_traces.
Ebi analyse-non-stochastic bounded
Ebi analyse-non-stochastic bounded
Short alias: Ebi anans bnd.
Compute whether the model has a bounded state space.
For Petri nets, a coverability graph is computed~\cite{esparza2019petri}.
For other types of models, `true' is returned.
Parameters:
| <MODEL> |
The model.
Accepted values:- Petri net markup language (.pnml)
- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- labelled Petri net (.lpn)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The boolean file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of boolean (.bool).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_bounded.
Ebi analyse-non-stochastic cluster
Ebi analyse-non-stochastic cluster
Short alias: Ebi anans clus.
Apply k-medoid clustering: group the traces into a given number of clusters, such that the average distance of each trace to its closest medoid is minimal. The computation is random and does not take into account how often each trace occurs.
More information is available in the
PDF manual.
Parameters:
| <LANGUAGE> |
The finite stochastic language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_CLUSTERS> |
The number of clusters.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_cluster.
Ebi analyse-non-stochastic executions
Ebi analyse-non-stochastic executions
Short alias: Ebi anans exe.
Compute executions.
NB 1: the model must be able to terminate and its states must be bounded.
NB 2: the search performed is not optimised. For Petri nets, the ProM implementation may be more efficient.
Parameters:
| <LOG> |
The event log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)*
- compressed event log (.xes.gz)
- extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <MODEL> |
The model.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The executions (.exs) file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of executions (.exs).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_executions.
Ebi analyse-non-stochastic infinitely-many-traces
Ebi analyse-non-stochastic infinitely-many-traces
Short alias: Ebi anans inft.
Compute whether the model has infinitely many traces. The computation may not terminate if the model is unbounded.
Parameters:
| <MODEL> |
The model.
Accepted values:- Petri net markup language (.pnml)
- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- labelled Petri net (.lpn)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The boolean file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of boolean (.bool).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_infinitely_many_traces.
Ebi analyse-non-stochastic medoid
Ebi analyse-non-stochastic medoid
Short alias: Ebi anans med.
Find the traces with the lowest average normalised Levenshtein distance to the other traces; ties are resolved arbritrarily. The computation is random and does not take into account how often each trace occurs.
Parameters:
| <FILE> |
The finite stochastic language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
The number of traces that should be extracted.
Accepted values:
Mandatory: no. If no value is provided, a default of 1 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function analyse_non_stochastic_medoid.
Ebi association all-trace-attributes
Ebi association all-trace-attributes
Short alias: Ebi asso atts.
Compute the association between the process and trace attributes.
More information is available in the
PDF manual.
Parameters:
| <FILE> |
The event log for which association is to be computed.
Accepted values:- compressed event log (.xes.gz)
- extensible event stream (.xes)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <SAMPLES> |
The number of samples taken.
Accepted values:
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function association_all_trace_attributes.
Ebi association trace-attribute
Ebi association trace-attribute
Short alias: Ebi asso att.
Compute the association between the process and a trace attribute.
More information is available in the
PDF manual.
Parameters:
| <FILE> |
The event log for which association is to be computed.
Accepted values:- compressed event log (.xes.gz)
- extensible event stream (.xes)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <ATTRIBUTE> |
The trace attribute for which association is to be computed the trace attributes of a log can be found using ebi info.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <SAMPLES> |
The number of samples.
Accepted values:
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The root file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of containsroot (.croot).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function association_trace_attribute.
Ebi conformance chi-squared
Ebi conformance chi-squared
Short alias: Ebi conf cssc.
Compute chi-square stochastic conformance.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language log to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A queriable stochastic language model to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_chi_squared.
Ebi conformance chi-squared-sample
Ebi conformance chi-squared-sample
Short alias: Ebi conf cssc-sample.
Compute chi-square stochastic conformance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `cssc`.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
Number of traces to sample.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_chi_squared_sample.
Ebi conformance earth-movers
Ebi conformance earth-movers
Short alias: Ebi conf emsc.
Compute Earth mover's stochastic conformance, which is 1 - the Wasserstein distance.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language to compare may be partially ordered.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A finite stochastic language to compare may be partially ordered.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_earth_movers.
Ebi conformance earth-movers-sample
Ebi conformance earth-movers-sample
Short alias: Ebi conf emsc-sample.
Compute Earth mover's stochastic conformance, which is 1 - the Wasserstein distance, where one or both of the inputs needs to be sampled. If both inputs are logs or finite stochastic languages, then use `emsc`.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A stochastic language log or model to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A stochastic language log or model to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
Number of traces to sample.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_earth_movers_sample.
Ebi conformance entropic-relevance
Ebi conformance entropic-relevance
Short alias: Ebi conf er.
Compute entropic relevance (uniform).
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language log to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A queriable stochastic language model to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The logarithm file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of logdiv (.logdiv).
| |
This command is available in the ebi-pm Python package using the function conformance_entropic_relevance.
Ebi conformance hellinger
Ebi conformance hellinger
Short alias: Ebi conf hsc.
Compute Hellinger stochastic conformance, which is 1 - the Hellinger distance.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language log to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A queriable stochastic language model to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_hellinger.
Ebi conformance hellinger-sample
Ebi conformance hellinger-sample
Short alias: Ebi conf hsc-sample.
Compute Hellinger stochastic conformance, which is 1 - the Hellinger distance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `hsc`.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
Number of traces to sample.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_hellinger_sample.
Ebi conformance jensen-shannon
Ebi conformance jensen-shannon
Short alias: Ebi conf jssc.
Compute Jensen-Shannon stochastic conformance, which is 1 - the Jensen-Shannon distance.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A queriable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The rootlog file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of rootlogdiv (.rldiv).
| |
This command is available in the ebi-pm Python package using the function conformance_jensen_shannon.
Ebi conformance jensen-shannon-sample
Ebi conformance jensen-shannon-sample
Short alias: Ebi conf jssc-sample.
Compute Jensen-Shannon stochastic conformance, which is 1 - the Jensen-Shannon distance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `jssc`.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
Number of traces to sample.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The rootlog file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of rootlogdiv (.rldiv).
| |
This command is available in the ebi-pm Python package using the function conformance_jensen_shannon_sample.
Ebi conformance markovian
Ebi conformance markovian
Short alias: Ebi conf ma.
Compute the conformance between two stochastic languages using a stochastic Markovian abstraction, which represents languages based on the expected frequency of subtraces to handle partially matching traces.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language or a stochastic labelled petri net log to compare an s l p n must be livelock free and bounded.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A finite stochastic language or a stochastic labelled petri net model to compare an s l p n must be livelock free and bounded.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <K_ORDER> |
The order of the markovian abstraction length of subtraces.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <MEASURE> |
The stochastic conformance measure to be applied to the abstractions.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_markovian.
Ebi conformance unit-earth-movers
Ebi conformance unit-earth-movers
Short alias: Ebi conf uemsc.
Compute unit-earth movers' stochastic conformance, which is 1 - the total variation distance.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language log to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A queriable stochastic language model to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_unit_earth_movers.
Ebi conformance unit-earth-movers-sample
Ebi conformance unit-earth-movers-sample
Short alias: Ebi conf uemsc-sample.
Compute unit-earth movers' stochastic conformance, which is 1 - the total variation distance, if both inputs need to be sampled. If one input is a log or a finite stochastic language, then use `uemsc`.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A sampleable stochastic language to compare.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
Number of traces to sample.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
This command is available in the ebi-pm Python package using the function conformance_unit_earth_movers_sample.
Ebi conformance-non-stochastic alignments
Ebi conformance-non-stochastic alignments
Short alias: Ebi confns ali.
Compute alignments.
The model must be able to terminate and its states must be bounded. The search performed is not optimised. For Petri nets, the ProM implementation may be more efficient.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
The finite stochastic language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
The model.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - ali (language of alignments)
- sali (stochastic language of alignments)
Mandatory: no. If no value is provided, the default of sali (stochastic language of alignments) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - language of alignments (.ali)
- stochastic language of alignments (.sali)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sali stochastic language of alignments (.sali).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_alignments.
Ebi conformance-non-stochastic escaping-edges-precision
Ebi conformance-non-stochastic escaping-edges-precision
Short alias: Ebi confns eep.
Computes a prefix automaton of the alignments, where the states represent model states that have been visited by the alignments. The states are weighed by the probability of traces visiting them. The precision is then the sum of the number of taken edges out of each state multiplied by the weight of the state, divided by the sum of the number of outgoing edges multiplied by the weight of the states.
More information is available in the
PDF manual.
Parameters:
| <ALIGNMENTS> |
The alignments.
Accepted values:- stochastic language of alignments (.sali)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <MODEL> |
The model from which the alignments were computed.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_escaping_edges_precision.
Ebi conformance-non-stochastic set-alignments
Ebi conformance-non-stochastic set-alignments
Short alias: Ebi confns setali.
Compute a non-weighted set of alignments.
The model must be able to terminate and its states must be bounded. The search performed is not optimised. For Petri nets, the ProM implementation may be more efficient.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
The finite language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
The model.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The language of alignments (.ali) file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of language of alignments (.ali).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_set_alignments.
Ebi conformance-non-stochastic trace-fitness
Ebi conformance-non-stochastic trace-fitness
Short alias: Ebi confns tfit.
Compute the trace-fitness of a stochastic language of alignments: the number of synchronous moves divided by the total number of moves, both without silent moves.
Parameters:
| <ALIGNMENTS> |
The stochastic language of alignments.
Accepted values:- stochastic language of alignments (.sali)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function conformance_non_stochastic_trace_fitness.
Ebi convert business-process-model-and-notation
Ebi convert business-process-model-and-notation
Short alias: Ebi conv bpmn.
Convert an object to a Business Process Model and Notation.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted.
Accepted values:- Petri net markup language (.pnml)*
- business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)*
- directly follows graph (.dfg)*
- directly follows model (.dfm)*
- labelled Petri net (.lpn)*
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)*
- stochastic directly follows model (.sdfm)*
- stochastic labelled Petri net (.slpn)*
- stochastic non-deterministic finite automaton (.snfa)*
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_business_process_model_and_notation.
Ebi convert finite-language
Ebi convert finite-language
Short alias: Ebi conv lang.
Convert an object to a finite language.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite language (.lang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
Mandatory: no. If no value is provided, the default of lang (finite language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lang finite language (.lang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_finite_language.
Ebi convert finite-stochastic-language
Ebi convert finite-stochastic-language
Short alias: Ebi conv slang.
Convert an object to a finite stochastic language.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
- slang (finite stochastic language)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
- finite stochastic language (.slang)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_finite_stochastic_language.
Ebi convert labelled-petri-net
Ebi convert labelled-petri-net
Short alias: Ebi conv lpn.
Convert an object to a labelled Petri net.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted.
Accepted values:- Petri net markup language (.pnml)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- labelled Petri net (.lpn)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of lpn (labelled Petri net) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is lpn labelled Petri net (.lpn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_labelled_petri_net.
Ebi convert log
Ebi convert log
Convert an object to an event log, considering only its traces.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - csv (comma-separated values)
- xes.gz (compressed event log)
- dfa (deterministic finite automaton)
- xes (extensible event stream)
- lang (finite language)
- slang (finite stochastic language)
- pel (Python event log)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- Python event log (.pel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_log.
Ebi convert stochastic-deterministic-finite-automaton
Ebi convert stochastic-deterministic-finite-automaton
Short alias: Ebi conv sdfa.
Convert an object to a stochastic deterministic finite automaton.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- sdfa (stochastic deterministic finite automaton)
- slpn (stochastic labelled Petri net)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of sdfa (stochastic deterministic finite automaton) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic deterministic finite automaton (.sdfa)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sdfa stochastic deterministic finite automaton (.sdfa).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_stochastic_deterministic_finite_automaton.
Ebi convert stochastic-labelled-petri-net
Ebi convert stochastic-labelled-petri-net
Short alias: Ebi conv slpn.
Convert an object to a stochastic labelled Petri net.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted.
Accepted values:- directly follows graph (.dfg)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_stochastic_labelled_petri_net.
Ebi convert stochastic-nondeterministic-finite-automaton
Ebi convert stochastic-nondeterministic-finite-automaton
Short alias: Ebi conv snfa.
Convert an object to a stochastic nondeterministic finite automaton.
Parameters:
| <FILE> |
Any file supported by ebi that can be converted an s l p n must be livelock free and bounded.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- slpn (stochastic labelled Petri net)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of snfa (stochastic non-deterministic finite automaton) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is snfa stochastic non-deterministic finite automaton (.snfa).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function convert_stochastic_nondeterministic_finite_automaton.
Ebi discover alignments stochastic-business-process-model-and-notation
Ebi discover alignments stochastic-business-process-model-and-notation
Short alias: Ebi disc ali sbpmn.
Give each transition a weight that matches the aligned occurrences of its label. The model must be livelock-free.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language log to get the occurrences from.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A business process model and notation with the control flow.
Accepted values:- Petri net markup language (.pnml)*
- business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)*
- directly follows graph (.dfg)*
- directly follows model (.dfm)*
- labelled Petri net (.lpn)*
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)*
- stochastic directly follows model (.sdfm)*
- stochastic labelled Petri net (.slpn)*
- stochastic non-deterministic finite automaton (.snfa)*
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_alignments_stochastic_business_process_model_and_notation.
Ebi discover alignments stochastic-labelled-Petri-nets
Ebi discover alignments stochastic-labelled-Petri-nets
Short alias: Ebi disc ali slpn.
Give each transition a weight that matches the aligned occurrences of its label. The model must be livelock-free.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language log to get the occurrences from.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A labelled petri net with the control flow.
Accepted values:- Petri net markup language (.pnml)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- labelled Petri net (.lpn)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_alignments_stochastic_labelled_petri_nets.
Ebi discover directly-follows-graph
Ebi discover directly-follows-graph
Short alias: Ebi disc dfg.
Discover a directly follows graph.
More information is available in the
PDF manual.
Parameters:
| <LANG> |
A finite stochastic language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <MIN_FITNESS> |
The minimum fraction of traces that should fit the resulting model.
Accepted values:
Mandatory: no. If no value is provided, a default of 1 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- dfg (directly follows graph)
- dfm (directly follows model)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- sdfm (stochastic directly follows model)
- slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of dfg (directly follows graph) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is dfg directly follows graph (.dfg).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_directly_follows_graph.
Ebi discover occurrence stochastic-business-process-model-and-notation
Ebi discover occurrence stochastic-business-process-model-and-notation
Short alias: Ebi disc occ sbpmn.
Give each sequence flow to a task a weight that matches the occurrences of its label; other sequence flows get a weight of 1.
More information is available in the
PDF manual.
Parameters:
| <LANG> |
A finite stochastic language log to get the occurrences from.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <BPMN> |
A business process model and notation model with the control flow.
Accepted values:- Petri net markup language (.pnml)*
- business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)*
- directly follows graph (.dfg)*
- directly follows model (.dfm)*
- labelled Petri net (.lpn)*
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)*
- stochastic directly follows model (.sdfm)*
- stochastic labelled Petri net (.slpn)*
- stochastic non-deterministic finite automaton (.snfa)*
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_occurrence_stochastic_business_process_model_and_notation.
Ebi discover occurrence stochastic-labelled-Petri-net
Ebi discover occurrence stochastic-labelled-Petri-net
Short alias: Ebi disc occ slpn.
Give each transition a weight that matches the occurrences of its label; silent transitions get a weight of 1.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
A finite stochastic language log to get the occurrences from.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
A labelled petri net with the control flow.
Accepted values:- Petri net markup language (.pnml)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- labelled Petri net (.lpn)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_occurrence_stochastic_labelled_petri_net.
Ebi discover occurrence stochastic-process-tree
Ebi discover occurrence stochastic-process-tree
Short alias: Ebi disc occ sptree.
Give each leaf a weight that matches the occurrences of its label; silent leaves get a weight of 1.
More information is available in the
PDF manual.
Parameters:
| <LANG> |
A finite stochastic language log to get the occurrences from.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <TREE> |
A process tree with the control flow.
Accepted values:- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- ptree (process tree)
- ptml (process tree markup language)
- svg (scalable vector graphics)
- snfa (stochastic non-deterministic finite automaton)
- sptree (stochastic process tree)
Mandatory: no. If no value is provided, the default of sptree (stochastic process tree) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- process tree (.ptree)
- process tree markup language (.ptml)
- scalable vector graphics (.svg)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sptree stochastic process tree (.sptree).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_occurrence_stochastic_process_tree.
Ebi discover random stochastic-business-process-model-and-notation
Ebi discover random stochastic-business-process-model-and-notation
Short alias: Ebi disc rnd sbpmn.
Give each sequence flow a random weight between 0 (exclusive) and 1 (inclusive).
Parameters:
| <BPMN> |
A business process model and notation model with the control flow.
Accepted values:- Petri net markup language (.pnml)*
- business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)*
- directly follows graph (.dfg)*
- directly follows model (.dfm)*
- labelled Petri net (.lpn)*
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)*
- stochastic directly follows model (.sdfm)*
- stochastic labelled Petri net (.slpn)*
- stochastic non-deterministic finite automaton (.snfa)*
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_random_stochastic_business_process_model_and_notation.
Ebi discover random stochastic-labelled-Petri-net
Ebi discover random stochastic-labelled-Petri-net
Short alias: Ebi disc rnd slpn.
Give each transition a random weight between 0 (exclusive) and 1 (inclusive).
Parameters:
| <LPN> |
A labelled petri net.
Accepted values:- Petri net markup language (.pnml)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- labelled Petri net (.lpn)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_random_stochastic_labelled_petri_net.
Ebi discover random stochastic-process-tree
Ebi discover random stochastic-process-tree
Short alias: Ebi disc rnd sptree.
Give each leaf a random weight between 0 (exclusive) and 1 (inclusive).
Parameters:
| <TREE> |
A process tree.
Accepted values:- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- ptree (process tree)
- ptml (process tree markup language)
- svg (scalable vector graphics)
- snfa (stochastic non-deterministic finite automaton)
- sptree (stochastic process tree)
Mandatory: no. If no value is provided, the default of sptree (stochastic process tree) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- process tree (.ptree)
- process tree markup language (.ptml)
- scalable vector graphics (.svg)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sptree stochastic process tree (.sptree).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_random_stochastic_process_tree.
Ebi discover uniform stochastic-business-process-model-and-notation
Ebi discover uniform stochastic-business-process-model-and-notation
Short alias: Ebi disc uni sbpmn.
Give each sequence flow a weight of 1.
Parameters:
| <BPMN> |
A business process model and notation model.
Accepted values:- Petri net markup language (.pnml)*
- business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)*
- directly follows graph (.dfg)*
- directly follows model (.dfm)*
- labelled Petri net (.lpn)*
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)*
- stochastic directly follows model (.sdfm)*
- stochastic labelled Petri net (.slpn)*
- stochastic non-deterministic finite automaton (.snfa)*
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- sbpmn (stochastic business process model and notation)
Mandatory: no. If no value is provided, the default of bpmn (business process model and notation) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- stochastic business process model and notation (.sbpmn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is bpmn business process model and notation (.bpmn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_uniform_stochastic_business_process_model_and_notation.
Ebi discover uniform stochastic-labelled-Petri-net
Ebi discover uniform stochastic-labelled-Petri-net
Short alias: Ebi disc uni slpn.
Give each transition a weight of 1.
Parameters:
| <LPN> |
A labelled petri net.
Accepted values:- Petri net markup language (.pnml)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- labelled Petri net (.lpn)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
- slpn (stochastic labelled Petri net)
Mandatory: no. If no value is provided, the default of slpn (stochastic labelled Petri net) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
- stochastic labelled Petri net (.slpn)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slpn stochastic labelled Petri net (.slpn).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_uniform_stochastic_labelled_petri_net.
Ebi discover uniform stochastic-process-tree
Ebi discover uniform stochastic-process-tree
Short alias: Ebi disc uni sptree.
Give each leaf a weight of 1 in a process tree.
Parameters:
| <TREE> |
A process tree.
Accepted values:- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- ptree (process tree)
- ptml (process tree markup language)
- svg (scalable vector graphics)
- snfa (stochastic non-deterministic finite automaton)
- sptree (stochastic process tree)
Mandatory: no. If no value is provided, the default of sptree (stochastic process tree) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- process tree (.ptree)
- process tree markup language (.ptml)
- scalable vector graphics (.svg)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is sptree stochastic process tree (.sptree).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_uniform_stochastic_process_tree.
Ebi discover-non-stochastic flower deterministic-finite-automaton
Ebi discover-non-stochastic flower deterministic-finite-automaton
Short alias: Ebi dins flw dfa.
Discover a DFA that supports any trace with the activities of the log.
Parameters:
| <FILE> |
A file with activities.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- language of alignments (.ali)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic language of alignments (.sali)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of dfa (deterministic finite automaton) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is dfa deterministic finite automaton (.dfa).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_non_stochastic_flower_deterministic_finite_automaton.
Ebi discover-non-stochastic flower process-tree
Ebi discover-non-stochastic flower process-tree
Short alias: Ebi dins flw ptree.
Discover a process tree that supports any trace with the activities of the log.
Parameters:
| <FILE> |
A file with activities.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- language of alignments (.ali)
- object-centric event log (.ocel)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic language of alignments (.sali)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- ptree (process tree)
- ptml (process tree markup language)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of ptree (process tree) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- process tree (.ptree)
- process tree markup language (.ptml)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is ptree process tree (.ptree).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_non_stochastic_flower_process_tree.
Ebi discover-non-stochastic prefix-tree deterministic-finite-automaton
Ebi discover-non-stochastic prefix-tree deterministic-finite-automaton
Short alias: Ebi dins pfxt dfa.
Discover a DFA that is a prefix tree of the log.
Parameters:
| <LANG> |
A finite language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- dfa (deterministic finite automaton)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of dfa (deterministic finite automaton) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is dfa deterministic finite automaton (.dfa).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_non_stochastic_prefix_tree_deterministic_finite_automaton.
Ebi discover-non-stochastic prefix-tree process-tree
Ebi discover-non-stochastic prefix-tree process-tree
Short alias: Ebi dins pfxt ptree.
Discover a process tree that is a prefix tree of the log.
Parameters:
| <LANG> |
A finite language.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - bpmn (business process model and notation)
- lpn (labelled Petri net)
- lola (LoLa Petri net)
- pnml (Petri net markup language)
- pdf (portable document format)
- png (portable network graphics)
- ptree (process tree)
- ptml (process tree markup language)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of ptree (process tree) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - business process model and notation (.bpmn)
- labelled Petri net (.lpn)
- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- portable document format (.pdf)
- portable network graphics (.png)
- process tree (.ptree)
- process tree markup language (.ptml)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is ptree process tree (.ptree).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function discover_non_stochastic_prefix_tree_process_tree.
Ebi filter traces empty
Ebi filter traces empty
Remove empty traces.
Parameters:
| <event log> |
The log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)*
- compressed event log (.xes.gz)
- extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - csv (comma-separated values)
- xes.gz (compressed event log)
- dfa (deterministic finite automaton)
- xes (extensible event stream)
- lang (finite language)
- slang (finite stochastic language)
- pel (Python event log)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- Python event log (.pel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function filter_traces_empty.
Ebi filter traces event activity
Ebi filter traces event activity
Short alias: Ebi fil tr event act.
Remove traces that have event(s) as specified.
Parameters:
| <event log> |
The log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)*
- compressed event log (.xes.gz)
- extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <event selector> |
Which event s in the trace should be the activity.
Accepted values:- `all`
- `any`
- `end`
- `none`
- `start`
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <activity> |
The activity the filter targets.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - csv (comma-separated values)
- xes.gz (compressed event log)
- dfa (deterministic finite automaton)
- xes (extensible event stream)
- lang (finite language)
- slang (finite stochastic language)
- pel (Python event log)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- Python event log (.pel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function filter_traces_event_activity.
Ebi filter traces length
Ebi filter traces length
Short alias: Ebi fil tr len.
Remove traces that have a given length.
Parameters:
| <event log> |
The log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)*
- compressed event log (.xes.gz)
- extensible event stream (.xes)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <operator> |
The operator.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <value> |
The value.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - csv (comma-separated values)
- xes.gz (compressed event log)
- dfa (deterministic finite automaton)
- xes (extensible event stream)
- lang (finite language)
- slang (finite stochastic language)
- pel (Python event log)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- Python event log (.pel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function filter_traces_length.
Ebi information
Ebi information
Short alias: Ebi info.
Show information about a file.
Parameters:
| <FILE> |
Any file supported by ebi.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- executions (.exs)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- language of alignments (.ali)
- object-centric event log (.ocel)
- portable document format (.pdf)
- portable network graphics (.png)
- process tree (.ptree)
- process tree markup language (.ptml)
- scalable vector graphics (.svg)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic language of alignments (.sali)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function information.
Ebi probability explain-trace
Ebi probability explain-trace
Short alias: Ebi prob exptra.
Compute the most likely explanation of a trace given the stochastic model.
Parameters:
| <FILE> |
The model.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <VALUE> |
Balance between0 only consider deviations to1 only consider weight in the model.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <TRACE> |
The trace.
Mandatory: yes.
|
-o or --output <FILE> |
The language of alignments (.ali) file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of language of alignments (.ali).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
Ebi probability log
Ebi probability log
Compute the probability that a stochastic model produces any trace of a log.
More information is available in the
PDF manual.
Parameters:
| <FILE_1> |
The queriable stochastic language model.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE_2> |
The finite language log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function probability_log.
Ebi probability trace
Ebi probability trace
Short alias: Ebi prob trac.
Compute the probability of a trace in a stochastic model.
More information is available in the
PDF manual.
Parameters:
| <FILE> |
The queriable stochastic language model.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <TRACE> |
The remaining multiple standard arguments after FILE are interpreted as the TRACE. Provide event labels in trace order, separated as normal command line arguments (e.g., a space).
Mandatory: yes.
|
-o or --output <FILE> |
The fraction file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of fraction (.frac).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
Ebi sample folds
Ebi sample folds
Randomly but reproducibly split a log into a given number of sub-logs. Each trace has a likelihood of 1/folds to end up in any of the folds. Giving the same random seed yields the same split, as long as the same build number of Ebi is used.
For instance, one can perform k-fold cross validation: one would repeatedly apply the folds command with the same seed and the same number of folds, but vary the returned sub-logs.
Parameters:
| <LOG> |
The event log.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_FOLDS> |
The number of folds.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <SEED> |
The random seed.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <RETURN_FOLD> |
The fold to be returned.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - csv (comma-separated values)
- xes.gz (compressed event log)
- dfa (deterministic finite automaton)
- xes (extensible event stream)
- lang (finite language)
- slang (finite stochastic language)
- pel (Python event log)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of xes.gz (compressed event log) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- Python event log (.pel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is xes.gz compressed event log (.xes.gz).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function sample_folds.
Ebi sample partially-ordered-traces
Ebi sample partially-ordered-traces
Short alias: Ebi sam potr.
Sample traces randomly. Please note that this may run forever if the model contains a livelock.
Parameters:
| <MODEL> |
The model with partially ordered semantics to sample from.
Accepted values:- stochastic business process model and notation (.sbpmn)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
The number of traces to be sampled.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - spolang (finite stochastic partially ordered language)
- pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of spolang (finite stochastic partially ordered language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - finite stochastic partially ordered language (.spolang)
- portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is spolang finite stochastic partially ordered language (.spolang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function sample_partially_ordered_traces.
Ebi sample traces
Ebi sample traces
Short alias: Ebi sam tra.
Sample traces randomly. Please note that this may run forever if the model contains a livelock.
Parameters:
| <FILE> |
The stochastic semantics model.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- directly follows graph (.dfg)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <NUMBER_OF_TRACES> |
The number of traces to be sampled.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - dfa (deterministic finite automaton)
- lang (finite language)
- slang (finite stochastic language)
- sdfa (stochastic deterministic finite automaton)
- snfa (stochastic non-deterministic finite automaton)
Mandatory: no. If no value is provided, the default of slang (finite stochastic language) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - deterministic finite automaton (.dfa)
- finite language (.lang)
- finite stochastic language (.slang)
- stochastic deterministic finite automaton (.sdfa)
- stochastic non-deterministic finite automaton (.snfa)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is slang finite stochastic language (.slang).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function sample_traces.
Ebi test bootstrap-test
Ebi test bootstrap-test
Short alias: Ebi tst btst.
Test the hypothesis that the logs are derived from identical processes.
More information is available in the
PDF manual.
Parameters:
| <LANG_1> |
The first event log for which the test is to be performed.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <LANG_2> |
The second event log for which the test is to be performed.
Accepted values:- Python event log (.pel)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- extensible event stream (.xes)
- finite stochastic language (.slang)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <SAMPLES> |
The number of samples taken.
Accepted values:
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
| <P-VALUE> |
The threshold p value.
Accepted values:
Mandatory: no. If no value is provided, a default of 1/20 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function test_bootstrap_test.
Ebi test log-categorical-attribute
Ebi test log-categorical-attribute
Short alias: Ebi tst lcat.
Test the hypothesis that the sub-logs defined by the categorical attribute are derived from identical processes.
More information is available in the
PDF manual.
Parameters:
| <FILE> |
The event log for which the test is to be performed.
Accepted values:- compressed event log (.xes.gz)
- extensible event stream (.xes)
- object-centric event log (.ocel)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <ATTRIBUTE> |
The trace attribute for which the test is to be performed the trace attributes of a log can be found using ebi info.
Accepted values:
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <SAMPLES> |
The number of samples taken.
Accepted values:
Mandatory: no. If no value is provided, a default of 500 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
| <P-VALUE> |
The threshold p value.
Accepted values:
Mandatory: no. If no value is provided, a default of 1/20 will be used. It can also be provided on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function test_log_categorical_attribute.
Ebi validate
Ebi validate
Short alias: Ebi vali.
Attempt to parse any file supported by Ebi, and return a parsing error if necessary.
If you do not know the type the file should have, try `Ebi info`.
Parameters:
| <TYPE> |
The type for which parsing should be attempted.
Accepted values:- the file extension of any file type supported by Ebi (xes.gz, dfg, dfa, dfm, sdfm, exs, sbpmn, bpmn, ocel, xes, lang, slang, spolang, lpn, ali, lola, pnml, sdfa, slpn, ptree, sali, sptree, ptml, csv or snfa)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
| <FILE> |
The file to be parsed.
Mandatory: yes.
|
-o or --output <FILE> |
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
Ebi visualise graph
Ebi visualise graph
Visualise a file as a graph.
Parameters:
| <FILE> |
Any file that can be visualised as a graph.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- business process model and notation (.bpmn)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- process tree (.ptree)
- process tree markup language (.ptml)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-t or --output_type <OUTPUT_TYPE> |
The file format as which Ebi should write the result. To be given as the file extension without period. Possible values are: - pdf (portable document format)
- png (portable network graphics)
- svg (scalable vector graphics)
Mandatory: no. If no value is provided, the default of svg (scalable vector graphics) will be used.
|
-o or --output <FILE> |
The file to which the results must be written. Ebi will use the file extension to determine the output file format, which may be - portable document format (.pdf)
- portable network graphics (.png)
- scalable vector graphics (.svg)
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format specified by -t, which by default is svg scalable vector graphics (.svg).
| |
| -a or --approximate |
Use approximate arithmetic instead of exact arithmetic.
Mandatory: no. If not provided, exact arithmetic will be used. |
This command is available in the ebi-pm Python package using the function visualise_graph.
Ebi visualise text
Ebi visualise text
Short alias: Ebi vis txt.
Visualise a file as text.
Parameters:
| <FILE> |
Any file that can be visualised textually.
Accepted values:- LoLa Petri net (.lola)
- Petri net markup language (.pnml)
- Python event log (.pel)
- business process model and notation (.bpmn)
- comma-separated values (.csv)
- compressed event log (.xes.gz)
- deterministic finite automaton (.dfa)
- directly follows graph (.dfg)
- directly follows model (.dfm)
- executions (.exs)
- extensible event stream (.xes)
- finite language (.lang)
- finite stochastic language (.slang)
- finite stochastic partially ordered language (.spolang)
- labelled Petri net (.lpn)
- language of alignments (.ali)
- object-centric event log (.ocel)
- portable document format (.pdf)
- portable network graphics (.png)
- process tree (.ptree)
- process tree markup language (.ptml)
- scalable vector graphics (.svg)
- stochastic business process model and notation (.sbpmn)
- stochastic deterministic finite automaton (.sdfa)
- stochastic directly follows model (.sdfm)
- stochastic labelled Petri net (.slpn)
- stochastic language of alignments (.sali)
- stochastic non-deterministic finite automaton (.snfa)
- stochastic process tree (.sptree)
For some of these files, importer parameters are available.
Mandatory: yes, though it can be given on STDIN by giving a `-' on the command line.
|
-o or --output <FILE> |
The text file to which the result must be written.
Mandatory: no. If no value is provided, the result will be written to STDOUT in the file format of string (.txt).
| |
This command is available in the ebi-pm Python package using the function visualise_text.