LSTM Networks for DataAware Remaining Time Prediction of Business Process Instances
Abstract
Predicting the completion time of business process instances would be a very helpful aid when managing processes under service level agreement constraints. The ability to know in advance the trend of running process instances would allow business managers to react in time, in order to prevent delays or undesirable situations. However, making such accurate forecasts is not easy: many factors may influence the required time to complete a process instance. In this paper, we propose an approach based on deep Recurrent Neural Networks (specifically LSTMs) that is able to exploit arbitrary information associated to single events, in order to produce an asaccurateaspossible prediction of the completion time of running instances. Experiments on realworld datasets confirm the quality of our proposal.
I Introduction
A business process is a collection of activities that takes one or more inputs and creates an output that is of value to the customer [4, 17].
The execution of a process leaves in the information system a trace of the performed activities, thus is usually referred as business process instance, or simply trace.
The prediction of the remaining time of a business process instance is a task that is receiving increasing attention in the last few years.
It has several Business applications, such as in ticketing services, where it is important to give to customers an as accurate as possible prediction of when the problem will be resolved.
Several approaches have been proposed to predict the remaining time of activities: [1, 31].
In real world processaware information systems (PAISs), traces and single activities can be associated with side information, such as the person that is performing such activity, the start and end time of such activity, the day of the week and so on.
These additional information can be valuable when predicting the completion time of a trace.
The most basic example is when a process instance, that usually requires one workday to complete, is started on Friday evening, and the company is closed in the weekend.
In such case, for a human it is immediate to infer that the activity will not be completed until Monday. However, for a predictive algorithm, this information has to be encoded in some way.
On this simple example, one possibility is to add an ifthenelse condition before the prediction, that considers this scenario and, in that case, adds two days (Saturday and Sunday) to the prediction.
However, we are interested in less trivial analyses.
In a general case the needed time to complete a process instance depends on some variables. A a recently approach [25] proposes to attach to each trace and to each activity, all the available sideinformation in the form of an attributevalue list (or, equivalently, a vector).
In this paper, we take inspiration from the approaches in [31] and [25]. Namely, we propose to adopt a Long ShortTerm Memory (LSTM) network, that is able to handle data attributes associated to the activities. Differently from [31], that adopts multitask learning, our proposed LSTM is just trained for predicting the remaining time of a trace. Even if authors in [31] state that predicting together the next activity and its timestamp via a single model is beneficial, in the paper this is shown to hold only when predicting a single activity and its execution time. Indeed, when predicting the whole remaining time of a trace, the approach in [31] has problems to deal with repeated activities, leading to worse results compared with other (simpler) methods in literature. Moreover, in [31] it is not clear whether, for the considered problems, multitask learning improves the predictive performances with respect to learning just one task at a time. Finally, such an approach is not easily extensible to consider other information attached to traces and events. Indeed, recent PAISs have the capability to store additional information associated to events. Such information may be very important for many predictive tasks [25].
In this paper, we propose an LSTM architecture for predicting the completion time of a trace, that can consider such additional information.
Our approach improves [31] in the following ways:

it is able to effectively deal with traces with repeated activities;

it can consider data attributes associated to events;

it has lower test times;
At the same time, our approach improves [25] in that it does not require to build a transition system, that can be very time and memory consuming for some realworld datasets. Moreover, we experimentally show that our proposed approach has higher predictive performances with respect to existing stateoftheart predictive algorithms, in many realworld datasets.
As a case study, we consider a new dataset generated from an Italian software company. It contains data of the process underlying the helpdesk activity. In particular, it describes the ticketing management process.
A new process instance starts when e new ticket is opened. After that, a company resource defines a severity level for the ticket. Then the ticket is assigned to a resource, it is managed and processed. During this phase the ticket could be subject to some anomalies, upgrades or technical operations. Each time the ticket changes step, the old activity stops and a new one is registered, so the current instance continues to follow a path described by the ticketing management process. Finally, when the problem is solved the ticket gets closed and the process instance arrives at the end.
The process consists of 10 activities and the event log has been filtered from the original log exported from the company’s PAIS. This log has cases with events in total, and the number of attributes associated to events are .
The paper is organized as follows. Section II introduces some definitions and notation. Section III discusses Recurrent Neural Networks. In Section IV we formally define the problem we face, and in Section VI we discuss our proposed solution. Section V discusses the related works. In Section VII we experimentally evaluate our proposed method against other stateoftheart methods in literature. Section VIII concludes the paper.
Ii Definitions and notation
A Business Process (BP) is a collection of related business activities which finds its end in the delivery of a service or product to a customer. It is usually represented as a workflow, e.g. with the standard Business Process Model and Notation (BPMN) [23]. The same BP can generate a different sequence of activities every time it is executed. A specific execution of an activity is referred to as event; a specific execution of the entire process, which corresponds to a path in the workflow model, is referred to as process instance.
Formally, an event is a tuple where: is the name of the process activity associated to the event (i.e., which tasks was executed); is the “caseid”, that is an identifier of the business process instance; is a timestamp which indicates the execution time of the specific activity; is a set of attributevalue pairs associated with the execution of the event . We assume the presence of a projection operator , which allows the extraction of specific attributes out of an event. Specifically, given an event , we define , , , and . The event universe indicates the set of all possible events. Moreover, we refer as the set of all possible sequences over . A trace , of length , is any of those sequences, where . A trace is also referred as business process instance.
An event log over a set of events is a set of traces such that each event appears at most once in the entire log, i.e., for any , , : , where transforms a sequence into the set with the same elements. In the paper we will deal with partial traces. A partial trace can be defined by the head operator over sequences as the first events in the trace, i.e., let , then . The continuation of a trace is given by the tail operator that returns the last events in the trace, i.e., .
Iii Recurrent networks
When the input depends on time, e.g. when we have to analyze sequences, one of the most known approaches are Recurrent Neural Networks (RNNs). A recurrent artificial neuron (or unit) is a neuron with a feedback connection (a loop). Recurrent neural networks can store representations of past events through those connections. Indeed, RNNs can be unrolled, i.e. they are equivalent to multiple copies of the same network, each passing a message (generated from the past inputs) to a successor (that processes the current input). More formally, a RNN unit takes in input its previous hidden state and the current input, and outputs a new hidden state. Let us consider a layer of recurrent units. In more detail, let be the input of the network at time t, and be the vector of hidden states for all the recurrent units at time . Then we can compute the hidden state at time as:
(1) 
where is the sigmoid function (or other nonlinear functions like hyperbolic tangent or the rectified linear function) applied elementwise, and , are the weight matrices and the biases (the parameters to learn). Then the output at time can be computed as a function of .
One can think as this mechanism as a ”shortterm memory”. It is known that a network composed by several RNN units is Turing complete and can therefore, in principle, implement any algorithm [29]. The main problem of these networks concerns the learning algorithm. The most adopted one is backpropagation through time [18], and shows the wellknown vanishing gradient and exploding gradient problems. These problems make the learning of longtime dependencies very difficult for (vanilla) RNNs [2]. While some values of the parameters able to deal with such sequences exist (i.e. a human could carefully pick the model parameters in order to solve problems with longtime dependencies), in practice learning algorithms seem not to be able to find them. Long ShortTerm Memory [18] are special kinds of recurrent neural networks that, coupled with appropriate learning algorithms, can alleviate these problems.
Iiia LSTM networks
Long ShortTerm Memory networks (LSTM) [18, 15] are a special kind of RNN, capable of learning longterm dependencies.
The idea is that, instead of having a recurrent neuron, we have a recurrent module. In particular, this module will have a memory cell that can store information. An LSTM unit takes in input its old cell state and its old hidden state, and outputs its new cell state and its new hidden state. More formally, an LSTM unit is composed by four gates, interacting in a very special way.
We can consider all gates of the same kind in a layer of LSTM units together using the following vector notation:

forget gate layer: ;

input gate layer: ;

cell state candidate layer: ;

