Merge pull request #208 from ahmedfgad/github-actions

GitHub actions

Author: ahmedfgad

docs/source/README_pygad_ReadTheDocs.rst

@@ -913,7 +913,7 @@ It returns the following:
 -  ``best_match_idx``: Index of the best solution in the current
    population.
 
-.. _plotfitness-1:
+.. _plotfitness:
 
 ``plot_fitness()``
 ------------------
@@ -946,7 +946,7 @@ and higher, this method accepts the following parameters:
 
 8. ``save_dir``: Directory to save the figure.
 
-.. _plotnewsolutionrate-1:
+.. _plotnewsolutionrate:
 
 ``plot_new_solution_rate()``
 ----------------------------
@@ -979,7 +979,7 @@ This method accepts the following parameters:
 
 8. ``save_dir``: Directory to save the figure.
 
-.. _plotgenes-1:
+.. _plotgenes:
 
 ``plot_genes()``
 ----------------
@@ -1229,7 +1229,7 @@ The next step is to import PyGAD as follows:
 The ``pygad.GA`` class holds the implementation of all methods for
 running the genetic algorithm.
 
-.. _create-an-instance-of-the-pygadga-class-1:
+.. _create-an-instance-of-the-pygadga-class:
 
 Create an Instance of the ``pygad.GA`` Class
 --------------------------------------------
@@ -2403,6 +2403,8 @@ The function should return 2 outputs:
 2. The indices of the selected parents inside the population. It is a 1D
    list with length equal to the number of selected parents.
 
+The outputs must be of type ``numpy.ndarray``.
+
 Here is a template for building a custom parent selection function.
 
 .. code:: python
@@ -2427,7 +2429,7 @@ parents are selected. The number of parents is equal to the value in the
        for parent_num in range(num_parents):
            parents[parent_num, :] = ga_instance.population[fitness_sorted[parent_num], :].copy()
 
-       return parents, fitness_sorted[:num_parents]
+       return parents, numpy.array(fitness_sorted[:num_parents])
 
 Finally, the defined function is assigned to the
 ``parent_selection_type`` parameter as in the next code.
@@ -2474,7 +2476,7 @@ previous 3 user-defined functions instead of the built-in functions.
        for parent_num in range(num_parents):
            parents[parent_num, :] = ga_instance.population[fitness_sorted[parent_num], :].copy()
 
-       return parents, fitness_sorted[:num_parents]
+       return parents, numpy.array(fitness_sorted[:num_parents])
 
    def crossover_func(parents, offspring_size, ga_instance):
 
@@ -3004,7 +3006,7 @@ methods.
 The ``plot_fitness()`` method shows the fitness value for each
 generation.
 
-.. _plottypeplot-1:
+.. _plottypeplot:
 
 ``plot_type="plot"``
 ~~~~~~~~~~~~~~~~~~~~
@@ -3021,7 +3023,7 @@ line connecting the fitness values across all generations:
 .. figure:: https://user-images.githubusercontent.com/16560492/122472609-d02f5280-cf8e-11eb-88a7-f9366ff6e7c6.png
    :alt: 
 
-.. _plottypescatter-1:
+.. _plottypescatter:
 
 ``plot_type="scatter"``
 ~~~~~~~~~~~~~~~~~~~~~~~
@@ -3037,7 +3039,7 @@ these dots can be changed using the ``linewidth`` parameter.
 .. figure:: https://user-images.githubusercontent.com/16560492/122473159-75e2c180-cf8f-11eb-942d-31279b286dbd.png
    :alt: 
 
-.. _plottypebar-1:
+.. _plottypebar:
 
 ``plot_type="bar"``
 ~~~~~~~~~~~~~~~~~~~
@@ -3393,8 +3395,6 @@ parameter:
    given the value 0, this means do not use parallel processing. This is
    identical to ``parallel_processing=None``.
 
-.. _examples-1:
-
 Examples
 --------
 

tests/test_adaptive_mutation.py

