Fix selecting a unique value from gene space

Author: Ahmed Gad

.DS_Store

@@ -1,39 +1,41 @@
 import pygad
 import numpy
+import random
 
-function_inputs = [4,-2,3.5,5,-11,-4.7]
-desired_output = 44
+def fitness_func(ga, solution, idx):
+    return random.random()
 
-def fitness_func(ga_instance, solution, solution_idx):
-    output = numpy.sum(solution*function_inputs)
-    fitness = 1.0 / (numpy.abs(output - desired_output) + 0.000001)
-    return fitness
-
-num_genes = len(function_inputs)
-
-ga_instance = pygad.GA(num_generations=100,
-                       num_parents_mating=10,
-                       sol_per_pop=20,
-                       num_genes=num_genes,
-                       mutation_num_genes=6,
-                       fitness_func=fitness_func,
-                       init_range_low=1,
-                       init_range_high=100,
-                       # suppress_warnings=True,
+ga_instance = pygad.GA(num_generations=1,
+                       num_parents_mating=5,
+                       sol_per_pop=10,
+                       num_genes=10,
+                       random_seed=123,
+                       # mutation_type=None,
+                       # crossover_type=None,
                        random_mutation_min_val=1,
                        random_mutation_max_val=100,
-                       mutation_by_replacement=True,
-                       gene_type=[float, 1],
-                       save_solutions=True,
+                       fitness_func=fitness_func,
+                       gene_space=[30, None, 40, 50, None, 60, 70, None, None, None],
+                       gene_type=int,
                        allow_duplicate_genes=False,
-                       # gene_space=numpy.unique(numpy.random.uniform(1, 100, size=100)),
-                       gene_space=[range(0, 100), {"low": 0, "high": 100, 'step': 1}, 2.5891221, [1,2,3,4], None, numpy.unique(numpy.random.uniform(1, 100, size=4))],
-                       gene_constraint=[lambda x: x[0]>=70,lambda x: x[1]>=70,lambda x: x[2]<98,lambda x: x[3]<98,lambda x: x[4]<98,lambda x: x[5]<98],
-                       )
+                       save_solutions=True)
 
 print(ga_instance.initial_population)
 
 ga_instance.run()
 
 # print(ga_instance.gene_space_unpacked)
 # print(ga_instance.population)
+
+"""
+gene_space=[[0, 0],
+            [1, 2],
+            [2, 3],
+            [3, 4],
+            [4, 5],
+            [5, 6],
+            [6, 7],
+            [7, 8],
+            [8, 9],
+            [9, 10]],
+"""

example2.py

