Optimized Early Prediction of Business Processes with Hyperdimensional Computing

Abstract

There is a growing interest in the early prediction of outcomes in ongoing business processes. Predictive process monitoring distills knowledge from the sequence of event data generated and stored during the execution of processes and trains models on this knowledge to predict outcomes of ongoing processes. However, most state-of-the-art methods require the training of complex and inefficient machine learning models and hyper-parameter optimization as well as numerous input data to achieve high performance. In this paper, we present a novel approach based on Hyperdimensional Computing (HDC) for predicting the outcome of ongoing processes before their completion. We highlight its simplicity, efficiency, and high performance while utilizing only a subset of the input data, which helps in achieving a lower memory demand and faster and more effective corrective measures. We evaluate our proposed method on four publicly available datasets with a total of 12 binary prediction tasks. Our proposed method achieves an average 6% higher area under the ROC curve (AUC) and up to a 14% higher F1-score, while yielding a 20× earlier prediction than state-of-the-art conventional machine learning- and neural network-based models.

1. Introduction

A business process is a sequence of relevant events that involve a number of users and attributes that ultimately lead to a desirable outcome within a system [1]. Process mining is the field that aims to extract valuable insights about the behavior of processes by analyzing processes recorded in tabular data formats called event logs [1,2]. Process instances within an event log are also known as traces. Each trace comprises a non-empty sequence of chronological events (also known as control flow) and their corresponding attributes.

Recently, new techniques have been developed and used at run-time, i.e., during the execution of a process, for prediction and recommendation purposes before the process terminates [3]. Given an incomplete sequence of events, the desired prediction might include the probability of fulfilling a business constraint in terms of a logical rule within a time cycle [4], identifying the next event to be executed in the ongoing process [5], estimating the remaining time for process execution [6,7], or determining the event at which the process instance will terminate among the possible outcomes [8,9,10]. Predicting the outcome of incomplete traces is analogous to early sequence classification [11]. If an ongoing process is predicted to violate a predefined constraint or business rule, result in an undesirable outcome, or exceed the expected execution time, appropriate measures can be taken to mitigate adverse effects. For example, predicting the waiting time of a patient during the registration process can help in taking appropriate measures such as bypassing activities or allocating extra resources to expedite the registration process [12]. Another business example is the loan application process, wherein the process starts when an application is submitted and ultimately ends with a decision on whether the application is approved, rejected, or canceled. In this case the goal of the early prediction of the final decision is gaining optimized resource allocation and risk management in the early steps of the ongoing process. We are interested in early prediction, while actions can still be taken to prevent potential violations and correct the process’s direction at an early stage [13,14].

Many studies have sought to propose predictive process monitoring techniques for early prediction in incomplete process instances. Generally, a pair of “sequences of events in trace prefixes, events attributes” is taken as the input of a prediction model. These models are trained on feature vectors derived from historical traces and their associated labels and are used to predict the label of an ongoing trace from a predefined set of possible outcomes [1,15,16,17].

Amongst the most commonly used methods are gradient-boosted trees (XGBoost) [18,19], Random Forest (RF) [8], K-Nearest Neighbor (KNN) [9], Long Short-Term Memory (LSTM) [10,20,21], and att-Bi-LSTM [10]. Nevertheless, traditional machine learning methods do not consider the order of events in traces or store the patterns observed in sub-sequences of data. However, some methods, such as the index-based approaches in [22] or LSTM-based approaches [18] require the continuous updating of the feature vector length and reprocessing and training from scratch with the execution of every new event, making them computationally intensive. Neural network-based models require arduous hyper-parameter tuning, and a new model is needed when features are added or removed from the events, making them computationally inefficient. To increase the speed of training, data sampling methods have been proposed specially for large datasets [12]. But expensive and time-consuming calculations are required to choose the appropriate instances representing the whole dataset [21].

In this work, we focus on predicting the label of ongoing processes, which is referred to as outcome-oriented predictive process monitoring [1]. We introduce a novel approach based on Hyperdimensional Computing (HDC) [23] to the process mining community wherein, in addition to event attributes and control flow information, we incorporate patterns in sequences of events within traces. HDC encodes low-dimensional input data into high-dimensional representations called hypervectors [24]. The hypervectors preserve the distance of the original data in the high-dimensional space and enable learning tasks such as classification through simple operations. We use fixed-length feature vectors to store patterns and attribute information, supporting traces of arbitrary lengths. The encoding step is followed by training using element-wise operations on the hypervectors, where the hypervectors belonging to the same label (e.g., same outcome) are summed up (superimposed) together to generate their representative class hypervector. Inference involves encoding input data into a query hypervector and comparing it to a class of hypervectors using a similarity metric like the dot product or cosine distance. We train our proposed method with and without considering event attributes and show that our proposed methods outperform conventional ML-based and neural network-based methods including XGBoost [19] and LSTM [10,18] in terms of previous AUC values and F1-scores. Additionally, we illustrate that even using a random subset of the input data (without the need for compute-intensive data sampling in large datasets), our proposed method achieves a high performance. Our main contributions are as follows:

• We propose a novel method for process outcome prediction based on Hyperdimensional Computing. Unlike conventional approaches, our method utilizes fixed-length vectors to maintain event patterns and attributes, effectively preserving memory. Also, unlike previous methods that require iterative encoding and training for prediction at different indices, in our proposed method, we adopt a novel approach wherein, for the observation of a new event or attribute, we add its corresponding hypervector to the previously constructed hypervector. This eliminates the need to encode and train an ongoing process from scratch.
• Through eliminating traditional hyper-parameter tuning and incorporating a wise storage mechanism for subsets of trace prefixes, our proposed method enables the construction of a classifier on historical data using basic element-wise operations along vectors.
• Choosing event attributes that determine the class of a process requires domain knowledge, but such information is lacking in many datasets. Therefore, we designed two algorithm versions: one, HDC-based, considers only patterns and event order within processes, and the other, attribute-based HDC (Att-HDC), considers patterns within sequence of events, event order, and event attributes.
• The experimental results demonstrate the F1-score improving by up to 14% compared to the best baseline (XGBoost [19]) and AUC scores improving by an average of 6% in the key early process stages. This highlights the algorithm’s ability to provide more accurate predictions early on, without sacrificing runtime efficiency. Furthermore, we showcase our proposed method’s high performance when training on a randomly chosen subset of the input data, eliminating the need for compute-intensive sampling methods. Our proposed method yields a similar F1-score and AUC score with only a sampling ratio of 0.5 of the training data. Thus, we propose more accurate early prediction, eliminating the need for passing over the whole training data.

The rest of this paper is organized as follows: Section 2 presents the outcome-oriented predictive process monitoring and an overview of Hyperdimensional Computing. Related works are discussed in Section 3. Section 4 presents our HDC-based approach that integrates additional event pattern information for predicting the outcome of an ongoing business process. Section 5 evaluates the advantages of our proposed approach through experimental studies. Finally, Section 7 draws the conclusion and outlines future work.

2. Background

In this section, we first explore the key concepts and terminologies related to early outcome prediction in processes. Then, we introduce Hyperdimensional Computing.

2.1. Outcome-Oriented Predictive Process Monitoring

Definition: The goal of outcome-oriented predictive process monitoring is predicting, as early as possible, how an ongoing process instance will terminate based on the execution records of processes stored in event logs [1]. This information helps businesses in different areas such as risk mitigation and increasing performance in processes [3]. A trace in an event log is a sequence of chronological events. Each event has a unique identifier in a given event log and is associated with a timestamp that is later used to determine the order of events. An event’s features, also called event attributes, may include categorical and numerical data such as the associated resource, device, person, or the cost of the activity [25]. Each trace in an event log also has a unique trace identifier. Additionally, a trace can carry attributes related to the entire process instance.