output candidate layer: .
Let us now detail how these layers interact. Let be the input vector at time , and let and be the output and the cell state vectors (respectively) of the LSTM layer at time . Then we can define the output vectors and of a layer of LSTM cells at time via the following equations:
(2)  
(3)  
(4)  
(5)  
(6)  
(7) 
where is the Hadamard (elementwise) product, is the elementwise sigmoid function, the elementwise hyperbolic tangent function, and , and are the matrices of the parameters and the vector of biases (one corresponding to each gate type). The outputs of the units are the the new cell state vector (at time ), and the hidden state vector . The LSTM unit architecture and its evolution through time is depicted in Figure 1. At time step , the LSTM output depends on the input at that time , and on the previous cell states and .
A common variation to the original architecture, that allows faster runtimes on GPUs, is to couple forget and input gates. In particular, we do not need to compute of eq. (3) anymore, and eq. (6) becomes:
(8) 
In this paper, we adopt this variation.
Let us draw some considerations on how the LSTM can alleviate the vanishing/exploding gradient problems when trained with backpropagation through time. When we compute the gradients of the error function during backpropagation, their magnitude is influenced by two factors: the weights and the derivatives of the activation functions. If either one of these factors is smaller than 1, then the gradients may vanish in time; if larger than 1, then they may explode.
Let us consider the cell state of eq. (6). The second part of the righthand side of the recurrency (after the sign) is some function of the inputs. When we backpropagate and take the derivative of with respect to , this added term disappears. In the first part of the recurrency, the cell state is multiplied by the output of the forget gate, so we can see as the weights for the cell state. In this case, there is no activation function (besides the identity, which derivative is always one). So, if the forget gate is on (activation close to 1.0), then the gradient does not vanish. Since the forget gate activation is never greater than 1.0, the gradient can’t explode either. This does not solve the vanishing gradient problem in general, but improves the situation a lot compared to vanilla RNNs of eq. (1).
Iv Problem statement
The problem we face in this paper is the remaining time prediction of business process instances. Let us assume there is a Business Process (or a set of them) that generates some business process instances, i.e. traces. Given a trace , it is straightforward to compute the amount of time that has been required for its execution: we just have to subtract the timestamp of the first event in the trace from the one of the last event. We refer to this quantity as the execution time of a trace .
When a process is still running (i.e. it has been not completed yet), we may be interested in estimating how much time is left for it to be completed. In this scenario, a (possibly small) part of its events have been performed. Our problem is then to estimate the difference between the (unknown) process completion time, and the time that passed since its first event has started. More formally, given a trace of which only the first events are known (i.e. we are given ), we want to learn a function that predicts .
Note that in this paper we are interested in predicting just the remaining time for a trace, and not the exact activities that will happen. Indeed, in many real world applications, we are just interested in the completion time of a trace. As a motivation case study, we consider the helpdesk sector of an Italian software company. The remaining time information can be communicated by a helpdesk resource to the customer. In this case, the customer is not interested in the exact steps that will happen, she just wants to know how long she has to wait for her ticket to be solved, as accurately as possible. On the other hand, the ability to know in advance the trend of running process instances would allow business managers to react in time, in order to prevent delays or undesirable situations.
V Related works
The literature proposes plenty of works aiming at improving business processes and provide support for their execution. Historically, the first approaches were based on measuring and monitoring activities and belong to the research area called “Business Activity Monitoring” [14]. The introduction of process mining techniques [32] allowed the automatic analysis of running process instances and the prediction of different aspects for them.
One of the first works that analyzes the execution duration problem is [26]. This particular work concentrates on crosstrained resources, but no detailed prediction algorithm is reported. In [34, 7], van Dongen et al. describe a prediction model which uses all the data recorded in an event log. This approach uses nonparametric regression in order to predict the “cycle time” (i.e., the remaining time) of running process instances. The recommendation system, described by van der Aalst et al. in [28], is built using historical information, and is able to predict the most likely activity that a running case is going to perform. The TIBCO Staffware iProcess Suite [27] is one of the first commercial tools that predicts the remaining time of running process instances. This tool simulates the complete process instance without analyzing historical data. The main building blocks of the prediction are parameters, provided by the users at “build time”, such as the process routing or the expected duration of activities. The first successful framework focused on the time perspective is proposed in [33]. Song et al. describe an approach which builds a finite state machine, called transition system, with respect to a given abstraction of the events inside the events log. An abstraction is a function which maps a trace to a state and it can be very influential to the success of the method. These functions generally create a mapping from a sequence of events (i.e., the trace) to an easier entity, e.g., the set of its events’ activity names. These mappings depend on an hyperparameter (the horizon) that is proportional to the dimension of the state space. The most popular abstractions are: the set, the bag (also called multiset) and the sequence. After the construction of the transition system is then augmented with time information about the historical process instances. The time forecast is performed using statistics over the time information (e.g., mean duration of specific class of cases) collected inside the state of the transition system corresponding to the current running instance. We refer to this method as VDA in SectionVII. The suffixes SET, BAG and SEQ refer to the used abstraction for constructing the transition system. A similar approach is presented in [5]. In this work the authors decorate the transition system with decision trees that are trained, over the collected data, and then used to predict the completion time. Moreover, the proposed method is also able to predict the next activity that a process instance is going to take. One of the first methods which has taken advantage of additional data (i.e., resources) is presented in [20]. The approach considers the data perspective in order to identify SLAs (Service Level Agreement) violations. The actual forecast is built using a multilayer perceptron, trained with the Backpropagation algorithm. An extended version of the technique described in [33] has been proposed by Folino et al. [10, 11]. In particular, the method clusters the log traces according to the corresponding ”context features” (i.e., the additional data of a trace) and then, for each cluster, a predictive model is created by using the method described in [33]. Clustering trees are used to form the clusters. At prediction time, the approach associates the new running instance to one of the clusters and then uses the model belonging to that specific cluster to make the prediction.
A probabilistic approach able to predict the likelihood of future activities, called Instancespecific Probabilistic Process Models (PPM), is reported in [19]. Even though it does not provide a remaining time prediction, it provides to business managers useful insights regarding the progress of the process. Another probabilistic method, based on Hidden Markov Models (HMM), is proposed in [24]. Experimental results seem to show how that the method outperforms the stateoftheart. However, the achieved results are not much different from the ones achieved by the transition system based method presented in [33]. In a recent work [13], Ghattas et al. exploit, what they call, Generic Process Models and decision trees, in order to provide decision criteria defined according to the actual process goals. In [25], Polato et al. proposed another approach based on [33] in which the additional attributes of the events are used in order to improve the remaining time prediction quality. This method exploits the concept of annotated transition system (presented in [33]) by adding machine learning models, such as Naïve Bayes and Support Vector Regressor. Experimental results show how the additional attributes can positively influence the prediction quality. We refer to this method as DATS in Section VII.
There are also approaches coming from different areas. For example, queue theory [16, 3] and queue mining can be seen as an instance of process mining, and recent works are starting to aim for prediction purposes [30]. Here authors focus on the delay prediction problem, i.e., providing information to user waiting in lines, in order to improve customer satisfaction. The method leverage on an annotated transition system. That model is then used to make delay predictions using simple averages or nonlinear regression.
More recently, deep neural network based approaches have been proposed. In [9], a recurrent neural network (RNN) for the prediction of the next process event. The network is composed by two hidden RNN layers using basic LSTM cells (Longshort term memory). Experimental results have shown good precision on the BPI challenge 2012 dataset. A closely related task to the remaining time prediction is the predictive monitoring, in which the goal is to provide early advice so that users can steer ongoing process executions towards the achievement of business constraints. In [22], Maggi et al. present a decision tree based predictor model. This framework continuously estimate how likely is that a user defined constraint will be fulfilled by the current process instances. The same task is faced in [21], where authors present an approach in which traces are treated as complex symbolic sequences. They propose different possible encodings: (i) indexbased and (ii) a combination of the first one and an HMM based one. From an AUC (Area Under the Roc Curve) perspective the proposed encoding outperforms the baselines. Using the same encoding, Verenich et al. [36] proposed a two phases approach: in the first phase the dataset is split in groups by means of unsupervised clustering; in the second phase a model is trained for each cluster. They used random forests as the predictor algorithm. A very similar approach is presented in [12].
The closest related work to the one presented in this paper is [31], where the authors propose a multitask learning modeling based on LSTM. The model predicts the next activity and its duration. Then, they are able to predict the continuation of a trace by iteratively predicting the next activity, until the end of case is predicted. This approach shown bad performance when the log has many repeated events. In [31], the comparison with simpler LSTMs trained for the single tasks is presented just in the setting of the prediction of the single next activity and its completion time. Such comparison in the task of predicting the completion time of a trace is missing.
Vi Our Proposal
We borrow from [31] the idea of applying LSTM on the trace remaining time prediction problem. Indeed, as detailed in Section II, a trace is modeled as a sequence of events, which is exactly the type of input a LSTM expects. Moreover, in recent Process Aware Information Systems, events can have information associated to them, that can be precious in predictive tasks such the one we are considering [25]. In our modeling (see Section II), we assume such additional information to be encoded in a fixedsize vector. Such vector can have both categorical or realvalued feature. Given an event log , we have to define a representation that is suitable for an LSTM network.
LSTM is defined over sequences of vectors as inputs, and hence we need to encode the event and its attributes in a fixedsize vector.
To do that, we encode the activity of the event () using a onehot encoding.
Moreover, we compute other features for each event, such as the time from trace start, time from last event, the time and weekday in which the event started.
Finally, we append to these features the encoded event attributes, in which categorical attributes are again onehot encoded, generated according to the following procedure.
Let us assume we know the number of attributes.
Let us also assume to have a function that returns the number of distinct values that can take in the log if is a categorical variable, or if is a realvalued attribute.
Then we can define the vector of length that will be our vectorial encoding for the attributes associated to an event . For each attribute , we will set if it is a realvalued attribute, or if it is categorical. Note that we use the hashing trick, with he function that maps from the space of possible distinct values of to the set of integers .
Eventually, we end up with a vector representation of an event, which size depends on the dataset, but that can be determined apriori knowing which data is available.
At this point, a trace is a sequence of events in their vectorial form. We can fix the maximum length of a trace (e.g., the maximum length of all the traces in the training data) obtaining a matrix representation for each (possibly partial) trace, where the matrix is filled with padding rows if the length of the trace is lower than the number of rows in the matrix. This matrix is a training example for our LSTM.
Note that, for training, we excluded completed traces that would have target to zero since it is out of the scope of our considered problem to predict if a trace is completed or not.
Vii Experimental Results
In this section, we compare our proposed DALSTM method against LSTM [31], three variants of DATS [25] and three variants of VDA [1] on three realworld datasets.
Viia Dataset description
For our experimental we adopted two real world datasets, one of which have been filtered to simplify the task, keeping only the traces with a certain endpoint activity. The result of this processing is a third, simpler dataset, that however reflects real world data. In the following, we describe in detail each dataset.

