Batch fitness for adaptive mutation

Author: ahmedfgad

pygad/pygad.py

@@ -1531,8 +1531,7 @@ def cal_pop_fitness(self):
                     elif (self.keep_elitism > 0) and (self.last_generation_elitism is not None) and (len(self.last_generation_elitism) > 0) and (list(sol) in last_generation_elitism_as_list):
                         # Return the index of the elitism from the elitism array 'self.last_generation_elitism'.
                         # This is not its index within the population. It is just its index in the 'self.last_generation_elitism' array.
-                        elitism_idx = last_generation_elitism_as_list.index(
-                            list(sol))
+                        elitism_idx = last_generation_elitism_as_list.index(list(sol))
                         # Use the returned elitism index to return its index in the last population.
                         elitism_idx = self.last_generation_elitism_indices[elitism_idx]
                         # Use the elitism's index to return its pre-calculated fitness value.
@@ -1544,8 +1543,7 @@ def cal_pop_fitness(self):
                         # Index of the parent in the 'self.last_generation_parents' array.
                         # This is not its index within the population. It is just its index in the 'self.last_generation_parents' array.
                         # parent_idx = numpy.where(numpy.all(self.last_generation_parents == sol, axis=1))[0][0]
-                        parent_idx = last_generation_parents_as_list.index(
-                            list(sol))
+                        parent_idx = last_generation_parents_as_list.index(list(sol))
                         # Use the returned parent index to return its index in the last population.
                         parent_idx = self.last_generation_parents_indices[parent_idx]
                         # Use the parent's index to return its pre-calculated fitness value.
@@ -1573,13 +1571,11 @@ def cal_pop_fitness(self):
                     solutions_indices = numpy.where(
                         numpy.array(pop_fitness) == "undefined")[0]
                     # Number of batches.
-                    num_batches = int(numpy.ceil(
-                        len(solutions_indices) / self.fitness_batch_size))
+                    num_batches = int(numpy.ceil(len(solutions_indices) / self.fitness_batch_size))
                     # 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_last_index = (batch_idx + 1) * self.fitness_batch_size
                         batch_indices = solutions_indices[batch_first_index:batch_last_index]
                         batch_solutions = self.population[batch_indices, :]
 
@@ -1660,17 +1656,15 @@ def cal_pop_fitness(self):
                         # Reaching this block means that batch processing is used. The fitness values are calculated in batches.
 
                         # Number of batches.
-                        num_batches = int(numpy.ceil(
-                            len(solutions_to_submit_indices) / self.fitness_batch_size))
+                        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_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, :]
 

pygad/utils/mutation.py

@@ -438,8 +438,39 @@ def adaptive_mutation_population_fitness(self, offspring):
 
         fitness[:self.last_generation_parents.shape[0]] = self.last_generation_fitness[self.last_generation_parents_indices]
 
-        for idx in range(len(parents_to_keep), fitness.shape[0]):
-            fitness[idx] = self.fitness_func(self, temp_population[idx], None)
+        first_idx = len(parents_to_keep)
+        last_idx = fitness.shape[0]
+        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):
+                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.
+                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]
+
         average_fitness = numpy.mean(fitness)
 
         return average_fitness, fitness[len(parents_to_keep):]