Predictive Process Monitoring Framework: Within a trace, the sequence of events and their associated attributes are analogous to independent attributes in machine learning algorithms. The corresponding variable label (classes) can be any label from the set of possible outcomes. Trace labels are often determined based on their terminating events. A label can also be determined using a labeling function based on a set of logical rules. The rules can include analyzing the presence of a combination of events within a process that lead to the desired label or specific order of particular events. First, control flow information and event attributes in traces are mapped to feature vectors [19]. Control flow refers to the sequence and order of events. The event attributes include characteristics of each event, e.g., the agent in charge, resource, and cost. Later, these feature vectors are used as inputs for the classification models. Generating classification models is often referred to as offline step. During the execution of an ongoing process, often referred to as online step [19], the ongoing process is mapped to a feature vector similar to the training data, then the classification models trained in the offline mode are used for classifying it. In our proposed method, we first encode an ongoing query trace to a high-dimensional vector, using the same method applied to the training data. Then, the query vector’s label can be predicted as either of the possible outcomes using the trained classifier model.

Example:

Table 1. BPIC—2019 event log traces.

Trace ID	Event Name	Timestamp	Resource and User	Cumulative Net Worth (EUR)
trace 338	Create Purchase Order Item	2018-01-02T03:20:00.000Z	batch-04	1833.0
	Record Goods Receipt	2018-01-22T16:33:00.000Z	user-031	1833.0
	Vendor creates invoice	2018-01-25T22:59:00.000Z	NONE	1833.0
	Record Invoice Receipt	2018-02-02T12:28:00.000Z	user-007	1833.0
	Clear Invoice	2018-02-22T15:17:00.000Z	user-002	1833.0
trace 529	Create Purchase Order Item	2018-01-02T08:51:00.000Z	user-052	0.0
	Record Goods Receipt	2018-01-18T10:02:00.000Z	user-053	0.0
trace 198181	Create Purchase Order Item	2018-10-15T05:34:00.000Z	user-119	15.0
	Record Goods Receipt	2018-10-18T11:43:00.000Z	user-080	15.0
	Create Purchase Order Item	2018-10-24T21:59:00.000Z	NONE	15.0
	Clear Invoice	2018-11-15T14:35:00.000Z	user-002	15.0

depicts three randomly selected traces in a real event log that is commonly used in the literature, $\mathtt{BPIC}\mathtt{2019}$ [26]. This dataset includes the history of purchase processes, and the early prediction is concerned with whether the application terminates as approved, rejected, or canceled. Events in this event log are associated with the Event Name, Timestamp, Resource and User, and Cumulative Net Worth (EUR) attributes.

In Table 1, trace 338, with five events, can be represented as $[e_{338,1},e_{338,2},e_{338,3},e_{338,4},$$e_{338,5}]$. Since we aim at predicting the outcome of incomplete traces, we use the prefixes of the ongoing traces instead of the completed ones. A prefix of this trace is a sequence of events with an arbitrary length. For example, $[e_{338,1},e_{338,4}]$, corresponding to [Create Purchase Order Item, Record Invoice Receipt], is a prefix with length 2 in trace $trac{e}_{338}$. In event log $\mathtt{BPIC}\mathtt{2019}$, following common practice in the field, we define the trace labels based on whether the trace terminates with the event Clear Invoice (positive) or not (negative), resulting in a binary classification. As a result, both $trac{e}_{338}$ and $trac{e}_{198181}$ are labeled as positive as they terminate with Clear Invoice event, whereas $trac{e}_{529}$ is labeled as negative.

2.2. Hyperdimensional Computing

Hyperdimensional Computing (HDC) is a novel computational approach that encodes a d-dimensional input data point $x\in R^d$ into a high-dimensional vector, denoted by $\mathcal{H}$. Hypervectors are the basis of HDC, and their dimension is denoted by $\mathcal{D}$, where $d\ll \mathcal{D}$, and is often set to be 2000–10,000 [23,24]. These encoded hypervectors are composed of independent and identically distributed ($i.i.d.$) elements [23]. A useful mathematical property in the high-dimensional space (also known as hyperspace) that HDC benefits from [23] is that when given a set of i.i.d. hypervectors ${\mathcal{H}}_{\alpha }$, ${\mathcal{H}}_{\beta }$, and ${\mathcal{H}}_{\gamma }$, their summation ${\mathcal{H}}_{\Sigma }={\mathcal{H}}_{\alpha }+{\mathcal{H}}_{\beta }+{\mathcal{H}}_{\gamma }$ is closer to ${\mathcal{H}}_{\alpha }$, ${\mathcal{H}}_{\beta }$, and ${\mathcal{H}}_{\gamma }$ than any other randomly selected vector in the hyperspace. This property can be used to represent classes (sets of elements with the same label) by bundling encoded data points of a particular class through simple summation. The resultant class hypervector is, in expectation, similar to the associated data points. Also, in hyperspace with a large enough dimension, any two randomly chosen hypervectors are nearly orthogonal to each other [23].

The HDC learning framework comprises three steps, as depicted in Figure 1. First, each sample of a given input dataset, i.e., a trace with a set of events and corresponding event attributes is encoded into a $\mathcal{D}$-dimensional hypervector. Determining an appropriate encoding algorithm is critical for this step. Based on the literature, n-gram encoding is often used in sequential data such as language [27] and DNA sequencing [28] where there is a spatiotemporal relationship between features [29]. Hence, in these sequential data types, n-gram encoding often yields higher performance compared to other encoding methods [27,29], so we use n-gram encoding as our encoding method.

A class of data representing a specific category of information (e.g., all business traces with the same label) is labeled using a class label, e.g., label positive or negative (e.g., terminating in a particular event or not). A single hypervector represents a class. To create the class vector, encoded hypervectors belonging to that label are superimposed (bundled) simply through dimension-wise addition to form class hypervectors.

A class of data representing a specific category of information (e.g., all business traces with the same label) is labeled using a class label, e.g., label positive or negative (e.g., terminating in a particular event or not). A single hypervector represents a class.

Third, with a set of n class hypervectors ${\mathcal{C}}_1,{\mathcal{C}}_2,\cdots ,{\mathcal{C}}_k$, the HDC approach classifies a query process $x_q$ first by mapping it into a hyperdimensional representation and then finds out how similar the given query vector is to any of the k classes using a similarity metric $\delta$ such as the cosine distance or dot product [24].

The operations in the HDC steps are simple (mostly binary or integer addition or multiplication) and highly parallelizable, as operations on hypervector dimensions are independent, e.g., the addition of two hypervectors can be run in parallel over all of the $\mathcal{D}$ dimensions. Hence, in many applications, it can achieve several orders of magnitude speed-up compared to classic machine learning techniques [30]. In some cases, HDC has been empirically shown to require less labeled training data than other machine learning techniques [31,32]. The latter feature enables implementing HDC in problems with insufficient data for other algorithms. We also need to remark that HDC does not need the costly hyper-parameter tuning required in neural networks [33].

Hyperdimensional computing has been successfully applied to a wide range of data types including sequential data such as DNA sequencing [28] and text [27], image datasets [34], time-series datasets such as seizure detection [35], and for different tasks such as classification, clustering, and regression.

Table 2. HDC application and performance in different domains.

Application Domain	Task & Reference	Dataset Type/Name	Performance
Image Classification	Classification [34]	Images (CIFAR10, MNIST, etc.)	Increased accuracy/energy efficiency vs. SOTA
Genomics	Classification [28]	DNA sequences	Increased accuracy/lower time and energy vs. SOTA
Graph Analytics	Classification [36]	Graphs	Faster inference vs. SOTA
Economics and Energy	Regression [37]	Boston housing, CCPP, etc.	Faster and energy efficient vs. SOTA
Bioinformatics	Clustering [38]	IRIS, ISOLET, RNA-seq, etc.	Higher clustering accuracy/less execution time vs. SOTA