@@ -0,0 +1,222 @@
+import pygad
+import random
+import numpy
+
+num_generations = 1
+
+initial_population = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
+                      [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]
+
+def output_adaptive_mutation(gene_space=None,
+                             gene_type=float,
+                             num_genes=10,
+                             mutation_by_replacement=False,
+                             random_mutation_min_val=-1,
+                             random_mutation_max_val=1,
+                             init_range_low=-4,
+                             init_range_high=4,
+                             initial_population=None,
+                             mutation_probability=[0.2, 0.1],
+                             fitness_batch_size=None,
+                             mutation_type="adaptive"):
+
+    def fitness_func_single(ga, solution, idx):
+        return random.random()
+
+    def fitness_func_batch(ga, soluions, idxs):
+        return numpy.random.uniform(size=len(soluions))
+    
+    if fitness_batch_size in [1, None]:
+        fitness_func = fitness_func_single
+    else:
+        fitness_func = fitness_func_batch
+
+    ga_instance = pygad.GA(num_generations=num_generations,
+                           num_parents_mating=5,
+                           fitness_func=fitness_func,
+                           sol_per_pop=10,
+                           num_genes=num_genes,
+                           gene_space=gene_space,
+                           gene_type=gene_type,
+                           initial_population=initial_population,
+                           init_range_low=init_range_low,
+                           init_range_high=init_range_high,
+                           random_mutation_min_val=random_mutation_min_val,
+                           random_mutation_max_val=random_mutation_max_val,
+                           allow_duplicate_genes=True,
+                           mutation_by_replacement=mutation_by_replacement,
+                           save_solutions=True,
+                           mutation_probability=mutation_probability,
+                           mutation_type=mutation_type,
+                           suppress_warnings=True,
+                           fitness_batch_size=fitness_batch_size,
+                           random_seed=1)
+
+    ga_instance.run()
+
+    return None, ga_instance
+
+def test_adaptive_mutation():
+    result, ga_instance = output_adaptive_mutation()
+
+    # assert result == True
+
+def test_adaptive_mutation_gene_space():
+    result, ga_instance = output_adaptive_mutation(gene_space=range(10))
+
+    # assert result == True
+
+def test_adaptive_mutation_int_gene_type():
+    result, ga_instance = output_adaptive_mutation(gene_type=int)
+
+    # assert result == True
+
+def test_adaptive_mutation_gene_space_gene_type():
+    result, ga_instance = output_adaptive_mutation(gene_space={"low": 0, "high": 10},
+                                                   gene_type=[float, 2])
+
+    # assert result == True
+
+def test_adaptive_mutation_nested_gene_space():
+    result, ga_instance = output_adaptive_mutation(gene_space=[[0, 1, 2, 3, 4], 
+                                                                numpy.arange(5, 10), 
+                                                                range(10, 15),
+                                                                {"low": 15, "high": 20},
+                                                                {"low": 20, "high": 30, "step": 2},
+                                                                None,
+                                                                numpy.arange(30, 35),
+                                                                numpy.arange(35, 40),
+                                                                numpy.arange(40, 45),
+                                                                [45, 46, 47, 48, 49]])
+    # assert result == True
+
+def test_adaptive_mutation_nested_gene_type():
+    result, ga_instance = output_adaptive_mutation(gene_type=[int, float, numpy.float64, [float, 3], [float, 4], numpy.int16, [numpy.float32, 1], int, float, [float, 3]])
+
+    # assert result == True
+
+def test_adaptive_mutation_nested_gene_space_nested_gene_type():
+    result, ga_instance = output_adaptive_mutation(gene_space=[[0, 1, 2, 3, 4], 
+                                                                numpy.arange(5, 10), 
+                                                                range(10, 15),
+                                                                {"low": 15, "high": 20},
+                                                                {"low": 20, "high": 30, "step": 2},
+                                                                None,
+                                                                numpy.arange(30, 35),
+                                                                numpy.arange(35, 40),
+                                                                numpy.arange(40, 45),
+                                                                [45, 46, 47, 48, 49]],
+                                                   gene_type=[int, float, numpy.float64, [float, 3], [float, 4], numpy.int16, [numpy.float32, 1], int, float, [float, 3]])
+
+    # assert result == True
+
+def test_adaptive_mutation_initial_population():
+    global initial_population
+    result, ga_instance = output_adaptive_mutation(initial_population=initial_population)
+
+    # assert result == True
+
+def test_adaptive_mutation_initial_population_nested_gene_type():
+    global initial_population
+    result, ga_instance = output_adaptive_mutation(initial_population=initial_population,
+                                                   gene_type=[int, float, numpy.float64, [float, 3], [float, 4], numpy.int16, [numpy.float32, 1], int, float, [float, 3]])
+
+    # assert result == True
+
+def test_adaptive_mutation_fitness_batch_size_1():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=1)
+
+def test_adaptive_mutation_fitness_batch_size_2():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=2)
+
+def test_adaptive_mutation_fitness_batch_size_3():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=3)
+
+def test_adaptive_mutation_fitness_batch_size_4():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=4)
+
+def test_adaptive_mutation_fitness_batch_size_5():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=5)
+
+def test_adaptive_mutation_fitness_batch_size_6():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=6)
+
+def test_adaptive_mutation_fitness_batch_size_7():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=7)
+
+def test_adaptive_mutation_fitness_batch_size_8():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=8)
+
+def test_adaptive_mutation_fitness_batch_size_9():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=9)
+
+def test_adaptive_mutation_fitness_batch_size_10():
+    result, ga_instance = output_adaptive_mutation(fitness_batch_size=10)
+
+if __name__ == "__main__":
+    print()
+    test_adaptive_mutation()
+    print()
+
+    test_adaptive_mutation_int_gene_type()
+    print()
+
+    test_adaptive_mutation_gene_space()
+    print()
+
+    test_adaptive_mutation_gene_space_gene_type()
+    print()
+
+    test_adaptive_mutation_nested_gene_space()
+    print()
+
+    test_adaptive_mutation_nested_gene_type()
+    print()
+
+    test_adaptive_mutation_initial_population()
+    print()
+
+    test_adaptive_mutation_initial_population_nested_gene_type()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_1()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_1()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_2()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_3()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_4()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_5()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_6()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_7()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_8()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_9()
+    print()
+
+    test_adaptive_mutation_fitness_batch_size_10()
+    print()
+