Helpdesk2017: this log is a reallife log of SIAV s.p.a. company in Italy. The event log represents instances of a ticketing process in the company helpdesk area. The cases range from July 2016 to February 2017. The log has 15,682 events, 4,454 cases and 10 activities in total. Each event has 7 attributes: resource, customer, product are literal type instead severity, serviceLevel, serviceType, ticketDifficulty are numeric type.

BPI12: this is a filtered version of the dataset from BPI 2012 challenge. The BPI 2012 challenge dataset represents a reallife log of Dutch Financial Institute. The event log describes an application process for a personal loan or overdraft within a global financing organization. The data has been filtered, we have taken events that are performed manually. Further, we have considered only events of type complete. This is the same dataset as in [31]: it contains 9,658 cases, 72,413 events and 6 different activities. There are two different event’s attributes the amount_req, that represents the amount requested by the customer. It’s a global attribute, i.e. every case contains amount_req attribute and it never changes in the same trace. The other one is the resource of the activity and the set has 60 values.

BPI12_oneEndAct: this is a subset of BPI12 dataset. In the filtering we have considered only traces with the same endpoint activity. The selected event is W_Valideren aanvraagCOMPLETE, because many traces finish with this activity. The final log has 31,829 events, 2,751 cases and 6 activities.
ViiB Implementation details
We implemented our proposed DALSTM network using the Keras framework [6]. For the LSTM [31] baseline, we fixed the number of shared layers to as suggested in the original paper. For both our approach and the LSTM [31] baseline, we tested different network configurations, validating the number of LSTM neurons per layer in and the number of layers in . Note that, for the proposed DALSTM, the results are relatively stable varying the architecture (at most approximately 0.025% difference in MAE between the worst and the best architecture). As learning algorithm, we adopted Nadam [8]. The VAD and DATS baseline experiments have been performed in ProM 6.5.1, that is an opensource framework of process mining [35]. It contains many plugins and it is written in Java. In particular we used the plugin implemented in [25]. For the VDA baseline, we tested all possible abstractions for transition system construction (sequence, set and bag). In the same way, for the DATS baseline, we have done a comparison between all abstractions. We used a grid to search the best hyperparameters, where the minimum value is and the maximum value is . The considered hyperparameters are the parameter for RBF kernel and the cost for SVR. We tested all possible pairs and chose the one with the minimal validation error.
BPI12 dataset is a reallife event log of a financial institute, which has a very complex workflow. For this reason the transition system construction for sequence and bag abstractions with the horizon set to infinity is hard. The plugin creates more then states and it is heavy to store and access in memory. So, for BPI12 and BPI12_oneEndAct datasets, we have decided to reduce the horizon to for sequence and bag abstractions.
ViiC Experimental setup
As stated in Section IV, we face the problem of predicting the remaining time required from a partial trace to complete.
In order to assess the performances of our proposed method, we adopted the datasets presented in the previous section.
The considered datasets comprehends only complete traces.
In order to derive partial traces from a trace of length , we generate one partial trace for each prefix length , i.e. the set of partial traces corresponding to a trace is .
Differently from [31], we consider all prefix lengths, including partial traces with just one event. This choice is motivated by the fact that the proposed method, if implemented in a real business environment like the helpdesk of our casestudy, has to be able to predict a completion time right after the ticket has been opened. In this way the remaining time predicted can help company resources to inform the final client how long will the ticket takes to be resolved.
We use the first of the traces as training and validation data (we randomly sample the 20% of training data as validation set).
We use the valdation set for selecting the best hyperparameters and network architecture.
Finally, we evaluate the time predictions on the remaining of the traces (test set).
As performance measure, we consider the Mean Absolute Error (MAE), that is an error measure among continuous variables.
Let the desired output, and be the output predicted from a model on , for some data samples . Than we can define the MAE as:
The MAE has an intuitive interpretation as the average absolute difference between the prediction and the expected output. Being an error measure, the lower the better. We computed the root mean squared error as well, and the results were concordant so we decided not to report them.
Method/Dataset  Helpdesk2017  BPI12  BPI12_oneEndAct 

