Apply constraints in initial population

Author: ahmedfgad

example.py

@@ -17,6 +17,8 @@ def fitness_func(ga_instance, solution, solution_idx):
                        num_genes=num_genes,
                        mutation_num_genes=6,
                        fitness_func=fitness_func,
+                       init_range_low=4,
+                       init_range_high=10,
                        # suppress_warnings=True,
                        random_mutation_min_val=4,
                        random_mutation_max_val=10,
@@ -25,4 +27,4 @@ def fitness_func(ga_instance, solution, solution_idx):
                        # mutation_probability=0.4,
                        gene_constraint=[lambda x: x[0]>=8,None,None,None,None,None])
 
-ga_instance.run()
+# ga_instance.run()

pygad/__pycache__/pygad.cpython-310.pyc

@@ -1,3 +1,4 @@
 from pygad.helper import unique
+from pygad.helper import misc
 
-__version__ = "1.1.0"
+__version__ = "1.2.0"

pygad/helper/__init__.py

@@ -0,0 +1,122 @@
+"""
+The pygad.helper.helper module has some generic helper methods.
+"""
+
+import numpy
+import warnings
+import random
+import pygad
+
+class Helper:
+
+    def get_random_mutation_range(self, gene_index):
+
+        """
+        Returns the minimum and maximum values of the mutation range.
+        It accepts a single parameter:
+            -gene_index: The index of the gene to get its range. Only used if the gene has a specific mutation range
+        It returns the minimum and maximum values of the gene mutation range.
+        """
+
+        # We can use either random_mutation_min_val or random_mutation_max_val.
+        if type(self.random_mutation_min_val) in self.supported_int_float_types:
+            range_min = self.random_mutation_min_val
+            range_max = self.random_mutation_max_val
+        else:
+            range_min = self.random_mutation_min_val[gene_index]
+            range_max = self.random_mutation_max_val[gene_index]
+        return range_min, range_max
+
+    def get_initial_population_range(self, gene_index):
+
+        """
+        Returns the minimum and maximum values of the initial population range.
+        It accepts a single parameter:
+            -gene_index: The index of the gene to get its range. Only used if the gene has a specific range
+        It returns the minimum and maximum values of the gene initial population range.
+        """
+
+        # We can use either init_range_low or init_range_high.
+        if type(self.init_range_low) in self.supported_int_float_types:
+            range_min = self.init_range_low
+            range_max = self.init_range_high
+        else:
+            range_min = self.init_range_low[gene_index]
+            range_max = self.init_range_high[gene_index]
+        return range_min, range_max
+
+    def generate_gene_random_value(self,
+                                   range_min, 
+                                   range_max, 
+                                   gene_value,
+                                   gene_idx, 
+                                   mutation_by_replacement,
+                                   num_values=1):
+        """
+        Randomly generate one or more values for the gene.
+        It accepts:
+            -range_min: The minimum value in the range from which a value is selected.
+            -range_max: The maximum value in the range from which a value is selected.
+            -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.
+            -num_values: The number of random valus to generate. It tries to generate a number of values up to a maximum of num_values. But it is not always guranteed because the total number of values might not be enough or the random generator creates duplicate random values.
+        If num_values=1, it returns a single numeric value. If num_values>1, it returns an array with number of values equal to num_values.
+        """
+
+        # Generating a random value.
+        random_value = numpy.asarray(numpy.random.uniform(low=range_min, 
+                                                          high=range_max, 
+                                                          size=num_values),
+                                     dtype=object)
+
+        # Change the random mutation value data type.
+        for idx, val in enumerate(random_value):
+            random_value[idx] = self.change_random_mutation_value_dtype(random_value[idx], 
+                                                                        gene_idx, 
+                                                                        gene_value,
+                                                                        mutation_by_replacement=mutation_by_replacement)
+
+            # Round the gene.
+            random_value[idx] = self.round_random_mutation_value(random_value[idx], gene_idx)
+
+        # Rounding different values could return the same value multiple times.
+        # For example, 2.8 and 2.7 will be 3.0.
+        # Use the unique() function to avoid any duplicates.
+        random_value = numpy.unique(random_value)
+
+        if num_values == 1:
+            random_value = random_value[0]
+
+        return random_value
+
+    def get_valid_gene_constraint_values(self,
+                                         range_min,
+                                         range_max,
+                                         gene_value,
+                                         gene_idx,
+                                         mutation_by_replacement,
+                                         solution,
+                                         num_values=100):
+        """
+        Randomly generate values for the gene that satisfy the constraint.
+        It accepts:
+            -range_min: The minimum value in the range from which a value is selected.
+            -range_max: The maximum value in the range from which a value is selected.
+            -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: The solution in which the gene exists.
+            -num_values: The number of random valus to generate. It tries to generate a number of values up to a maximum of num_values. But it is not always guranteed because the total number of values might not be enough or the random generator creates duplicate random values.
+        If num_values=1, it returns a single numeric value. If num_values>1, it returns an array with number of values equal to num_values.
+        """
+        random_values = self.generate_gene_random_value(range_min=range_min, 
+                                                        range_max=range_max, 
+                                                        gene_value=gene_value,
+                                                        gene_idx=gene_idx, 
+                                                        mutation_by_replacement=mutation_by_replacement,
+                                                        num_values=num_values)
+        random_values_filtered = self.mutation_filter_values_by_constraint(random_values=random_values,
+                                                                           solution=solution,
+                                                                           gene_idx=gene_idx)
+        return random_values_filtered

