Gray-box implementation

Author: DimitriWeiss

.gitignore

@@ -10,6 +10,11 @@ __pycache__/
 rtac/logs/Cadical_ReACTR
 rtac/logs/TSP_Q_ReACTR
 rtac/logs/TSP_RT_ReACTR
+rtac/logs/Cadical_CPPL
+rtac/logs/Cadicalpp_CPPL_gb
+rtac/logs/TSP_Qpp_ReACTRpp
+rtac/logs/TSP_RT_CPPL
+rtac/logs/TSP_RTpp_ReACTRpp
 rtac/data/instances/power_law_easy
 rtac/data/solvers/cadical
 

README.md

@@ -1,4 +1,4 @@
 # RTAC
 Realtime Algorithm Configuration Methods
 
-This Software is a refactored version of the software used in "Pool-Based Realtime Algorithm Configuration" and "Realtime gray-box algorithm configuration using cost-sensitive classification". It has also extended options regarding logging, input, e.g. parameter space via PCS files, and target algorithm calls.
+This Software is a reimplementation of the realtime algorithm configurators (RAC) described in "ReACTR: Realtime Algorithm Configuration through Tournament Rankings", "Pool-Based Realtime Algorithm Configuration" and "Realtime gray-box algorithm configuration using cost-sensitive classification" into a collective RAC suite. It also includes extended options regarding logging, input, e.g. parameter space via PCS files, and target algorithm calls.

rtac/.ipynb_checkpoints/gb_test-checkpoint.ipynb

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

rtac/ac_functionalities/logs.py

@@ -48,6 +48,8 @@ def __init__(self, scenario: argparse.Namespace):
         self.log_path = scenario.log_folder + '/' \
             + scenario.wrapper_name + '_' \
             + str(scenario.ac).split('.')[1]
+        if scenario.gray_box:
+            self.log_path += '_gb'
         if not os.path.isdir(self.log_path):
             os.makedirs(self.log_path)
         self.experimental = scenario.experimental
@@ -63,6 +65,7 @@ def __init__(self, scenario: argparse.Namespace):
             for f in filelist:
                 os.remove(os.path.join(self.log_path, f))
         self.objective_min = scenario.objective_min
+        print('\n')
         print(f'Logging to {self.log_path}')
 
     def init_rtac_logs(self) -> None:
@@ -266,21 +269,31 @@ def ranking_log(self, pool: dict[str: Configuration],
                 os.mkdir(f'{self.log_path}/bandit_models')
             self.bm_path = f'{self.log_path}/bandit_models'
             bandit_models = kwargs['bandit_models']
-            joblib.dump(
-                bandit_models['standard_scaler'],
-                f'{self.bm_path}/standard_scaler_{tourn_nr}.pkl')
-            joblib.dump(
-                bandit_models['min_max_scaler'],
-                f'{self.bm_path}/min_max_scaler_{tourn_nr}.pkl')
-            joblib.dump(
-                bandit_models['one_hot_encoder'],
-                f'{self.bm_path}/one_hot_encoder_{tourn_nr}.pkl')
-            joblib.dump(
-                bandit_models['pca_obj_params'],
-                f'{self.bm_path}/pca_obj_params_{tourn_nr}.pkl')
-            joblib.dump(
-                bandit_models['pca_obj_inst'],
-                f'{self.bm_path}/pca_obj_inst_{tourn_nr}.pkl')
+            if tourn_nr == 0:
+                joblib.dump(
+                    bandit_models['standard_scaler'],
+                    f'{self.bm_path}/standard_scaler_{tourn_nr}.pkl')
+                joblib.dump(
+                    bandit_models['min_max_scaler'],
+                    f'{self.bm_path}/min_max_scaler_{tourn_nr}.pkl')
+                joblib.dump(
+                    bandit_models['one_hot_encoder'],
+                    f'{self.bm_path}/one_hot_encoder_{tourn_nr}.pkl')
+                joblib.dump(
+                    bandit_models['pca_obj_params'],
+                    f'{self.bm_path}/pca_obj_params_{tourn_nr}.pkl')
+                joblib.dump(
+                    bandit_models['pca_obj_inst'],
+                    f'{self.bm_path}/pca_obj_inst_{tourn_nr}.pkl')
+            elif self.scenario.online_instance_train and tourn_nr > 0:
+                joblib.dump(
+                    bandit_models['standard_scaler'],
+                    f'{self.bm_path}/standard_scaler_{tourn_nr}.pkl')
+                joblib.dump(
+                    bandit_models['pca_obj_inst'],
+                    f'{self.bm_path}/pca_obj_inst_{tourn_nr}.pkl')
+            elif len(bandit_models) == 0:
+                pass
             self.bandit_log.handlers.clear()
             b_fh = logging.FileHandler(
                 f'{self.log_path}/bandit_tourn_{tourn_nr}.log')
@@ -335,21 +348,23 @@ def load_data(self, tourn_nr: int | None = None) \
                 assessment = dict(zip(list(pool.keys()), assessment.values()))
         elif self.ranking is ACMethod.CPPL:
             self.bm_path = f'{self.log_path}/bandit_models'
+            if not self.scenario.online_instance_train:
+                tourn_nr = 0
             with open(
                     f'{self.log_path}/bandit_tourn_{tourn_nr}.log', 'r') as f:
                 assessment = f.read()
-            #assessment = ast.literal_eval(assessment)
+
             assessment = eval(assessment, {"array": np.array})
             assessment = \
                 {k: self.parse_array(v) for k, v in assessment.items()}
             standard_scaler = \
                 joblib.load(f'{self.bm_path}/standard_scaler_{tourn_nr}.pkl')
             min_max_scaler = \
-                joblib.load(f'{self.bm_path}/min_max_scaler_{tourn_nr}.pkl')
+                joblib.load(f'{self.bm_path}/min_max_scaler_0.pkl')
             one_hot_encoder = \
-                joblib.load(f'{self.bm_path}/one_hot_encoder_{tourn_nr}.pkl')
+                joblib.load(f'{self.bm_path}/one_hot_encoder_0.pkl')
             pca_obj_params = \
-                joblib.load(f'{self.bm_path}/pca_obj_params_{tourn_nr}.pkl')
+                joblib.load(f'{self.bm_path}/pca_obj_params_0.pkl')
             pca_obj_inst = \
                 joblib.load(f'{self.bm_path}/pca_obj_inst_{tourn_nr}.pkl')
             bandit_models = {'standard_scaler': standard_scaler,
@@ -367,11 +382,9 @@ def load_data(self, tourn_nr: int | None = None) \
                 os.remove(f'{self.log_path}/scores_tourn_{tourn_nr}.log')
             elif self.ranking is ACMethod.CPPL:
                 os.remove(f'{self.log_path}/bandit_tourn_{tourn_nr}.log')
-                os.remove(f'{self.bm_path}/standard_scaler_{tourn_nr}.pkl')
-                os.remove(f'{self.bm_path}/min_max_scaler_{tourn_nr}.pkl')
-                os.remove(f'{self.bm_path}/one_hot_encoder_{tourn_nr}.pkl')
-                os.remove(f'{self.bm_path}/pca_obj_params_{tourn_nr}.pkl')
-                os.remove(f'{self.bm_path}/pca_obj_inst_{tourn_nr}.pkl')
+                filelist = [f for f in os.listdir(self.bm_path)]
+                for f in filelist:
+                    os.remove(os.path.join(self.bm_path, f))
             os.remove(f'{self.log_path}/pool_tourn_{tourn_nr}.log')
             os.remove(f'{self.log_path}/contender_dict_tourn_{tourn_nr}.log')
 
@@ -383,3 +396,7 @@ def load_data(self, tourn_nr: int | None = None) \
             return pool, assessment, contender_dict, tourn_nr
         elif self.ranking is ACMethod.CPPL:
             return pool, assessment, contender_dict, tourn_nr, bandit_models
+
+
+if __name__ == '__main__':
+    pass

rtac/ac_functionalities/ranking/cppl.py

@@ -98,6 +98,7 @@ def __init__(self, scenario, pool, contender_dict=None):
         self.t = 1
         self.Y_t = 0
         self.S_t = []
+        self.S_t_prior = []
         self.grad = np.zeros(self.dim, dtype=np.float32)
 
         self.pool_replacement = False
@@ -132,11 +133,23 @@ def record_bandit(self):
                        'Y_t': self.Y_t,
                        'S_t': self.S_t,
                        'grad': np.array2string(self.grad, threshold=np.inf)}
-        self.bandit_models = {'standard_scaler': self.standard_scaler,
-                              'min_max_scaler': self.min_max_scaler,
-                              'one_hot_encoder': self.one_hot_enc,
-                              'pca_obj_params': self.pca_obj_params,
-                              'pca_obj_inst': self.pca_obj_inst}
+
+        if hasattr(self, 'X_t'):
+            self.bandit['X_t'] = np.array2string(self.X_t, threshold=np.inf)
+        if hasattr(self, 'hess'):
+            self.bandit['hess'] = np.array2string(self.hess, threshold=np.inf)
+
+        if self.tourn == 0:
+            self.bandit_models = {'standard_scaler': self.standard_scaler,
+                                  'min_max_scaler': self.min_max_scaler,
+                                  'one_hot_encoder': self.one_hot_enc,
+                                  'pca_obj_params': self.pca_obj_params,
+                                  'pca_obj_inst': self.pca_obj_inst}
+        elif self.scenario.online_instance_train:
+            self.bandit_models = {'standard_scaler': self.standard_scaler,
+                                  'pca_obj_inst': self.pca_obj_inst}
+        else:
+            self.bandit_models = {}
 
     def process_results(self, queue1=None, queue2=None):
 
@@ -207,27 +220,6 @@ def update_data(self):
 
             results = self.results
 
-            if self.scenario.verbosity == 2:
-                if not self.scenario.objective_min:
-                    unit = 'seconds'
-                else:
-                    unit = 'objective value'
-                self.time_sum += round(min(results), 3)
-                len_str = len('Instance nr. ' + str(self.tourn) + ' : ' + str(
-                    round(self.time_sum, 3)) + f' {unit} total')
-                print('\n')
-                print('-' * len_str)
-                if min(results) == self.scenario.timeout:
-                    print('Instance nr.', self.tourn, ':',
-                          round(self.time_sum, 3), f'{unit} total'
-                          ' *** TIMEOUT on instance')
-                else:
-                    print('Instance nr.', self.tourn, ':',
-                          round(self.time_sum, 3), f'{unit} total')
-                print('-' * len_str)
-                print('\n')
-                self.tourn += 1
-
             # Get pool index of winner
             self.Y_t = min(range(len(results)), key=results.__getitem__)
             contender_ids = list(copy.deepcopy(self.pool).keys())
@@ -305,7 +297,7 @@ def discard_configs(self):
 
     def crossover(self, parents, nr_children, core):
 
-        parent_a, parent_b = parents #[core]
+        parent_a, parent_b = parents
 
         new_candids = []
         for child in range(nr_children):
@@ -478,7 +470,10 @@ def insert_in_pool(self, configs):
                       'by contender generated via', c.gen, '\n')
 
     def skill_and_confidence(self):
