removed all memetic algo related stuff

Author: MiloLurati

Diff for: kernel_tuner/interface.py

@@ -58,8 +58,7 @@
     pso,
     random_sample,
     simulated_annealing,
-    ensemble,
-    memetic
+    ensemble
 )
 
 strategy_map = {
@@ -79,7 +78,6 @@
     "firefly_algorithm": firefly_algorithm,
     "bayes_opt": bayes_opt,
     "ensemble": ensemble,
-    "memetic": memetic,
 }
 
 

Diff for: kernel_tuner/runners/parallel.py

@@ -51,11 +51,7 @@ def run(self, parameter_space=None, tuning_options=None, ensemble=None, searchsp
         if self.actors is None:
             runner_attributes = [self.kernel_source, self.kernel_options, self.device_options, self.iterations, self.observers]
             self.actors = [create_actor_on_device(*runner_attributes, id=_id, cache_manager=self.cache_manager, simulation_mode=self.simulation_mode) for _id in range(self.num_gpus)]
-            # actors_ready_futures = [actor.__ray_ready__.remote() for actor in futures]
-            # ray.wait(actors_ready_futures, num_returns=len(actors_ready_futures), timeout=None)
-            # self.actors = futures
-
-
+            
         # Check if all GPUs are of the same type
         if not self.simulation_mode and not self._check_gpus_equals():
             raise GPUTypeMismatchError(f"Different GPU types found") 
@@ -137,43 +133,28 @@ def multi_strategy_parallel_execution(self, ensemble, tuning_options, searchspac
                     task = actor.execute.remote(strategy=strategy, searchspace=searchspace, tuning_options=remote_tuning_options)
                     pending_tasks[task] = actor
 
-        # Process results to extract population and candidates for further use
-        results, tuning_options_list, population, candidates = self._process_results_ensemble(all_results)
-
-        # Update tuning options for memetic strategies
-        if population:
-            tuning_options.strategy_options["population"] = population
-        if candidates:
-            tuning_options.strategy_options["candidates"] = candidates
+        # Process results
+        results, tuning_options_list = self._process_results_ensemble(all_results)
 
         return results, tuning_options_list
 
 
     def _setup_tuning_options(self, tuning_options, evaluations_per_strategy):
         new_tuning_options = copy.deepcopy(tuning_options)
-        if "candidates" in tuning_options.strategy_options:
-            if len(tuning_options.strategy_options["candidates"]) > 0:
-                new_tuning_options.strategy_options["candidate"] = tuning_options.strategy_options["candidates"].pop(0)
         new_tuning_options.strategy_options["max_fevals"] = evaluations_per_strategy.pop(0)
         # the stop criterion uses the max feval in tuning options for some reason
         new_tuning_options["max_fevals"] = new_tuning_options.strategy_options["max_fevals"]
         return new_tuning_options
 
     def _process_results_ensemble(self, all_results):
-        population = [] # for memetic strategy
-        candidates = [] # for memetic strategy
         results = []
         tuning_options_list = []
 
         for (strategy_results, tuning_options) in all_results:
-            if "old_candidate" in tuning_options.strategy_options:
-                candidates.append(tuning_options.strategy_options["old_candidate"])
-            if "candidate" in tuning_options.strategy_options:
-                population.append(tuning_options.strategy_options["candidate"])
             results.extend(strategy_results)
             tuning_options_list.append(tuning_options)
 
-        return results, tuning_options_list, population, candidates
+        return results, tuning_options_list
 
 
     def parallel_function_evaluation(self, tuning_options, parameter_space):
@@ -201,7 +182,6 @@ def _calculate_simulated_time(self, tuning_options_list):
         simulated_times = []
         for tuning_options in tuning_options_list:
             simulated_times.append(tuning_options.simulated_time)
-        #simulated_times = [tuning_options.simulated_time for tuning_options in tuning_options_list]
         return max(simulated_times)
 
     def _check_gpus_equals(self):

Diff for: kernel_tuner/strategies/common.py

@@ -52,8 +52,7 @@ def make_strategy_options_doc(strategy_options):
 
 def get_options(strategy_options, options):
     """Get the strategy-specific options or their defaults from user-supplied strategy_options."""
-    accepted = list(options.keys()) + ["max_fevals", "time_limit", "ensemble", "candidates", "candidate", "population", 
-                                       "maxiter", "lsd", "popsize", "alsd", "split_searchspace", "check_and_retrieve"]
+    accepted = list(options.keys()) + ["max_fevals", "time_limit", "ensemble", "check_and_retrieve"]
     for key in strategy_options:
         if key not in accepted:
             raise ValueError(f"Unrecognized option {key} in strategy_options")

Diff for: kernel_tuner/strategies/genetic_algorithm.py

@@ -7,42 +7,39 @@
 from kernel_tuner.searchspace import Searchspace
 from kernel_tuner.strategies import common
 from kernel_tuner.strategies.common import CostFunc
-from kernel_tuner.runners.parallel import ParallelRunner
 
 _options = dict(
     popsize=("population size", 20),
     maxiter=("maximum number of generations", 100),
     method=("crossover method to use, choose any from single_point, two_point, uniform, disruptive_uniform", "uniform"),
     mutation_chance=("chance to mutate is 1 in mutation_chance", 10),
-    population=("initial population", None),
 )
 
 
 def tune(searchspace: Searchspace, runner, tuning_options):
 
     options = tuning_options.strategy_options
-    pop_size, generations, method, mutation_chance, population = common.get_options(options, _options)
+    pop_size, generations, method, mutation_chance = common.get_options(options, _options)
     crossover = supported_methods[method]
 
     best_score = 1e20
     cost_func = CostFunc(searchspace, tuning_options, runner)
 
-    if not population:
-        population = list(list(p) for p in searchspace.get_random_sample(pop_size))
-    else:
-        pop_size = len(population)
-    
-    old_population = population
+    population = list(list(p) for p in searchspace.get_random_sample(pop_size))
+
     for generation in range(generations):
 
-        # Evaluate the entire population
-        try:
-            old_population = population
-            weighted_population = evaluate_population(runner, cost_func, population)
-        except util.StopCriterionReached as e:
-            if tuning_options.verbose:
-                print(e)
-            return cost_func.results
+        # determine fitness of population members
+        weighted_population = []
+        for dna in population:
+            try:
+                time = cost_func(dna, check_restrictions=False)
+            except util.StopCriterionReached as e:
+                if tuning_options.verbose:
+                    print(e)
+                return cost_func.results
+
+            weighted_population.append((dna, time))
 
         # population is sorted such that better configs have higher chance of reproducing
         weighted_population.sort(key=lambda x: x[1])
@@ -72,8 +69,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
                     break
 
         # could combine old + new generation here and do a selection
-    tuning_options.strategy_options["population"] = old_population # for memetic strategy
-    tuning_options.strategy_options["candidates"] = population # for memetic strategy
+
     return cost_func.results
 
 
@@ -180,28 +176,4 @@ def disruptive_uniform_crossover(dna1, dna2):
     "two_point": two_point_crossover,
     "uniform": uniform_crossover,
     "disruptive_uniform": disruptive_uniform_crossover,
-}
-
-def evaluate_population(runner, cost_func, population):
-    """
-    Evaluate the population based on the type of runner.
-
-    Parameters:
-    - runner: The runner (ParallelRunner or SequentialRunner) determining how to process evaluations.
-    - cost_func: A function capable of evaluating the population.
-    - population: List of individuals to be evaluated.
-
-    Returns:
-    - List of tuples (dna, fitness_score) representing the population and their evaluation results.
-    """
-    if isinstance(runner, ParallelRunner):
-        # Process the whole population at once if using a ParallelRunner
-        results = cost_func(population, check_restrictions=False)
-        return list(zip(population, results))
-    else:
-        # Process each individual sequentially for SequentialRunner
-        weighted_population = []
-        for dna in population:
-            time = cost_func(dna, check_restrictions=False)  # Cost function called with a single-element list
-            weighted_population.append((dna, time))
-        return weighted_population
+}