@@ -216,13 +216,15 @@ def get_initial_population_range(self, gene_index):
     def generate_gene_value_from_space(self,
                                        gene_idx,
                                        mutation_by_replacement,
+                                       solution=None,
                                        gene_value=None,
                                        sample_size=1):
         """
         Generate/select one or more values for the gene from the gene space.
         It accepts:
             -gene_idx: The index of the gene in the solution.
             -mutation_by_replacement: A flag indicating whether mutation by replacement is enabled or not. The reason is to make this helper method usable while generating the initial population. In this case, mutation_by_replacement does not matter and should be considered False.
+            -solution (iterable, optional): The solution where we need to generate a gene. Needed if you are selecting a single value (sample_size=1) to select a value that respects the allow_duplicate_genes parameter instead of selecting a value randomly. If None, then the gene value is selected randomly.
             -gene_value (int, optional): The original gene value before applying mutation. Needed if you are calling this method to apply mutation. If None, then a sample is created from the gene space without being summed to the gene value.
             -sample_size (int, optional): The number of random values to generate. It tries to generate a number of values up to a maximum of sample_size. But it is not always guaranteed because the total number of values might not be enough or the random generator creates duplicate random values. For int data types, it could be None to keep all the values. For float data types, a None value returns only a single value.
 
@@ -314,10 +316,13 @@ def generate_gene_value_from_space(self,
                                                             high=self.gene_space['high'],
                                                             size=sample_size)
             else:
-                # Change the data type and round the generated values.
-                # Pass a copy of the gene_space to avoid changing its value.
+                curr_gene_space = list(self.gene_space).copy()
+                for idx in range(len(curr_gene_space)):
+                    if curr_gene_space[idx] is None:
+                        curr_gene_space[idx] = numpy.random.uniform(low=range_min,
+                                                                    high=range_max)
                 curr_gene_space = self.change_gene_dtype_and_round(gene_index=gene_idx,
-                                                                   gene_value=self.gene_space)
+                                                                   gene_value=curr_gene_space)
 
                 if gene_value is None:
                     # Just generate the value(s) without being added to the gene value specially when initializing the population.
@@ -334,8 +339,19 @@ def generate_gene_value_from_space(self,
                 # After removing the current gene value from the space, there are no more values.
                 # Then keep the current gene value.
                 value_from_space = gene_value
+                if sample_size > 1:
+                    value_from_space = numpy.array([gene_value])
         elif sample_size == 1:
-            value_from_space = random.choice(value_from_space)
+            if self.allow_duplicate_genes == True:
+                # Select a value randomly from the current gene space.
+                value_from_space = random.choice(value_from_space)
+            else:
+                # We must check if the selected value will respect the allow_duplicate_genes parameter.
+                # Instead of selecting a value randomly, we have to select a value that will be unique if allow_duplicate_genes=False.
+                # Only select a value from the current gene space that is, hopefully, unique.
+                value_from_space = self.select_unique_value(gene_values=value_from_space,
+                                                            solution=solution,
+                                                            gene_index=gene_idx)
 
             # The gene space might be [None, 1, 7].
             # It might happen that the value None is selected.
@@ -425,6 +441,7 @@ def generate_gene_value(self,
                             gene_value,
                             gene_idx,
                             mutation_by_replacement,
+                            solution=None,
                             range_min=None,
                             range_max=None,
                             sample_size=1,
@@ -435,6 +452,7 @@ def generate_gene_value(self,
             -gene_value: The original gene value before applying mutation.
             -gene_idx: The index of the gene in the solution.
             -mutation_by_replacement: A flag indicating whether mutation by replacement is enabled or not. The reason is to make this helper method usable while generating the initial population. In this case, mutation_by_replacement does not matter and should be considered False.
+            -solution (iterable, optional): The solution where we need to generate a gene. Needed if you are selecting a single value (sample_size=1) to select a value that respects the allow_duplicate_genes parameter instead of selecting a value randomly. If None, then the gene value is selected randomly.
             -range_min (int, optional): The minimum value in the range from which a value is selected. It must be passed for generating the gene value randomly because we cannot decide whether it is the range for the initial population (init_range_low and init_range_high) or mutation (random_mutation_min_val and random_mutation_max_val).
             -range_max (int, optional): The maximum value in the range from which a value is selected. It must be passed for generating the gene value randomly because we cannot decide whether it is the range for the initial population (init_range_low and init_range_high) or mutation (random_mutation_min_val and random_mutation_max_val).
             -sample_size: The number of random values to generate/select and return. It tries to generate a number of values up to a maximum of sample_size. But it is not always guaranteed because the total number of values might not be enough or the random generator creates duplicate random values. For int data types, it could be None to keep all the values. For float data types, a None value returns only a single value.
@@ -456,6 +474,7 @@ def generate_gene_value(self,
             output = self.generate_gene_value_from_space(gene_value=gene_value,
                                                          gene_idx=gene_idx,
                                                          mutation_by_replacement=mutation_by_replacement,
+                                                         solution=solution,
                                                          sample_size=sample_size)
         return output
 

pygad/__pycache__/__init__.cpython-310.pyc

@@ -120,7 +120,7 @@ def solve_duplicate_genes_by_space(self,
                                                                                                    build_initial_pop=build_initial_pop)
         else:
             return new_solution, not_unique_indices, len(not_unique_indices)
-    
+
         # DEEP-DUPLICATE-REMOVAL-NEEDED
         # Search by this phrase to find where deep duplicates removal should be applied.
         # If there exist duplicate genes, then changing either of the 2 duplicating genes (with indices 2 and 3) will not solve the problem.
@@ -179,6 +179,7 @@ def unique_int_gene_from_range(self,
                                                      range_max=max_val,
                                                      gene_value=solution[gene_index],
                                                      gene_idx=gene_index,
+                                                     solution=solution,
                                                      mutation_by_replacement=mutation_by_replacement,
                                                      sample_size=None,
                                                      step=step)
@@ -237,6 +238,7 @@ def unique_float_gene_from_range(self,
                                               range_max=max_val,
                                               gene_value=solution[gene_index],
                                               gene_idx=gene_index,
+                                              solution=solution,
                                               mutation_by_replacement=mutation_by_replacement,
                                               sample_size=sample_size)
 
@@ -253,17 +255,15 @@ def select_unique_value(self, gene_values, solution, gene_index):
         Args:
             gene_values (NumPy Array): An array of values from which a unique value should be selected.
             solution (list): A solution containing genes, potentially with duplicate values.
+            gene_index (int): The index of the gene for which to find a unique value.
 
         Returns:
             selected_gene: The new (hopefully unique) value of the gene. If no unique value can be found, the original gene value is returned.
         """
 
         values_to_select_from = list(set(list(gene_values)) - set(solution))
-    
+
         if len(values_to_select_from) == 0:
-            print("@@@@@@@@")
-            print(solution)
-            print(gene_values)
             # If there are no values, then keep the current gene value.
             if not self.suppress_warnings: warnings.warn(f"'allow_duplicate_genes=False' but cannot find a unique value for the gene at index {gene_index} with value {solution[gene_index]}.")
             selected_value = solution[gene_index]
@@ -367,6 +367,7 @@ def unique_gene_by_space(self,
                                               range_max=None,
                                               gene_value=gene_value,
                                               gene_idx=gene_idx,
+                                              solution=solution,
                                               mutation_by_replacement=mutation_by_replacement,
                                               sample_size=sample_size)
 
@@ -438,6 +439,10 @@ def unpack_gene_space(self,
 
             if self.gene_type_single == True:
                 # Change the data type.
+                for idx in range(len(gene_space_unpacked)):
+                    if gene_space_unpacked[idx] is None:
+                        gene_space_unpacked[idx] = numpy.random.uniform(low=range_min,
+                                                                        high=range_max)
                 gene_space_unpacked = numpy.array(gene_space_unpacked,
                                                   dtype=self.gene_type[0])
                 if not self.gene_type[1] is None: