Content uploaded by Gyunam Park
Author content
All content in this area was uploaded by Gyunam Park on Nov 05, 2022
Content may be subject to copyright.
OPerA: Object-Centric Performance Analysis
Gyunam Park[0000−0001−9394−6513], Jan Niklas Adams[0000−0001−8954−4925], and
Wil. M. P. van der Aalst[0000−0002−0955−6940]
Process and Data Science Group (PADS), RWTH Aachen University
{gnpark,niklas.adams,wvdaalst}@pads.rwth-aachen.de
Abstract. Performance analysis in process mining aims to provide in-
sights on the performance of a business process by using a process model
as a formal representation of the process. Such insights are reliably in-
terpreted by process analysts in the context of a model with formal
semantics. Existing techniques for performance analysis assume that a
single case notion exists in a business process (e.g., a patient in health-
care process). However, in reality, different objects might interact (e.g.,
order, item, delivery, and invoice in an O2C process). In such a setting,
traditional techniques may yield misleading or even incorrect insights on
performance metrics such as waiting time. More importantly, by consid-
ering the interaction between objects, we can define object-centric per-
formance metrics such as synchronization time, pooling time, and lagging
time. In this work, we propose a novel approach to performance analy-
sis considering multiple case notions by using object-centric Petri nets
as formal representations of business processes. The proposed approach
correctly computes existing performance metrics, while supporting the
derivation of newly-introduced object-centric performance metrics. We
have implemented the approach as a web application and conducted a
case study based on a real-life loan application process.
Keywords: Performance Analysis ·Object-Centric Process Mining ·
Object-Centric Petri Net ·Actionable Insights ·Process Improvement
1 Introduction
Process mining provides techniques to extract insights from event data recorded
by information systems, including process discovery, conformance checking, and
performance analysis [1]. Especially performance analysis provides techniques to
analyze the performance of a business process, e.g., bottlenecks, using process
models as representations of the process [6].
Existing techniques for performance analysis have been developed, assum-
ing that a single case notion exists in business processes, e.g., a patient in a
healthcare process [5, 6, 10, 14, 16,17, 19]. Such a case notion correlates events of
a process instance and represents them as a single sequence, e.g., a sequence of
events of a patient. However, in real-life business processes supported by ERP
systems such as SAP and Oracle, multiple objects (i.e., multiple sequences of
events) exist in a process instance [2,7] and they share events (i.e., sequences are
arXiv:2204.10662v2 [cs.AI] 27 Jun 2022
2 G. Park, J. N. Adams, and W.M.P. van der Aalst
overlapping). Fig. 1(a) shows a process instance in a simple blood test process as
multiple overlapping sequences. The red sequence represents the event sequence
of test T1, whereas the blue sequences indicate the event sequences of samples
S1 and S2, respectively. The objects share conduct test event (e4 ), i.e., all the
sequences overlap, and the samples share transfer samples event (e6 ), i.e., the
sample sequences overlap.
Fig. 1. A motivating example showing misleading insights from existing approaches to
performance analysis and the proposed object-centric performance analysis
The goal of object-centric performance analysis is to analyze performance in
such “object-centric” processes with multiple overlapping sequences using 1) ex-
isting performance measures and 2) new performance measures considering the
interaction between objects. Fig. 1(b)(1) visualizes existing performance mea-
sures related to event conduct test.Waiting time of conduct test is the time
spent before conducting the test after preparing test T1 and samples S1 and
S2, while the service time is the time spent for conducting the test and sojourn
time is the sum of waiting time and service time. Furthermore, Fig. 1(b)(2)
shows new performance measures considering the interaction between objects.
First, synchronization time is the time spent for synchronizing different objects,
i.e., samples S1 and S2 with test T1 to conduct the test. Next, pooling time is
the time spent for pooling all objects of an object type, e.g., the pooling time of
OPerA: Object-Centric Performance Analysis 3
conduct test w.r.t. sample is the time taken to pool the second sample. Third,
lagging time is the time spent due to the lag of an object type, e.g., the lagging
time of conduct test w.r.t. test is the time taken due to the lag of the second
sample. Finally, flow time is the sum of sojourn time and synchronization time.
A natural way to apply existing techniques to multiple overlapping sequences
is to flatten them into a single sequence. To this end, we select an object type(s)
as a case notion, removing events not having the object type and replicating
events with multiple objects of the selected type [2]. For instance, Fig. 1(a) is
flattened to Fig. 1(c) by using test as a case notion, to Fig. 1(d) by using sample
as a case notion, and Fig. 1(e) by using both test and sample as a case notion.
However, depending on the selection, flattening results in misleading insights.
Fig. 1(f) summarizes the correctness of object-centric performance analysis on
flattened sequences. 1) Flattening on test provides a misleading waiting time,
measured as the time difference between the complete time of prepare test and
the start time of conduct test, and, thus, a misleading sojourn time. 2) Flattening
on sample results in misleading insights on the service time since two service
times are measured despite the single occurrence of the event. 3) By flattening
on both test and sample, the waiting time for take sample is measured in relation
to prepare test although they are independent events from different object types.
In this work, we suggest a novel approach to object-centric performance anal-
ysis. The approach uses an Object-Centric Event Log (OCEL) that store multiple
overlapping sequences without flattening (cf. Fig. 1(g)) as an input. Moreover, we
use Object-Centric Petri Nets (OCPNs) [2] as a formalism to represent process
models, and the object-centric performance is analyzed in the context of process
models. With formal semantics of OCPNs, we can reliably compute and interpret
performance analysis results, considering the concurrency, loops, etc [?].
More in detail, we first discover an OCPN that formally represents a process
model from the OCEL. Next, we replay the OCEL on the discovered OCPN to
produce token visits and event occurrences. Finally, we compute object-centric
performance measures using the token visit and event occurrence. For instance,
in the proposed approach, the waiting time of Conduct test is computed as the
difference between e4 ’s start and e1 ’s complete. The synchronization time is
computed as the time difference between e3 ’s complete and e1 ’s complete.
In summary, we provide the following contributions.
1. Our approach correctly calculates existing performance measures in an object-
centric setting.
2. Our approach supports novel object-centric performance metrics taking the
interaction between objects into account, such as synchronization time.
3. The proposed approach has been implemented as a web application1and
a case study with a real-life event log has been conducted to evaluate the
effectiveness of the approach.
The remainder is organized as follows. We discuss the related work in Sec. 2.
Next, we present the preliminaries, including OCELs and OCPNs in Sec. 3. In
1A demo video, sources, and manuals are available at https://github.com/
gyunamister/OPerA
4 G. Park, J. N. Adams, and W.M.P. van der Aalst
Sec. 4, we explains the approach to object-centric performance analysis. After-
ward, Sec. 5 introduces the implementation of the proposed approach and a case
study using real-life event data. Finally, Sec. 6 concludes the paper.
2 Related Work
2.1 Performance Analysis in Process Mining
Performance analysis has been widely studied in the context of process min-
ing. Table 1 compares existing work and our proposed work in different criteria:
1) if formal semantics exist to analyze performance in the context of process
models, 2) if aggregated measures, e.g., mean and median, are supported, 3)
if frequency analysis is covered, 4) if time analysis is covered, and 5) if mul-
tiple case notions are allowed to consider the interactions of different objects.
Existing algorithms/techniques assume a single case notion, not considering the
interaction among different objects.
Table 1. Comparison of algorithms/techniques for performance analysis
Author Technique Form. Agg. Freq. Perf. Obj.
Mat´e et al. [17] Business Strategy Model -X X X -
Denisov et al. [10] Performance Spectrum -X X X -
Hornix [14] Petri Nets X X X X -
Rogge-Solti et al. [19] Stochastic Petri Nets X X -X-
Leemans et al. [16] Directly Follows Model X X X X -
Adriansyah et al. [6] Robust Performance X X X X -
Adriansyah [5] Alignments X X X X -
Our work Object-Centric X X X X X
2.2 Object-Centric Process Mining
Traditionally, methods in process mining have the assumption that each event
is associated with exactly one case, viewing the event log as a set of isolated
event sequences. Object-centric process mining breaks with this assumption,
allowing one event to be associated with multiple cases and, thus, having shared
events between event sequences. An event log format has been proposed to store
object-centric event logs [13], as well as a discovery technique for OCPNs [2]
and a conformance checking technique to determine precision and fitness of the
net [4]. Furthermore, Esser and Fahland [11] propose a graph database as a
storage format for object-centric event data, enabling a user to use queries to
calculate different statistics. A study on performance analysis is, so far, missing
in the literature, with only limited metrics being supported in [2] by flattening
event logs and replaying them. However, object-centric performance metrics are
OPerA: Object-Centric Performance Analysis 5
needed to accurately assess performance in processes where multiple case notions
occur.
The literature contains several notable approaches to deal with multiple case
notions. Proclets [12] is the first introduced modeling technique to describe
interacting workflow processes and, later, artifact-centric modeling [9] extends
this approach. DB nets [18] are a modeling technique based on colored Petri
nets. OCBC [3] is a newly proposed technique that includes the evolution of a
database into an event log, allowing for the tracking of multiple objects. Object-
centric process mining aims to alleviate the weaknesses of these techniques. The
approaches and their weaknesses are more deeply discussed in [2].
3 Background
3.1 Object-Centric Event Data
Definition 1 (Universes). Let Uei be the universe of event identifiers, Uact the
universe of activity names, Utime the universe of timestamps, Uot the universe of
object types, and Uoi the universe of object identifiers. type ∈Uoi →Uot assigns
precisely one type to each object identifier. Uomap ={omap ∈Uot 6→ P(Uoi )|
∀ot∈dom (omap )∀oi∈omap (ot )type(oi )=ot }is the universe of all object mappings
indicating which object identifiers are included per type. Uevent=Uei ×Uact ×
Utime ×Utime ×Uomap is the universe of events.
Given e=(ei, act, st, ct, omap)∈Uevent ,πei(e)=ei,πact(e)=act,πst (e)=st,
πct(e)=ct, and πomap (e)=omap. Note that we assume an event has start and
complete timestamps.
Fig. 1(b) describes a fraction of a simple object-centric event log with two
types of objects. For the event in the fourth row, denoted as e4, πei(e4)=e4,
πact(e4)=conduct test,πst(e4) = 180,πct (e4)=240,πomap(e4)(test)={T1}, and
πomap(e4)(sample)={S1,S2}. Note that the timestamp in the example is sim-
plified using the relative scale.
Definition 2 (Object-Centric Event Log (OCEL)). An object-centric event
log is a tuple L=(E, ≺E), where E⊆Uevent is a set of events and ≺E⊆E×E
is a total order underlying E.ULis the set of all possible object-centric event
logs.
3.2 Object-Centric Petri Nets
A Petri net is a directed graph having places and transitions as nodes and flow
relations as edges. A labeled Petri net is a Petri net where the transitions can
be labeled.
Definition 3 (Labeled Petri Net). A labeled Petri net is a tuple N=(P, T, F, l)
with Pthe set of places, Tthe set of transitions, P∩T=∅,F⊆(P×T)∪(T×P)
the flow relation, and l∈T6→ Uact a labeling function.
6 G. Park, J. N. Adams, and W.M.P. van der Aalst
Each place in an OCPN is associated with an object type to represent inter-
actions among different object types. Besides, variable arcs represent the con-
sumption/production of a variable amount of tokens in one step.
Definition 4 (Ob ject-Centric Petri Net). An object-centric Petri net is a
tuple ON =(N, pt, Fvar )where N=(P, T, F, l)is a labeled Petri net, pt ∈P→
Uot maps places to object types, and Fvar ⊆Fis the subset of variable arcs.
Fig. 3(a) depicts an OCPN, ON1=(N, pt, Fvar ) with N=(P, T , F, l) where
P={p1, . . . , p9},T={t1, . . . , t6},F={(p1, t1),(p2, t2), . . . },l(t1)=prepare test, etc.,
pt(p1)=test,pt(p2)=sample, etc., and Fvar ={(p4, t3),(t3, p6), . . . }.
Definition 5 (Marking). Let ON =(N , pt, Fvar )be an object-centric Petri net,
where N=(P, T, F, l).QON ={(p, oi )∈P×Uoi |type(oi)=pt(p)}is the set of
possible tokens. A marking Mof ON is a multiset of tokens, i.e., M∈ B(QON ).
For instance, marking M1=[(p3, T 1),(p4, S1),(p4, S2)] denotes three tokens,
among which place p3 has one token referring to object T1 and p4 has two
tokens referring to objects S1 and S2.
A binding describes the execution of a transition consuming objects from its
input places and producing objects for its output places. A binding (t, b) is a
tuple of transition tand function bmapping the object types of the surrounding
places to sets of object identifiers. For instance, (t3, b1) describes the execution
of transition t3 with b1 where b1(test)={T1}and b1(sample)={S1, S2}, where
test and sample are the object types of its surrounding places (i.e., p3, p4, p5, p6).
A binding (t, b) is enabled in marking Mif all the objects specified by bexist
in the input places of t. For instance, (t3, b1) is enabled in marking M1since T1,
S1, and S2 exist in its input places, i.e., p3 and p4.
A new marking M0is reached by executing enabled binding (t, b) at Mleads
to, denoted by M(t,b)
−→ M0. As a result of executing (t1, b1), T1 is removed from
p3 and added to p5. Besides, S1 and S2 are removed from p4 and added to p6,
resulting in new marking M0=[(p5, T 1),(p6, S1),(p6, S2)].
4 Object-Centric Performance Analysis
This section introduces an approach to object-centric performance analysis.
Fig. 2 shows an overview of the proposed approach. First, we discover an OCPN
based on an OCEL. Next, we replay the OCEL with timestamps on the dis-
covered OCPN to connect events in the OCEL to the elements of OCPN and
compute event occurrences and token visits. Finally, we measure various object-
centric performance metrics based on the event occurrence and token visit. The
discovery follows the general approach presented in [2]. In the following subsec-
tions, we focus on explaining the rest.
OPerA: Object-Centric Performance Analysis 7
Fig. 2. An overview of the proposed approach.
4.1 Replaying OCELs on OCPNs
First, we couple events in an OCEL to an OCPN by “playing the token game”
using the formal semantics of OCPNs. Note that most of business processes are
not sequential, and, thus, simply relating an event to its directly following event
does not work. By using the semantics of OCPNs, we can reliably relate events
to process models by considering the concurrency and loop and correctly identify
relationships between events.
As a result of the replay, a collection of event occurrences are annotated to
each visible transition, and a collection of token visits are recorded for each place.
First, an event occurrence represents the occurrence of an event in relation to a
transition.
Definition 6 (Event Occurrence). Let ON =(N , pt, Fvar )be an object-centric
Petri net, where N=(P, T, F, l). An event occurrence eo ∈T×Uevent is a tuple
of a transition and an event. OON is the set of possible event occurrences of ON.
For instance, (t3 ,e4 )∈OON1is a possible event occurrence in ON 1shown
in Fig. 3(a). It indicates that t3 is associated with the occurrence of event e4 . In
other words, t3 is fired by 1) consuming tokens (p3 ,T1 ) from p3 and (p4 ,S1 )
and (p4 ,S2 ) fromp4 at 180 and 2) producing tokens (p5 ,T1 ) to p5 and (p6 ,S1 )
and (p6 ,S2 )p6 at 240. Note that we derive the consumed and produced tokens
by using the transition and the event, i.e., we are aware of the input and output
places of the transition and the involved objects of the event. Moreover, we know
when the event starts and completes.
A token visit describes “visit” of a token to the corresponding place with the
begin time of the visit, i.e., the timestamp when the token is produced, and the
end time of the visit, i.e., the timestamp when the token is consumed.
Definition 7 (Token Visit). Let ON =(N, pt , Fvar )be an object-centric Petri
net, where N=(P, T, F, l).QON ={(p, oi )∈P×Uoi |type(oi)=pt(p)}is the set
of possible tokens. A token visit tv ∈QON ×Utime ×Utime is a tuple of a token,
a begin time, and an end time. TV ON is the set of possible token visits of ON .
Given token visit tv=((p, oi), bt, et), πp(tv)=p,πoi(tv)=oi,πbt(tv)=bt, and
πet(tv)=et. For instance, ((p3 ,T1 ),15,180) ∈TV ON 1is a possible token visit
8 G. Park, J. N. Adams, and W.M.P. van der Aalst
Fig. 3. An example of replaying object-centric event logs on an object-centric Petri net
in ON 1shown in Fig. 3. It represents that token (p3 ,T1 )∈QON 1is produced
in place p3 at 15 and consumed at 180.
Given an OCEL, a replay function produces event occurrences and token
visits of an OCPN, connecting events in the log to the OCPN.
Definition 8 (Replay). Let ON be an object-centric Petri net. A replay func-
tion replayON ∈UL→ P(OON )× P(VON )maps an event log to a set of event
occurrences and a set of token visits.
Fig. 3(b) shows the result of replaying the events in L1shown in Fig. 3(a) on
model ON1depicted in Fig. 3(a). The dark gray boxes represent event occur-
rences O1and the light gray boxes represent token visits V1, where replayON1(L1)
=(O1, V1). For instance, replaying event e1 and e4 in L1produces event oc-
currences, (t1 ,e1 ) and (t3 ,e4 ), respectively, and token visit ((p3 ,T1 ),15,180)
where 15 is the time when e1 completes and 180 is the time when e4 starts.
In this work, we instantiate the replay function based on the token-based
replay approach described in [8]. We first flatten an OCEL to a traditional event
log and project an OCPN to an accepting Petri net for each object type. Next,
we apply the token-based replay for each log and Petri net, as introduced in [2].
The replay function needs to be instantiated to ignore non-fitting events to deal
with logs with non-perfect fitness. To simplify matters, we assume the flattened
logs perfectly fit the projected Petri nets (i.e., no missing or remaining tokens).
OPerA: Object-Centric Performance Analysis 9
4.2 Measuring Object-Centric Performance Measures
We compute object-centric performance measures per event occurrence. For in-
stance, we compute synchronization,pooling,lagging, and waiting time of (t3 ,e4 )
that analyzes an event of conduct test. For meaningful insights, we may aggre-
gate all waiting time measures of conduct test events into the average, median,
maximum, or minimum waiting time of conduct test.
To this end, we first relate an event occurrence to the token visits 1) associ-
ated with the event occurrence’s transition and 2) involving the objects linked
to the event occurrence’s event.
Definition 9 (Relating An Event Occurrence to Token Visits). Let Lbe
an object-centric event log and ON an object-centric Petri net. Let eo=(t, e)∈O
be an event occurrence. OI(eo)= Sot ∈dom(πomap (e)) πomap (e)(ot)denotes the set
of objects related to the event occurrence. relON ∈OON × P (VON )→ P(VON )is
a function mapping an event occurrence and a set of token visits to the set of the
token visits related to the event occurrence, s.t., for any eo ∈OON and V⊆VON ,
relON (eo, V )= Soi∈OI (eo)argmax tv∈{tv0∈V|πp(tv0)∈•t∧πoi (tv0)=oi}πbt (tv).
Fig. 4(a) shows the token visits related to eo 1=(t3 ,e4 ). relON 1(eo1, V1)={tv1=((
p3 ,T1 ),15,180), tv2=((p4 ,S1 ),120,180), tv3=((p4 ,S2 ),150,180)}since p3 ,p4
∈ •t3, {T1 ,S1 ,S2 } ⊆ OI(eo1), and each token visit is with the latest begin
time among other token visits of the corresponding object, e.g., tv1is the latest
token visit of T1 .
A measurement function computes a performance measure of an event oc-
currence by using the related token visits.
Definition 10 (Measurement). Let ON be an object-centric Petri net. measure
∈OON ×P (VON )→Ris a function mapping an event occurrence and its related
token visits to a performance value. Umdenotes the set of all such functions.
In this paper, we introduce seven measurement functions to compute object-
centric performance measures as shown in Fig. 4(c). With Lan OCEL, ON
an OCPN, and (O, V )=replayON (L), we introduce the functions with formal
definitions and examples as below:
–flow ∈Umcomputes flow time, i.e., the time difference between the comple-
tion of the event and the earliest token visit related to the event. Formally,
for any eo=(t, e)∈O,flow(eo, V )=πct (e)−min(T) with T={πbt(tv)|tv ∈
relON (eo, V )}. In Fig. 4(c), the flow time of eo1is the time difference be-
tween the completion of the event, i.e., the completion time of e4 (240), and
the earliest token visit related to the event, i.e., the begin time of tv1(15).
Note that flow time is equal to the sum of synchronization time and sojourn
time.
–sojourn ∈Umcomputes sojourn time, i.e., the time difference between the
completion of the event and the latest token visit related to the event. For-
mally, for any eo=(t, e)∈O,sojourn(eo, V )=πct (e)−max (T) with T={πbt (tv)
10 G. Park, J. N. Adams, and W.M.P. van der Aalst
Fig. 4. An example of corresponding token visits of an event occurrence and object-
centric performance measures of the event occurrence
|tv ∈relON (eo, V )}. In Fig. 4(c), the sojourn time of eo1is the time dif-
ference between the completion of the event, i.e., the completion time of e4
(240), and the latest token visit related to the event, i.e., the begin time of
tk3(150). Note that sojourn time is equal to the sum of waiting time and
service time.
–wait ∈Umcomputes waiting time, i.e., the time difference between the start
of the event and the latest token visit related to the event. Formally, for
any eo=(t, e)∈O,wait(eo, V )=πst(e)−max (T) with T={πbt (tv)|tv ∈
relON (eo, V )}. In Fig. 4(c), the waiting time of eo1is the time difference
between its start, i.e., the start time of e4 (180), and the latest token visit,
i.e., the begin time of tk3(150).
–service ∈Umcomputes service time, i.e., the time difference between the
completion of the event and the start of the event. Formally, for any eo=(t, e)∈
O,service(eo, V )=πct (e)−πst(e). In Fig. 4(c), the service time of eo1is the
time difference between the completion of the event, i.e., the completion time
of e4 (240), and the start of the event, i.e., the start time of e4 (180).
–sync ∈Umcomputes synchronization time, i.e., the time difference between
the latest token visit and the earliest token visit related to the event. For-
mally, for any eo=(t, e)∈O,sync(eo, V )=max (T)−min (T) with T={πbt (tv)|
tv ∈relON (eo, V )}. In Fig. 4(c), the synchronization time of eo1is the time
difference between the latest token visit, i.e., the begin time of tv3(150),
OPerA: Object-Centric Performance Analysis 11
and the earliest token visit, i.e., the begin time of tv1(15). Note that the
synchronization time consists of pooling time and lagging time.
–pool ot ∈Umcomputes pooling time w.r.t. object type ot , i.e., the time differ-
ence between the latest token visit of ot and the earliest token visit of ot re-
lated to the event. Formally, for any eo=(t, e)∈O,pool ot (eo, V )=max (T)−
min(T) with T={πbt(tv)|tv ∈relON (eo, V )∧type(πoi(tv))=ot}. In Fig. 4(c),
the pooling time of eo1w.r.t. sample is the time difference between the latest
token visit of sample, i.e., the begin time of tv3(150), and the earliest token
visit of sample, i.e., the begin time of tv2(120). Note that the pooling time
can be the same as the synchronization time.
–lagot ∈Umcomputes lagging time w.r.t. object type ot , i.e., the time dif-
ference between the latest token visit of ot and the earliest token visit of
other object types related to the event. Formally, for any eo=(t, e)∈O,
lagot (eo, V )=max (T0)−min (T) with T={πbt (tv)|tv ∈relON (eo, V )}and
T0={πbt(tv)|tv ∈relON (eo, V )∧type(πoi(tv))6=ot}if max (T0)>min(T).
0 otherwise. In Fig. 4(c), the lagging time of eo1w.r.t. sample is the time
difference between the latest token visit of samples, i.e., the begin time of
tv3(150), and the earliest token visit of any object types, i.e., the begin time
of tv1(15). Note that, in some cases, the lagging time is the same as the
synchronization time.
Non-temporal performance measures are trivial to compute given object-
centric event data, but still provide valuable insights. They include object fre-
quency, i.e., the number of objects involved with the event, and object type
frequency, i.e., the number of object types involved with the event. In Fig. 4(c),
the object frequency of e4 is 3 including T1,S1, and S2 and the object type
frequency of e4 is 2 including Test and Sample.
5 Evaluation
In this section, we present the implementation of the proposed approach and
evaluate the effectiveness of the approach by applying it to a real-life event log.
5.1 Implementation
The approach discussed in Sec. 4 has been fully implemented as a web applica-
tion2with a dedicated user interface. We containerize it as a Docker container,
structuring functional components into a coherent set of microservices. The fol-
lowing functions are supported:
–Importing object-centric event logs in different formats including OCEL
JSON, OCEL XML, and CSV.
2A demo video, sources, and manuals are available at https://github.com/
gyunamister/OPerA
12 G. Park, J. N. Adams, and W.M.P. van der Aalst
–Discovering OCPNs based on the general approach presented in [2] with
Inductive Miner Directly-Follows process discovery algorithm [15].
–Replaying tokens with timestamps on OCPNs based on token-based replay
approach suggested in [8].
–Computing object-centric performance measures based on the replay results,
i.e., event occurrences and token visits.
–Visualizing OCPNs with the object-centric performance measure.
Fig. 5. A screenshot of the application: Importing Object-Centric Event Logs
(OCELs). 1Importing OCELs in OCEL JSON, OCEL XML, and CSV formats.
2Preprocessing OCELs. 3Displaying OCELs.
5.2 Case Study: Loan Application Process
Using the implementation, we conduct a case study on a real-life loan application
process of a Dutch Financial Institute3. Two object types exist in the process:
application and offer. An application can have one or more offers. First, a cus-
tomer creates an application by visiting the bank or using an online system. In
the former case, submit activity is skipped. After the completion and acceptance
of the application, the bank offers loans to the customer by sending the offer to
the customer and making a call. An offer is either accepted or canceled.
3doi.org/10.4121/uuid:3926db30-f712-4394-aebc- 75976070e91f
OPerA: Object-Centric Performance Analysis 13
Fig. 6. A screenshot of the application: Analyzing and visualizing object-centric performance measures. 1Selecting object-centric
performance measures, aggregations, and a time period to analyze. 2An object-centric Petri net visualizing the computed performance
measures. 3Visualizing the detailed performance measures of a selected activity from the model.
14 G. Park, J. N. Adams, and W.M.P. van der Aalst
In this case study, we focus on the offers canceled due to various reasons. We
filter infrequent behaviors by selecting the ten most frequent types of process
executions. Moreover, we remove redundant activities, e.g., status updates such
as Completed after Complete application. The resulting event log, available at
the Github repository, contains 20,478 events by 1,682 applications and 3,573
offers.
First, we compare our approach to a traditional technique for performance
analysis based on alignments [5]. To apply the traditional technique, we first
flatten the log using the application and offer as a case notion. Fig. 7(a) shows the
performance analysis results from Inductive Visual Miner in ProM framework4.
As shown in 1
○, 1,799 applications repeat activity Send. In reality, as shown in
1, no repetition occurs while the activity is conducted once for each offer except
92 offers skipping it. Furthermore, the average sojourn time for the activity is
computed as around 2 days and 23 hours, whereas, in reality, it is around 15
minutes as shown in 1.
Furthermore, 2
○shows that activity Cancel application is repeated 1891
times, but it occurs, in reality, 1,682 times for each application, as depicted
in 2. In addition, the average sojourn time for the activity is measured as
around 12 days and 22 hours, but in fact, it is around 31 days and 22 hours, as
shown in 2.
Next, we analyze the newly-introduced object-centric performance measures,
including synchronization, lagging, and pooling time. As described in 3, the
average synchronization time of activity Cancel application is around 4 days
and 11 hours.
Moreover, the average lagging time of applications is 3 days and 15 hours
and the lagging time of offers is 19 hours, i.e., offers are more severely lagging
applications. Furthermore, the pooling time of offers is almost the same as the
synchronization time, indicating that the application is ready to be cancelled
almost at the same time as the first offer, and the second offer is ready in around
4 days and 11 hours.
6 Conclusion
In this paper, we proposed an approach to object-centric performance analysis,
supporting the correct computation of existing performance measures and the
derivation of new performance measures considering the interaction between ob-
jects. To that end, we first replay OCELs on OCPNs to couple events to process
models, producing event occurrences and token visits. Next, we measure object-
centric performance metrics per event occurrence by using the corresponding
token visits of the event occurrence. We have implemented the approach as a
web application and conducted a case study using a real-life loan application
process of a financial institute.
The proposed approach has several limitations. First, our approach relies on
the quality of the discovered process model. Discovering process models that
4https://www.promtools.org
OPerA: Object-Centric Performance Analysis 15
Fig. 7. (a) Performance analysis results based on Inductive Visual Miner in ProM
framework and (b) Performance analysis results based on our proposed approach. We
compare 1
○,2
○, and 3
○with 1,2, and 3, respectively. 4shows the result on
newly-introduced performance measures.
16 G. Park, J. N. Adams, and W.M.P. van der Aalst
can be easily interpreted and comprehensively reflect the reality is a remain-
ing challenge. Second, non-conforming behavior in event data w.r.t. a process
model can lead to misleading insights. If Transfer samples is missing for a sam-
ple in an event log, although a process model describes that it always occurs
for samples, the performance measure of Clear sample w.r.t. the sample will
be computed based on the wrong timestamps from Conduct Test. In the imple-
mentation, we use process discovery techniques that guarantee the discovery of a
perfectly-fitting process model and remove the issue of non-conforming behavior.
As future work, we plan to extend the approach to support reliable performance
analysis of non-conforming event logs. Moreover, we plan to develop an approach
to object-centric performance analysis based on event data independently from
process models. Another direction of future work is to define and compute more
interesting performance metrics that consider the interaction between objects.
References
1. van der Aalst, W.M.P.: Process Mining - Data Science in Action, Second Edi-
tion. Springer (2016). https://doi.org/10.1007/978-3-662-49851-4, https://doi.
org/10.1007/978-3-662-49851- 4
2. van der Aalst, W.M.P., Berti, A.: Discovering object-centric petri nets. Fundam.
Informaticae 175(1-4), 1–40 (2020). https://doi.org/10.3233/FI-2020-1946, https:
//doi.org/10.3233/FI-2020-1946
3. van der Aalst, W.M.P., Li, G., Montali, M.: Object-centric behavioral constraints.
CoRR abs/1703.05740 (2017), http://arxiv.org/abs/1703.05740
4. Adams, J.N., van der Aalst, W.M.P.: Precision and fitness in ob ject-
centric process mining. In: Ciccio, C.D., Francescomarino, C.D., Soffer, P.
(eds.) 3rd International Conference on Process Mining, ICPM 2021, Eind-
hoven, The Netherlands, October 31 - Nov. 4, 2021. pp. 128–135. IEEE
(2021). https://doi.org/10.1109/ICPM53251.2021.9576886, https://doi.org/10.
1109/ICPM53251.2021.9576886
5. Adriansyah, A.: Aligning observed and modeled behavior. Ph.D. thesis, Mathe-
matics and Computer Science (2014). https://doi.org/10.6100/IR770080
6. Adriansyah, A., Dongen, van, B., Piessens, D., Wynn, M., Adams, M.: Robust
performance analysis on YAWL process models with advanced constructs. Journal
of Information Technology Theory and Application 12(3), 5–26 (2011)
7. Bayomie, D., Ciccio, C.D., Rosa, M.L., Mendling, J.: A probabilistic ap-
proach to event-case correlation for process mining. In: Laender, A.H.F., Per-
nici, B., Lim, E., de Oliveira, J.P.M. (eds.) Conceptual Modeling - 38th
International Conference, ER 2019, Salvador, Brazil, November 4-7, 2019,
Proceedings. Lecture Notes in Computer Science, vol. 11788, pp. 136–152.
Springer (2019). https://doi.org/10.1007/978-3-030-33223-5 12, https://doi.
org/10.1007/978-3-030-33223- 5_12
8. Berti, A., van der Aalst, W.M.P.: A novel token-based replay technique to speed up
conformance checking and process enhancement. Trans. Petri Nets Other Model.
Concurr. 15, 1–26 (2021). https://doi.org/10.1007/978-3-662-63079-2 1, https://
doi.org/10.1007/978-3-662-63079- 2_1
9. Cohn, D., Hull, R.: Business artifacts: A data-centric approach to modeling
business operations and processes. IEEE Data Eng. Bull. 32(3), 3–9 (2009),
http://sites.computer.org/debull/A09sept/david.pdf
OPerA: Object-Centric Performance Analysis 17
10. Denisov, V., Fahland, D., van der Aalst, W.M.P.: Unbiased, fine-grained descrip-
tion of processes performance from event data. In: Weske, M., Montali, M., We-
ber, I., vom Brocke, J. (eds.) Business Process Management - 16th International
Conference, BPM 2018, Sydney, NSW, Australia, September 9-14, 2018, Pro-
ceedings. Lecture Notes in Computer Science, vol. 11080, pp. 139–157. Springer
(2018). https://doi.org/10.1007/978-3-319-98648-7 9, https://doi.org/10.1007/
978-3-319-98648- 7_9
11. Esser, S., Fahland, D.: Multi-dimensional event data in graph databases. J.
Data Semant. 10(1-2), 109–141 (2021). https://doi.org/10.1007/s13740-021-00122-
1, https://doi.org/10.1007/s13740-021-00122-1
12. Fahland, D.: Describing behavior of processes with many-to-many interactions. In:
PETRI NETS 2019. vol. 11522, pp. 3–24. Springer (2019), https://doi.org/10.
1007/978-3-030-21571- 2_1
13. Ghahfarokhi, A.F., Park, G., Berti, A., van der Aalst, W.M.P.: Ocel standard,
http://ocel-standard.org/
14. Hornix, P.T.: Performance analysis of business processes through pro-
cess mining. Master’s thesis, Mathematics and Computer Science (2007).
https://doi.org/10.6100/IR770080
15. Leemans, S.J.J., Fahland, D., van der Aalst, W.M.P.: Scalable process
discovery and conformance checking. Softw. Syst. Model. 17(2), 599–631
(2018). https://doi.org/10.1007/s10270-016-0545-x, https://doi.org/10.1007/
s10270-016-0545-x
16. Leemans, S.J.J., Poppe, E., Wynn, M.T.: Directly follows-based process mining:
Exploration & a case study. In: International Conference on Process Mining 2019.
pp. 25–32. IEEE (2019). https://doi.org/10.1109/ICPM.2019.00015, https://doi.
org/10.1109/ICPM.2019.00015
17. Mat´e, A., Trujillo, J., Mylopoulos, J.: Conceptualizing and specifying key per-
formance indicators in business strategy models. In: Atzeni, P., Cheung, D.W.,
Ram, S. (eds.) Conceptual Modeling - 31st International Conference ER 2012, Flo-
rence, Italy, October 15-18, 2012. Proceedings. Lecture Notes in Computer Science,
vol. 7532, pp. 282–291. Springer (2012). https://doi.org/10.1007/978-3-642-34002-
4 22, https://doi.org/10.1007/978-3- 642-34002-4_22
18. Montali, M., Rivkin, A.: Db-nets: On the marriage of colored Petri nets and
relational databases. Trans. Petri Nets Other Model. Concurr. 12, 91–118
(2017). https://doi.org/10.1007/978-3-662-55862-1 5, https://doi.org/10.1007/
978-3-662-55862- 1_5
19. Rogge-Solti, A., Weske, M.: Prediction of remaining service execution time
using stochastic petri nets with arbitrary firing delays. In: Basu, S., Pau-
tasso, C., Zhang, L., Fu, X. (eds.) Service-Oriented Computing - 11th In-
ternational Conference, ICSOC 2013, Berlin, Germany, December 2-5, 2013,
Proceedings. Lecture Notes in Computer Science, vol. 8274, pp. 389–403.
Springer (2013). https://doi.org/10.1007/978-3-642-45005-1 27, https://doi.
org/10.1007/978-3-642-45005- 1_27