GECCO: Constraint-driven Abstraction of Low-level Event Logs

Adrian Rebmann, Matthias Weidlich, Han van der Aa

Introduction

In process mining, the goal is to discover how business processes actually operate by analyzing event logs. However, modern data sources—such as UI logs or sensor data—often produce event logs that are excessively granular. These logs record every minor interaction, resulting in what is known as a spaghetti process model: a tangled, incomprehensible web of nodes and edges that defies human interpretation.

A typical "spaghetti" process model resulting from low-level event logs.

Existing log abstraction techniques attempt to simplify these models by grouping low-level events into high-level activities. However, most current methods are procedural, forcing users to accept the algorithm's internal logic (e.g., grouping events based solely on temporal proximity). This lack of control often leads to abstractions that satisfy algorithmic metrics but fail to meet business requirements.

The GECCO Framework

The authors propose GECCO (Constraint-driven Abstraction of Low-level Event Logs), a framework that treats log abstraction as an optimization problem. GECCO allows users to define exactly what the resulting abstraction should look like through declarative constraints (e.g., "do not group events performed by different departments").

The GECCO pipeline: from candidate computation to optimal grouping and log transformation.

As shown in the pipeline above, GECCO operates in three main stages:

  1. Candidate Computation: The system identifies potential groups of event classes that satisfy user-defined constraints. It offers an Exhaustive Approach for mathematical optimality and a DFG-based Heuristic that uses a Directly-Follows Graph (DFG) to focus on events that naturally appear near each other, significantly reducing search time.
  2. Optimal Grouping: Once candidates are identified, GECCO employs Mixed-Integer Programming (MIP) to select the optimal set of groups. This selection minimizes a custom distance measure that balances cohesion (events in a group should occur close together), correlation (events should appear together consistently), and abstraction degree (favoring larger, more meaningful groups).
  3. Log Transformation: Finally, the original low-level events are replaced with the new high-level activity labels to create an abstracted event log.

Evaluation and Results

GECCO was evaluated using 13 real-world event logs from diverse domains, including medical (Sepsis cases), administrative (Road Traffic Fines), and standard benchmarks (BPI Challenges). The logs ranged from 4 to 70 distinct event classes and up to 150,000 traces.

Key findings from the evaluation include:

  • Complexity Reduction: GECCO reduced log size by an average of 60% and control-flow complexity by 55%, effectively transforming spaghetti models into structured process maps.
  • Superior Cohesion: GECCO produced more cohesive clusters than baseline methods (like graph partitioning), as measured by higher Silhouette coefficients.
  • Efficiency: The DFG-based heuristic achieved near-optimal results while taking only 40% of the time required by the exhaustive approach (49 minutes vs. 130 minutes on average).
  • Constraint Flexibility: The framework successfully handled a wide array of constraints—such as cost, duration, and roles—that traditional methods cannot process.

Discussion and Future Work

The core innovation of GECCO is the shift from procedural to declarative abstraction. By exploiting mathematical properties like monotonicity pruning, the framework manages the exponential complexity of checking event combinations efficiently.

Future work aims to address current limitations, such as handling cases where user constraints are too strict to find a feasible solution. The authors also plan to extend GECCO to support online processing for streaming data and develop automated constraint discovery to help users identify relevant constraints without manual definition.

Summary updated

BibTeX
@inproceedings{rebmann2022gecco,
  author = {Adrian Rebmann and Matthias Weidlich and Han van der Aa},
  title = {{GECCO: Constraint-driven Abstraction of Low-level Event Logs}},
  booktitle = {ICDE},
  year = {2022},
  url = {https://openreview.net/forum?id=DFMLp9mbEb},
}
Figure