Sensor2EventLog 2.0.0__py3-none-any.whl

models/base_model.py

@@ -0,0 +1,68 @@
+"""
+Base model interface for pluggable models
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Tuple, Any
+import numpy as np
+
+
+class BaseModel(ABC):
+    """
+    Abstract base class for all models in Sensor2EventLog.
+    
+    This interface ensures that all models can be used interchangeably
+    in the Machine Teaching loop.
+    """
+    
+    @abstractmethod
+    def fit(self, X: np.ndarray, lengths: List[int], y: Optional[np.ndarray] = None) -> 'BaseModel':
+        """
+        Fit the model to training data.
+        
+        Parameters:
+        -----------
+        X : np.ndarray
+            Feature matrix (n_samples, n_features)
+        lengths : List[int]
+            Lengths of each sequence
+        y : np.ndarray, optional
+            Labels for supervised learning
+            
+        Returns:
+        --------
+        self : BaseModel
+            Fitted model
+        """
+        pass
+    
+    @abstractmethod
+    def predict(self, X: np.ndarray, lengths: List[int]) -> np.ndarray:
+        """
+        Predict states for new data.
+        
+        Parameters:
+        -----------
+        X : np.ndarray
+            Feature matrix (n_samples, n_features)
+        lengths : List[int]
+            Lengths of each sequence
+            
+        Returns:
+        --------
+        predictions : np.ndarray
+            Predicted state indices (n_samples,)
+        """
+        pass
+    
+    @abstractmethod
+    def get_state_mapping(self) -> Dict[int, str]:
+        """
+        Get mapping from state indices to state names.
+        
+        Returns:
+        --------
+        Dict[int, str]
+            Mapping from index to state name
+        """
+        pass

models/hmm_model.py

@@ -0,0 +1,174 @@
+"""
+Hidden Markov Model implementation
+"""
+
+import numpy as np
+from typing import Dict, List, Optional, Tuple
+from hmmlearn.hmm import GaussianHMM
+from scipy.optimize import linear_sum_assignment
+
+from models.base_model import BaseModel
+from utils.hmm_utils import (
+    empirical_start_trans, emissions_from_labels, viterbi_decode, print_evaluation
+)
+
+
+class HMMModel(BaseModel):
+    """
+    Gaussian Hidden Markov Model for process state discovery.
+    
+    Supports both supervised and unsupervised learning modes.
+    """
+    
+    def __init__(self, config=None):
+        """
+        Initialize HMM model.
+        
+        Parameters:
+        -----------
+        config : module
+            Configuration module with HMM parameters
+        """
+        self.config = config
+        self.model = None
+        self._state_mapping = None
+        self._idx_to_state = None
+        self._state_list = None
+        
+        # Default HMM parameters
+        self.covariance_type = getattr(config, 'HMM_CONFIG', {}).get("covariance_type", "diag")
+        self.n_iter = getattr(config, 'HMM_CONFIG', {}).get("n_iter", 100)
+        self.random_seed = getattr(config, 'HMM_CONFIG', {}).get("random_seed", 42)
+        self.tol = getattr(config, 'HMM_CONFIG', {}).get("tol", 1e-6)
+    
+    def fit(self, X: np.ndarray, lengths: List[int], y: Optional[np.ndarray] = None) -> 'HMMModel':
+        """
+        Fit HMM to data.
+        
+        If y is provided, uses supervised initialization.
+        Otherwise, uses unsupervised learning.
+        """
+        if y is not None:
+            # Supervised initialization
+            n_states = len(np.unique(y))
+            startprob, transmat = empirical_start_trans(y, lengths, n_states)
+            means, covars = emissions_from_labels(X, y, n_states)
+            
+            self.model = GaussianHMM(
+                n_components=n_states,
+                covariance_type=self.covariance_type,
+                n_iter=self.n_iter,
+                init_params="",
+                random_state=self.random_seed,
+                tol=self.tol
+            )
+            self.model.startprob_ = startprob
+            self.model.transmat_ = transmat
+            self.model.means_ = means
+            self.model.covars_ = covars
+            
+            self.model.fit(X, lengths)
+        else:
+            # Unsupervised learning
+            # n_components must be set externally
+            pass
+        
+        return self
+    
+    def predict(self, X: np.ndarray, lengths: List[int]) -> np.ndarray:
+        """Predict state sequence using Viterbi algorithm."""
+        if self.model is None:
+            raise ValueError("Model must be fitted before prediction")
+        return viterbi_decode(self.model, X, lengths)
+    
+    def get_state_mapping(self) -> Dict[int, str]:
+        """Get mapping from state indices to state names."""
+        return self._state_mapping or {}
+    
+    def train_supervised(self, X_train, lengths_train, X_test, lengths_test,
+                        y_train, y_test, state_list, idx_to_state) -> Tuple:
+        """Train supervised HMM with labeled data."""
+        print("\nTraining supervised HMM...")
+        
+        n_states = len(state_list)
+        self._state_list = state_list
+        self._idx_to_state = idx_to_state
+        
+        # Initialize from labels
+        startprob, transmat = empirical_start_trans(y_train, lengths_train, n_states)
+        means, covars = emissions_from_labels(X_train, y_train, n_states)
+        
+        # Build and fit HMM
+        self.model = GaussianHMM(
+            n_components=n_states,
+            covariance_type=self.covariance_type,
+            n_iter=self.n_iter,
+            init_params="",
+            random_state=self.random_seed,
+            tol=self.tol
+        )
+        self.model.startprob_ = startprob
+        self.model.transmat_ = transmat
+        self.model.means_ = means
+        self.model.covars_ = covars
+        
+        self.model.fit(X_train, lengths_train)
+        
+        # Decode and evaluate
+        y_pred_test = self.predict(X_test, lengths_test)
+        print_evaluation(y_test, y_pred_test, idx_to_state, state_list, 
+                        title="Supervised HMM (Test)")
+        
+        # Create state mapping (1:1 for supervised)
+        state_mapping = {i: state_list[i] for i in range(n_states)}
+        self._state_mapping = state_mapping
+        
+        return y_pred_test, self.model, state_mapping
+    
+    def train_unsupervised(self, X_train, lengths_train, X_test, lengths_test,
+                          y_train, y_test, state_list, idx_to_state, n_unsup) -> Tuple:
+        """Train unsupervised HMM with state mapping."""
+        print("\nTraining unsupervised HMM...")
+        
+        n_states = n_unsup if n_unsup is not None else len(state_list)
+        self._state_list = state_list
+        self._idx_to_state = idx_to_state
+        
+        # Train unsupervised HMM
+        self.model = GaussianHMM(
+            n_components=n_states,
+            covariance_type=self.covariance_type,
+            n_iter=self.n_iter,
+            random_state=self.random_seed,
+            tol=self.tol,
+            init_params="stmc",
+            params="stmc"
+        )
+        self.model.fit(X_train, lengths_train)
+        
+        # Predict and map states
+        y_train_hat = self.predict(X_train, lengths_train)
+        
+        # Build contingency matrix for mapping
+        K = len(state_list)
+        cont = np.zeros((K, K), dtype=int)
+        for t, p in zip(y_train, y_train_hat):
+            if t < K and p < K:
+                cont[t, p] += 1
+        
+        # Optimal mapping using Hungarian algorithm
+        row_ind, col_ind = linear_sum_assignment(cont.max() - cont)
+        mapping = {pred: true for true, pred in zip(row_ind, col_ind)}
+        
+        # Decode test set and map states
+        y_test_hat = self.predict(X_test, lengths_test)
+        y_test_mapped = np.array([mapping.get(s, 0) for s in y_test_hat], dtype=int)
+        
+        print_evaluation(y_test, y_test_mapped, idx_to_state, state_list,
+                        title="Unsupervised HMM (mapped) — Test")
+        
+        # Create full mapping for event log
+        state_mapping = {pred: idx_to_state[true] for pred, true in mapping.items() if true in idx_to_state}
+        self._state_mapping = state_mapping
+        
+        return y_test_hat, self.model, state_mapping

sensor2eventlog-2.0.0.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: Sensor2EventLog
+Version: 2.0.0
+Summary: Knowledge-guided framework for transforming sensor data into event logs
+Author: Azin Moradbeikie
+License: MIT
+Project-URL: Homepage, https://github.com/azinmoradbeikie/Sensor2EventLog
+Project-URL: Repository, https://github.com/azinmoradbeikie/Sensor2EventLog
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: scikit-learn>=0.24.0
+Requires-Dist: hmmlearn>=0.2.8
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: seaborn>=0.11.0
+Dynamic: license-file
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/azinmoradbeikie/Sensor2EventLog/main/images/Sensor2EventLog_001.png" width="300" />
+</p>
+
+[![Documentation Status](https://readthedocs.org/projects/sensor2eventlog/badge/?version=latest)](https://sensor2eventlog.readthedocs.io/en/latest/?badge=latest)
+
+# Sensor2EventLog
+knowledge-guided framework that transforms raw sensor data into process-aware event logs by incorporating Machine Teaching (MT) principles. The core of the framework is a modular abstraction layer embedded in an interactive teaching loop (planning, explaining, and reviewing) where human experts map sensor behaviors correspond to process states.
+
+
+
+## Setup
+
+- Clone the repository:
+  ```bash
+  git clone https://github.com/azinmoradbeikie/Sensor2EventLog.git
+- Install dependencies
+  ```bash
+  pip install -r requirements.txt
+  cd Sensor2EventLog
+- Running the Analysis
+  ```bash
+  python3 main.py
+
+## Tutorial
+
+A self-contained toy walkthrough is available in [`tutorial/`](tutorial/README.md).
+
+Run it with:
+
+```bash
+python3 tutorial/toy_walkthrough.py
+```

sensor2eventlog-2.0.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+S2E_v2.py,sha256=_M6i1fUQ801E_a83pSffE0Mh9io_Rpi11op7MmHQEck,46621
+config.py,sha256=SyGlw-g3OcxSG5l3x57rjVgkpaBOLGRMxLDXW0QyfpI,1079
+main.py,sha256=8ZNdhT86oZFw28cRr5aeqwAxB4rAzf_fcMRJl6hlqrQ,13768
+abstraction/mt_loop.py,sha256=U4RSiigFTv-qgGt-csaid95sE2wjsJk-vL1UBXNi7dY,5338
+contextualization/event_log.py,sha256=_2SE7dbfcukKZkHcqd6rl0k7M8j0v9cx7DtaeVl_D2w,12196
+core/__init__.py,sha256=ZSybjdo1g9g9dSWL3r1-KeC7WEatvT_UqX_zxyd5Flc,86
+core/pipeline.py,sha256=vqvEfFnvaCazSdzQg8hofkrs1Khujm-bVzsLpsZ66vE,6828
+evaluation/rule_analyzer.py,sha256=mi7tsxO8TWdE6F4y6akqThWjrk5kKc-_bqPPCQDOU5c,11352
+features/feature_library.py,sha256=jXZ4qH3NG7B_Vp9k4H27jbSN6bpjlAKyNAIZ2TVTXBc,11879
+models/base_model.py,sha256=T9inyiwAeF30KRQRXJN4xUstvl44BG5mEoO3TbSbKkk,1764
+models/hmm_model.py,sha256=6HAFXQtfp9WTMvMf9LA_MElg9rEB-jdZuUZsKuvSWUE,6593
+sensor2eventlog-2.0.0.dist-info/licenses/LICENSE,sha256=IMc9ORhSJ07tr8EolCdcfbQG4k0f6-9OwDaE22yGkns,1077
+utils/__init__.py,sha256=ZmQOyX7EFv5xkDBg1FAfoyf16qqcweapZYA_2H1ZqGI,718
+utils/hmm_utils.py,sha256=lERCRRDqB9zB-aPuBrPNJZs5zPlK6I0s711sHFjEGxk,11976
+sensor2eventlog-2.0.0.dist-info/METADATA,sha256=QiGodv2Vzcc1gB-h7E8ejbLRGBkyN36zARvXxBlDhEo,1803
+sensor2eventlog-2.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+sensor2eventlog-2.0.0.dist-info/top_level.txt,sha256=IiPSdf5ZLi1NUq0dwUwB8aTFqOXEC-Z1xGeDw_Q1aoc,87
+sensor2eventlog-2.0.0.dist-info/RECORD,,

sensor2eventlog-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

sensor2eventlog-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Azin Moradbeikie
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

sensor2eventlog-2.0.0.dist-info/top_level.txt

@@ -0,0 +1,10 @@
+S2E_v2
+abstraction
+config
+contextualization
+core
+evaluation
+features
+main
+models
+utils

utils/__init__.py

@@ -0,0 +1,30 @@
+"""
+HMM Process Analyzer Utilities
+"""
+
+# Re-export from their new locations
+from features.feature_library import ModularFeatureLibrary
+from evaluation.rule_analyzer import RuleDiagnosticAnalyzer
+
+# Import from local hmm_utils
+from .hmm_utils import (
+    empirical_start_trans,
+    emissions_from_labels,
+    viterbi_decode,
+    print_evaluation,
+    create_interval_event_log_normalized,
+    filter_brief_states,
+    normalize_timestamps
+)
+
+__all__ = [
+    'ModularFeatureLibrary',
+    'RuleDiagnosticAnalyzer',
+    'empirical_start_trans',
+    'emissions_from_labels',
+    'viterbi_decode',
+    'print_evaluation',
+    'create_interval_event_log_normalized',
+    'filter_brief_states',
+    'normalize_timestamps'
+]

utils/hmm_utils.py

@@ -0,0 +1,277 @@
+"""
+HMM utility functions for training, evaluation, and event log generation
+"""
+
+import numpy as np
+import pandas as pd
+from hmmlearn.hmm import GaussianHMM
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import confusion_matrix, classification_report
+from scipy.optimize import linear_sum_assignment
+import matplotlib.pyplot as plt
+
+
+def empirical_start_trans(labels, lengths, n_states):
+    """Estimate startprob_ and transmat_ from labeled sequences."""
+    start = np.zeros(n_states)
+    trans = np.zeros((n_states, n_states))
+    idx = 0
+    for L in lengths:
+        seq = labels[idx:idx+L]
+        start[seq[0]] += 1
+        for i in range(L-1):
+            trans[seq[i], seq[i+1]] += 1
+        idx += L
+    # normalize with small epsilon to avoid zeros
+    start = (start + 1e-6) / (start.sum() + 1e-6*n_states)
+    trans = (trans + 1e-6)
+    trans /= trans.sum(axis=1, keepdims=True)
+    return start, trans
+
+
+def emissions_from_labels(X_np, labels_np, n_states):
+    """Compute means and covariances per labeled state."""
+    D = X_np.shape[1]
+    means = np.zeros((n_states, D))
+    covars = np.zeros((n_states, D, D))
+    for s in range(n_states):
+        sel = (labels_np == s)
+        Xi = X_np[sel]
+        if len(Xi) < 2:
+            # fallback tiny variance
+            means[s] = 0.0
+            covars[s] = np.eye(D)*1e-2
+        else:
+            means[s] = Xi.mean(axis=0)
+            covars[s] = np.cov(Xi.T) + np.eye(D)*1e-6
+    return means, covars
+
+
+def viterbi_decode(model, X_np, lengths):
+    """Wrapper for HMM Viterbi decoding."""
+    return model.predict(X_np, lengths)
+
+
+def print_evaluation(y_true_idx, y_pred_idx, idx_to_state, state_list, title=""):
+    """Print classification report and confusion matrix."""
+    labs_true = [idx_to_state[i] for i in y_true_idx]
+    labs_pred = [idx_to_state.get(i, f"UNK{i}") for i in y_pred_idx]
+    print(f"\n== {title} ==")
+    print(classification_report(labs_true, labs_pred, labels=state_list, zero_division=0))
+    cm = confusion_matrix(labs_true, labs_pred, labels=state_list)
+    print("Confusion matrix (rows=true, cols=pred):")
+    print(pd.DataFrame(cm, index=state_list, columns=state_list))
+
+
+def normalize_timestamps(df, timestamp_col="timestamp", case_id_col="batch_id", base_date="2023-01-01"):
+    """
+    Normalize timestamps by handling different time units properly.
+    """
+    df_normalized = df.copy()
+    
+    # Check timestamp format
+    print(f"Original timestamp sample: {df[timestamp_col].iloc[:5].tolist()}")
+    
+    # Convert numeric seconds to datetime or parse as datetime
+    if np.issubdtype(df[timestamp_col].dtype, np.number):
+        print("Timestamps are numeric - assuming they represent seconds")
+        base_datetime = pd.to_datetime(base_date)
+        df_normalized[timestamp_col] = base_datetime + pd.to_timedelta(df[timestamp_col], unit='s')
+    else:
+        try:
+            df_normalized[timestamp_col] = pd.to_datetime(df[timestamp_col])
+            print("Timestamps successfully parsed as datetime")
+        except:
+            print("Could not parse timestamps. Please check the format.")
+            return df
+    
+    # Normalize each case to start at base_date
+    case_groups = df_normalized.groupby(case_id_col)
+    
+    for case_id, case_data in case_groups:
+        case_start = case_data[timestamp_col].min()
+        time_deltas = case_data[timestamp_col] - case_start
+        df_normalized.loc[case_data.index, timestamp_col] = pd.to_datetime(base_date) + time_deltas
+    
+    return df_normalized
+
+
+def create_interval_event_log_normalized(df, y_pred, state_mapping, 
+                                        case_id_col="batch_id", timestamp_col="timestamp"):
+    """
+    Create interval-based event log using normalized timestamps.
+    """
+    df_with_pred = df.copy()
+    df_with_pred['predicted_state'] = [state_mapping.get(i, f"Unknown_{i}") for i in y_pred]
+    
+    event_log_segments = []
+    
+    for case_id in df_with_pred[case_id_col].unique():
+        case_data = df_with_pred[df_with_pred[case_id_col] == case_id].copy()
+        case_data = case_data.sort_values(timestamp_col)
+        
+        current_state = None
+        segment_start = None
+        segment_indices = []
+        
+        for idx, row in case_data.iterrows():
+            if current_state is None:
+                current_state = row['predicted_state']
+                segment_start = row[timestamp_col]
+                segment_indices = [idx]
+            elif row['predicted_state'] == current_state:
+                segment_indices.append(idx)
+            else:
+                segment_end = case_data.loc[segment_indices[-1], timestamp_col]
+                duration = (pd.to_datetime(segment_end) - pd.to_datetime(segment_start)).total_seconds()
+                event_log_segments.append({
+                    'case_id': case_id,
+                    'activity': current_state,
+                    'start_timestamp': segment_start,
+                    'end_timestamp': segment_end,
+                    'duration_seconds': duration,
+                    'event_count': len(segment_indices)
+                })
+                current_state = row['predicted_state']
+                segment_start = row[timestamp_col]
+                segment_indices = [idx]
+        
+        # Add the last segment
+        if current_state is not None and segment_start is not None:
+            segment_end = case_data.loc[segment_indices[-1], timestamp_col]
+            duration = (pd.to_datetime(segment_end) - pd.to_datetime(segment_start)).total_seconds()
+            
+            event_log_segments.append({
+                'case_id': case_id,
+                'activity': current_state,
+                'start_timestamp': segment_start,
+                'end_timestamp': segment_end,
+                'duration_seconds': duration,
+                'event_count': len(segment_indices)
+            })
+    
+    event_log = pd.DataFrame(event_log_segments)
+    event_log['activity_sequence'] = event_log.groupby('case_id').cumcount() + 1
+    
+    event_log = event_log[['case_id', 'activity_sequence', 'activity', 
+                          'start_timestamp', 'end_timestamp', 
+                          'duration_seconds', 'event_count']]
+    
+    return event_log
+
+
+def filter_brief_states(event_log, min_duration_seconds=5.0):
+    """
+    Remove state segments that are too brief by merging them with adjacent states.
+    """
+    filtered_segments = []
+    
+    for case_id in event_log['case_id'].unique():
+        case_data = event_log[event_log['case_id'] == case_id].copy()
+        
+        i = 0
+        while i < len(case_data):
+            current_segment = case_data.iloc[i]
+            
+            # If segment is too brief, merge with previous or next
+            if current_segment['duration_seconds'] < min_duration_seconds and len(case_data) > 1:
+                
+                if i == 0:  # First segment - merge with next
+                    next_segment = case_data.iloc[i + 1]
+                    merged_segment = {
+                        'case_id': case_id,
+                        'activity': next_segment['activity'],
+                        'start_timestamp': current_segment['start_timestamp'],
+                        'end_timestamp': next_segment['end_timestamp'],
+                        'duration_seconds': current_segment['duration_seconds'] + next_segment['duration_seconds'],
+                        'event_count': current_segment['event_count'] + next_segment['event_count']
+                    }
+                    filtered_segments.append(merged_segment)
+                    i += 2  # Skip next segment since we merged it
+                    
+                elif i == len(case_data) - 1:  # Last segment - merge with previous
+                    prev_segment = case_data.iloc[i - 1]
+                    merged_segment = {
+                        'case_id': case_id,
+                        'activity': prev_segment['activity'],
+                        'start_timestamp': prev_segment['start_timestamp'],
+                        'end_timestamp': current_segment['end_timestamp'],
+                        'duration_seconds': prev_segment['duration_seconds'] + current_segment['duration_seconds'],
+                        'event_count': prev_segment['event_count'] + current_segment['event_count']
+                    }
+                    # Replace the last segment we added
+                    filtered_segments = filtered_segments[:-1]
+                    filtered_segments.append(merged_segment)
+                    i += 1
+                    
+                else:  # Middle segment - merge with previous
+                    prev_segment = case_data.iloc[i - 1]
+                    merged_segment = {
+                        'case_id': case_id,
+                        'activity': prev_segment['activity'],
+                        'start_timestamp': prev_segment['start_timestamp'],
+                        'end_timestamp': current_segment['end_timestamp'],
+                        'duration_seconds': prev_segment['duration_seconds'] + current_segment['duration_seconds'],
+                        'event_count': prev_segment['event_count'] + current_segment['event_count']
+                    }
+                    # Replace the last segment we added
+                    filtered_segments = filtered_segments[:-1]
+                    filtered_segments.append(merged_segment)
+                    i += 1
+            else:
+                # Keep segments that are long enough
+                filtered_segments.append(current_segment.to_dict())
+                i += 1
+    
+    # Create new event log
+    filtered_log = pd.DataFrame(filtered_segments)
+    
+    # Recalculate activity sequence
+    filtered_log['activity_sequence'] = filtered_log.groupby('case_id').cumcount() + 1
+    
+    return filtered_log
+
+
+def create_gantt_chart(event_log, max_cases=10, figsize=(14, 8), color_map='Set3'):
+    """
+    Create Gantt chart visualization of process execution.
+    """
+    plt.figure(figsize=figsize)
+    
+    activities = event_log['activity'].unique()
+    colors = plt.cm.get_cmap(color_map)(np.linspace(0, 1, len(activities)))
+    color_dict = dict(zip(activities, colors))
+    
+    case_ids = event_log['case_id'].unique()[:max_cases]
+    
+    for i, case_id in enumerate(case_ids):
+        case_data = event_log[event_log['case_id'] == case_id]
+        
+        for _, activity_row in case_data.iterrows():
+            start = pd.to_datetime(activity_row['start_timestamp'])
+            end = pd.to_datetime(activity_row['end_timestamp'])
+            duration = (end - start).total_seconds() / 3600  # Convert to hours
+            
+            plt.barh(y=i, width=duration, left=start, 
+                    color=color_dict[activity_row['activity']], 
+                    edgecolor='black', alpha=0.7)
+            
+            # Add activity label for longer segments
+            if duration > 0.1:  # Only label segments longer than 6 minutes
+                plt.text(start + pd.Timedelta(seconds=duration*3600/2), i, 
+                        activity_row['activity'], ha='center', va='center', 
+                        fontsize=8, fontweight='bold')
+    
+    plt.yticks(range(len(case_ids)), case_ids)
+    plt.xlabel('Time (from normalized start)')
+    plt.ylabel('Case ID')
+    plt.title(f'Process Execution Gantt Chart (First {len(case_ids)} Cases)')
+    
+    # Create legend
+    legend_patches = [plt.Rectangle((0,0),1,1, color=color_dict[act]) for act in activities]
+    plt.legend(legend_patches, activities, bbox_to_anchor=(1.05, 1), loc='upper left')
+    
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+    
+    return plt