provides a summary of some of HDC’s applications in different domains. To the best of our knowledge, this is the first study that deploys a Hyperdimensional Computing-based method in the Predictive Process Mining Field. To perform a thorough analysis, we experimented on four benchmarks conventionally used in the literature within this domain, which we discuss further in Section 5.

3. Related Work

Traditional machine learning models that are widely used in predictive process mining adopt different procedures in the choice of the input data in the mapping control feature encoding phase. Ref. [22] selects all events up to the prediction state and, using the occurrence count of an event observed in a sequence, creates frequency-based vectors, ignoring the order of events and their attributes. In other studies such as [4], only the event attributes of the event at which the prediction is made are used as input data. Considering merely trace attributes instead of event attributes or the attributes of the last k events is the other approach discussed in [1]. On the other hand, Ref. [15] uses a combination of the order of events and attributes, which takes care of both the control flow and events features. However, the feature vector length is continuously updated as new executed events are being added to the prefix, impeding the use of a fixed-length feature vector. Once traces of events are represented as feature vectors, a classifier is trained on the feature vectors [8]. Among the most conventional machine learning-based techniques used are Random Forest (RF) [8], Gradient-Boosted Trees (XGBoost) [19], Support Vector Machines (SVM) [39], and Logistic Regression (LR) [19]. In the aforementioned methods, for prediction in different prefixes, a new model is needed to be trained.

More recently, NN-based methods including [10,19] use neural network-based techniques for outcome prediction, which consider the sequence of events as well as event attributes. The authors of [10] use Attention-based Bidirectional LSTM (Att-Bi-LSTM), which is a combination of a bidirectional long short-term memory neural network and an attention layer mechanism. However, similar to the other neural network-based algorithms, the proposed LSTM-based method in [10] requires hyper-parameter tuning in model creation, which can be complex and time consuming. Moreover, different datasets might need customized models, making the prediction even more challenging [40]. Also, it requires constant training in a trace for continuous predictions in different states of the given trace.

We present a novel approach for outcome prediction in ongoing traces based on Hyperdimensional Computing that will be further discussed in the following sections. Our method eliminates the need for encoding and training an ongoing process from scratch using single-pass inference. Also, our proposed method inherently eliminates the need for time and compute-intensive hyper-parameter tuning and is capable of yielding high performance, while in the initial steps of a process. We conducted a series of experiments to compare the efficiency and performance of our proposed method with the best state-of-the-art methods, namely, RF [8], XGBoost [19], SVM [39], and LR [19]. We also used a variation of LSTM, i.e., Att-bi-LSTM [10], which yields better performance than the conventional LSTM studied in [21].

4. HDC-Based Framework for Predicting Process Outcomes

In the following, we elaborate on the three main steps of Hyperdimensional Computing in the context of predicting the process outcome, namely encoding, training, and inference (prediction). We first introduce our proposed HDC algorithm which merely considers the patterns in sequences of events, and later, we introduce attribute-based HDC (Att-HDC), which, in addition to patterns in sequences of events, considers event attributes and has an additional step in the encoding compared to the HDC-based method. This section finally ends with the framework for the proposed Att-HDC algorithm.

Table 3. Table of notations.

Symbol	Definition	Symbol	Definition
$\mathcal{D}$	dimension of encoded data	$\mathcal{H}$	hypervector of encoded data
$\mathcal{L}$	level hypervector $\in {\{\pm 1\}}^{\mathcal{D}}$	${\mathcal{P}}^n$	permutation by n indexes
e	event	C	class hypervector
t	trace	$\omega$	tri-gram of events
$\lambda$	trace prefix	$attr$	event attribute
m	trace length	Q	# of quantized levels
$e_k$	prediction event	l	quantizer’s level hypervector $\in {\{\pm 1\}}^{\mathcal{D}}$

summarizes the notations used throughout this paper.

4.1. Encoding

The first phase in the HDC framework is mapping input data into a hypervector. As mentioned earlier, we use patterns in sequences of events and event attributes to create feature vectors. We extract the unique IDs of events across the entire event log. Similarly, we store the unique attribute values of each event from all traces within the event log.

We map each unique event $e_i$ to a random $\mathcal{D}$-dimensional binary hypervector in the hyperspace, dubbed an ID hypervector, denoted by ${\mathcal{H}}_{e_i}={\{\pm 1\}}^{\mathcal{D}}$. ID hypervectors are alternatives of scalar values in the hyperspace. Note that events are qualitative, i.e., the comparison of events is meaningless without any domain knowledge. For instance, two particular actions (events) of “Record Invoice Receipt” and “Record Goods Receipt” might be used interchangeably in a dataset or might have close meaning, so if the domain knowledge implies this, we expect that their mapping hypervectors should also preserve this proximity, i.e., ${\mathcal{H}}_{e_i}·{\mathcal{H}}_{e_j}>0$. However, due to the lack of such domain knowledge, we assume that no similarity is considered between any two ${\mathcal{H}}_{e_i}$ and ${\mathcal{H}}_{e_j}$ in the high-dimensional space; hence, ${\mathcal{H}}_{e_i}·{\mathcal{H}}_{e_j}=0$. Thereby, we do not need to store the proximity of events.

We illustrate our procedure on a real-life example by running it in our framework. We consider trace $t_{198181}$ in Table 1 as our ongoing example. This trace consists of four events and terminates in the ‘Clear Invoice’ event. It can be represented as [‘Create Purchase Order Item’, ‘Record Goods Receipt’, ‘Create Purchase Order Item’, ‘Clear Invoice’]. Based on Table 1, each of the events in this dataset has four attributes, namely ‘Event Name’, ‘Timestamp’, ‘Resource and User’, and ‘Cumulative Net Worth’. We first map each of the event names into the hyperspace. This step is performed by randomly mapping each unique event name into a D (here, 4000)-dimensional hyperspace. We experimented with different values of D and did not observe significant difference in the prediction results. Figure 2 in Section 5 illustrates results of deploying the method using different dimensions. We later show in the attribute-binding Section 5 thew difference of taking a similar measure for the ‘Resource and User’ categorical attribute. The encoded event would be $\mathcal{H}\left(e_i\right)={\{0,1\}}^D$ wherein D stands for the dimension of the hyperspace. Each of the coordinates of the hypervector is equally likely to be 0 or 1. This randomness ensures that the dissimilarity of different event names is preserved and variant events are mapped into distinguishable representations, as each pair of randomly generated vectors is orthogonal.

Although we might have complete sequences during the training, predictions are aimed to be performed at event k of the query trace $x_q$, i.e., before its termination. Thus, during encoding, prefixes of length k are extracted from historical traces as well. Therefore, for a historical trace $t_i$, the prefix ${\lambda }_i$ of length k that starts from the first event in the trace is ${\lambda }_i=[e_{i,1},\cdots ,e_{i,k-1},e_{i,k}]$. Traces within the training and test data can be of any arbitrary and dissimilar lengths to each other. If k is equal to or more than the length of a trace $t_i$ of length m, the last $m-1$ events of the trace are considered the prefix. The reason for choosing $m-1$ events in such traces is that we want to make sure to perform the prediction before the end of a trace rather than on or after its termination. Similarly, for encoding historical traces, we disregard their last event (process outcome).

As explained in Section 2, HDC can represent a set by simply adding up the hypervectors of the comprising elements of that set. Thus, we can represent event prefix ${\lambda }_i$ by Equation (1). Such encoding, however, is not able to retain the temporal information of the sequences (order/pattern of events), i.e., $\mathcal{H}\left([e_A,e_B,e_C]\right)=\mathcal{H}\left([e_C,e_A,e_B]\right)$.

$$\mathcal{H}\left({\lambda }_i\right)=\sum _{j=1}^k{\mathcal{L}}_{e_{i,j}}$$

(1)

