Implemented getting a random neighbor over the full list where applicable, other improvements

Author: fjwillemsen

kernel_tuner/searchspace.py

@@ -1044,7 +1044,7 @@ def get_random_neighbor(self, param_config: tuple, neighbor_method=None) -> tupl
         """Get an approximately random neighbor for a parameter configuration. Much faster than taking a random choice of all neighbors, but does not build cache."""
         if self.are_neighbors_indices_cached(param_config, neighbor_method):
             neighbors = self.get_neighbors(param_config, neighbor_method)
-            return choice(neighbors)
+            return choice(neighbors) if len(neighbors) > 0 else None
         else:
             # check if there is a neighbor method to use
             if neighbor_method is None:

kernel_tuner/strategies/diff_evo.py

@@ -389,13 +389,10 @@ def repair(trial_vector, searchspace):
         # search for valid configurations neighboring trial_vector
         # start from strictly-adjacent to increasingly allowing more neighbors
         for neighbor_method in ["strictly-adjacent", "adjacent", "Hamming"]:
-            neighbors = searchspace.get_neighbors_no_cache(tuple(trial_vector), neighbor_method=neighbor_method)
-
-            # if we have found valid neighboring configurations, select one at random
-            if len(neighbors) > 0:
-                new_trial_vector = list(random.choice(neighbors))
+            new_trial_vector = searchspace.get_random_neighbor(tuple(trial_vector), neighbor_method=neighbor_method)
+            if new_trial_vector is not None:
                 print(f"Differential evolution resulted in invalid config {trial_vector=}, repaired to {new_trial_vector=}")
-                return new_trial_vector
+                return list(new_trial_vector)
 
     return trial_vector
 

kernel_tuner/strategies/genetic_algorithm.py

@@ -155,17 +155,14 @@ def random_index_weighted(pop_size):
         return [population[ind][0] for ind in chosen]
 
 
-    def mutate(self, dna, cache=False):
+    def mutate(self, dna):
         """Mutate DNA with 1/mutation_chance chance."""
         # this is actually a neighbors problem with Hamming distance, choose randomly from returned searchspace list
         if int(random.random() * self.mutation_chance) == 0:
             if self.constraint_aware:
-                if cache:
-                    neighbors = self.searchspace.get_neighbors(tuple(dna), neighbor_method="Hamming")
-                else:
-                    neighbors = self.searchspace.get_neighbors_no_cache(tuple(dna), neighbor_method="Hamming")
-                if len(neighbors) > 0:
-                    return list(random.choice(neighbors))
+                neighbor = self.searchspace.get_random_neighbor(tuple(dna), neighbor_method="Hamming")
+                if neighbor is not None:
+                    return list(neighbor)
             else:
                 # select a tunable parameter at random
                 mutate_index = random.randint(0, len(self.tune_params)-1)
@@ -187,13 +184,11 @@ def repair(self, dna):
             # search for valid configurations neighboring this config
             # start from strictly-adjacent to increasingly allowing more neighbors
             for neighbor_method in ["strictly-adjacent", "adjacent", "Hamming"]:
-                neighbors = self.searchspace.get_neighbors(tuple(dna), neighbor_method=neighbor_method)
-
+                neighbor = self.searchspace.get_random_neighbor(tuple(dna), neighbor_method=neighbor_method)
                 # if we have found valid neighboring configurations, select one at random
-                if len(neighbors) > 0:
-                    new_dna = list(random.choice(neighbors))
-                    # print(f"GA crossover resulted in invalid config {dna=}, repaired dna to {new_dna=}")
-                    return new_dna
+                if neighbor is not None:
+                    # print(f"GA crossover resulted in invalid config {dna=}, repaired dna to {neighbor=}")
+                    return list(neighbor)
 
         return dna
 

kernel_tuner/strategies/greedy_ils.py

@@ -60,8 +60,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
 tune.__doc__ = common.get_strategy_docstring("Greedy Iterative Local Search (ILS)", _options)
 
 def mutate(indiv, searchspace: Searchspace):
-    neighbors = searchspace.get_neighbors(tuple(indiv), neighbor_method="Hamming")
-    return list(random_choice(neighbors))
+    return list(searchspace.get_random_neighbor(tuple(indiv), neighbor_method="Hamming"))
 
 
 def random_walk(indiv, permutation_size, no_improve, last_improve, searchspace: Searchspace):