Exploring Task Execution Patterns in Event Graphs

Abstract

-Classical process mining aims to capture the behavior of a process based on a single dimension: the sequence of activities grouped by process cases. This viewpoint fails to capture how individual actors are organizing their work across multiple cases. We present a tool that uses the graph database Neo4j to model actor behavior over different cases as an event graph. We then use Neo4j queries to detect task execution patterns in the graph describing how multiple actors collaborate across multiple cases. Exploring and visualizing these patterns enables the data driven analysis of tasks, routines, and habits as studied in organizations research.

I. INTRODUCTION

Process mining focuses on improving processes by analyzing event data. Classically, recorded events are grouped in an event log under the viewpoint of one (or more) case identifiers and ordered by time. The resulting event log describes which tasks were performed in which process execution viz. case. Process discovery identifies behavioral patterns and information along each case and aggregates them into a process model describing the control-flow perspective [ 1 ] of a process, which can consist of multiple data objects or entities [ 2 ].

Each task is performed by an actor (or resource) working on the case, which is studied under the resource-perspective of the process [ 1 ]. An actor moving from one task in a case to a task in another case introduces behavior along the resource perspective and dependencies between tasks of different cases. In [ 3 ] we showed that the control-flow and resourceperspective can be studied together as an event graph [ 2 ] where each event is part of two paths, a case path and a resource path, modeling event dependencies over two behavioral dimensions. One or more case and resource paths synchronizing form a task execution pattern which describes work habits of an actor or routines, i.e., how one or more actors collaborate over multiple cases.

In this paper, we present a command-line tool for analyzing such task execution patterns as described in [ 3 ]. The tool is realized in Python 3.7 and publicly available1. It connects to a Neo4j (neo4j.com) database instance to execute queries (1) for constructing an event graph over the case and resource dimension from a classical event log; (2) for detecting various forms of task execution patterns in the event graph and aggregating them to high-level events which can be queried, visualized, and explored using Neo4j. A screencast2 and a detailed instruction manual1 explain usage of the tool.

1https://github.com/multi-dimensional-process-mining/event-graph-task-p attern-detection 2https://vimeo.com/630382325

II. TASK EXECUTION PATTERN DETECTION The configurable end-to-end workflow is implemented in main.py and shown in Fig.1.

A. Input & Parameters

The input is a classical event log in CSV format. The CSV file must contain columns for the event classifier, timestamp, case identifier and resource identifier. The columns and details on the used CSV format need to be provided as parameters, e.g., its filename, column keys, column separator and the timestamp format used. We assume a Neo4j database has already been set up and the credentials are provided as parameters. The graph labels assigned for the entities and relationships can be customized if wanted.

B. Event Graph Creation

The tool creates the event graph in three steps: 1. Preprocessing. Preprocess the event data (PreprocessSelector.py) to make it suitable to import to a Neo4j Database instance by standardizing the name and formatting of the event classifier and timestamp column.

2. Initial Graph Creation. Invoke Cypher queries to construct an event graph (EventGraphConstructor.py) by limiting the original event graph construction approach [ 2 ] to the resource and case entities. In the resulting event graph, each event is an Event node that is part of two paths of directlyfollows edges: the path of all events correlated to the same case entity, and the path of all events correlated to the same resource entity. For event data over multiple case entities, a user can also choose to construct a custom event graph following the original approach [ 2 ] and may then skip step 1 and 2.

3. High Level Event Construction. Detect task execution

patterns in the event graph and materialize them in the graph as “high-level event” nodes (HighLevelEventConstructor.py). For the most basic pattern type, we query for sub-graphs of event nodes that are all part of the same case path and the same resource path (i.e., the resource works on the case over one or more consecutive events); sub-graphs of other pattern types [ 3 ] are found through variations of this query. For each found subgraph, we create a new HLEvent node linked to the events in the sub-graph. We lift the directly-follows edges from Event nodes to HLEvent nodes. This allows to query for larger task execution patterns as patterns of HLEvent nodes along case and resource directly-follows edges, see [ 3 ] for details.

Event data

Event graph construction

Event graph

Explore task execution patterns Explore process executions

Subgraph of task execution instance

Subgraph of process executions

C. Event Graph Exploration

Once the graph and HLEvents are constructed, the tool prompts the user to explore the graph for (1) task patterns of a particular type or (2) patterns occurring in a subset cases.

1. Exploring task execution patterns. In [ 3 ], several task pattern types have been identified and assigned numbers from

1 to 16. GraphExplorer.explore patterns() prompts the user to

specify which pattern type they wish to explore, e.g., type 4 in Fig. 2. It then returns a list of all distinct task execution patterns of this type ordered by frequency. The user can select a specific task pattern to explore further, which will return a list of all instances (sub-graphs) of that particular task pattern. The user can select to visualize a specific instance of the pattern, which is shown in a separate window as a PDF. Fig. 1 (top-right) shows an example of a task execution instance that shows pattern 8’, i.e., an actor performing the same sequence of steps for a number of cases one after the other. Other patterns such as resource interruptions (pattern 2, see [ 3 ]) and case interruptions (pattern 3, see [ 3 ]) can also be explored.

2. Exploring subsets of process executions. GraphEx

plorer.explore cases() lets the user specify the case identifiers for which they want to explore task execution patterns. The resulting subgraph of those process executions and task patterns is then output in a separate window in PDF as shown at the bottom right part of Fig. 1.

III. MATURITY & PERFORMANCE

The tool was successfully evaluated in [ 3 ], where it was used on two real-life event data sets (BPIC’14 and BPIC’17). These experiments were run on an Intel i7 CPU @ 2.2GHz machine with 32GB RAM. For the larger of the two data sets (BPIC’17, 237MB), the tool was able to construct all graph related constructs in 140 seconds and return lists of executions and instances of all pattern types in under 4 seconds. The subgraph visualizations are generally retrieved in under 2 seconds, but we have also seen various instances that take almost 60 seconds. The tool’s performance on this aspect highly depends on the complexity of the subgraph to be visualized. The preprocessing scripts and label settings for the graph output are easily adaptable. We provide example scripts for BPIC’14 and BPIC’17.

IV. CONCLUSION

We developed an open-source command-line tool for exploring task execution patterns in event graphs. In [ 3 ], we have shown that the exploration of specific execution patterns that include the behavioral dimensions of both cases and resources, can reveal a complex interplay of cases and actors engaging in recurrent patterns of work, i.e., routines and habits. This makes our tool applicable in any process mining use case where resource information is recorded. Future work is to extend the subgraph visualization feature for all task execution patterns introduced in [ 3 ]. Still, we covered a core set of patterns that occur in public datasets. Furthermore, we plan to build an interactive and graphical user interface to enable a seamless interaction with the tool.

References

[1] M. Dumas , M. L. Rosa , J. Mendling , and H. A. Reijers , Fundamentals of Business Process Management. Springer, 2 ed., 2018 .

[2] S. Esser and D. Fahland , “Multi-dimensional event data in graph databases , ” J. Data Semant. , vol. 10 , no. 1 , pp. 109 - 141 , 2021 .

[3] E. L. Klijn , F. Mannhardt , and D. Fahland , “ Classifying and detecting task executions and routines in processes using event graphs,” in BPM Forum 2021 , vol. 427 of LNBIP, pp. 212 - 229 , Springer, 2021 .