To preserve the patterns of events in a prefix ${\lambda }_i$, we split the prefix to sub-sequences of length n, called n-grams. The selection of n is tentative, but for the majority of applications, $n\in \{3,4\}$ yields good accuracy. However, we experimented with different values of n for n-grams, and no significant difference was observed. In Section 5 we show the impact of several values of n on the performance of our proposed HDC method. We set the step of the n-gram encoding to be 1 to preserve all possible patterns of length 3. To encode a tri-gram ${\omega }_j=[e_j,e_{j+1},e_{j+2}]$, we applied a permutation-based (circular shift) encoding on its events. The permutation operation, by rotating the hypervector coordinates and generating dissimilar vectors to the origin by scrambling the original vector, is used for storing a sequence of hypervectors [41]. We denote the left permutation of elements of a sequence $\mathcal{S}=(s_1,\cdots ,s_m)$ by ${\mathcal{P}}^l\left(\mathcal{S}\right)$, wherein l means permutation by l indices, i.e., ${\mathcal{P}}^{\left(2\right)}\left(s\right)=(s_3,\cdots ,s_n,s_1,s_2)$. Accordingly, the encoding of each tri-gram of events is calculated as

$$\mathcal{H}\left({\omega }_j\right)=\sum _{l=0}^2{\mathcal{P}}^l\mathcal{H}\left(e_{j+l}\right)$$

(2)

That is, the ID hypervector of all three events in the tri-gram is selected and is permuted by 0, 1, and 2 for the first, second, and third event, and added up to form $\mathcal{H}\left({\omega }_j\right)$. To preserve the sequence of events, we need to perform a left rotation on different indices. Starting from the first event of a prefix, the tri-grams are encoded. Each of the events in a prefix is the starting event of a tri-gram.

The encoding hypervector of the whole prefix with k events, $\mathcal{H}\left({\lambda }_i\right)$, is produced by adding up all the $k-2$ encoded tri-grams (e.g., in a trace of length $k=3$, there is only one tri-gram). Algorithm 1 illustrates the pseudo-code for the encoding process.

$$\mathcal{H}\left({\lambda }_i\right)=\sum _{j=1}^{k-2}\mathcal{H}\left({\omega }_j\right)$$

(3)

Algorithm 1: HDC Encoding Algorithm

Algorithm 2: Function: LeftRotate

Input: Vector $vector$, Number of positions $positions$    Output: Vector rotated left by $positions$ indices 1  return $vector$ rotated left by $positions$ indices

Algorithm 3: Function: RandomBinaryVector

Input: Dimension D    Output: A D-dimensional vector with random binary (0 or 1) elements 1  return A D-dimensional vector with random binary elements

4.2. Single-Pass Encoding and Inference

The encoding technique outlined above only visits each prediction index (input sample) once for different prefixes. In case a new event $k+1$ is added to the prefix, as encoding is all about bundling the tri-grams, we only need to encode the tri-gram of ${\omega }_{k-1}=[e_{k-1},e_k,e_{k+1}]$ and add the result to the existing encoding hypervector.

$$\begin{array}{c}\hfill \mathcal{H}\left({\lambda }_{i,k+1}\right)=\sum _{j=1}^{k-1}\mathcal{H}\left({\omega }_j\right)=\sum _{j=1}^{k-2}\mathcal{H}\left({\omega }_j\right)+\mathcal{H}\left({\omega }_{k-1}\right)=\mathcal{H}\left({\lambda }_{i,k}\right)+\mathcal{H}\left({\omega }_{k-1}\right)\end{array}$$

(4)

Therefore, HDC only needs to store the last two observations along with the encoded hypervector. This impedes encoding and training from scratch for each inference, as opposed to conventional methods where the feature vector and learned model must adjust with each new event and attribute. Therefore, our proposed HDC-based methods result in lower computation and time consumption in continuous prediction across various prefix lengths.

4.3. Training

We built a classifier by running a binary classification algorithm for each label. To this end, we first encoded each and every input sample (prefix) using Equation (3). Then, we added all encoded hypervectors with the same label, e.g., in the $\mathtt{BPIC}\mathtt{2019}$ dataset, the class hypervector of ‘Clear Invoice’ traces is the aggregation of hypervectors of all prefixes terminating in ‘Clear Invoice’ event. The class hypervector is a single hypervector that represents all prefixes with the same label.

$$\begin{array}{c}\hfill {\mathcal{C}}_k=\sum _{is.t.y_i=k}\mathcal{H}\left({\lambda }_i\right)\\ \hfill {{\mathcal{C}}^{\prime }}_k=\sum _{is.t.y_i\ne k}\mathcal{H}\left({\lambda }_i\right)\end{array}$$

(5)

Since we formed it as a binary classification task (to concur with the literature), the complement class hypervector ${\mathcal{C}}^{\prime }$ was the aggregation of traces not terminating in the ‘Clear Invoice’ event. Algorithm 4 illustrates the pseudo-code for the the training phase.

Algorithm 4: HDC Training

4.4. Inference (Prediction)

The ultimate goal is to predict the label of an incomplete trace. Assume that the last observed event in an ongoing trace $x_q$ is $e_k$. To begin, we need to encode the $x_q=[e_1,e_2,\dots ,e_k]$ query trace with the same procedure used for encoding the training traces. Then, we compare the resulting hypervector $\mathcal{H}\left({\lambda }_q\right)$ to all of the k class hypervectors. For measuring similarity, we use the cosine similarity (normalized dot product) metric, which is commonly used in the HDC field [42]. The cosine of the angle $\theta$ between vectors $enc\left(x_q\right)$ and class ${\mathcal{C}}_k$ is defined as follows:

$$cos(\mathcal{H}\left({\lambda }_q\right),{\mathcal{C}}_k)={\displaystyle \frac{<\mathcal{H}\left({\lambda }_q\right),{\mathcal{C}}_k>}{|\mathcal{H}\left({\lambda }_q\right)\left|\right|{\mathcal{C}}_k|}}$$

(6)

The label of the query is determined by the class with the highest similarity to the encoded query hypervector.

$$l_q=argma{x}_{k\in \mathcal{C}}\delta (\mathcal{H}\left({\lambda }_q\right),{\mathcal{C}}_k)$$

(7)

The above equation simply returns the predicted label $l_q$ for query trace $x_q$. Here, $\delta$ is the cosine distance. The pseudo-code for the inference phase is shown in Algorithm 5.

Algorithm 5: HDC Inference

4.5. Retraining

In contrast to deep neural networks that need tens of iterations (epochs) over the train data, the HDC algorithm achieves reasonable accuracy by visiting each input data point only once. However, the HDC accuracy can also be improved using a few retraining epochs at run-time. During the retraining, an inference is conducted between the training data and already-created class hypervectors. In case the class of a training query trace is predicted incorrectly, we add the encoded query process $\mathcal{H}\left({\lambda }_q\right)$ to the true class hypervector and subtract it from the incorrectly predicted class. If we denote the true class as ${\mathcal{C}}_t$ and the falsely predicted one (complement of ${\mathcal{C}}_t$ in binary classification) as ${\mathcal{C}}_f$, the retraining entails that

$$\begin{array}{c}\hfill {\mathcal{C}}_t={\mathcal{C}}_t+\mathcal{H}\left({\lambda }_q\right)\\ \hfill {\mathcal{C}}_f={\mathcal{C}}_f-\mathcal{H}\left({\lambda }_q\right)\end{array}$$

(8)

Intuitively, this equation makes the incorrectly classified trace closer to the correct class and simultaneously increases the dissimilarity between the incorrect class and the query trace based on the set property of hyperspaces discussed earlier.

4.6. Attribute Binding in Att-HD

