Fixes benchmark run with logs from memory.

gedi/benchmark.py

@@ -25,7 +25,7 @@ class BenchmarkTest:
 
         print(f"INFO: Running with {params}")
 
-        if len(event_logs) == 0:
+        if event_logs is None or len(event_logs) == 0:
             log_path = params[INPUT_PATH]
             if log_path.endswith(".xes"):
                 event_logs = [""]

gedi/generator.py

@@ -151,7 +151,7 @@ class GenerateEventLogs():
             os.makedirs(self.output_path, exist_ok=True)
 
         if self.output_path.endswith('csv'):
-            self.log_features = pd.read_csv(self.output_path)
+            self.generated_features = pd.read_csv(self.output_path)
             return
 
         generator_params = params.get(GENERATOR_PARAMS)
@@ -171,14 +171,16 @@ class GenerateEventLogs():
                 print(f"INFO: Generator starting at {start.strftime('%H:%M:%S')} using {num_cores} cores for {len(tasks)} tasks...")
                 random.seed(RANDOM_SEED)
                 partial_wrapper = partial(self.generator_wrapper, generator_params=generator_params)
-                log_features = p.map(partial_wrapper, [(index, row) for index, row in tasks.iterrows()])
+                generated_features = p.map(partial_wrapper, [(index, row) for index, row in tasks.iterrows()])
             # TODO: Split log and metafeatures into separate object attributes
             # TODO: Access not storing log in memory
-            # TODO: identify why log is needed in self.log_features
-            self.log_features = [
-                        {'log': config.get('log'), 'metafeatures': config.get('metafeatures')}
-                        for config in log_features
-                        if 'metafeatures' in config and 'log' in config
+            # TODO: identify why log is needed in self.generated_features
+            self.generated_features = [
+                        {
+                            #'log': config.get('log'),
+                            'metafeatures': config.get('metafeatures')}
+                            for config in generated_features
+                            if 'metafeatures' in config #and 'log' in config
                     ]
 
         else:
@@ -187,20 +189,19 @@ class GenerateEventLogs():
             if type(configs) is not list:
                 configs = [configs]
             temp = self.generate_optimized_log(configs[0])
-            self.log_features = [temp['metafeatures']] if 'metafeatures' in temp else []
+            self.generated_features = [temp['metafeatures']] if 'metafeatures' in temp else []
             save_path = get_output_key_value_location(generator_params[EXPERIMENT],
                                              self.output_path, "genEL")+".xes"
             write_xes(temp['log'], save_path)
             add_extension_before_traces(save_path)
             print("SUCCESS: Saved generated event log in", save_path)
-        import pdb; pdb.set_trace()
-        print(f"SUCCESS: Generator took {dt.now()-start} sec. Generated {len(self.log_features)} event log(s).")
+        print(f"SUCCESS: Generator took {dt.now()-start} sec. Generated {len(self.generated_features)} event log(s).")
         print(f"         Saved generated logs in {self.output_path}")
         print("========================= ~ Generator ==========================")
 
     def clear(self):
         print("Clearing parameters...")
-        self.log_features = None
+        self.generated_features = None
         # self.configs = None
         # self.params = None
         self.output_path = None
@@ -220,17 +221,17 @@ class GenerateEventLogs():
 
         random.seed(RANDOM_SEED)
         if isinstance(configs, list):
-            log_features = self.generate_optimized_log(configs[0])
+            generated_features = self.generate_optimized_log(configs[0])
         else:
-            log_features = self.generate_optimized_log(configs)
+            generated_features = self.generate_optimized_log(configs)
 
         save_path = get_output_key_value_location(task.to_dict(),
                                          self.output_path, identifier, self.feature_keys)+".xes"
 
-        write_xes(log_features['log'], save_path)
+        write_xes(generated_features['log'], save_path)
         add_extension_before_traces(save_path)
         print("SUCCESS: Saved generated event log in", save_path)
-        features_to_dump = log_features['metafeatures']
+        features_to_dump = generated_features['metafeatures']
 
         features_to_dump['log']= os.path.split(save_path)[1].split(".")[0]
         # calculating the manhattan distance of the generated log to the target features
@@ -238,7 +239,7 @@ class GenerateEventLogs():
         features_to_dump['target_similarity'] = compute_similarity(self.objectives, features_to_dump)
         dump_features_json(features_to_dump, save_path)
 
-        return log_features
+        return generated_features
 
     def generate_optimized_log(self, config):
         ''' Returns event log from given configuration'''

gedi/run.py

@@ -24,21 +24,21 @@ def run(kwargs:dict, model_params_list: list, filename_list:list):
     params = kwargs[PARAMS]
     ft = EventLogFeatures(None)
     augmented_ft = InstanceAugmentator()
-    gen = pd.DataFrame(columns=['log'])
+    gen = pd.DataFrame(columns=['metafeatures'])
 
     for model_params in model_params_list:
         if model_params.get(PIPELINE_STEP) == 'instance_augmentation':
             augmented_ft = InstanceAugmentator(aug_params=model_params, samples=ft.feat)
             AugmentationPlotter(augmented_ft, model_params)
         elif model_params.get(PIPELINE_STEP) == 'event_logs_generation':
-            gen = pd.DataFrame(GenerateEventLogs(model_params).log_features)
+            gen = pd.DataFrame(GenerateEventLogs(model_params).generation_features)
             #gen = pd.read_csv("output/features/generated/grid_2objectives_enseef_enve/2_enseef_enve_feat.csv")
             #GenerationPlotter(gen, model_params, output_path="output/plots")
         elif model_params.get(PIPELINE_STEP) == 'benchmark_test':
-            benchmark = BenchmarkTest(model_params, event_logs=gen['log'])
+            benchmark = BenchmarkTest(model_params)#, event_logs=gen['log'])
             # BenchmarkPlotter(benchmark.features, output_path="output/plots")
         elif model_params.get(PIPELINE_STEP) == 'feature_extraction':
-            ft = EventLogFeatures(**kwargs, logs=gen['log'], ft_params=model_params)
+            ft = EventLogFeatures(**kwargs, ft_params=model_params)
             FeaturesPlotter(ft.feat, model_params)
         elif model_params.get(PIPELINE_STEP) == "evaluation_plotter":
             GenerationPlotter(gen, model_params, output_path=model_params['output_path'], input_path=model_params['input_path'])