Merge remote-tracking branch 'upstream/hotfixes' into release

fit-alessandro-berti · fit-alessandro-berti · commit 47a2bfaa4956 · 2026-01-29T15:12:39.000+01:00
diff --git a/examples/prefix_classification.py b/examples/prefix_classification.py
@@ -8,42 +8,14 @@
 from sklearn.metrics import accuracy_score
 from sklearn.model_selection import train_test_split
 
-
-def build_prefix_onehot(log, activity_key):
-    activities = sorted(
-        {event[activity_key] for trace in log for event in trace if activity_key in event}
-    )
-    activity_to_index = {activity: idx for idx, activity in enumerate(activities)}
-
-    feature = []
-    target = []
-
-    for trace in log:
-        if len(trace) < 2:
-            continue
-        seen = set()
-        for idx, event in enumerate(trace):
-            if activity_key not in event:
-                continue
-            activity = event[activity_key]
-            if idx == 0:
-                seen.add(activity)
-                continue
-            row = [0] * len(activities)
-            for seen_activity in seen:
-                row[activity_to_index[seen_activity]] = 1
-            feature.append(row)
-            target.append(activity_to_index[activity])
-            seen.add(activity)
-
-    return feature, target, activities, activity_to_index
+from prefix_feature_extraction import build_prefix_features_next_activity
 
 
 def main():
     parser = argparse.ArgumentParser(
         description=(
-            "One-hot encode every prefix (length >= 2) of each trace using the "
-            "activities up to the penultimate event, with the last event as class."
+            "Encode every prefix of each trace using the activities and paths up to the "
+            "penultimate event, plus time-based features, with the next event as class."
         )
     )
     parser.add_argument(
@@ -57,6 +29,11 @@ def main():
         default=xes_constants.DEFAULT_NAME_KEY,
         help=f"Event attribute to use as activity (default: {xes_constants.DEFAULT_NAME_KEY})",
     )
+    parser.add_argument(
+        "--timestamp-key",
+        default=xes_constants.DEFAULT_TIMESTAMP_KEY,
+        help=f"Event attribute to use as timestamp (default: {xes_constants.DEFAULT_TIMESTAMP_KEY})",
+    )
     parser.add_argument(
         "--show-sample",
         action="store_true",
@@ -65,11 +42,18 @@ def main():
     args = parser.parse_args()
 
     log = pm4py.read_xes(args.log_path, return_legacy_log_object=True)
-    feature, target, activities, activity_to_index = build_prefix_onehot(
-        log, args.activity_key
+    (
+        feature,
+        target,
+        activities,
+        activity_to_index,
+        paths,
+        _,
+    ) = build_prefix_features_next_activity(
+        log, args.activity_key, args.timestamp_key
     )
     if not feature:
-        raise SystemExit("No prefixes of length >= 2 found in the log.")
+        raise SystemExit("No prefixes found in the log.")
 
     class_counts = Counter(target)
     min_class = min(class_counts.values()) if class_counts else 0
@@ -92,8 +76,9 @@ def main():
     print(f"Log path: {args.log_path}")
     print(f"Activity key: {args.activity_key}")
     print(f"Activities: {len(activities)}")
+    print(f"Paths: {len(paths)}")
     print(f"Samples (prefixes): {len(feature)}")
-    print(f"Feature dimension: {len(activities)}")
+    print(f"Feature dimension: {len(activities) + len(paths) + 3}")
     print(f"Target classes: {len(activity_to_index)}")
     print(f"Train size: {len(X_train)}")
     print(f"Test size: {len(X_test)}")
diff --git a/examples/prefix_feature_extraction.py b/examples/prefix_feature_extraction.py
@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+from pm4py.util import xes_constants
+
+
+def _collect_activities_and_paths(log, activity_key):
+    activities = set()
+    paths = set()
+    for trace in log:
+        events = [event for event in trace if activity_key in event]
+        for event in events:
+            activities.add(event[activity_key])
+        for idx in range(1, len(events)):
+            paths.add((events[idx - 1][activity_key], events[idx][activity_key]))
+    activities = sorted(activities)
+    paths = sorted(paths)
+    return activities, paths
+
+
+def _build_prefix_features(log, activity_key, timestamp_key, target_mode):
+    activities, paths = _collect_activities_and_paths(log, activity_key)
+    activity_to_index = {activity: idx for idx, activity in enumerate(activities)}
+    path_to_index = {path: idx for idx, path in enumerate(paths)}
+
+    feature = []
+    target = []
+    case_ids = []
+
+    for trace_index, trace in enumerate(log):
+        events = [event for event in trace if activity_key in event]
+        if len(events) < 2:
+            continue
+        trace_id = trace.attributes.get(
+            xes_constants.DEFAULT_TRACEID_KEY, trace_index
+        )
+        end_time = events[-1].get(timestamp_key) if timestamp_key else None
+        if target_mode == "remaining_time" and end_time is None:
+            continue
+        start_time = events[0].get(timestamp_key) if timestamp_key else None
+
+        seen_activities = {events[0][activity_key]}
+        seen_paths = set()
+
+        for idx in range(1, len(events)):
+            prev_event = events[idx - 1]
+            curr_event = events[idx]
+
+            if idx >= 2:
+                prior_event = events[idx - 2]
+                seen_paths.add(
+                    (prior_event[activity_key], prev_event[activity_key])
+                )
+
+            row = [0] * (len(activities) + len(paths))
+            for seen_activity in seen_activities:
+                row[activity_to_index[seen_activity]] = 1
+            for seen_path in seen_paths:
+                row[len(activities) + path_to_index[seen_path]] = 1
+
+            prev_to_penultimate = 0.0
+            if idx >= 2 and timestamp_key:
+                prev_ts = prev_event.get(timestamp_key)
+                prior_ts = events[idx - 2].get(timestamp_key)
+                if prev_ts is not None and prior_ts is not None:
+                    prev_to_penultimate = (prev_ts - prior_ts).total_seconds()
+
+            start_to_penultimate = 0.0
+            if timestamp_key and start_time is not None:
+                penultimate_ts = prev_event.get(timestamp_key)
+                if penultimate_ts is not None:
+                    start_to_penultimate = (penultimate_ts - start_time).total_seconds()
+
+            path_time_diff = 0.0
+            if timestamp_key:
+                prev_ts = prev_event.get(timestamp_key)
+                curr_ts = curr_event.get(timestamp_key)
+                if prev_ts is not None and curr_ts is not None:
+                    path_time_diff = (curr_ts - prev_ts).total_seconds()
+
+            row.extend([prev_to_penultimate, start_to_penultimate, path_time_diff])
+
+            curr_activity = curr_event[activity_key]
+            if target_mode == "next_activity":
+                target.append(activity_to_index[curr_activity])
+                feature.append(row)
+            else:
+                curr_ts = curr_event.get(timestamp_key) if timestamp_key else None
+                if curr_ts is not None:
+                    remaining = (end_time - curr_ts).total_seconds()
+                    target.append(remaining)
+                    feature.append(row)
+                    case_ids.append(trace_id)
+
+            seen_activities.add(curr_activity)
+
+    return feature, target, case_ids, activities, activity_to_index, paths, path_to_index
+
+
+def build_prefix_features_next_activity(
+    log,
+    activity_key=xes_constants.DEFAULT_NAME_KEY,
+    timestamp_key=xes_constants.DEFAULT_TIMESTAMP_KEY,
+):
+    feature, target, _, activities, activity_to_index, paths, path_to_index = (
+        _build_prefix_features(log, activity_key, timestamp_key, "next_activity")
+    )
+    return feature, target, activities, activity_to_index, paths, path_to_index
+
+
+def build_prefix_features_remaining_time(
+    log,
+    activity_key=xes_constants.DEFAULT_NAME_KEY,
+    timestamp_key=xes_constants.DEFAULT_TIMESTAMP_KEY,
+):
+    feature, target, case_ids, activities, activity_to_index, paths, path_to_index = (
+        _build_prefix_features(log, activity_key, timestamp_key, "remaining_time")
+    )
+    return feature, target, case_ids, activities, activity_to_index, paths, path_to_index
diff --git a/examples/prefix_regression.py b/examples/prefix_regression.py
@@ -10,54 +10,14 @@
 from sklearn.metrics import r2_score
 from sklearn.model_selection import train_test_split
 
-
-def build_prefix_onehot_remaining_time(log, activity_key, timestamp_key):
-    activities = sorted(
-        {event[activity_key] for trace in log for event in trace if activity_key in event}
-    )
-    activity_to_index = {activity: idx for idx, activity in enumerate(activities)}
-
-    feature = []
-    target = []
-    case_ids = []
-
-    for trace_index, trace in enumerate(log):
-        if len(trace) < 2:
-            continue
-        if timestamp_key not in trace[-1]:
-            continue
-        end_time = trace[-1][timestamp_key]
-        trace_id = trace.attributes.get(
-            xes_constants.DEFAULT_TRACEID_KEY, trace_index
-        )
-        seen = set()
-        for idx, event in enumerate(trace):
-            if activity_key not in event:
-                continue
-            activity = event[activity_key]
-            if idx == 0:
-                seen.add(activity)
-                continue
-            if timestamp_key not in event:
-                seen.add(activity)
-                continue
-            row = [0] * len(activities)
-            for seen_activity in seen:
-                row[activity_to_index[seen_activity]] = 1
-            remaining = (end_time - event[timestamp_key]).total_seconds()
-            feature.append(row)
-            target.append(remaining)
-            case_ids.append(trace_id)
-            seen.add(activity)
-
-    return feature, target, case_ids, activities, activity_to_index
+from prefix_feature_extraction import build_prefix_features_remaining_time
 
 
 def main():
     parser = argparse.ArgumentParser(
         description=(
-            "One-hot encode every prefix (length >= 2) of each trace using the "
-            "activities up to the penultimate event, with remaining time to case end as target."
+            "Encode every prefix of each trace using the activities and paths up to the "
+            "penultimate event, plus time-based features, with remaining time to case end as target."
         )
     )
     parser.add_argument(
@@ -84,11 +44,19 @@ def main():
     args = parser.parse_args()
 
     log = pm4py.read_xes(args.log_path, return_legacy_log_object=True)
-    feature, target, case_ids, activities, activity_to_index = build_prefix_onehot_remaining_time(
+    (
+        feature,
+        target,
+        case_ids,
+        activities,
+        activity_to_index,
+        paths,
+        _,
+    ) = build_prefix_features_remaining_time(
         log, args.activity_key, args.timestamp_key
     )
     if not feature:
-        raise SystemExit("No prefixes of length >= 2 with timestamps found in the log.")
+        raise SystemExit("No prefixes with timestamps found in the log.")
 
     X_train, X_test, y_train, y_test, case_train, case_test = train_test_split(
         feature, target, case_ids, test_size=0.2, random_state=42
@@ -122,8 +90,9 @@ def main():
     print(f"Activity key: {args.activity_key}")
     print(f"Timestamp key: {args.timestamp_key}")
     print(f"Activities: {len(activities)}")
+    print(f"Paths: {len(paths)}")
     print(f"Samples (prefixes): {len(feature)}")
-    print(f"Feature dimension: {len(activities)}")
+    print(f"Feature dimension: {len(activities) + len(paths) + 3}")
     print(f"Train size: {len(X_train)}")
     print(f"Test size: {len(X_test)}")
     print(f"Per-case MAE (hours): {mae_hours:.4f}")