In an event log, each event contains attributes. These attributes might be categorical or numerical, and the values associated with event attributes in a given trace might affect determining its outcome. Hence, besides the HDC algorithm, we propose Att-HDC, which, in addition to a sequence of events in traces, takes the attributes of the events into account for creating feature vectors. Att-HDC is similar to HDC and only has an additional step compared to the HDC’s encoding phase. Hence, encoded feature vectors in the HDC algorithm can be easily converted to Att-HD. We treat the encoding of categorical attributes like unique event encoding. Let $\{att{r}_0,att{r}_1,\dots ,att{r}_k\}$ be the set of unique event attributes across all traces in an event log. We assign each unique attribute a random $\mathcal{D}$-dimensional hypervector in the hyperspace. If the attribute is in a given range of numerical values $(v_{min},v_{max})$, we cannot consider $i.i.d$ vectors for each of the given values as we need to preserve the proximity of similar values in the hyperspace. In order to impede creating various vectors for unique values, we need to quantize the attribute value range into $Q=100$ bins and create “level hypervectors” for each of these quantized bins and preserve the proximity of close values. We set $Q=100$ as our data range was large and our proposed method yields a slightly better AUC and F1-score with $Q=100$. The first quantizer receives ${\mathcal{L}}_0={\{\pm 1\}}^{\mathcal{D}}$. The second quantizer ${\mathcal{L}}_1$ is generated by flipping ${\displaystyle \frac{D}{2Q}}$ randomly chosen coordinates of ${\mathcal{L}}_0$. For example, if $D=10,000$ and $Q=100$, then ${\mathcal{L}}_0$ and ${\mathcal{L}}_1$ will differ in 100 coordinates. Similarly ${\mathcal{L}}_2$ is generated by randomly flipping ${\displaystyle \frac{D}{2Q}}$ coordinates of ${\mathcal{L}}_1$. Hence, the expected similarity (dot product) between ${\mathcal{L}}_0$ and ${\mathcal{L}}_j$ decays to zero. This insures that two similar values are mapped to similar hypervectors. These encoded attributes are later bound with the hypervector of the event that contains them. Thereby, if we consider ${\mathcal{H}}_{e_{i,j}}$ as the hypervector associated with event j in trace i, the t hypervectors associated with its attributes are summed up and added to its hypervector as follows:

$${\mathcal{H}}_{e_{i,j}}:={\mathcal{H}}_{e_{i,j}}+\sum _{s=1}^t{\mathcal{L}}_{i,j,s}$$

(9)

For example, in Table 1, for ‘Cumulative Net Worth’, which contains numerical attributes, ${\mathcal{L}}_0$ and ${\mathcal{L}}_{Q-1}$ are hypervectors associated with the values 0 and 1833, respectively, and are orthogonal to each other. After mapping the attributes, we need to bind each event attributes to itself. Then, for the first event in this dataset, we sum the hypervectors corresponding to ‘Create Purchase Order Item’, ‘user-119’, and ‘15.0’ together. We perform the same thing for the subsequent events and finally, by shifting the hypervectors of the events in the sequence, create the hypervector associated with the given trace.

We use timestamp information to maintain the chronological order of events in processes. Moreover, we exclude attributes that are significantly different across different events within processes as they do not help in identifying similar processes, i.e., processes with the same label. In Algorithm 6, we show how events are encoded when attributes are considered in the Att-HDC algorithm. Algorithm 6 uses Algorithms 2 and 3 respectively for generating random binary vectors and left rotation.

Algorithm 6: Att-HDC attribute binding

4.7. Proposed HDC-Based Framework

Figure 3 illustrates an overview of the proposed Att-HDC classification method. The first step is encoding, where unique events are mapped into the hyperspace of size D. Categorical event attributes are mapped to the hyperspace in a similar manner. For numerical values, quantization is conducted as discussed in Section 4.6. Then, after binding attributes vectors with event vectors for a given trace $t_i$, sequences of length 3 (tri-grams) are chosen. After applying permutation on the elements of each tri-gram, they are summed up. The last phase in encoding is summing all such tri-grams to represent the trace i in the hyperspace. HDC differs only in that it does not bind attributes hypervectors to the event hypervectors.

In the second phase (training), traces of the same label are aggregated using a simple element-wise summation to create class hypervectors. Eventually, in the query phase for classifying an prefix ${\lambda }_q$ in an ongoing trace $x_q$, after encoding it to $\mathcal{H}\left(lambd{a}_q\right)$, a similarity metric is calculated between the encoded prefix and the class hypervectors. In the retraining phase, the hypervector of a wrongly classified trace is added to the class hypervector it belongs to and is subtracted from the class hypervector it is mistakenly labeled as, to increase the prediction accuracy in further predictions. The proposed framework is independent of the event logs, meaning that we can implement a similar framework for any other event log with any number of unique events, traces, or classes and attributes upon obtaining the chronological event $id$s of its traces. We present the pseudo-code for the proposed HDC and Att-HDC methods in Algorithm 1.

5. Experimental Evaluations

In this section, we discuss the datasets we used and the comprehensive series of tests we devised to evaluate our proposed method’s effectiveness as an accurate yet efficient means for predicting the label of an ongoing process instance using historical data. Our goal was to demonstrate that HDC attains superior performance than other techniques previously proposed in the literature. We measured our proposed method’s performance based on the F1-score, AUC score, and earliness and compare our proposed methods with XGBoost [19], RF [8], SVM [39], LR [19], and Att-bi-LSTM [10].

5.1. Datasets and Labeling Functions

We used four publicly available real-life process datasets from the Business Process Intelligence Challenge (BPIC), widely used in the literature, (1) $\mathtt{BPIC}\mathtt{2012}$, (2) $\mathtt{BPIC}\mathtt{2015}$, (3) $\mathtt{BPIC}\mathtt{2017}$, and (4) $\mathtt{BPIC}\mathtt{2019}$, to evaluate the performance of our method. For classification purposes, we followed the same procedure taken in previous studies for labeling traces [8,21]. Previous studies treat the outcome classification as a set of separate binary classifications instead of multi-label classification. In these datasets, several labeling functions are required for determining classes of traces. For instance, in $\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Approved}$, the binary classifier determines whether each ongoing trace terminates as Approved or not terminating in any of the other possible outcomes. We defined a total of 12 binary classifications across all of the datasets:

(1)

The $\mathtt{BPIC}\mathtt{2012}$ event log represents the history of loan application processes in a Dutch financial institute. Based on the literature, we define three labels for this dataset: $\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Approved}$, $\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Cancelled}$, and $\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Declined}$, corresponding to cases terminated as approved, cancelled, or declined.

(2)

$\mathtt{BPIC}\mathtt{2015}$ consists of five datasets provided by Dutch municipalities, containing event logs of building permit application processes. For labeling processes, the following Linear-time Temporal Logic (LTL) rule based on the literature is applied in each dataset i, where $i\in \{1,2,\cdots ,5\}$ denotes the number of the municipality: “$\mathtt{BPIC}\mathtt{2015}\text{—}i:$ $\phi =$G (send confirmation receipt) → F(retrieve missing data)”, where $\phi$ is the LTL rule, and the label is 0 if $\phi$ is violated in the trace, and 1 otherwise. Operator G means that the activity should always hold in the subsequent positions of a path, and F means it should finally hold somewhere in the subsequent positions of a path. G → F is the conditional propositions ($p\to q$). It expresses that if the confirmation receipt is always being sent, the missing data should be eventually retrieved.

(3)

The $\mathtt{BPIC}\mathtt{2017}$ event log is an extended version of $\mathtt{BPIC}\mathtt{2012}$ with richer and cleaner data. Similar to $\mathtt{BPIC}\mathtt{2012}$, we define three labels referred to as $\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Approved}$, $\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Cancelled}$, and $\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Declined}$ for processes terminating in approved, canceled, and declined events, respectively.

(4)

$\mathtt{BPIC}\mathtt{2019}$ is collected from a large multinational company in the Netherlands and contains the handling of a purchase order. We label traces in this event log based on whether they terminate in the “Clear Invoice” event or not.

Table 4. Statistics of benchmark event logs.

