madprog
diff --git a/‎pygad/pygad.py
Lines changed: 10 additions & 5 deletions b/‎pygad/pygad.py
Lines changed: 10 additions & 5 deletions
diff --git a/‎pygad/utils/mutation.py
Lines changed: 100 additions & 31 deletions b/‎pygad/utils/mutation.py
Lines changed: 100 additions & 31 deletions
@@ -114,7 +114,7 @@ def __init__(self,
         on_generation: Accepts a function/method to be called after each generation. If function, then it must accept a single parameter representing the instance of the genetic algorithm. If the function returned "stop", then the run() method stops without completing the other generations. If method, then it must accept 2 parameters where the second one refers to the method's object. Added in PyGAD 2.6.0.
         on_stop: Accepts a function/method to be called only once exactly before the genetic algorithm stops or when it completes all the generations. If function, then it must accept 2 parameters: the first one represents the instance of the genetic algorithm and the second one is a list of fitness values of the last population's solutions. If method, then it must accept 3 parameters where the third one refers to the method's object. Added in PyGAD 2.6.0. 
 
-        delay_after_gen: Added in PyGAD 2.4.0. It accepts a non-negative number specifying the number of seconds to wait after a generation completes and before going to the next generation. It defaults to 0.0 which means no delay after the generation.
+        delay_after_gen: Added in PyGAD 2.4.0 and deprecated in PyGAD 3.3.0. It accepts a non-negative number specifying the number of seconds to wait after a generation completes and before going to the next generation. It defaults to 0.0 which means no delay after the generation.
 
         save_best_solutions: Added in PyGAD 2.9.0 and its type is bool. If True, then the best solution in each generation is saved into the 'best_solutions' attribute. Use this parameter with caution as it may cause memory overflow when either the number of generations or the number of genes is large.
         save_solutions: Added in PyGAD 2.15.0 and its type is bool. If True, then all solutions in each generation are saved into the 'solutions' attribute. Use this parameter with caution as it may cause memory overflow when either the number of generations, number of genes, or number of solutions in population is large.
@@ -1135,6 +1135,8 @@ def __init__(self,
 
             # Validate delay_after_gen
             if type(delay_after_gen) in GA.supported_int_float_types:
+                if not self.suppress_warnings:
+                    warnings.warn("The 'delay_after_gen' parameter is deprecated starting from PyGAD 3.3.0. To delay or pause the evolution after each generation, assign a callback function/method to the 'on_generation' parameter to adds some time delay.")
                 if delay_after_gen >= 0.0:
                     self.delay_after_gen = delay_after_gen
                 else:
@@ -1803,9 +1805,13 @@ def cal_pop_fitness(self):
                     solutions_to_submit = []
                     for sol_idx, sol in enumerate(self.population):
                         # The "undefined" value means that the fitness of this solution must be calculated.
-                        if pop_fitness[sol_idx] == "undefined":
-                            solutions_to_submit.append(sol.copy())
-                            solutions_to_submit_indices.append(sol_idx)
+                        if type(pop_fitness[sol_idx]) is str:
+                            if pop_fitness[sol_idx] == "undefined":
+                                solutions_to_submit.append(sol.copy())
+                                solutions_to_submit_indices.append(sol_idx)
+                        elif type(pop_fitness[sol_idx]) in [list, tuple, numpy.ndarray]:
+                            # This is a multi-objective problem. The fitness is already calculated. Nothing to do.
+                            pass
 
                     # Check if batch processing is used. If not, then calculate the fitness value for individual solutions.
                     if self.fitness_batch_size in [1, None]:
@@ -1843,7 +1849,6 @@ def cal_pop_fitness(self):
                             if type(batch_fitness) not in [list, tuple, numpy.ndarray]:
                                 raise TypeError(f"Expected to receive a list, tuple, or numpy.ndarray from the fitness function but the value ({batch_fitness}) of type {type(batch_fitness)}.")
                             elif len(numpy.array(batch_fitness)) != len(batch_indices):
-                                
                                 raise ValueError(f"There is a mismatch between the number of solutions passed to the fitness function ({len(batch_indices)}) and the number of fitness values returned ({len(batch_fitness)}). They must match.")
 
                             for index, fitness in zip(batch_indices, batch_fitness):
 
@@ -6,6 +6,7 @@
 import random
 
 import pygad
+import concurrent.futures
 
 class Mutation:
 
@@ -483,40 +484,108 @@ def adaptive_mutation_population_fitness(self, offspring):
             # This is a single-objective optimization problem.
             fitness[first_idx:last_idx] = [0]*(last_idx - first_idx)
 
-        if self.fitness_batch_size in [1, None]:
-            # Calculate the fitness for each individual solution.
-            for idx in range(first_idx, last_idx):
-                # We cannot return the index of the solution within the population.
-                # Because the new solution (offspring) does not yet exist in the population.
-                # The user should handle this situation if the solution index is used anywhere.
-                fitness[idx] = self.fitness_func(self, 
-                                                 temp_population[idx], 
-                                                 None)
+        # # No parallel processing.
+        if self.parallel_processing is None:
+            if self.fitness_batch_size in [1, None]:
+                # Calculate the fitness for each individual solution.
+                for idx in range(first_idx, last_idx):
+                    # We cannot return the index of the solution within the population.
+                    # Because the new solution (offspring) does not yet exist in the population.
+                    fitness[idx] = self.fitness_func(self, 
+                                                      temp_population[idx], 
+                                                      None)
+            else:
+                # Calculate the fitness for batch of solutions.
+    
+                # Number of batches.
+                num_batches = int(numpy.ceil((last_idx - first_idx) / self.fitness_batch_size))
+    
+                for batch_idx in range(num_batches):
+                    # The index of the first solution in the current batch.
+                    batch_first_index = first_idx + batch_idx * self.fitness_batch_size
+                    # The index of the last solution in the current batch.
+                    if batch_idx == (num_batches - 1):
+                        batch_last_index = last_idx
+                    else:
+                        batch_last_index = first_idx + (batch_idx + 1) * self.fitness_batch_size
+    
+                    # Calculate the fitness values for the batch.
+                    # We cannot return the index/indices of the solution(s) within the population.
+                    # Because the new solution(s) (offspring) do(es) not yet exist in the population.
+                    # The user should handle this situation if the solution index is used anywhere.
+                    fitness_temp = self.fitness_func(self, 
+                                                     temp_population[batch_first_index:batch_last_index], 
+                                                     None) 
+                    # Insert the fitness of each solution at the proper index.
+                    for idx in range(batch_first_index, batch_last_index):
+                        fitness[idx] = fitness_temp[idx - batch_first_index]
+
         else:
-            # Calculate the fitness for batch of solutions.
+            # Parallel processing
+            # Decide which class to use based on whether the user selected "process" or "thread"
+            # TODO Add ExecutorClass as an instance attribute in the pygad.GA instances. Then retrieve this instance here instead of creating a new one.
+            if self.parallel_processing[0] == "process":
+                ExecutorClass = concurrent.futures.ProcessPoolExecutor
+            else:
+                ExecutorClass = concurrent.futures.ThreadPoolExecutor
+    
+            # We can use a with statement to ensure threads are cleaned up promptly (https://docs.python.org/3/library/concurrent.futures.html#threadpoolexecutor-example)
+            with ExecutorClass(max_workers=self.parallel_processing[1]) as executor:
+                # Indices of the solutions to calculate its fitness.
+                solutions_to_submit_indices = list(range(first_idx, last_idx))
+                # The solutions to calculate its fitness.
+                solutions_to_submit = [temp_population[sol_idx].copy() for sol_idx in solutions_to_submit_indices]
+                if self.fitness_batch_size in [1, None]:
+                    # Use parallel processing to calculate the fitness of the solutions.
+                    for index, sol_fitness in zip(solutions_to_submit_indices, executor.map(self.fitness_func, [self]*len(solutions_to_submit_indices), solutions_to_submit, solutions_to_submit_indices)):
+                        if type(sol_fitness) in self.supported_int_float_types:
+                            # The fitness function returns a single numeric value.
+                            # This is a single-objective optimization problem.
+                            fitness[index] = sol_fitness
+                        elif type(sol_fitness) in [list, tuple, numpy.ndarray]:
+                            # The fitness function returns a list/tuple/numpy.ndarray.
+                            # This is a multi-objective optimization problem.
+                            fitness[index] = sol_fitness
+                        else:
+                            raise ValueError(f"The fitness function should return a number or an iterable (list, tuple, or numpy.ndarray) but the value {sol_fitness} of type {type(sol_fitness)} found.")
+                else:
+                    # Reaching this point means that batch processing is in effect to calculate the fitness values.
+                    # Number of batches.
+                    num_batches = int(numpy.ceil(len(solutions_to_submit_indices) / self.fitness_batch_size))
+                    # Each element of the `batches_solutions` list represents the solutions in one batch.
+                    batches_solutions = []
+                    # Each element of the `batches_indices` list represents the solutions' indices in one batch.
+                    batches_indices = []
+                    # For each batch, get its indices and call the fitness function.
                     for batch_idx in range(num_batches):
+                        batch_first_index = batch_idx * self.fitness_batch_size
+                        batch_last_index = (batch_idx + 1) * self.fitness_batch_size
+                        batch_indices = solutions_to_submit_indices[batch_first_index:batch_last_index]
+                        batch_solutions = self.population[batch_indices, :]
+    
+                        batches_solutions.append(batch_solutions)
+                        batches_indices.append(batch_indices)
+
+                    for batch_indices, batch_fitness in zip(batches_indices, executor.map(self.fitness_func, [self]*len(solutions_to_submit_indices), batches_solutions, batches_indices)):
+                        if type(batch_fitness) not in [list, tuple, numpy.ndarray]:
+                            raise TypeError(f"Expected to receive a list, tuple, or numpy.ndarray from the fitness function but the value ({batch_fitness}) of type {type(batch_fitness)}.")
+                        elif len(numpy.array(batch_fitness)) != len(batch_indices):
+                            raise ValueError(f"There is a mismatch between the number of solutions passed to the fitness function ({len(batch_indices)}) and the number of fitness values returned ({len(batch_fitness)}). They must match.")
+
+                        for index, sol_fitness in zip(batch_indices, batch_fitness):
+                            if type(sol_fitness) in self.supported_int_float_types:
+                                # The fitness function returns a single numeric value.
+                                # This is a single-objective optimization problem.
+                                fitness[index] = sol_fitness
+                            elif type(sol_fitness) in [list, tuple, numpy.ndarray]:
+                                # The fitness function returns a list/tuple/numpy.ndarray.
+                                # This is a multi-objective optimization problem.
+                                fitness[index] = sol_fitness
+                            else:
+                                raise ValueError(f"The fitness function should return a number or an iterable (list, tuple, or numpy.ndarray) but the value ({sol_fitness}) of type {type(sol_fitness)} found.")
 
-            # Number of batches.
-            num_batches = int(numpy.ceil((last_idx - first_idx) / self.fitness_batch_size))
 
-            for batch_idx in range(num_batches):
-                # The index of the first solution in the current batch.
-                batch_first_index = first_idx + batch_idx * self.fitness_batch_size
-                # The index of the last solution in the current batch.
-                if batch_idx == (num_batches - 1):
-                    batch_last_index = last_idx
-                else:
-                    batch_last_index = first_idx + (batch_idx + 1) * self.fitness_batch_size
-
-                # Calculate the fitness values for the batch.
-                # We cannot return the index/indices of the solution(s) within the population.
-                # Because the new solution(s) (offspring) do(es) not yet exist in the population.
-                # The user should handle this situation if the solution index is used anywhere.
-                fitness_temp = self.fitness_func(self, 
-                                                 temp_population[batch_first_index:batch_last_index], 
-                                                 None) 
-                # Insert the fitness of each solution at the proper index.
-                for idx in range(batch_first_index, batch_last_index):
-                    fitness[idx] = fitness_temp[idx - batch_first_index]
 
         if len(fitness.shape) > 1:
             # TODO This is a multi-objective optimization problem.