Sensor2EventLog 2.0.0__py3-none-any.whl

features/feature_library.py

@@ -0,0 +1,270 @@
+"""
+Modular feature extraction library with diagnostic capabilities
+"""
+
+import numpy as np
+import pandas as pd
+import re
+from typing import Dict, List
+from evaluation.rule_analyzer import RuleDiagnosticAnalyzer
+
+
+class ModularFeatureLibrary:
+    """
+    Modular feature extraction library supporting multiple feature families
+    with integrated rule diagnostics.
+    """
+    
+    def __init__(self, window_sizes=None, stability_eps=1, peak_threshold=0.1):
+        self.window_sizes = window_sizes or [5]
+        self.stability_eps = stability_eps
+        self.peak_threshold = peak_threshold
+        
+        # Feature family implementations
+        self.feature_families = {
+            'statistical': self._compute_statistical_features,
+            'temporal': self._compute_temporal_features,
+            'stability': self._compute_stability_features,
+            'interaction': self._compute_interaction_features,
+            'event': self._compute_event_features,
+            'contextual': self._compute_contextual_features
+        }
+        
+        self.diagnostic_analyzer = RuleDiagnosticAnalyzer()
+        self._feature_cache = {}
+    
+    def _normalize_rule_expr(self, expr: str) -> str:
+        """Convert human-friendly logical ops to pandas-style bitwise ops."""
+        s = expr.strip()
+        s = re.sub(r'\bAND\b', '&', s, flags=re.I)
+        s = re.sub(r'\bOR\b', '|', s, flags=re.I)
+        s = re.sub(r'\bNOT\b', '~', s, flags=re.I)
+        s = re.sub(r'\band\b', '&', s)
+        s = re.sub(r'\bor\b', '|', s)
+        s = re.sub(r'\bnot\b', '~', s)
+        s = re.sub(r'\s*([&|~><=!]+)\s*', r' \1 ', s)
+        s = re.sub(r'\s+', ' ', s)
+        return s.strip()
+    
+    def _evaluate_rule(self, rule_expr: str, available_features: pd.DataFrame) -> pd.Series:
+        """Evaluate a rule expression using available features."""
+        normalized_expr = self._normalize_rule_expr(rule_expr)
+        
+        try:
+            eval_env = {col: available_features[col] for col in available_features.columns}
+            eval_env.update({
+                'np': np, 'pd': pd, 'abs': np.abs, 
+                'min': np.minimum, 'max': np.maximum
+            })
+            
+            result = eval(normalized_expr, {"__builtins__": {}}, eval_env)
+            
+            if isinstance(result, pd.Series):
+                return result.astype(bool)
+            else:
+                return pd.Series([bool(result)] * len(available_features), 
+                               index=available_features.index)
+                
+        except Exception as e:
+            print(f"Error evaluating rule '{rule_expr}': {e}")
+            return pd.Series(False, index=available_features.index)
+    
+    def _safe_ratio(self, a, b):
+        """Safe ratio calculation with log transformation."""
+        a_safe = np.abs(a) + 1e-6
+        b_safe = np.abs(b) + 1e-6
+        ratio = np.log1p(a_safe) - np.log1p(b_safe)
+        sign = np.sign(a * b)
+        return ratio * sign
+    
+    def _compute_statistical_features(self, df, signals, **kwargs):
+        """Statistical features: rolling means."""
+        features = pd.DataFrame(index=df.index)
+        
+        for signal in signals:
+            s = df[signal]
+            for win in self.window_sizes:
+                roll = s.rolling(win, min_periods=1)
+                features[f"{signal}_roll_mean_{win}"] = roll.mean()
+        
+        return features
+    
+    def _compute_temporal_features(self, df, signals, **kwargs):
+        """Temporal dynamics features: differences and rates."""
+        features = pd.DataFrame(index=df.index)
+        
+        for signal in signals:
+            s = df[signal]
+            diff = s.diff().fillna(0)
+            features[f"{signal}_diff"] = diff
+            features[f"{signal}_diff_sign"] = np.sign(diff)
+            features[f"{signal}_diff_smooth"] = diff.ewm(span=5).mean()
+            features[f"{signal}_abs_diff"] = np.abs(diff)
+        
+        return features
+    
+    def _compute_stability_features(self, df, signals, **kwargs):
+        """Stability features: stability flags and consecutive stable periods."""
+        features = pd.DataFrame(index=df.index)
+        
+        for signal in signals:
+            s = df[signal]
+            diff = s.diff().fillna(0)
+            features[f"{signal}_stability"] = 1.0 / (1.0 + np.abs(diff))
+            features[f"{signal}_stable_flag"] = (np.abs(diff) < self.stability_eps).astype(int)
+            
+            stable_periods = (np.abs(diff) < self.stability_eps)
+            consecutive_stable = stable_periods.groupby((~stable_periods).cumsum()).cumsum()
+            features[f"{signal}_consecutive_stable"] = consecutive_stable
+        
+        return features
+    
+    def _compute_interaction_features(self, df, signals, **kwargs):
+        """Interaction features: products and ratios between signals."""
+        features = pd.DataFrame(index=df.index)
+        
+        if len(signals) < 2:
+            return features
+        
+        for i in range(len(signals)):
+            for j in range(i + 1, len(signals)):
+                sig1, sig2 = signals[i], signals[j]
+                features[f"{sig1}_x_{sig2}"] = df[sig1] * df[sig2]
+                features[f"{sig1}_ratio_{sig2}"] = self._safe_ratio(df[sig1], df[sig2])
+        
+        return features
+    
+    def _compute_event_features(self, df, signals, **kwargs):
+        """Event/regime features with rule-based definitions."""
+        features = pd.DataFrame(index=df.index)
+        
+        # Create comprehensive set of available features
+        available_features = df.copy()
+        
+        # Pre-compute derived features for all numeric columns
+        for signal in df.columns:
+            if pd.api.types.is_numeric_dtype(df[signal]):
+                try:
+                    diff = df[signal].diff().fillna(0)
+                    available_features[f"{signal}_diff"] = diff
+                    available_features[f"{signal}_diff_smooth"] = diff.ewm(span=5).mean()
+                    available_features[f"{signal}_abs_diff"] = np.abs(diff)
+                    available_features[f"{signal}_stability"] = 1.0 / (1.0 + np.abs(diff))
+                    available_features[f"{signal}_stable_flag"] = (np.abs(diff) < self.stability_eps).astype(int)
+                except (TypeError, ValueError) as e:
+                    print(f"Warning: Could not compute derived features for {signal}: {e}")
+        
+        # Process event definitions
+        rule_counter = 0
+        for signal_def in signals:
+            if isinstance(signal_def, str) and any(op in signal_def for op in ['>', '<', '==', '&', '|']):
+                rule_counter += 1
+                try:
+                    fixed_expr = self._fix_rule_parentheses(signal_def)
+                    rule_result = self._evaluate_rule(fixed_expr, available_features)
+                    clean_name = re.sub(r'[^a-zA-Z0-9_]', '_', signal_def[:20])
+                    feature_name = f"event_{clean_name}"
+                    if feature_name in features.columns:
+                        feature_name = f"event_{clean_name}_{rule_counter}"
+                    features[feature_name] = rule_result.astype(int)
+                    print(f"Created event feature: {feature_name} from rule: {signal_def}")
+                except Exception as e:
+                    print(f"Error processing rule '{signal_def}': {e}")
+                    features[f"event_rule_error_{rule_counter}"] = 0
+                    
+            elif isinstance(signal_def, dict):
+                for rule_name, rule_expr in signal_def.items():
+                    try:
+                        fixed_expr = self._fix_rule_parentheses(rule_expr)
+                        rule_result = self._evaluate_rule(fixed_expr, available_features)
+                        features[f"event_{rule_name}"] = rule_result.astype(int)
+                        print(f"Created named event feature: event_{rule_name}")
+                    except Exception as e:
+                        print(f"Error processing named rule '{rule_name}': {e}")
+                        features[f"event_{rule_name}_error"] = 0
+        
+        return features
+    
+    def _compute_contextual_features(self, df, signals, **kwargs):
+        """Contextual features: batch position and boundaries."""
+        features = pd.DataFrame(index=df.index)
+        batch_id = kwargs.get('batch_id', 'batch_id')
+        
+        if batch_id in df.columns:
+            batch_pos = df.groupby(batch_id).cumcount()
+            features["batch_position"] = batch_pos / batch_pos.groupby(df[batch_id]).transform('max')
+            features["is_batch_start"] = (batch_pos == 0).astype(int)
+            features["is_batch_end"] = (batch_pos == batch_pos.groupby(df[batch_id]).transform('max')).astype(int)
+        
+        return features
+    
+    def _fix_rule_parentheses(self, expr: str) -> str:
+        """Add parentheses around comparison operations to avoid ambiguous truth values."""
+        normalized = self._normalize_rule_expr(expr)
+        parts = re.split(r'(\s*[&|]\s*)', normalized)
+        
+        if len(parts) == 1:
+            return normalized
+        
+        result_parts = []
+        for part in parts:
+            if part.strip() in ['&', '|']:
+                result_parts.append(part)
+            else:
+                if any(op in part for op in ['>', '<', '==', '!=', '>=', '<=']):
+                    result_parts.append(f'({part})')
+                else:
+                    result_parts.append(part)
+        
+        return ''.join(result_parts)
+    
+    def compute_features(self, df, feature_plan: Dict[str, List[str]]):
+        """Compute features based on a feature plan."""
+        all_features = pd.DataFrame(index=df.index)
+        
+        for family, signals in feature_plan.items():
+            if family not in self.feature_families:
+                print(f"Warning: Unknown feature family '{family}'")
+                continue
+            
+            if family == 'interaction':
+                for signal_pair in signals:
+                    if len(signal_pair) == 2:
+                        family_features = self.feature_families[family](df, signal_pair)
+                        all_features = pd.concat([all_features, family_features], axis=1)
+            else:
+                family_features = self.feature_families[family](df, signals)
+                all_features = pd.concat([all_features, family_features], axis=1)
+        
+        return all_features.fillna(0)
+    
+    def analyze_rule_performance(self, df: pd.DataFrame, feature_plan: Dict[str, List[str]]) -> Dict:
+        """
+        Compute features and analyze rule performance.
+        
+        Parameters:
+        -----------
+        df : Input data with sensor signals and state labels
+        feature_plan : Feature plan including event rules
+        
+        Returns:
+        --------
+        Dict with features and diagnostic results
+        """
+        # Compute features
+        features = self.compute_features(df, feature_plan)
+        
+        # Extract event features for analysis
+        event_features = features[[col for col in features.columns if col.startswith('event_')]]
+        
+        if event_features.empty:
+            print("No event features found for analysis")
+            return {'features': features, 'diagnostics': None}
+        
+        # Run diagnostic analysis
+        diagnostic_results = self.diagnostic_analyzer.compute_rule_metrics(df, event_features)
+        
+        return {
+            'features': features,
+            'diagnostics': diagnostic_results
+        }

main.py

@@ -0,0 +1,394 @@
+"""
+Main analysis pipeline for HMM process analyzer
+"""
+
+import numpy as np
+import pandas as pd
+from hmmlearn.hmm import GaussianHMM
+from sklearn.preprocessing import StandardScaler
+from scipy.optimize import linear_sum_assignment
+
+from features.feature_library import ModularFeatureLibrary
+from utils.hmm_utils import (
+    empirical_start_trans, emissions_from_labels, viterbi_decode, 
+    print_evaluation, normalize_timestamps, create_interval_event_log_normalized,
+    filter_brief_states, create_gantt_chart
+)
+import config
+
+import sys
+import io
+import os
+# --- capture print output to save to results.txt ---
+
+class _Tee:
+    """Write to multiple streams at once (e.g., console + file buffer)."""
+    def __init__(self, *streams):
+        self.streams = streams
+    def write(self, data):
+        for s in self.streams:
+            s.write(data)
+    def flush(self):
+        for s in self.streams:
+            s.flush()
+
+    
+def analyze_process(data_path, feature_plan, mode="unsupervised",
+                    use_cip=False, n_unsup=None, random_seed=42,
+                    results_txt_path=None):
+    if results_txt_path is None:
+        script_dir = os.path.dirname(os.path.abspath(__file__))
+        results_txt_path = os.path.join(script_dir, "results.txt")
+    buffer = io.StringIO()
+    original_stdout = sys.stdout
+    sys.stdout = _Tee(original_stdout, buffer)
+    """
+    Main analysis pipeline for process data.
+    
+    Parameters:
+    -----------
+    data_path : str
+        Path to CSV data file
+    feature_plan : dict
+        Feature extraction plan
+    mode : str
+        "supervised" or "unsupervised"
+    use_cip : bool
+        Whether to include CIP states
+    n_unsup : int
+        Number of states for unsupervised mode
+    random_seed : int
+        Random seed for reproducibility
+        
+    Returns:
+    --------
+    dict with analysis results
+    """
+    
+    try:
+        # Load and prepare data
+        df = load_and_prepare_data(data_path, use_cip)
+        
+        # Initialize feature library
+        feature_lib = ModularFeatureLibrary(
+            window_sizes=config.FEATURE_CONFIG["window_sizes"],
+            stability_eps=config.FEATURE_CONFIG["stability_eps"],
+            peak_threshold=config.FEATURE_CONFIG["peak_threshold"]
+        )
+        
+        # Compute features and analyze rule performance
+        print("Computing features and analyzing rule performance...")
+        result = feature_lib.analyze_rule_performance(df, feature_plan)
+        all_features = result['features']
+        diagnostics = result['diagnostics']
+        
+        # Print diagnostic report
+        if diagnostics:
+            feature_lib.diagnostic_analyzer.print_diagnostic_report(diagnostics)
+        
+        # Prepare features for HMM
+        event_features = all_features[[col for col in all_features.columns if col.startswith('event_')]]
+        important_raw_features = ['T_roll_mean_5', 'Q_in_roll_mean_5', 'Q_out_roll_mean_5', 'T_diff']
+        
+        # Combine features
+        features = pd.concat([all_features[important_raw_features], event_features], axis=1)
+        
+        # Split data into train/test
+        train_features, test_features, df_train, df_test = split_train_test(df, features)
+        
+        # Scale features
+        scaler = StandardScaler()
+        X_train_scaled = scaler.fit_transform(train_features)
+        X_test_scaled = scaler.transform(test_features)
+        
+        # Pack sequences for HMM
+        X_train_np, lengths_train = pack_sequences(df_train, X_train_scaled)
+        X_test_np, lengths_test = pack_sequences(df_test, X_test_scaled)
+        
+        # Create state mappings
+        state_list = get_state_list(use_cip, n_unsup, mode)
+        state_to_idx, idx_to_state = create_state_mappings(state_list)
+        
+        # Train and evaluate HMM
+        if mode.lower() == "supervised":
+            results = train_supervised_hmm(
+                X_train_np, lengths_train, X_test_np, lengths_test,
+                df_train, df_test, state_to_idx, idx_to_state, state_list
+            )
+        else:
+            results = train_unsupervised_hmm(
+                X_train_np, lengths_train, X_test_np, lengths_test,
+                df_train, df_test, state_to_idx, idx_to_state, state_list, n_unsup
+            )
+        
+        # Generate event log
+        print("\nGenerating event log...")
+        event_log = generate_event_log(df, results['model'], results['mapping'], 
+                                    results['test_predictions'], scaler, features)
+        
+        # Create visualizations
+        print("\nCreating visualizations...")
+        create_visualizations(event_log)
+        
+        return {
+            'model': results['model'],
+            'features': features,
+            'event_log': event_log,
+            'diagnostics': diagnostics,
+            'predictions': results['test_predictions']
+        }
+    finally:
+        # --- always restore stdout and save the captured text ---
+        sys.stdout = original_stdout
+        with open(results_txt_path, "w", encoding="utf-8") as f:
+            f.write(buffer.getvalue())
+        print(f"Results text saved to: {results_txt_path}")
+
+
+def load_and_prepare_data(data_path, use_cip):
+    """Load and prepare data for analysis."""
+    df = pd.read_csv(data_path)
+    
+    # Determine state list
+    state_list = config.PROCESS_STATES["production"]
+    if use_cip:
+        state_list += config.PROCESS_STATES["cip"]
+    
+    # Filter to relevant states and sort
+    df = df[df["state"].isin(state_list)].copy()
+    df.sort_values(["batch_id", "timestamp"], inplace=True)
+    
+    return df
+
+
+def split_train_test(df, features, train_ratio=0.6):
+    """Split data into training and testing sets."""
+    batch_ids = df["batch_id"].unique()
+    n_train = max(1, int(train_ratio * len(batch_ids)))
+    
+    train_batch_ids = set(batch_ids[:n_train])
+    test_batch_ids = set(batch_ids[n_train:])
+    
+    # Split features
+    X_train = features[df["batch_id"].isin(train_batch_ids)]
+    X_test = features[df["batch_id"].isin(test_batch_ids)]
+    
+    # Split labels
+    df_train = df[df["batch_id"].isin(train_batch_ids)]
+    df_test = df[df["batch_id"].isin(test_batch_ids)]
+    
+    return X_train, X_test, df_train, df_test
+
+
+def pack_sequences(df_subset, X_subset):
+    """Pack sequences for HMM training."""
+    lengths = df_subset.groupby("batch_id").size().tolist()
+    if isinstance(X_subset, pd.DataFrame):
+        X_subset = X_subset.values
+    return X_subset, lengths
+
+
+def get_state_list(use_cip, n_unsup, mode):
+    """Get the list of states based on configuration."""
+    state_list = config.PROCESS_STATES["production"]
+    if use_cip:
+        state_list += config.PROCESS_STATES["cip"]
+    
+    if mode.lower() == "unsupervised" and n_unsup is not None:
+        n_states = n_unsup
+    else:
+        n_states = len(state_list)
+    
+    return state_list
+
+
+def create_state_mappings(state_list):
+    """Create mappings between state names and indices."""
+    state_to_idx = {s: i for i, s in enumerate(state_list)}
+    idx_to_state = {i: s for s, i in state_to_idx.items()}
+    return state_to_idx, idx_to_state
+
+
+def train_supervised_hmm(X_train_np, lengths_train, X_test_np, lengths_test,
+                        df_train, df_test, state_to_idx, idx_to_state, state_list):
+    """Train and evaluate supervised HMM."""
+    print("\nTraining supervised HMM...")
+    
+    # Convert labels to indices
+    y_train_idx = df_train["state"].map(state_to_idx).values
+    y_test_idx = df_test["state"].map(state_to_idx).values
+    
+    # Initialize from labels
+    startprob_, transmat_ = empirical_start_trans(y_train_idx, lengths_train, len(state_list))
+    means_, covars_ = emissions_from_labels(X_train_np, y_train_idx, len(state_list))
+    
+    # Build and fit HMM
+    hmm = GaussianHMM(
+        n_components=len(state_list),
+        covariance_type="full",
+        n_iter=30,
+        init_params="",
+        random_state=config.HMM_CONFIG["random_seed"],
+        tol=config.HMM_CONFIG["tol"],
+        verbose=False
+    )
+    hmm.startprob_ = startprob_
+    hmm.transmat_ = transmat_
+    hmm.means_ = means_
+    hmm.covars_ = covars_
+    
+    hmm.fit(X_train_np, lengths_train)
+    
+    # Decode and evaluate
+    y_pred_test = viterbi_decode(hmm, X_test_np, lengths_test)
+    print_evaluation(y_test_idx, y_pred_test, idx_to_state, state_list, 
+                    title="Supervised HMM (Test)")
+    
+    return {
+        'model': hmm,
+        'mapping': idx_to_state,
+        'test_predictions': y_pred_test
+    }
+
+
+def train_unsupervised_hmm(X_train_np, lengths_train, X_test_np, lengths_test,
+                          df_train, df_test, state_to_idx, idx_to_state, state_list, n_unsup):
+    """Train and evaluate unsupervised HMM with state mapping."""
+    print("\nTraining unsupervised HMM...")
+    
+    n_states = n_unsup if n_unsup is not None else len(state_list)
+    
+    # Train unsupervised HMM
+    hmm = GaussianHMM(
+        n_components=n_states,
+        covariance_type=config.HMM_CONFIG["covariance_type"],
+        n_iter=config.HMM_CONFIG["n_iter"],
+        random_state=config.HMM_CONFIG["random_seed"],
+        tol=config.HMM_CONFIG["tol"],
+        init_params="stmc",
+        params="stmc"
+    )
+    hmm.fit(X_train_np, lengths_train)
+    
+    # Predict and map states
+    y_train_true = df_train["state"].map(state_to_idx).values
+    y_train_hat = viterbi_decode(hmm, X_train_np, 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_true, 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 = viterbi_decode(hmm, X_test_np, lengths_test)
+    y_test_mapped = np.array([mapping.get(s, 0) for s in y_test_hat], dtype=int)
+    y_test_true = df_test["state"].map(state_to_idx).values
+    
+    print_evaluation(y_test_true, 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}
+    
+    return {
+        'model': hmm,
+        'mapping': state_mapping,
+        'test_predictions': y_test_hat
+    }
+
+
+def generate_event_log(df, hmm, state_mapping, predictions, scaler, features):
+    """Generate event log from HMM predictions."""
+    # Normalize timestamps
+    df_normalized = normalize_timestamps(df)
+    
+    # Prepare test features
+    X_test_scaled = scaler.transform(features)
+    X_test_np, lengths_test = pack_sequences(df, X_test_scaled)
+    
+    # Get predictions for full dataset
+    y_pred_full = viterbi_decode(hmm, X_test_np, lengths_test)
+    
+    # Create event log
+    event_log = create_interval_event_log_normalized(
+        df_normalized, y_pred_full, state_mapping
+    )
+    
+    # Filter brief states
+    filtered_log = filter_brief_states(
+        event_log, 
+        min_duration_seconds=2.0
+    )
+    
+    # Save logs
+    event_log.to_csv(config.PATHS["event_log"], index=False)
+    filtered_log.to_csv(config.PATHS["filtered_log"], index=False)
+    
+    print(f"Event log saved to: {config.PATHS['event_log']}")
+    print(f"Filtered event log saved to: {config.PATHS['filtered_log']}")
+    
+    return filtered_log
+
+
+def create_visualizations(event_log):
+    """Create visualization of process execution."""
+    # Create Gantt chart
+    gantt_chart = create_gantt_chart(
+        event_log,
+        max_cases=10,
+        figsize=config.VISUALIZATION_CONFIG["gantt_figsize"],
+        color_map=config.VISUALIZATION_CONFIG["colors"]
+    )
+    
+    # Save and show
+    gantt_chart.savefig(config.PATHS["gantt_chart"], dpi=300, bbox_inches='tight')
+    gantt_chart.show()
+    
+    print(f"Gantt chart saved to: {config.PATHS['gantt_chart']}")
+
+
+if __name__ == "__main__":
+    # Example feature plan
+    feature_plan = {
+        'statistical': ['T', 'Q_in','Q_out'],           
+        'temporal': ['T', 'Q_in','Q_out'],                      
+        'stability': ['T', 'Q_in','Q_out'],             
+        'interaction': [['T', 'Q_in','Q_out']],
+        'event': [
+        '(T_diff_smooth < -1)',
+
+        # Fill rules
+        '(Q_in > 0.2) AND (Q_out < 0.05)',
+        '(Q_in > 0.2) AND (abs(T_diff) < 0.5) AND (Q_out < 0.05)',
+        
+        # Hold rules
+        '(abs(T_diff) < 0.3) AND (T > 70)',
+        '(abs(T_diff) < 0.2) AND (Q_in < 0.1) AND (Q_out < 0.1) AND (T > 70)',
+        
+        # Discharge rules
+        '(Q_out > 0.2)',
+        '(Q_out > 0.3)',
+        
+        # Idle rules
+        '(Q_in < 0.05) AND (Q_out < 0.05) AND (abs(T_diff) < 0.2)',
+        '(T < 15) AND (Q_in < 0.05) AND (Q_out < 0.05)',
+        '(Q_in < 0.05) AND (Q_out < 0.05) AND (abs(T_diff) < 0.2) AND (T < 15)'
+        ],
+        'contextual': []  
+    }
+    
+    # Run analysis
+    results = analyze_process(
+        data_path="synthetic_pasteurization_with_cip_signals_100.csv",
+        feature_plan=feature_plan,
+        mode="unsupervised",
+        use_cip=False,
+        n_unsup=None,
+        random_seed=42
+    )