pygad/helper/__pycache__/__init__.cpython-310.pyc

@@ -15,6 +15,7 @@ class GA(utils.parent_selection.ParentSelection,
          utils.mutation.Mutation,
          utils.nsga2.NSGA2,
          helper.unique.Unique,
+         helper.misc.Helper,
          visualize.plot.Plot):
 
     supported_int_types = [int, numpy.int8, numpy.int16, numpy.int32, numpy.int64,
@@ -435,7 +436,8 @@ def __init__(self,
                                                high=self.init_range_high,
                                                allow_duplicate_genes=allow_duplicate_genes,
                                                mutation_by_replacement=True,
-                                               gene_type=self.gene_type)
+                                               gene_type=self.gene_type,
+                                               gene_constraint=gene_constraint)
                 else:
                     self.valid_parameters = False
                     raise TypeError(f"The expected type of both the sol_per_pop and num_genes parameters is int but {type(sol_per_pop)} and {type(num_genes)} found.")
@@ -1377,12 +1379,18 @@ def initialize_population(self,
                               high,
                               allow_duplicate_genes,
                               mutation_by_replacement,
-                              gene_type):
+                              gene_type,
+                              gene_constraint):
         """
         Creates an initial population randomly as a NumPy array. The array is saved in the instance attribute named 'population'.
 
-        low: The lower value of the random range from which the gene values in the initial population are selected. It defaults to -4. Available in PyGAD 1.0.20 and higher.
-        high: The upper value of the random range from which the gene values in the initial population are selected. It defaults to -4. Available in PyGAD 1.0.20.
+        It accepts:
+            -low: The lower value of the random range from which the gene values in the initial population are selected. It defaults to -4. Available in PyGAD 1.0.20 and higher.
+            -high: The upper value of the random range from which the gene values in the initial population are selected. It defaults to -4. Available in PyGAD 1.0.20.
+            -allow_duplicate_genes: Whether duplicate genes are allowed or not.
+            -mutation_by_replacement: Whether mutation by replacement is enabled or not.
+            -gene_type: The data type of the genes.
+            -gene_constraint: The constraints of the genes.
 
         This method assigns the values of the following 3 instance attributes:
             1. pop_size: Size of the population.
@@ -1397,23 +1405,19 @@ def initialize_population(self,
         if self.gene_space is None:
             # Creating the initial population randomly.
             if self.gene_type_single == True:
+                # A NumPy array holding the initial population.
                 self.population = numpy.asarray(numpy.random.uniform(low=low,
                                                                      high=high,
                                                                      size=self.pop_size),
-                                                dtype=self.gene_type[0])  # A NumPy array holding the initial population.
+                                                dtype=self.gene_type[0])
             else:
                 # Create an empty population of dtype=object to support storing mixed data types within the same array.
                 self.population = numpy.zeros(
                     shape=self.pop_size, dtype=object)
                 # Loop through the genes, randomly generate the values of a single gene across the entire population, and add the values of each gene to the population.
                 for gene_idx in range(self.num_genes):
 
-                    if type(self.init_range_low) in self.supported_int_float_types:
-                        range_min = self.init_range_low
-                        range_max = self.init_range_high
-                    else:
-                        range_min = self.init_range_low[gene_idx]
-                        range_max = self.init_range_high[gene_idx]
+                    range_min, range_max = self.get_initial_population_range(gene_index=gene_idx)
 
                     # A vector of all values of this single gene across all solutions in the population.
                     gene_values = numpy.asarray(numpy.random.uniform(low=range_min,
@@ -1423,6 +1427,30 @@ def initialize_population(self,
                     # Adding the current gene values to the population.
                     self.population[:, gene_idx] = gene_values
 
+            # Enforce the gene constraints as much as possible.
+            if gene_constraint is None:
+                pass
+            else:
+                # Note that gene_constraint is not validated yet.
+                # We have to set it as a propery of the pygad.GA instance to retrieve without passing it as an additional parameter.
+                self.gene_constraint = gene_constraint
+                for solution in self.population:
+                    for gene_idx in range(self.num_genes):
+                        # Check that a constraint is available for the gene and that the current value does not satisfy that constraint
+                        if self.gene_constraint[gene_idx]:
+                            print(gene_idx, solution[gene_idx])
+                            if not self.gene_constraint[gene_idx](solution):
+                                range_min, range_max = self.get_initial_population_range(gene_index=gene_idx)
+                                # While initializing the population, we follow a mutation by replacement approach. So, the gene value is not needed.
+                                random_values_filtered = self.get_valid_gene_constraint_values(range_min=range_min,
+                                                                                               range_max=range_max,
+                                                                                               gene_value=None,
+                                                                                               gene_idx=gene_idx,
+                                                                                               mutation_by_replacement=True,
+                                                                                               solution=solution,
+                                                                                               num_values=100)
+                                print(gene_idx, random_values_filtered)
+
             if allow_duplicate_genes == False:
                 for solution_idx in range(self.population.shape[0]):
                     # self.logger.info("Before", self.population[solution_idx])
@@ -1444,12 +1472,7 @@ def initialize_population(self,
                 for sol_idx in range(self.sol_per_pop):
                     for gene_idx in range(self.num_genes):
 
-                        if type(self.init_range_low) in self.supported_int_float_types:
-                            range_min = self.init_range_low
-                            range_max = self.init_range_high
-                        else:
-                            range_min = self.init_range_low[gene_idx]
-                            range_max = self.init_range_high[gene_idx]
+                        range_min, range_max = self.get_initial_population_range(gene_index=gene_idx)
 
                         if self.gene_space[gene_idx] is None:
 
@@ -1524,12 +1547,7 @@ def initialize_population(self,
                 for sol_idx in range(self.sol_per_pop):
                     for gene_idx in range(self.num_genes):
 
-                        if type(self.init_range_low) in self.supported_int_float_types:
-                            range_min = self.init_range_low
-                            range_max = self.init_range_high
-                        else:
-                            range_min = self.init_range_low[gene_idx]
-                            range_max = self.init_range_high[gene_idx]
+                        range_min, range_max = self.get_initial_population_range(gene_index=gene_idx)
 
                         if type(self.gene_space[gene_idx]) in [numpy.ndarray, list, tuple, range]:
                             # Convert to list because tuple and range do not have copy().
@@ -1584,12 +1602,7 @@ def initialize_population(self,
                 # Replace all the None values with random values using the init_range_low, init_range_high, and gene_type attributes.
                 for gene_idx, curr_gene_space in enumerate(self.gene_space):
 
-                    if type(self.init_range_low) in self.supported_int_float_types:
-                        range_min = self.init_range_low
-                        range_max = self.init_range_high
-                    else:
-                        range_min = self.init_range_low[gene_idx]
-                        range_max = self.init_range_high[gene_idx]
+                    range_min, range_max = self.get_initial_population_range(gene_index=gene_idx)
 
                     if curr_gene_space is None:
                         self.gene_space[gene_idx] = numpy.asarray(numpy.random.uniform(low=range_min,