-        with threadpool_limits(limits=1):            
+        with threadpool_limits(limits=1):
+
+            self.S_t_prior = copy.deepcopy(self.S_t)
+
             # Estimated skill parameters
             self.v_hat = np.zeros(self.pool_size)
             for i in range(self.pool_size):
@@ -548,15 +543,16 @@ def skill_and_confidence(self):
                     -(self.v_hat)
                 ).argsort()[0:self.scenario.number_cores]
 
-            if self.scenario.verbosity in (1, 2):
+            if self.scenario.verbosity in (1, 2) and len(self.S_t_prior) != 0:
                 print('\nSkill and confidence assessment of the contenders',
                       'from tournament:\n \nContender',
-                      ' ' * 34, '   (v_hat', ' ' * 13, ', c_t)')
+                      ' ' * 34, '   ( v_hat', ' ' * 12, ', c_t', + 14 * ' ',
+                      ')')
                 pool_ids = list(self.pool.keys())
                 for core in range(self.scenario.number_cores):
-                    print(pool_ids[self.S_t[core]], 'assessment is:',
-                          '(', self.v_hat[self.S_t[core]], ',',
-                          self.c_t[self.S_t[core]], ')')
+                    print(pool_ids[self.S_t_prior[core]], 'assessment is:',
+                          '(', self.v_hat[self.S_t_prior[core]], ',',
+                          self.c_t[self.S_t_prior[core]], ')')
                 print('\n\n')
 
     def assess_children(self, transformed_configs, nd):
@@ -741,7 +737,7 @@ def transform_conf(self, conf):
                                                  for k in
                                                  self.cat_param_names]])
             # One-hot encoding increases impact of the feature in the model
-            # so we reduce the impact the number of binary features created
+            # so we reduce the impact by the number of binary features created
             normalized = []
             start = 0
             for cat in self.cat_values: