↑ Return to Platform

Standalone tools

This page counts 17 standalone distributions of the tools that are or will become plugins of Apromore.

  • BPMN Miner 2.0

    (by R. Conforti, A. Augusto, M. Dumas, L. Garcia-Baneulos and M. La Rosa)
    BPMN Miner is a tool for the automated discovery of maximally-structured, hierarchical BPMN models containing subprocesses, interrupting and non-interrupting boundary events and activity markers. The tool works on top of a range of flat process discovery algorithms: Heuristics Miner, InductiveMiner, Fodina, ILP Miner and the Alpha algorithm. It employs functional and inclusion dependency discovery techniques in order to elicit a process-subprocess hierarchy from the event log. It requires as input a log in the XES or MXML format, and produces a standard BPMN 2.0 model (.bpmn) as output. The tool will identify inclusion dependencies from the log, and ask the user to validate these dependencies before proceeding with the mining of the BPMN model. The identification of the inclusion dependencies in noise-tolerant. Moreover, the tool integrates Structured Miner, meaning that it returns a maximally structured BPMN 2.0 model by combining BPStruct and Extended Oulsnam Structurer (both used with default settings).

  • Business Process Clone Detector

    (by R. Uba, M. La Rosa, L. Garcia-Banuelos and M. Dumas)
    Business Process Clone Detector is a command-line tool for detecting duplicate fragments (a.k.a. clones) in repositories of process models. The tool works with a collection of EPC models as input (at least two models) and returns a DOT image for each identified clone. These images can be opened with ProM 5.2 (www.processmining.org). It is possible to choose the minimum size of a clone, which is 4 nodes by default.

    Source code (provided “as is”, under LPGL v3.0)

  • Infrequent Process Behavior Filter

    (by R. Conforti, M. La Rosa and A.H.M. ter Hofstede)
    The analysis of business process event logs can be negatively influenced by the presence of outliers, which reflect infrequent behavior or “noise”. In process discovery, where the objective is to automatically extract a process model from an event log, this may result in rarely travelled pathways that clutter the process model. The Infrequent Process Behavior Filter automatically filters out infrequent behavior while minimizing the number of events being removed from the log. The tool accepts as input an event log in XES or MXML format and provides a filtered log in output.

  • OptimizeKnockout

    (by I. Verenich, M. Dumas, M. La Rosa, F.M. Maggi and C. Di Francescomarino)
    OptimizeKnockout is a tool for finding an optimal ordering of check activities in a so-called “knockout section” of a business process in order to minimize overprocessing. Overprocessing waste occurs in a business process when effort is spent in a way that does not add value to the customer nor to the business. A recurrent overprocessing pattern in business processes happens in the context of “knockout checks”, i.e. activities that classify a case into “accepted” or “rejected”, such that if the case is accepted it proceeds forward, while if rejected, it is cancelled and all work performed in the case is considered unnecessary. Thus, when a knockout check rejects a case, the effort spent in other (previous) checks becomes overprocessing waste, according to the Lean classification. This tool implements a fine-grained approach to reorder knockout checks at runtime based on predictive machine learning models.

  • PNSA Algorithm

    (by M. Gambini, M. La Rosa, S. Migliorini and A. ter Hofstede)
    PNSA Algorithm is a command-line tool for automatically fixing unsound Workflow nets. The core procedure is a heuristic optimization algorithm inspired by the dominance-based Multi-Objective Simulated Annealing procedure. Given an Workflow nets and the output of its soundness check, at each run, the algorithm generates a small set of alternative models (“solutions”) similar to the original model but containing fewer or no behavioral errors, until a maximum number of desired solutions is found or a given timeframe elapses. These solutions are produced by applying a number of controlled changes on the current solution, which in turn is derived from the original model. The similarity of a solution to the original model is determined by its structural similarity and (to remain efficient) by an approximation of its behavioral similarity to the original model. Since the intentions of the process modeler are not known and there are usually many ways in which an error can be corrected, the algorithm returns several non-redundant final solutions (i.e. no solution is worse than any of the others). The differences between these solutions and the original model can then be presented to a process modeler as suggestions to rectify the behavioral errors in the original model.

  • Predictive Business Process Monitoring with LSTM

    (by N. Tax, I. Verenich, M. La Rosa and M. Dumas)
    This tool can be used to perform the following prediction tasks: i) prediction of the next type of activity to be executed in a running process instance; ii) prediction of the timestamp of the next type of activity to be executed; iii) prediction of the continuation of a running instance, i.e. its suffix; and iv) prediction of the remaining cycle time of an instance. The tool trains a Long Short Term Memory (LSTM)-based predictive model using  data about historical process instances. Next, the models are evaluated on running, i.e. incomplete instances. It assumes the input is a complete log of all traces in the CSV format wherein the first column is a case ID, then activity name or ID and finally the activity timestamp. Then, this input log is temporally split on 66% (training set) vs 34% (test set), and on the test set the tool evaluates prediction performance for every size of a partial trace, e.g a test trace cut at the 2nd event, the same trace cut at the 3rd event and so on, along all four prediction tasks.

  • Process Merger

    (by M. La Rosa, M. Dumas, R. Uba and R. Dijkman)
    Process Merger is a command-line tool for merging (C-)EPC process models into a C-EPC process model. This tool accepts two or more models in the EPML format (.epml) and merges them by creating a configurable process model in C-EPC. Nodes that belong to all input models are only taken once, and reconnected to all other nodes that are not in common by means of configurable XOR connectors. It is possible to select the matching algorithm (Greedy or Hungarian) used to determine the mapping between the nodes of the two input models, and to customize the matching thresholds for functions/events and for connectors. To compute the similarity between each pair of input models, the Process Merger tool embeds the Process Similarity tool, which is also available for download separately. Moreover, this tool can compute the digest of a merged model. The digest is a projection of a configurable model where only the nodes that satisfy a given occurrence frequency appear, e.g. all nodes that occur in at least three of the five input models, or all nodes that are in common to all input models. Placeholder nodes may be added to avoid disconnections in the resulting digest.

  • Process Similarity

    (by M. La Rosa, M. Dumas, R. Uba and R. Dijkman)
    Process Similarity is a command-line tool which computes the similarity between two (C-)EPC models based on graph-matching techniques. It is possible to choose the matching algorithm (Hungarian or Greedy) and configure the thresholds for model similarity, label similarity and connector similarity, and the weights for skipped nodes/edges and matched nodes/edges. The result is a value between 0 and 1 indicating the degree of similarity between the two input models.

  • ProConformance

    (by L. Garcia-Banuelos, N. van Beest, M. Dumas  and M. La Rosa)
    Given a process model and a process execution log, ProConformance provides a list of statements in natural language capturing behavior that is present or frequent in the model, while absent or infrequent in the log, and vice versa. This conformance analysis method allows users to diagnose differences between prescriptive process behavior (as captured in the process model) and deviant executions of a process as captured in the log, e.g. for compliance purposes. or between two versions or variants of a process. The model can be provided in BPMN and the log in the MXML or XES format.

  • ProDelta

    (by N. van Beest, M. Dumas, L. Garcia-Baneulos and M. La Rosa)
    Given two process execution logs, ProDelta provides a list of statements in natural language capturing behavior that is present or frequent in one log, while absent or infrequent in the other. This log delta analysis method allows users to diagnose differences between normal and deviant executions of a process or between two versions or variants of a process. The logs can be provided in the MXML or XES format.

  • ProDrift 2.3

    (by A. Maaradji, A. Ostovar, M. Dumas, M. La Rosa)
    ProDrift is a fully-automated tool for detecting and characterizing business process drifts. The tool accepts as input a process execution log in MXML or XES format, and performs statistical tests over a stream of runs or a stream of events, obtained by replaying the event log. ProDrift accepts an optional window size (specified as number of traces or events), as well as the possibility of using an adaptive window. If the latter option is chosen, ProDrift will adapt the window size in order to strike a trade-off between classification accuracy and drift detection delay. The output is a list of drifts, each with information on the location in the stream of traces (or events) where the drift occurred, and a list of behavioral relations that have been modified by the drift.

    Synthetic logs used in “Fast and Accurate Business Process Drift Detection”
    Synthetic logs used in “Detecting Drift from Event Streams of Unpredictable Business Processes”
    Source code (provided “as is”, under LPGL v3.0)

  • ProLoCon

    (by A. Armas Cervantes, M. Dumas and M. La Rosa)
    ProLoCon is a command line tool for the computation of local concurrency oracles out of event logs. Given an event log, the tool constructs a state space representing the behaviou captured in the log and identifies parts within such state space, referred to as scopes, where concurrency relations between pairs of events hold. The state space abstracts the behavior in the log as an acyclic transition graph, where every vertex in the graph denotes an execution state and every transition denotes an event occurrence. Then, a scope is a pair of vertices (execution states) where pairs of events can occur concurrently. The current version of the tool uses the Alpha algorithm for the computation of the concurrency relations between events. The input required for the tool is simply an event log in either XES or MXML format.

  • ProSeqPredict

    (by I. Verenich, D. Chasovskyi, M. Dumas, M. La Rosa, F. Maggi and A. Rozumnyi)
    ProSeqPredict is a tool to predict the most likely sequence of activities (trace suffix) that will be executed from a partial process instance (trace prefix), based on the information already available on the prefix as well as on the availability of past traces already executed, which are recorded in an event log. It requires as input an event log in CSV format and the length of the prefix to be used. The tool will predict the most likely suffix for each prefix of that length present in the log.

  • Slice Mine Dice (SMD) Process Miner

    (by C.C. Ekanayake, M. Dumas, L. Garcia-Baneulos and M. La Rosa)
    SMD is a tool for mining a collection of process models from a process log. This tool uses a combination of trace clustering and clone detection techniques to mine a process model collection where similar process sections are extracted as subprocesses. The tool requires as input a log, an existing trace clustering technique (different ones can be chosen) and a complexity threshold. The result is a hierarchical process model collection where the size of each process model is bounded by the threshold. As this tool can detect and extract common sections from discovered process models, the resulting process model collection has a smaller overall size and less number of process models compared to a collection of process models obtained with a trace clustering technique under the same complexity bound. Furthermore, identification and extraction of similar sections could facilitate better analysis of the generated process model collection.

  • Staged Process Flow Performance Analyzer

    (by H. Nguyen, A.H.M. ter Hofstede, M. Dumas, M. La Rosa, F.M Maggi)
    Existing process mining techniques provide summary views of the overall process performance over a period of time, allowing analysts to identify bottlenecks and associated performance issues. However, these tools are not designed to help analysts understand how bottlenecks form and dissolve over time nor how the formation and dissolution of bottlenecks – and associated fluctuations in demand and capacity – affect the overall process performance. Staged Process Flow (SPF) is a ProM plugin offering a number of visualizations that collectively allow process performance evolution to be analyzed from multiple perspectives. The idea underlying this tool is an abstraction of a business process as a series of queues corresponding to stages.

  • Staged Process Miner

    (by H. Nguyen, A.H.M. ter Hofstede, M. Dumas, M. La Rosa, F.M Maggi)
    Staged Process Miner (SPM) is a ProM plugin that takes as input an event log in XES or MXML format and returns a partitioning of this log into stages. The only parameter required is the minimum number of events for each stage. You can download the Staged Process Miner plugin directly from the ProM nightly build. Here we provide a standalone ProM distribution that includes the Staged Process Miner plugin, as well as the plugins implementing the two baseline techniques used in our paper for the evaluation, namely the Divide and Conquer framework (DC) and the Performance Analysis with Simple Precedence Diagram (SPD), which have been modified to export their output to file, and a plugin to visualize the output of these latter two techniques.

  • Structured Miner

    (by A. Augusto, R. Conforti, M. Dumas, M. La Rosa, G. Bruno)
    Structured Miner is a tool for mining maximally structured process models in BPMN from an event log. The approach works in two phases. The first phase discovers the BPMN process model from an input log using a baseline discovery algorithm which does not force the discovered model to be structured (currently, Heuristics Miner and Fodina Miner are supported). The second phase structures the discovered model combining BPStruct and Extended Oulsnam Structurer (both used with default settings). The event log can be in MXML or XES format. The discovered model, in BPMN 2.0, can be opened and visualized using different tools, e.g. Apromore. Structured Miner is also part of BPMN Miner 2.0. The difference between the two is that Structured Miner always discovers flat process models whereas BPMN Miner 2.0 discovers hierarchical process models with subprocesses.