Merge pull request #7 from andreamalhera/6-frontend-for-configfiles

.conda.yml

@@ -0,0 +1,22 @@
+name: gedi
+channels:
+  - conda-forge
+dependencies:
+  - python=3.9
+  - numpy=1.23.1
+  - scikit-learn=1.2.2
+  - scipy
+  - pandas
+  - matplotlib
+  - pip
+  - pip:
+    - pm4py==2.7.2
+    - imblearn
+    - seaborn
+    - feeed
+    - smac
+    - ConfigSpace
+    - tqdm
+    - Levenshtein
+    - streamlit
+    - streamlit-toggle-switch

.gitignore

@@ -1,8 +1,9 @@
-smac3_output/
-data/
-output/
+*.pyc
 .ipynb_checkpoints/
-notebooks/.ipynb_checkpoints/*
-gedi.egg-info/
 build/
-*.pyc
+config_files/algorithm/grid_*/*
+data/
+gedi.egg-info/
+notebooks/.ipynb_checkpoints/*
+output/
+smac3_output/

README.md

@@ -63,7 +63,7 @@ The JSON file consists of the following key-value pairs:
 - real_eventlog_path: defines the file with the features extracted from the real event logs
 - plot_type: defines the style of the output plotting (possible values: violinplot, boxplot)
 - font_size: label font size of the output plot
-- boxplot_widht: width of the violinplot/boxplot
+- boxplot_width: width of the violinplot/boxplot
 
 
 ### Generation
@@ -153,8 +153,16 @@ To execute the experiments with grid targets, a single [configuration](config_fi
 conda activate gedi
 python execute_grid_experiments.py config_files/algorithm/grid_2obj
 ```
-We employ the [experiment_grid_2obj_configfiles_fabric.ipynb](notebooks/experiment_grid_2obj_configfiles_fabric.ipynb) to create all necessary [configuration](config_files/algorithm/grid_2obj) and [objective](data/grid_2obj) files for this experiment. For more details about these config_files, please refer to [Feature Extraction](#feature-extraction), [Generation](#generation), and [Benchmark](#benchmark).
+We employ the [experiment_grid_2obj_configfiles_fabric.ipynb](notebooks/experiment_grid_2obj_configfiles_fabric.ipynb) to create all necessary [configuration](config_files/algorithm/grid_2obj) and [objective](data/grid_2obj) files for this experiment.
+For more details about these config_files, please refer to [Feature Extraction](#feature-extraction), [Generation](#generation), and [Benchmark](#benchmark).
+To create configuration files for grid objectives interactively, you can use the start the following dashboard:
+```
+streamlit run utils/config_fabric.py # To tunnel to local machine add: --server.port 8501 --server.headless true
 
+# In local machine (only in case you are tunneling):
+ssh -N -f -L 9000:localhost:8501 <user@remote_machine.com>
+open "http://localhost:9000/"
+```
 ### Visualizations
 To run the visualizations, we employ [jupyter notebooks](https://jupyter.org/install) and [add the installed environment to the jupyter notebook](https://medium.com/@nrk25693/how-to-add-your-conda-environment-to-your-jupyter-notebook-in-just-4-steps-abeab8b8d084). We then start all visualizations by running e.g.: `jupyter noteboook`. In the following, we describe the `.ipynb`-files in the folder `\notebooks` to reproduce the figures from our paper. 
 

config_files/config_layout.json

@@ -0,0 +1,48 @@
+[
+  {
+    "pipeline_step": "instance_augmentation",
+    "augmentation_params":{"method":"SMOTE", "no_samples":2,
+        "feature_selection": ["ratio_top_20_variants", "epa_normalized_sequence_entropy_linear_forgetting"]},
+    "input_path": "data/test/bpic_features.csv",
+    "output_path": "output"
+  },
+  {
+    "pipeline_step": "event_logs_generation",
+    "output_path": "output/features/2_bpic_features/2_ense_rmcv_feat.csv",
+    "output_path": "data/test",
+    "generator_params": {
+      "experiment": "data/grid_objectives.csv",
+      "experiment": {"input_path": "data/2_bpic_features.csv",
+        "objectives": ["ratio_top_20_variants", "epa_normalized_sequence_entropy_linear_forgetting"]},
+      "experiment": {"n_traces":832, "n_unique_traces":828, "ratio_variants_per_number_of_traces":0.99, "trace_len_min":1, "trace_len_max":132, "trace_len_mean":53.31, "trace_len_median":54, "trace_len_mode":61, "trace_len_std":19.89, "trace_len_variance":395.81, "trace_len_q1":44, "trace_len_q3":62, "trace_len_iqr":18, "trace_len_geometric_mean":48.15, "trace_len_geometric_std":1.69, "trace_len_harmonic_mean":37.58, "trace_len_skewness":0.0541, "trace_len_kurtosis":0.81, "trace_len_coefficient_variation":0.37, "trace_len_entropy":6.65, "trace_len_hist1":0.004, "trace_len_hist2":0.005, "trace_len_hist3":0.005, "trace_len_hist4":0.024, "trace_len_hist5":0.024, "trace_len_hist6":0.008, "trace_len_hist7":0.005, "trace_len_hist8":0.001, "trace_len_hist9":0.0, "trace_len_hist10":0.00, "trace_len_skewness_hist":0.05, "trace_len_kurtosis_hist":0.8, "ratio_most_common_variant":0.0, "ratio_top_1_variants":0.01, "ratio_top_5_variants":0.05, "ratio_top_10_variants":0.10, "ratio_top_20_variants":0.2, "ratio_top_50_variants":0.5, "ratio_top_75_variants":0.75, "mean_variant_occurrence":1.0, "std_variant_occurrence":0.07, "skewness_variant_occurrence":14.28, "kurtosis_variant_occurrence":202.00, "n_unique_activities":410, "activities_min":1, "activities_max":830, "activities_mean":108.18, "activities_median":12, "activities_std":187.59, "activities_variance":35189, "activities_q1":3, "activities_q3":125, "activities_iqr":122, "activities_skewness":2.13, "activities_kurtosis":3.81, "n_unique_start_activities":14, "start_activities_min":1, "start_activities_max":731, "start_activities_mean":59.43, "start_activities_median":1, "start_activities_std":186.72, "start_activities_variance":34863, "start_activities_q1":1, "start_activities_q3":8, "start_activities_iqr":7, "start_activities_skewness":3, "start_activities_kurtosis":9.0, "n_unique_end_activities":82, "end_activities_min":1, "end_activities_max":216, "end_activities_mean":10, "end_activities_median":1, "end_activities_std":35, "end_activities_variance":1247, "end_activities_q1":1, "end_activities_q3":3, "end_activities_iqr":2, "end_activities_skewness":5, "end_activities_kurtosis":26, "eventropy_trace":10, "eventropy_prefix":15, "eventropy_global_block":19, "eventropy_lempel_ziv":4, "eventropy_k_block_diff_1":7.1, "eventropy_k_block_diff_3":7.1, "eventropy_k_block_diff_5":7.1, "eventropy_k_block_ratio_1":7.1, "eventropy_k_block_ratio_3":7.1, "eventropy_k_block_ratio_5":7.1, "eventropy_knn_3":5.54, "eventropy_knn_5":5.04, "eventropy_knn_7":4.72, "epa_variant_entropy":240512, "epa_normalized_variant_entropy":0.68, "epa_sequence_entropy":285876, "epa_normalized_sequence_entropy":0.60, "epa_sequence_entropy_linear_forgetting":150546, "epa_normalized_sequence_entropy_linear_forgetting":0.32, "epa_sequence_entropy_exponential_forgetting":185312, "epa_normalized_sequence_entropy_exponential_forgetting":0.39},
+      "config_space": {
+        "mode": [5, 20],
+        "sequence": [0.01, 1],
+        "choice": [0.01, 1],
+        "parallel": [0.01, 1],
+        "loop": [0.01, 1],
+        "silent": [0.01, 1],
+        "lt_dependency": [0.01, 1],
+        "num_traces": [10, 100],
+        "duplicate": [0],
+        "or": [0]
+      },
+      "n_trials": 2
+    }
+  },
+  {
+    "pipeline_step": "feature_extraction",
+    "input_path": "data/test",
+    "feature_params": {"feature_set": ["n_traces", "n_unique_traces", "ratio_unique_traces_per_trace", "trace_len_min", "trace_len_max", "trace_len_mean", "trace_len_median", "trace_len_mode", "trace_len_std", "trace_len_variance", "trace_len_q1", "trace_len_q3", "trace_len_iqr", "trace_len_geometric_mean", "trace_len_geometric_std", "trace_len_harmonic_mean", "trace_len_skewness", "trace_len_kurtosis", "trace_len_coefficient_variation", "trace_len_entropy", "trace_len_hist1", "trace_len_hist2", "trace_len_hist3", "trace_len_hist4", "trace_len_hist5", "trace_len_hist6", "trace_len_hist7", "trace_len_hist8", "trace_len_hist9", "trace_len_hist10", "trace_len_skewness_hist", "trace_len_kurtosis_hist", "ratio_most_common_variant", "ratio_top_1_variants", "ratio_top_5_variants", "ratio_top_10_variants", "ratio_top_20_variants", "ratio_top_50_variants", "ratio_top_75_variants", "mean_variant_occurrence", "std_variant_occurrence", "skewness_variant_occurrence", "kurtosis_variant_occurrence", "n_unique_activities", "activities_min", "activities_max", "activities_mean", "activities_median", "activities_std", "activities_variance", "activities_q1", "activities_q3", "activities_iqr", "activities_skewness", "activities_kurtosis", "n_unique_start_activities", "start_activities_min", "start_activities_max", "start_activities_mean", "start_activities_median", "start_activities_std", "start_activities_variance", "start_activities_q1", "start_activities_q3", "start_activities_iqr", "start_activities_skewness", "start_activities_kurtosis", "n_unique_end_activities", "end_activities_min", "end_activities_max", "end_activities_mean", "end_activities_median", "end_activities_std", "end_activities_variance", "end_activities_q1", "end_activities_q3", "end_activities_iqr", "end_activities_skewness", "end_activities_kurtosis", "eventropy_trace", "eventropy_prefix", "eventropy_prefix_flattened", "eventropy_global_block", "eventropy_global_block_flattened", "eventropy_lempel_ziv", "eventropy_lempel_ziv_flattened", "eventropy_k_block_diff_1", "eventropy_k_block_diff_3", "eventropy_k_block_diff_5", "eventropy_k_block_ratio_1", "eventropy_k_block_ratio_3", "eventropy_k_block_ratio_5", "eventropy_knn_3", "eventropy_knn_5", "eventropy_knn_7", "epa_variant_entropy", "epa_normalized_variant_entropy", "epa_sequence_entropy", "epa_normalized_sequence_entropy", "epa_sequence_entropy_linear_forgetting", "epa_normalized_sequence_entropy_linear_forgetting", "epa_sequence_entropy_exponential_forgetting", "epa_normalized_sequence_entropy_exponential_forgetting"]},
+    "output_path": "output/plots",
+    "real_eventlog_path": "data/BaselineED_feat.csv",
+    "plot_type": "boxplot"
+  },
+  {
+    "pipeline_step": "benchmark_test",
+    "benchmark_task": "discovery",
+    "input_path":"data/test",
+    "output_path":"output",
+    "miners" : ["inductive", "heu", "imf", "ilp"]
+  }
+]

main.py

@@ -35,7 +35,7 @@ def run(kwargs:dict, model_paramas_list: list, filename_list:list):
             elif model_params.get(PIPELINE_STEP) == 'event_logs_generation':
                 gen = pd.DataFrame(GenerateEventLogs(model_params).log_config)
                 #gen = pd.read_csv("output/features/generated/grid_2objectives_enseef_enve/2_enseef_enve_feat.csv")
-                GenerationPlotter(gen, model_params, output_path="output/plots")
+                #GenerationPlotter(gen, model_params, output_path="output/plots")
             elif model_params.get(PIPELINE_STEP) == 'benchmark_test':
                 benchmark = BenchmarkTest(model_params, event_logs=gen['log'])
                 # BenchmarkPlotter(benchmark.features, output_path="output/plots")

setup.py

@@ -32,6 +32,7 @@ setup(
             'seaborn==0.13.2',
             'smac==2.0.2',
             'tqdm==4.65.0',
+            'streamlit-toggle-switch>=1.0.2'
             ],
         packages = ['gedi'],
         classifiers=[

utils/config_fabric.py

@@ -0,0 +1,258 @@
+from copy import deepcopy
+from importlib import reload
+from itertools import product as cproduct
+from itertools import combinations
+from pylab import *
+import itertools
+import json
+import math
+import os
+import pandas as pd
+import pm4py
+import random
+import streamlit as st
+import subprocess
+
+st.set_page_config(layout='wide')
+INPUT_XES="output/inputlog_temp.xes"
+
+"""
+# Configuration File fabric for
+## GEDI: **G**enerating **E**vent **D**ata with **I**ntentional Features for Benchmarking Process Mining
+"""
+def double_switch(label_left, label_right, third_label=None, fourth_label=None):
+    if third_label==None and fourth_label==None:
+        # Create two columns for the labels and toggle switch
+        col0, col1, col2, col3, col4 = st.columns([2,1,1,1,2])
+    else:
+        # Create two columns for the labels and toggle switch
+        col0, col1, col2, col3, col4, col5, col6, col7, col8 = st.columns([1,1,1,1,1,1,1,1,1])
+
+    # Add labels to the columns
+    with col1:
+        st.write(label_left)
+
+    with col2:
+        # Create the toggle switch
+        toggle_option = st.toggle(" ",value=False,
+            key="toggle_switch_"+label_left,
+        )
+
+    with col3:
+        st.write(label_right)
+    if third_label is None and fourth_label is None:return toggle_option
+    else:
+        with col5:
+            st.write(third_label)
+
+        with col6:
+            # Create the toggle switch
+            toggle_option_2 = st.toggle(" ",value=False,
+                key="toggle_switch_"+third_label,
+            )
+
+        with col7:
+            st.write(fourth_label)
+        return toggle_option, toggle_option_2
+
+def multi_button(labels):
+    cols = st.columns(len(labels))
+    activations = []
+    for col, label in zip(cols, labels):
+        activations.append(col.button(label))
+    return activations
+
+def input_multicolumn(labels, default_values, n_cols=5):
+    result = {}
+    cols = st.columns(n_cols)
+    factor = math.ceil(len(labels)/n_cols)
+    extended = cols.copy()
+    for _ in range(factor):
+        extended.extend(cols)
+    for label, default_value, col in zip(labels, default_values, extended):
+        with col:
+            result[label] = col.text_input(label, default_value, key=f"input_"+label+'_'+str(default_value))
+    return result.values()
+
+def split_list(input_list, n):
+    # Calculate the size of each chunk
+    k, m = divmod(len(input_list), n)
+    # Use list comprehension to create n sublists
+    return [input_list[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n)]
+
+def get_ranges_from_stats(stats, tuple_values):
+    col_for_row = ", ".join([f"x[\'{i}\'].astype(float)" for i in tuple_values])
+    stats['range'] = stats.apply(lambda x: tuple([eval(col_for_row)]), axis=1)
+    #tasks = eval(f"list(itertools.product({(parameters*n_para_obj)[:-2]}))")
+    result = [f"np.around({x}, 2)" for x in stats['range']]
+    result = ", ".join(result)
+    return result
+
+def create_objectives_grid(df, objectives, n_para_obj=2, method="combinatorial"):
+        if method=="combinatorial":
+            sel_features = df.index.to_list()
+            parameters_o = "objectives, "
+            parameters = get_ranges_from_stats(df, sorted(objectives))
+            objectives = sorted(sel_features)
+            tasks = f"list(cproduct({parameters}))[0]"
+
+        elif method=="range-from-csv":
+            tasks = ""
+            for objective in objectives:
+                min_col, max_col, step_col = st.columns(3)
+                with min_col:
+                    selcted_min = st.slider(objective+': min', min_value=float(df[objective].min()), max_value=float(df[objective].max()), value=df[objective].quantile(0.1), step=0.1, key=objective+"min")
+                with max_col:
+                    selcted_max = st.slider('max', min_value=selcted_min, max_value=float(df[objective].max()), value=df[objective].quantile(0.9), step=0.1, key=objective+"max")
+                with step_col:
+                    step_value = st.slider('step', min_value=float(df[objective].min()), max_value=float(df[objective].quantile(0.9)), value=df[objective].median()/(df[objective].min()+0.0001), step=0.01, key=objective+"step")
+                tasks += f"np.around(np.arange({selcted_min}, {selcted_max}+{step_value}, {step_value}),2), "
+        else :#method=="range-manual":
+            experitments = []
+            tasks=""
+            if objectives != None:
+                cross_labels =  [feature[0]+': '+feature[1] for feature in list(cproduct(objectives,['min', 'max', 'step']))]
+                cross_values = [round(eval(str(combination[0])+combination[1]), 2) for combination in list(cproduct(list(df.values()), ['*1', '*2', '/3']))]
+                ranges = zip(objectives, split_list(list(input_multicolumn(cross_labels, cross_values, n_cols=3)), n_para_obj))
+                for objective, range_value in ranges:
+                    selcted_min, selcted_max, step_value = range_value
+                    tasks += f"np.around(np.arange({selcted_min}, {selcted_max}+{step_value}, {step_value}),2), "
+
+        #import pdb; pdb.set_trace()
+        cartesian_product = list(cproduct(*eval(tasks)))
+        experiments = [{key: value[idx] for idx, key in enumerate(objectives)} for value in cartesian_product]
+        return experiments
+
+def set_generator_experiments(generator_params):
+    def handle_csv_file(grid_option):
+        uploaded_file = st.file_uploader("Pick a csv-file containing feature values for features:", type="csv")
+        if uploaded_file is not None:
+            df = pd.read_csv(uploaded_file)
+            sel_features = st.multiselect("Selected features", list(df.columns))
+            if sel_features:
+                df = df[sel_features]
+                return df, sel_features
+        return None, None
+
+    def handle_combinatorial(sel_features, stats, tuple_values):
+        triangular_option = double_switch("Square", "Triangular")
+        if triangular_option:
+            experiments = []
+            elements = sel_features
+            # List to store all combinations
+            all_combinations = [combinations(sel_features, r) for r in range(1, len(sel_features) + 1)]
+            all_combinations = [comb for sublist in all_combinations for comb in sublist]
+
+            # Print or use the result as needed
+            for comb in all_combinations:
+                sel_stats = stats.loc[sorted(list(comb))]
+                experiments += create_objectives_grid(sel_stats, tuple_values, n_para_obj=len(tuple_values), method="combinatorial")
+        else:
+            experiments = create_objectives_grid(stats, tuple_values, n_para_obj=len(tuple_values))
+        return experiments
+
+    def handle_grid_option(grid_option, df, sel_features):
+        if grid_option:
+            combinatorial = double_switch("Range", "Combinatorial")
+            if combinatorial:
+                add_quantile = st.slider('Add %-quantile', min_value=0.0, max_value=100.0, value=50.0, step=5.0)
+                stats = df.describe().transpose().sort_index()
+                stats[f"{int(add_quantile)}%"] = df.quantile(q=add_quantile / 100)
+                st.write(stats)
+                tuple_values = st.multiselect("Tuples including", list(stats.columns)[3:], default=['min', 'max'])
+                return handle_combinatorial(sel_features, stats, tuple_values)
+            else:  # Range
+                return create_objectives_grid(df, sel_features, n_para_obj=len(sel_features), method="range-from-csv")
+        else:  # Point
+            st.write(df)
+            return df.to_dict(orient='records')
+
+    def handle_manual_option(sel_features, grid_option):
+        if sel_features:
+            if grid_option:
+                return create_objectives_grid(generator_params['experiment'], sel_features, n_para_obj=len(sel_features), method="range-manual")
+            else:
+                experiment = {sel_feature: float(st.text_input(sel_feature, generator_params['experiment'][sel_feature])) for sel_feature in sel_features}
+                return [experiment]
+        return []
+
+    grid_option, csv_option = double_switch("Point-", "Grid-based", third_label="Manual", fourth_label="From CSV")
+
+    if csv_option:
+        df, sel_features = handle_csv_file(grid_option)
+        if df is not None and sel_features is not None:
+            experiments = handle_grid_option(grid_option, df, sel_features)
+        else:
+            experiments = []
+    else:  # Manual
+        sel_features = st.multiselect("Selected features", list(generator_params['experiment'].keys()))
+        experiments = handle_manual_option(sel_features, grid_option)
+
+    generator_params['experiment'] = experiments
+    st.write(f"...result in {len(generator_params['experiment'])} experiment(s)")
+
+    """
+    #### Configuration space
+    """
+    updated_values = input_multicolumn(generator_params['config_space'].keys(), generator_params['config_space'].values())
+    for key, new_value in zip(generator_params['config_space'].keys(), updated_values):
+        generator_params['config_space'][key] = eval(new_value)
+    generator_params['n_trials'] = int(st.text_input('n_trials', generator_params['n_trials']))
+
+    return generator_params
+
+if __name__ == '__main__':
+    config_layout = json.load(open("config_files/config_layout.json"))
+    type(config_layout)
+    step_candidates = ["instance_augmentation","event_logs_generation","feature_extraction","benchmark_test"]
+    pipeline_steps = st.multiselect(
+        "Choose pipeline step",
+        step_candidates,
+        []
+    )
+    step_configs = []
+    set_col, view_col = st.columns([3, 2])
+    for pipeline_step in pipeline_steps:
+        step_config = [d for d in config_layout if d['pipeline_step'] == pipeline_step][0]
+        with set_col:
+            st.header(pipeline_step)
+            for step_key in step_config.keys():
+                if step_key == "generator_params":
+                    st.subheader("Set-up experiments")
+                    step_config[step_key] = set_generator_experiments(step_config[step_key])
+                elif step_key == "feature_params":
+                    layout_features = list(step_config[step_key]['feature_set'])
+                    step_config[step_key]["feature_set"] = st.multiselect(
+                            "features to extract",
+                            layout_features)
+                elif step_key != "pipeline_step":
+                    step_config[step_key] = st.text_input(step_key, step_config[step_key])
+        with view_col:
+            st.write(step_config)
+        step_configs.append(step_config)
+    config_file = json.dumps(step_configs, indent=4)
+    output_path = st.text_input("Output file path", "config_files/experiment_config.json")
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    save_labels = ["Save config file", "Save and run config_file"]
+    save_labels = ["Save configuration file"]
+    #create_button, create_run_button = multi_button(save_labels)
+    create_button = multi_button(save_labels)
+    if create_button: # or create_run_button:
+        with open(output_path, "w") as f:
+            f.write(config_file)
+        st.write("Saved configuration in ", output_path, ". Run command:")
+        #if create_run_button:
+        if True:
+            options_path = os.path.join("config_files", "options", "baseline.json")
+            var = f"python -W ignore main.py -o {options_path} -a {output_path}"
+            st.code(var, language='bash')
+        if False: #FIXME: Command fails when using multiprocessing 
+            command = var.split()
+
+            # Run the command
+            result = subprocess.run(command, capture_output=True, text=True)
+
+            if len(result.stderr)==0:
+                st.write(result.stdout)
+            else:
+                st.write("ERROR: ", result.stderr)