Dataset	Traces	Min Len	Median Len	Max Len	Unique Events	Event Attr.	Pos. Class Ratio
$\mathtt{BPIC}\mathtt{12}\text{—}\mathtt{Approved}$	13,087	3	11	175	24	3	0.19
$\mathtt{BPIC}\mathtt{12}\text{—}\mathtt{Cancelled}$	13,087	3	11	175	24	3	0.22
$\mathtt{BPIC}\mathtt{12}\text{—}\mathtt{Declined}$	13,087	3	11	175	24	3	0.58
$\mathtt{BPIC}\mathtt{15}\text{—}\mathtt{1}$	1199	2	44	101	289	0	0.24
$\mathtt{BPIC}\mathtt{15}\text{—}\mathtt{2}$	832	1	54	132	304	0	0.19
$\mathtt{BPIC}\mathtt{15}\text{—}\mathtt{3}$	1409	3	42	124	277	0	0.20
$\mathtt{BPIC}\mathtt{15}\text{—}\mathtt{4}$	1053	1	44	116	272	0	0.16
$\mathtt{BPIC}\mathtt{15}\text{—}\mathtt{5}$	1156	5	50	154	285	0	0.31
$\mathtt{BPIC}\mathtt{17}\text{—}\mathtt{Approved}$	31,413	10	35	180	26	4	0.41
$\mathtt{BPIC}\mathtt{17}\text{—}\mathtt{Cancelled}$	31,413	10	35	180	26	4	0.12
$\mathtt{BPIC}\mathtt{17}\text{—}\mathtt{Declined}$	31,413	10	35	180	26	4	0.47
$\mathtt{BPIC}\mathtt{19}$	251,734	1	5	990	42	3	0.72

presents the event log statistics such as the frequency of labels (classes), information regarding the length of traces, and the number of unique events and their unique attributes used across each event log. We consider patterns in the sequence of events (the control flow) and event attributes as input data. We discard the attributes that have the same value in all the traces as they do not contribute to better classification. Also, attributes with different values in all or most of the traces are discarded as uninformative.

5.2. Evaluation Metrics

We mainly use the F1-score, AUC (area under the ROC curve), time consumption, and earliness, which are the common metrics used to evaluate the performance of a classifier in predictive process monitoring [1] to evaluate the effectiveness of our classifier. We also report the execution time analysis during the ongoing prediction (aka online phase). We consistently use hypervector lengths of $D=4k$ through the experiments as we observed it saturates the accuracy.

F1-score is referred to as the golden standard in the literature, represents the correct labeling of a trace [16]. The prediction outcome for an ongoing trace can be $\mathtt{TP}$ (true positive; correctly predicted as positive), $\mathtt{TN}$ (true negative; correctly predicted as negative), $\mathtt{FN}$ (false negative; falsely predicted as negative), or $\mathtt{FP}$ (false positive; falsely predicted as positive). The F1-score is a harmonic mean of recall (${\displaystyle \frac{\mathtt{TP}}{\mathtt{TP}+\mathtt{FN}}}$) and precision (${\displaystyle \frac{\mathtt{TP}}{\mathtt{TP}+\mathtt{FP}}}$) [1], simplified as follows:

$$\mathrm{F}1\text{-}\mathrm{score}={\displaystyle \frac{\mathtt{TP}}{\mathtt{2}\times \mathtt{TP}+\mathtt{FP}+\mathtt{FN}}}$$

(10)

Note that positive depends on the labeling function. For instance, in $\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Approved}$, a trace is labeled positive if it terminates in the approved event, and negative otherwise, while in $\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{i}$, the labeling function is a given logical rule, wherein the label is positive if a trace follows the rule and negative otherwise.

AUC represents the probability that a binary classifier scores a positive case higher than a negative one [43]. An ROC curve shows $\mathtt{FPR}={\displaystyle \frac{\mathtt{FP}}{\mathtt{F}}}={\displaystyle \frac{\mathtt{FP}}{\mathtt{FP}+\mathtt{TN}}}$ versus $\mathtt{TPR}={\displaystyle \frac{\mathtt{TP}}{T}}={\displaystyle \frac{\mathtt{TP}}{\mathtt{TP}+\mathtt{FN}}}$ in the horizontal and vertical axes, respectively [15]. The AUC score varies between 0.5 (for a random guess classifier) and 1.0 (for an optimal classifier). Despite the accuracy and F1-score metrics, the AUC is resilient to the imbalanced distribution of classes and represents a holistic measure for the performance of classification [1,44]. Hence, in predictive process monitoring, the AUC is often preferred to F1-score and accuracy. Our benchmark event logs also comprise an imbalanced distribution of classes, as shown in the last column of Table 4.

Earliness serves as a metric to ascertain how swiftly a predictive model achieves a predefined accuracy threshold. The earlier a prediction happens, the higher the chance of taking preventing and correcting actions for violations actions [14]. Earliness is defined differently in the literature, but in this study, we followed the same explanation presented in [10]. We define earliness as ${\displaystyle \frac{P}{L}}$, where P denotes the index at which prediction accuracy surpasses a specified threshold ($\lambda =0.7$ as used in the literature [10]), and L indicates the length of a trace.

5.3. Results

We evaluated our proposed method’s performance for all binary classification tasks in each of the event logs. Since the goal was using historical data and then applying the learned model to the ongoing cases, we split each event log into training and test sets chronologically [45], meaning that we considered the timestamps of traces into account and took the first 80% of traces as training data and the 20% recent ones as test data. We encoded the prefixes of events using the HDC algorithm, then trained a classifier on the training data, and, using the learned classifier, associated the most similar class to the query trace. For each binary classification task, the reported result at each prefix for our proposed algorithm is based on the average of 10 iterations over test prefixes of length 3 to median length within each of the datasets with a step size of 3 as performed in state-of-the-art methods [30,46]. The iterations are on random hypervector initializations for unique events, i.e., ID hypervectors as explained in Section 4.1 since the initialization of ID hypervectors might slightly affect the performance.

To analyze the impact of D dimensions in the encoding process, we experimented with different D values and did not observe significant changes across different datasets for the above metrics. Figure 2 shows the AUC score on BPIC-2012-Approved dataset for the HDC method. The reported AUC scores at each prefix are the average of 10 iterations. As depicted in Figure 2, there are no notable changes in the AUC scores across D = 4 k and D = 6 k dimensions; hence, we chose D = 4 k for efficiency. Also, to choose that value of n in n-gram encoding, we experimented with different values of n and no significant difference was observed across all datasets. We show the results for one dataset for clarity and brevity. Figure 4 depicts the AUC score of our proposed HDC method across several n values on the BPIC-2012-Approved dataset. We observed a similar pattern across all different datasets and depict the results for one dataset for clarity and brevity. We set $n=3$ following common practice in the literature and based on our observations discussed earlier [30,47,48].

For comparison, we used XGBoost [19], RF [8], SVM [39], LR [19], and Att-bi-LSTM [10] for predictive process monitoring tasks, specifically, outcome prediction. We also used a variation of LSTM, i.e., Att-bi-LSTM [10] as it yields better performance for outcome prediction than the LSTM method often discussed in the recent literature [21].

AUC Score:

Table 5. Comparison of average and std of AUC in early prefixes (before median length).

	Baseline Methods					Proposed Methods		Best HDC-Based vs. Best Baseline (%)
Dataset	XGBoost [19]	RF [1]	SVM [39]	LR [1]	Att-bi-LSTM [10]	HDC	Att-HDC
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Approved}$	0.56 ± 0.06	0.56 ± 0.06	0.56 ± 0.06	0.56 ± 0.05	0.52 ± 0.02	0.66 ± 0.01	0.66 ± 0.01	+10%
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Cancelled}$	0.57 ± 0.08	0.57 ± 0.08	0.57 ± 0.08	0.57 ± 0.08	0.58 ± 0.09	0.66 ± 0.01	0.66 ± 0.01	+8%
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Declined}$	0.81 ± 0.15	0.81 ± 0.15	0.81 ± 0.16	0.81 ± 0.15	0.74 ± 0.17	0.73 ± 0.14	0.70 ± 0.13	−8%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{1}$	0.80 ± 0.17	0.82 ± 0.16	0.81 ± 0.16	0.82 ± 0.16	0.77 ± 0.14	0.85 ± 0.14	0.85 ± 0.14	+3%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{2}$	0.81 ± 0.17	0.81 ± 0.16	0.81 ± 0.11	0.82 ± 0.14	0.73 ± 0.20	0.82 ± 0.11	0.82 ± 0.11	0%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{3}$	0.80 ± 0.17	0.81 ± 0.16	0.81 ± 0.12	0.83 ± 0.15	0.71 ± 0.18	0.86 ± 0.14	0.86 ± 0.14	+3%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{4}$	0.60 ± 0.38	0.57 ± 0.41	0.44 ± 0.38	0.46 ± 0.37	0.59 ± 0.34	0.85 ± 0.23	0.85 ± 0.23	+23%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{5}$	0.83 ± 0.14	0.81 ± 0.16	0.86 ± 0.11	0.83 ± 0.14	0.78 ± 0.15	0.82 ± 0.15	0.82 ± 0.15	−1%
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Approved}$	0.65 ± 0.12	0.52 ± 0.05	0.66 ± 0.13	0.65 ± 0.12	0.84 ± 0.15	0.59 ± 0.08	0.60 ± 0.11	−24%
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Cancelled}$	0.68 ± 0.15	0.69 ± 0.15	0.68 ± 0.15	0.66 ± 0.14	0.69 ± 0.15	0.67 ± 0.13	0.71 ± 0.14	+2%
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Declined}$	0.70 ± 0.15	0.70 ± 0.14	0.69 ± 0.15	0.68 ± 0.15	0.67 ± 0.14	0.74 ± 0.11	0.75 ± 0.13	+ 5%
$\mathtt{Average}$	0.70 ± 0.18	0.70 ± 0.09	0.70 ± 0.14	0.70 ± 0.24	0.69 ± 0.15	0.75 ± 0.09	0.76 ± 0.09	$+\mathbf{6}\%$

compares the AUC values for different algorithms across all 12 binary classification tasks in different datasets. Our proposed Att-HDC yields the highest AUC for 7 out of the 12 binary classification tasks. However, the next best algorithm yields a higher AUC for only two classification tasks while having a high standard deviation of AUC of 18% across different datasets (compared to Att-HDC’s 9%). This variability implies inconsistent performance and sub-optimal results in some datasets. The reported AUC represents the algorithms’ performance in precision and recall and its ability to discriminate between positive and negative instances. Machine learning methods are often not generalizable to all different applications, so the average performance is a good criterion for showing the performance of a model. Notably, our HDC-based method, excluding attributes, outperforms the best state-of-the-art algorithms: it achieves an average AUC that is 5% higher compared to the best baseline, XGBoost [19]. Att-HDC, which considers event attributes, further improves the AUC score, outperforming XGBoost [19], RF [8], SVM [39], LR [19], and Att-bi-LSTM [10] by an average of 6%, 6%, 6%, and 7.4%, respectively.

As an example, in Figure 5, we show the AUC scores of all the methods on prefixes of lengths 1 to 30 for the ‘$\mathtt{BPIC}\mathtt{2012}\text{—}\mathrm{Approved}$’ dataset. The vertical line at index 11 indicates the median length of the processes, i.e., half of the processes finish before they reach the 11th event in the process. Evidently, our proposed methods yield higher AUC scores, particularly in the early stages of processes, reaching an AUC score of 0.69 with only observing four events of processes on average. A similar AUC score is observed for both the Att-HDC and HDC methods, implying that adding event attributes in Att-HDC did not contribute to better distinguishing between positive and negative instances as intended using the AUC metric. For the other methods, it takes a longer time (and process length) to reach a comparable AUC score. For example, the best method Att-bi-LSTM [10] yields a similar AUC score to our proposed methods after observing 20 events in the traces. Therefore, Figure 5 implies that a better AUC score is gained in the early stages of an ongoing process, which ultimately leads to preserving memory and computation and enabling earlier corrective measures in business processes.

F1-Score:

Table 6. Comparison of average and std of F1-score in early prefixes (before median length).

	Baseline Methods					Proposed Methods		Best HDC-Based vs. Best Baseline (%)
Dataset	XGBoost [19]	RF [1]	SVM [39]	LR [1]	Att-bi-LSTM [10]	HDC	Att-HDC
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Approved}$	0.53 ± 0.10	0.55 ± 0.09	0.53 ± 0.10	0.53 ± 0.14	0.53 ± 0.09	0.55 ± 0.19	0.60 ± 0.12	+7%
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Cancelled}$	0.54 ± 0.12	0.54 ± 0.12	0.54 ± 0.11	0.55 ± 0.12	0.53 ± 0.12	0.59 ± 0.11	0.59 ± 0.11	+4%
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Declined}$	0.82 ± 0.15	0.78 ± 0.21	0.78 ± 0.21	0.78 ± 0.20	0.77 ± 0.19	0.67 ± 0.23	0.69 ± 0.23	−14%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{1}$	0.73 ± 0.23	0.74 ± 0.23	0.68 ± 0.22	0.70 ± 0.27	0.66 ± 0.13	0.76 ± 0.17	0.76 ± 0.17	+2%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{2}$	0.74 ± 0.21	0.76 ± 0.23	0.73 ± 0.18	0.77 ± 0.22	0.69 ± 0.11	0.73 ± 0.16	0.73 ± 0.16	−3%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{3}$	0.76 ± 0.22	0.76 ± 0.22	0.73 ± 0.18	0.77 ± 0.22	0.69 ± 0.16	0.79 ± 0.15	0.79 ± 0.15	+2%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{4}$	0.75 ± 0.22	0.76 ± 0.22	0.72 ± 0.17	0.76 ± 0.21	0.71 ± 0.18	0.73 ± 0.19	0.73 ± 0.19	−3%
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{5}$	0.64 ± 0.07	0.65 ± 0.06	0.65 ± 0.06	0.72 ± 0.26	0.63 ± 0.08	0.73 ± 0.05	0.73 ± 0.05	+7%
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Approved}$	0.63 ± 0.13	0.50 ± 0.07	0.63 ± 0.13	0.63 ± 0.14	0.73 ± 0.16	0.63 ± 0.09	0.67 ± 0.11	+4%
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Cancelled}$	0.67 ± 0.16	0.67 ± 0.16	0.66 ± 0.16	0.67 ± 0.16	0.67 ± 0.16	0.63 ± 0.13	0.67 ± 0.14	0%
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Declined}$	0.52 ± 0.09	0.53 ± 0.10	0.52 ± 0.10	0.52 ± 0.09	0.52 ± 0.09	0.56 ± 0.06	0.58 ± 0.06	+3%
$\mathtt{Average}$	0.52 ± 0.09	0.53 ± 0.10	0.52 ± 0.10	0.52 ± 0.09	0.52 ± 0.09	0.56 ± 0.06	0.58 ± 0.06	$+\mathbf{6}\%$

reports the average F1-score values for the various prefix lengths from 3 to the median length of traces within each dataset with a step size of 3. The table contains the average F1-score of all the 12 classification tasks across four event logs. Our proposed methods yield higher F1-scores in 9 out of 12 classification tasks. Also, our proposed Att-HDC method yields an average F1-score of 76%, which is 6% higher in comparison to the best state-of-the-art approaches.

Earliness: Earliness measures how early a classifier predicts the terminating state in terms of event count [10]. We evaluate the earliness of our HDC-based and Att-HDC methods, along with state-of-the-art methods, across all event logs.

Table 7. Comparison of average earliness (as a fraction of the whole trace) in different processes within an event log.

	Baseline Methods					Proposed Methods