Diff for: kernel_tuner/strategies/greedy_ils.py

@@ -9,16 +9,15 @@
 _options = dict(neighbor=("Method for selecting neighboring nodes, choose from Hamming or adjacent", "Hamming"),
                        restart=("controls greedyness, i.e. whether to restart from a position as soon as an improvement is found", True),
                        no_improvement=("number of evaluations to exceed without improvement before restarting", 50),
-                       random_walk=("controls greedyness, i.e. whether to restart from a position as soon as an improvement is found", 0.3),
-                       candidate=("initial candidate for the search", None))
+                       random_walk=("controls greedyness, i.e. whether to restart from a position as soon as an improvement is found", 0.3))
 
 def tune(searchspace: Searchspace, runner, tuning_options):
 
     dna_size = len(searchspace.tune_params.keys())
 
     options = tuning_options.strategy_options
 
-    neighbor, restart, no_improvement, randomwalk, candidate = common.get_options(options, _options)
+    neighbor, restart, no_improvement, randomwalk = common.get_options(options, _options)
 
     perm_size = int(randomwalk * dna_size)
     if perm_size == 0:
@@ -32,28 +31,16 @@ def tune(searchspace: Searchspace, runner, tuning_options):
     cost_func = CostFunc(searchspace, tuning_options, runner)
 
     #while searching
-    if not candidate:
-        candidate = searchspace.get_random_sample(1)[0]
-    old_candidate = candidate # for memetic strategy
-    try:
-        best_score = cost_func(candidate, check_restrictions=False)
-    except util.StopCriterionReached as e:
-        tuning_options.strategy_options["old_candidate"] = old_candidate # for memetic strategy
-        tuning_options.strategy_options["candidate"] = candidate # for memetic strategy
-        if tuning_options.verbose:
-            print(e)
-        return cost_func.results
+    candidate = searchspace.get_random_sample(1)[0]
+    best_score = cost_func(candidate, check_restrictions=False)
 
     last_improvement = 0
     while fevals < max_fevals:
 
         try:
-            old_candidate = candidate # for memetic strategy
             candidate = base_hillclimb(candidate, neighbor, max_fevals, searchspace, tuning_options, cost_func, restart=restart, randomize=True)
             new_score = cost_func(candidate, check_restrictions=False)
         except util.StopCriterionReached as e:
-            tuning_options.strategy_options["old_candidate"] = old_candidate # for memetic strategy
-            tuning_options.strategy_options["candidate"] = candidate # for memetic strategy
             if tuning_options.verbose:
                 print(e)
             return cost_func.results
@@ -66,8 +53,6 @@ def tune(searchspace: Searchspace, runner, tuning_options):
 
         # Instead of full restart, permute the starting candidate
         candidate = random_walk(candidate, perm_size, no_improvement, last_improvement, searchspace)
-    tuning_options.strategy_options["old_candidate"] = old_candidate # for memetic strategy
-    tuning_options.strategy_options["candidate"] = candidate # for memetic strategy
     return cost_func.results
 
 
@@ -78,4 +63,4 @@ def random_walk(indiv, permutation_size, no_improve, last_improve, searchspace:
         return searchspace.get_random_sample(1)[0]
     for _ in range(permutation_size):
         indiv = mutate(indiv, 0, searchspace, cache=False)
-    return indiv
+    return indiv