VDASEQ [1]  5.95  8.74  6.60 
VDASET [1]  6.03  8.45  5.80 
VDABAG [1]  6.06  8.69  6.58 
DATSSEQ [25]  5.27  8.13*  5.44* 
DATSSET [25]  5.53  8.15  5.43 
DATSBAG [25]  5.37  8.12*  5.50* 
LSTM [31]  4.03  9.74  5.95 
(n=150, l=5)  (n=150, l=5)  (n=100, l=3)  
DALSTM  4.01  7.04  4.65 
(n=250, l=5)  (n=100, l=4)  (n=250, l=1) 
Table I reports the results of our experiments. For each dataset and method, we report the MAE in days. For the two methods based on LSTM, we furthermore report the number of neurons and number of layers of the selected network architecture. Note that, on this scale, it makes little sense to compare decimal points, i.e. for the results discussion, we will round the results considering whole days. In the Helpdesk2017 dataset, LSTM [31] is the better performing method among the competitors. Our proposed DALSTM shows basically the same performance.
Let us now consider the BPI12 dataset. One characteristic of this dataset is that the same trace may have multiple events corresponding to the same activity. This is an issue for LSTM [31] (see Section V), that is the worst performing method on this dataset. The four variations of VDA [1] generally perform slightly better, with the SET abstraction being the better performing one. The DATS [25] method shows improved performance compared to VDA. In this case, the BAG abstraction is the best among the three variants. Our proposed method is the better performing one, with a MAE difference with respect to the best competitor of more than day.
As for the BPI12_OneEndAct dataset, VDASET [1] and LSTM [31] show comparable performance, with the former showing a slightly lower MAE. DATS [25] is again the better performing method among the competitors, with all its variants performing better than VDA and LSTM. In this dataset, our proposed DALSTM is able to improve the performance of DATS, showing again the best predictive performances among the considered methods, with a MAE gap of almost days on the second best method.
From the table we can see that the proposed DALSTM method has always higher predictive performance with respect to the best baseline approach.
From these results it emerges that for the Helpdesk2017 dataset the most important information lies in the workflow, and not in the additional events’ attributes. On the contrary, for the BPI12 dataset, the techniques that consider additional attributes (DATS and the proposed DALSTM) are the best performing ones, showing the importance of considering such attributes in the learning procedure.
A note on computational times. The computational time required for training our proposed model is in general lower compared to [31], because we have a single output layer. The main advantage is in the prediction phase, where our approach have to perform just one prediction per trace while, on the other hand, [31] have to perform one prediction for every (predicted) activity in the continuation of the trace. From a realworld point of view, this difference may be important since, for instance in our helpdesk case study, having a fast prediction means that it is possible to give an user the expected completion time right after the insertion of the ticket in the system (e.g. while he is still on the phone), even under heavy load. In this way the customer can know in a more precise way the expected waiting time, and the helpdesk service can monitor the behavior of such predictions in order to maximize its efficiency.
Viii Conclusion
In this paper, we proposed a new method for the problem of remaining time prediction of Business Process Instances. Our approach is based on LSTM, a specific type of Recurrent Neural Network. It allows to associate additional information to each event, that may be useful for the task. We demonstrated the quality of our proposal with experiments on several realworld datasets. As a future work, we plan to explore techniques for alleviating the encoding size resulting from having many categorical features among the attributes. Indeed, when the universe of values a discrete value can take is high, the dimensionality of the vectorial encoding of each activity grows as well. Hashing techniques and random projections can be applied in order to make the approach more spaceefficient.
Moreover, we plan to apply other machine learning techniques to the problem faced in this paper, e.g. kernels for sequences coupled with SVM.
References
 [1] V. D. Aalst. Time prediction based on process mining. Information Systems, 36(2):450–475, 2011.
 [2] Y. Bengio, P. Simard, and P. Frasconi. Learning longterm dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2):157–166, mar 1994.
 [3] G. Bolch, S. Greiner, H. de Meer, and K. S. Trivedi. Queueing networks and Markov chains: modeling and performance evaluation with computer science applications. John Wiley & Sons, 2006.
 [4] A. Burattin. Process Mining Techniques in Business Environments, volume 207 of Lecture Notes in Business Information Processing. Springer International Publishing, Cham, 2015.
 [5] M. Ceci, P. F. Lanotte, F. Fumarola, D. P. Cavallo, and D. Malerba. Completion time and next activity prediction of processes using sequential pattern mining. In Discovery Science  17th International Conference, DS 2014, Bled, Slovenia, October 810, 2014. Proceedings, pages 49–61, 2014.
 [6] F. Chollet et al. Keras. https://github.com/fchollet/keras, 2015.
 [7] R. Crooy. Predictions in Information Systems  A process mining perspective. Master thesis, Technische Universiteit Eindhoven, 2008.
 [8] T. Dozat. Incorporating Nesterov Momentum into Adam. In ICLR Workshop, 2016.
 [9] J. Evermann, J.R. Rehse, and P. Fettke. A Deep Learning Approach for Predicting Process Behaviour at Runtime, pages 327–338. Springer International Publishing, Cham, 2017.
 [10] F. Folino, M. Guarascio, and L. Pontieri. Discovering contextaware models for predicting business process performances. In Proceedings of On the Move to Meaningful Internet Systems Conference: OTM, volume 7565, pages 287–304. Springer Berlin Heidelberg, 2012.
 [11] F. Folino, M. Guarascio, and L. Pontieri. Discovering HighLevel Performance Models for Ticket Resolution Processes. In Proceedings of On the Move to Meaningful Internet Systems Conference: OTM, volume 8185, pages 275–282. Springer Berlin Heidelberg, 2013.
 [12] C. D. Francescomarino, M. Dumas, F. M. Maggi, and I. Teinemaa. Clusteringbased predictive process monitoring. IEEE Transactions on Services Computing, PP(99):1–1, 2017.
 [13] J. Ghattas, P. Soffer, and M. Peleg. Improving business process decision making based on past experience. Decision Support Systems, 59:93–107, Mar. 2014.
 [14] M. Golfarelli, S. Rizzi, and I. Cella. Beyond Data Warehousing : What ’ s Next in Business Intelligence ? In 7th ACM international workshop on Data warehousing and OLAP, pages 1–6, 2004.
 [15] A. Graves. Supervised Sequence Labelling with Recurrent Neural Networks, volume 385 of Studies in Computational Intelligence. Springer Berlin Heidelberg, Berlin, Heidelberg, aug 2012.
 [16] R. W. Hall. Queueing methods for services and manufacturing. Prentice Hall, 1990.
 [17] M. Hammer and J. Champy. Reengineering the Corporation: A Manifesto for Business Revolution. Nicholas Brealey Publishing, London, 1993.
 [18] S. Hochreiter and J. Urgen Schmidhuber. Long ShortTerm Memory. Neural Computation, 9(8):1735–1780, 1997.
 [19] G. T. Lakshmanan, D. Shamsi, Y. N. Doganata, M. Unuvar, and R. Khalaf. A markov prediction model for datadriven semistructured business processes. Knowledge and Information Systems, Oct. 2013.
 [20] P. Leitner, B. Wetzstein, F. Rosenberg, A. Michlmayr, S. Dustdar, and F. Leymann. Runtime prediction of service level agreement violations for composite services. In International Workshops, ICSOC/ServiceWave, pages 176–186. Springer, 2009.
 [21] A. Leontjeva, R. Conforti, C. Di Francescomarino, M. Dumas, and F. M. Maggi. Complex Symbolic Sequence Encodings for Predictive Monitoring of Business Processes, pages 297–313. Springer International Publishing, Cham, 2015.
 [22] F. M. Maggi, C. Di Francescomarino, M. Dumas, and C. Ghidini. Predictive Monitoring of Business Processes, pages 457–472. Springer International Publishing, Cham, 2014.
 [23] Object Management Group (OMG). Business Process Model and Notation (BPMN) Version 2.0. Business, 50(January):170, 2011.
 [24] S. Pandey, S. Nepal, and S. Chen. A testbed for the evaluation of business process prediction techniques. In 7th International Conference on Collaborative Computing: Networking, Applications and Worksharing (CollaborateCom), pages 382–391, Oct 2011.
 [25] M. Polato, A. Sperduti, A. Burattin, and M. de Leoni. Dataaware remaining time prediction of business process instances. In 2014 International Joint Conference on Neural Networks (IJCNN), pages 816–823. IEEE, jul 2014.
 [26] H. Reijers. Case prediction in BPM systems: a research challenge. Journal of the Korean Institute of Industrial Engineers, 33(1):1–10, 2006.
 [27] B. Schellekens. Cycle time prediction in Staffware. Master thesis, Technische Universiteit Eindhoven, 2009.
 [28] H. Schonenberg, B. Weber, B. F. van Dongen, and W. M. P. van der Aalst. Supporting flexible processes through recommendations based on history. In Proceedings of 6th International Conference BPM, pages 51–66. Springer, 2008.
 [29] H. T. Seigelmann and E. D. Sontag. On the Computational Power of Neural Nets, 1995.
 [30] A. Senderovich, M. Weidlich, A. Gal, and A. Mandelbaum. Queue mining for delay prediction in multiclass service processes. Information Systems, 53:278 – 295, 2015.
 [31] N. Tax, I. Verenich, M. L. Rosa, and M. Dumas. Predictive Business Process Monitoring with LSTM Neural Networks. In CAiSE, 2017.
 [32] W. M. P. van der Aalst. Process Mining  Discovery, Conformance and Enhancement of Business Processes. Springer, 1st edition, 2011.
 [33] W. M. P. van der Aalst, H. Schonenberg, and M. Song. Time prediction based on process mining. Information Systems, 36(2):450–475, Apr. 2011.
 [34] B. F. Van Dongen, R. A. Crooy, and W. M. P. Van Der Aalst. Cycle time prediction: When will this case finally be finished? Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), 5331 LNCS(PART 1):319–336, 2008.
 [35] B. F. van Dongen, A. K. A. de Medeiros, H. M. W. Verbeek, A. J. M. M. Weijters, and W. M. P. van der Aalst. The ProM Framework: A New Era in Process Mining Tool Support. In Applications and Theory of Petri Nets 2005, volume Volume 353, pages 444–454, 2005.
 [36] I. Verenich, M. Dumas, M. L. Rosa, F. M. Maggi, and C. D. Francescomarino. Complex symbolic sequence clustering and multiple classifiers for predictive process monitoring. In 11th International Workshop on Business Process Intelligence 2015, pages 218–229, Innsbruck, Austria, December 2016. Springer.