Dataset	XGBoost [19]	RF [8]	SVM [39]	LR [19]	Att-bi-LSTM [10]	HDC-Based	Att-HDC
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Approved}$	0.82	0.82	0.82	0.82	0.82	0.049	0.049
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Cancelled}$	1.00	1.00	1.00	1.00	1.00	0.051	0.051
$\mathtt{BPIC}\mathtt{2012}\text{—}\mathtt{Declined}$	0.79	0.79	0.79	0.79	0.79	0.027	0.027
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{1}$	0.80	0.82	0.78	0.82	0.82	0.021	0.021
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{2}$	0.80	0.82	0.78	0.82	0.82	0.021	0.021
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{3}$	0.80	0.82	0.78	0.82	0.82	0.021	0.021
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{4}$	0.80	0.82	0.78	0.82	0.82	0.021	0.021
$\mathtt{BPIC}\mathtt{2015}\text{—}\mathtt{5}$	0.80	0.82	0.78	0.82	0.82	0.021	0.021
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Approved}$	0.79	0.79	0.79	0.79	0.79	0.027	0.027
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Cancelled}$	0.78	0.78	0.78	0.78	0.78	0.028	0.028
$\mathtt{BPIC}\mathtt{2017}\text{—}\mathtt{Declined}$	0.79	0.79	1.0	0.79	0.79	0.020	0.020

compares the earliness of the methods as a fraction of the whole sequence length, i.e., what fraction of the whole trace was needed to be observed in order to achieve the same results. For instance, for the BPIC2012-Approved dataset, XGBoost [18] requires 82% of the whole process to yield a high accuracy, while this value is less than a percent for our proposed methods. HDC-based and Att-HDC methods achieve substantially better earliness, up to a 20× faster average earliness for a reliable prediction compared to the baseline methods.

Execution Time: We also report the execution time of our algorithm for the run-time (encoding the test query and Inference) in

Table 8. Algorithms’ overall average run-times (s) in event logs (over all prefixes).

Dataset	RF	XGBoost	Att-bi-LSTM	HDC	Att-HDC
BPIC2012—Approved	107	147	11	0.61	13
BPIC2012—Cancelled	129	123	7	0.47	16
BPIC2012—Declined	236	98	8	0.48	17
BPIC2015—1	21	101	108	0.16	0.16
BPIC2015—2	36	42	217	0.11	0.11
BPIC2015—3	29	33	134	0.5	0.5
BPIC2015—4	30	28	98	0.36	0.36
BPIC2015—5	33	17	124	0.62	8
BPIC2017—Approved	143	112	217	14	36
BPIC2017—Cancelled	204	183	187	5	29
BPIC2017—Declined	181	154	219	11	35
BPIC2019	153	249	104	104	139
Average	107.08	114.08	128.58	10.38	26.35

for the full prefix length. Based on Table 8, HDC requires a lower run-time in comparison to the best baseline algorithms, namely, XGBoost [19], RF [8], and Att-bi-LSTM [10]. The proposed HDC’s property in eliminating encoding the traces from scratch, which was mentioned as single-pass inference] before, helps in lowering the time consumption. More specifically, our HDC method requires a $10-12\times$ lower run-time on average in comparison to XGBoost, RF, and Att-bi-LSTM, as well as Att-HDC. Att-HDC slightly consumes more time than HDC for encoding the attributes, but still, it is $4.8\times$ faster than the best state-of-the-art approach. We conclude that HDC’s and Att-HDC’s inference, including the mapping of the input data, is significantly faster than that of the state-of-the-art methods. This highlights HDC’s superiority for business processes, where the real-time aspect is imperative, e.g., online shopping processes.

5.4. Instance Sampling

Due to extensive training and hyper-parameter tuning, machine learning techniques are computationally expensive, which limits their practical application in dynamic business environments [12]. The instance sampling of training data aims to improve the training speed of processes by reducing training set size while maintaining accuracy. However, these methods often require additional computations for choosing samples within the training that best represent the whole data, which can still hinder their efficiency in real- world applications.

Hyperdimensional Computing has proven to yield high performance when trained on small portions of training data [49]. We use this property to further show the efficiency of our proposed method, which impedes the use of instance selection methods. We show that with small proportions of the training data that are randomly chosen, with hte HDC-based method, we can gain high performance using Hyperdimensional Computing. The F1-score and AUC on the BPIC2012-Approved dataset are shown in in Figure 6 for different ratios of the training data for prefixes of length 11 (median length of traces in this dataset). We depict the results of one dataset for brevity. We consider the samples being chosen independently and randomly without replacement. The depicted results are the average, minimum, and maximum over 10 iterations. We observe a similar average F1-score and AUC score with a sampling ratio of 0.5 for the training data. As can be observed in Figure 6, the error bars are narrow, indicating that the inherent variability in the data has a minimal impact on the model’s performance metrics across different subsampling ratios, and the results are consistent with different iterations over the dataset. Figure 6 also shows that with a 10% of the training data, our proposed method still yields high performance (only 3% and 5.1% drops in average F1-score and AUC score in comparison to training on the whole data).

Our proposed method streamlines predictive training using a single-pass inference approach and leveraging known tri-grams, while other algorithms require repetitive encoding and training for each prefix. Preserving attributes alongside event patterns incurs slight latency for Att-HDC but significantly improves the F1-score by up to 14% and AUC by an average of 6%, and an average 20× faster earliness. The experiments were conducted using Python 3.8 on a computer with a 2.3 GHz quad-core Intel Core i5 and 8 GB of RAM.

6. Discussion of Limitations and Future Work

Process mining data during the execution of business processes can be generated and stored in noisy environments. Noise could come from human error in inputting information, environmental factors such as network interruptions, and other sources. Future research can investigate the reliability and robustness to noise of the predictive process monitoring methods. Also, this study paves the way to several other future work directions. Further analysis can be applied in choosing event attributes as in Section 4.6 rather than merely considering the frequency of the attributes. Also, adding trace attributes might help in distinguishing traces with different outcomes. As the next step, we aim to apply a novel retraining technique for weighted retraining as in Section 4.5. In weighted retraining, a higher value is assigned to infrequent historical traces to decrease the impact of dominant patterns in traces and further improve the prediction results. Also, recently, many studies have tried to use the benefits of both NN-based and HD-based methods, i.e., combining a feature extraction factor in NN-based methods with the energy efficiency and simplicity of Hyperdimensional Computing [49]. In the next step, rather than using the raw sequences, we aim to extract more useful spatiotemporal features from the data using neural network based methods for the better extraction of features and then deploy our method on the extracted features.

7. Conclusions

We proposed a novel approach based on HDC learning for predicting the outcome of ongoing processes. Unlike previous approaches, our technique builds upon preserving the pattern of events and event attributes in fixed-length vectors (disregarding prefix length) rather than using one-hot encoded vectors or frequency-based feature vectors. Also, our proposed method does not need conventional hyper-parameter tuning found in machine learning-based algorithms. Our algorithm stores the subsets (n-grams) of trace prefixes and maps the observed patterns into a high-dimensional space to realize a linearly separable classifier on historical data using basic element-wise operations along the vectors. Our experimental results on four publicly available event logs with a general of 12 classification tasks show the efficiency of the proposed method in improving the F1-score by up to 14% and average AUC scores by 6% in the early prefixes within an ongoing process. The average AUC and F1 scores across all prefix lengths are improved in our algorithm while yielding a comparable F1-score. Also, due to single-pass inference, our algorithm has up to 20× higher earliness in comparison to the best state-of-the art methods, i.e., our proposed methods yield high F1-scores and AUC scores in the initial observed events of the processes. Also, when observing 10% of the input data using our proposed methods only slightly affects the F1-score and AUC, meaning that less computation and memory overhead is needed. Based on our observations, patterns and order of events together with event attributes provide valuable insights about how a particular ongoing trace will end. Our proposed algorithm yields a more accurate prediction in the early steps of an ongoing process instance compared to other algorithms, and the earlier an accurate prediction is conducted, the more useful it will be in practice.