Move unique_results from tuning_options to CostFunc

Author: stijnh

kernel_tuner/interface.py

@@ -616,7 +616,6 @@ def tune_kernel(
     kernel_options = Options([(k, opts[k]) for k in _kernel_options.keys()])
     tuning_options = Options([(k, opts[k]) for k in _tuning_options.keys()])
     device_options = Options([(k, opts[k]) for k in _device_options.keys()])
-    tuning_options["unique_results"] = {}
 
     # copy some values from strategy_options
     searchspace_construction_options = {}

kernel_tuner/runners/sequential.py

@@ -138,7 +138,5 @@ def run(self, parameter_space, tuning_options):
 
             # all visited configurations are added to results to provide a trace for optimization strategies
             results.append(params)
-            if x_int not in tuning_options.unique_results:
-                tuning_options.unique_results[x_int] = result
 
         return results

kernel_tuner/strategies/common.py

@@ -98,6 +98,7 @@ def __init__(
         self.scaling = scaling
         self.snap = snap
         self.return_invalid = return_invalid
+        self.unique_results = dict()
         self.results = []
         self.budget_spent_fraction = 0.0
         self.invalid_return_value = invalid_value
@@ -147,7 +148,7 @@ def _run_configs(self, xs, check_restrictions=True):
         final_results = []  # List returned to the user
 
         # Loop over all configurations. For each configurations there are four cases:
-        # 1. The configuration is valid, we can skip it
+        # 1. The configuration is invalid, we can skip it
         # 2. The configuration is in  `unique_results`, we can get it from there
         # 3. The configuration is in  `pending_indices_by_key`, it is duplicate in `xs`
         # 4. The configuration must be evaluated by the runner.
@@ -163,8 +164,8 @@ def _run_configs(self, xs, check_restrictions=True):
                 final_results.append(result)
 
             # 2. Attempt to retrieve from `unique_results` 
-            elif key in self.tuning_options.unique_results:
-                result = dict(self.tuning_options.unique_results[key])
+            elif key in self.unique_results:
+                result = dict(self.unique_results[key])
                 final_results.append(result)
 
             # 3. We have already seen this config in the current batch
@@ -197,8 +198,12 @@ def _run_configs(self, xs, check_restrictions=True):
                 result["benchmark_time"] = 0
 
             # Put result in `unique_results`
-            self.tuning_options.unique_results[key] = result
-            self.results.append(result)
+            self.unique_results[key] = result
+
+        for result in final_results:
+            # Skip if None. Result is missing if runner exhausted the budget
+            if result is not None:
+                self.results.append(result)
 
         # upon returning from this function control will be given back to the strategy, so reset the start time
         self.runner.last_strategy_start_time = perf_counter()
@@ -243,6 +248,12 @@ def eval(self, x, check_restrictions=True):
 
     def __call__(self, x, check_restrictions=True):
         return self.eval(x, check_restrictions=check_restrictions)
+    
+    def get_results(self):
+        return self.results
+    
+    def get_num_unique_results(self):
+        return len(self.unique_results)
 
     def get_start_pos(self):
         """Get starting position for optimization."""

kernel_tuner/strategies/diff_evo.py

@@ -115,7 +115,7 @@ def generate_population(tune_params, max_idx, popsize, searchspace, constraint_a
     return population
 
 
-def differential_evolution(searchspace, cost_func, bounds, popsize, maxiter, F, CR, method, constraint_aware, verbose):
+def differential_evolution(searchspace, cost_func: CostFunc, bounds, popsize, maxiter, F, CR, method, constraint_aware, verbose):
     """
     A basic implementation of the Differential Evolution algorithm.
 
@@ -244,7 +244,7 @@ def differential_evolution(searchspace, cost_func, bounds, popsize, maxiter, F,
             print(f"Generation {generation + 1}, Best Cost: {best_cost:.6f}")
 
     if verbose:
-        print(f"Differential Evolution completed fevals={len(cost_func.tuning_options.unique_results)}")
+        print(f"Differential Evolution completed fevals={cost_func.get_num_unique_results()}")
 
     return {"solution": best_solution, "cost": best_cost}
 

kernel_tuner/strategies/greedy_ils.py

@@ -37,7 +37,6 @@ def tune(searchspace: Searchspace, runner, tuning_options):
 
     last_improvement = 0
     while fevals < max_fevals:
-
         try:
             candidate = base_hillclimb(candidate, neighbor, max_fevals, searchspace, tuning_options, cost_func, restart=restart, randomize=True)
             new_score = cost_func(candidate, check_restrictions=False)
@@ -46,7 +45,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
                 print(e)
             return cost_func.results
 
-        fevals = len(tuning_options.unique_results)
+        fevals = cost_func.get_num_unique_results()
         if new_score < best_score:
             last_improvement = 0
         else:

kernel_tuner/strategies/greedy_mls.py

@@ -36,8 +36,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
             return cost_func.results
 
         candidate = searchspace.get_random_sample(1)[0]
-
-        fevals = len(tuning_options.unique_results)
+        fevals = cost_func.get_num_unique_results()
 
     return cost_func.results
 

kernel_tuner/strategies/pyatf_strategies.py

@@ -85,7 +85,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
 
     try:
         # optimization loop (KT-compatible re-implementation of `make_step` from TuningRun)
-        while len(tuning_options.unique_results) < searchspace.size:
+        while cost_func.get_num_unique_results() < searchspace.size:
 
             # get new coordinates
             if not coordinates_or_indices:

kernel_tuner/strategies/simulated_annealing.py

@@ -68,7 +68,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
                 pos = new_pos
                 old_cost = new_cost
 
-        c = len(tuning_options.unique_results)
+        c = cost_func.get_num_unique_results()
         T = T_start * alpha**(max_iter/max_fevals*c)
 
         # check if solver gets stuck and if so restart from random position