One Max Problem

Detailed Version

 1from deap_er import creator
 2from deap_er import tools
 3from deap_er import base
 4import random
 5
 6
 7random.seed(1234)  # disables randomization
 8
 9NGEN = 1000
10CX_PROB = 0.5
11MUT_PROB = 0.2
12
13
14def setup():
15    creator.create("FitnessMax", base.Fitness, weights=(1.0,))
16    creator.create("Individual", list, fitness=creator.FitnessMax)
17
18    toolbox = base.Toolbox()
19    toolbox.register("attr_bool", random.randint, 0, 1)
20    toolbox.register("individual", tools.init_repeat, creator.Individual, toolbox.attr_bool, 100)
21    toolbox.register("population", tools.init_repeat, list, toolbox.individual)
22    toolbox.register("mate", tools.cx_two_point)
23    toolbox.register("mutate", tools.mut_flip_bit, mut_prob=0.05)
24    toolbox.register("select", tools.sel_tournament, contestants=3)
25    toolbox.register("evaluate", lambda x: sum(x))
26
27    return toolbox
28
29
30def print_results(best_ind):
31    if not all(gene == 1 for gene in best_ind):
32        raise RuntimeError('Evolution failed to converge.')
33    print(f'\nEvolution converged correctly.')
34
35
36def main():
37    toolbox = setup()
38    population = toolbox.population(size=300)
39
40    fitness = map(toolbox.evaluate, population)
41    for ind, fit in zip(population, fitness):
42        ind.fitness.values = fit
43    fits = [ind.fitness.values[0] for ind in population]
44
45    generation = 0
46    while max(fits) < 100 and generation < NGEN:
47        offspring = toolbox.select(population, len(population))
48        offspring = list(map(toolbox.clone, offspring))
49
50        for child1, child2 in zip(offspring[::2], offspring[1::2]):
51            if random.random() < CX_PROB:
52                toolbox.mate(child1, child2)
53                del child1.fitness.values
54                del child2.fitness.values
55
56        for mutant in offspring:
57            if random.random() < MUT_PROB:
58                toolbox.mutate(mutant)
59                del mutant.fitness.values
60
61        invalid_ind = [ind for ind in offspring if not ind.fitness.is_valid()]
62        fitness = map(toolbox.evaluate, invalid_ind)
63        for ind, fit in zip(invalid_ind, fitness):
64            ind.fitness.values = fit
65        population[:] = offspring
66        fits = [ind.fitness.values[0] for ind in population]
67        generation += 1
68
69    best_ind = tools.sel_best(population, sel_count=1)[0]
70    print_results(best_ind)
71
72
73if __name__ == "__main__":
74    main()

Short Version

 1from deap_er import creator
 2from deap_er import tools
 3from deap_er import base
 4import random
 5import numpy
 6import array
 7
 8
 9random.seed(1234)  # disables randomization
10
11
12def setup():
13    creator.create("FitnessMax", base.Fitness, weights=(1.0,))
14    creator.create("Individual", array.array, typecode='b', fitness=creator.FitnessMax)
15
16    toolbox = base.Toolbox()
17    toolbox.register("attr_bool", random.randint, 0, 1)
18    toolbox.register("individual", tools.init_repeat, creator.Individual, toolbox.attr_bool, 100)
19    toolbox.register("population", tools.init_repeat, list, toolbox.individual)
20    toolbox.register("mate", tools.cx_two_point)
21    toolbox.register("mutate", tools.mut_flip_bit, mut_prob=0.05)
22    toolbox.register("select", tools.sel_tournament, contestants=3)
23    toolbox.register("evaluate", lambda x: sum(x))
24
25    stats = tools.Statistics(lambda ind: ind.fitness.values)
26    stats.register("avg", numpy.mean)
27    stats.register("std", numpy.std)
28    stats.register("min", numpy.min)
29    stats.register("max", numpy.max)
30
31    return toolbox, stats
32
33
34def print_results(best_ind):
35    if not all(gene == 1 for gene in best_ind):
36        raise RuntimeError('Evolution failed to converge.')
37    print(f'\nEvolution converged correctly.')
38
39
40def main():
41    toolbox, stats = setup()
42    pop = toolbox.population(size=300)
43    hof = tools.HallOfFame(maxsize=1)
44    args = dict(
45        toolbox=toolbox,
46        population=pop,
47        generations=50,
48        cx_prob=0.5,
49        mut_prob=0.2,
50        hof=hof,
51        stats=stats,
52        verbose=True  # prints stats
53    )
54    tools.ea_simple(**args)
55    print_results(hof[0])
56
57
58if __name__ == "__main__":
59    main()

Using Numpy

 1from deap_er import creator
 2from deap_er import tools
 3from deap_er import base
 4import random
 5import numpy
 6
 7
 8random.seed(1234)  # disables randomization
 9
10
11def setup():
12    creator.create("FitnessMax", base.Fitness, weights=(1.0,))
13    creator.create("Individual", numpy.ndarray, fitness=creator.FitnessMax)
14
15    toolbox = base.Toolbox()
16    toolbox.register("attr_bool", random.randint, 0, 1)
17    toolbox.register("individual", tools.init_repeat, creator.Individual, toolbox.attr_bool, 100)
18    toolbox.register("population", tools.init_repeat, list, toolbox.individual)
19
20    toolbox.register("mate", tools.cx_two_point_copy)
21    toolbox.register("mutate", tools.mut_flip_bit, mut_prob=0.05)
22    toolbox.register("select", tools.sel_tournament, contestants=3)
23    toolbox.register("evaluate", lambda x: sum(x))
24
25    stats = tools.Statistics(lambda ind: ind.fitness.values)
26    stats.register("avg", numpy.mean)
27    stats.register("std", numpy.std)
28    stats.register("min", numpy.min)
29    stats.register("max", numpy.max)
30
31    return toolbox, stats
32
33
34def print_results(best_ind):
35    if not all(gene == 1 for gene in best_ind):
36        raise RuntimeError('Evolution failed to converge.')
37    print(f'\nEvolution converged correctly.')
38
39
40def main():
41    toolbox, stats = setup()
42    pop = toolbox.population(size=300)
43    hof = tools.HallOfFame(maxsize=1, similar=numpy.array_equal)
44    args = dict(
45        toolbox=toolbox,
46        population=pop,
47        generations=50,
48        cx_prob=0.5,
49        mut_prob=0.2,
50        hof=hof,
51        stats=stats,
52        verbose=True  # prints stats
53    )
54    tools.ea_simple(**args)
55    print_results(hof[0])
56
57
58if __name__ == "__main__":
59    main()

Using Multiprocessing

 1from deap_er import creator
 2from deap_er import tools
 3from deap_er import base
 4import multiprocessing as mp
 5import random
 6import numpy
 7import array
 8
 9
10random.seed(1234)  # disables randomization
11
12
13# Evaluator can't be a lambda, because lambdas can't be pickled.
14def evaluate(individual):
15    return sum(individual)
16
17
18# Can't be in setup(), because subprocesses need these objects.
19creator.create("FitnessMax", base.Fitness, weights=(1.0,))
20creator.create("Individual", array.array, typecode='b', fitness=creator.FitnessMax)
21
22
23def setup():
24    toolbox = base.Toolbox()
25    toolbox.register("attr_bool", random.randint, 0, 1)
26    toolbox.register("individual", tools.init_repeat, creator.Individual, toolbox.attr_bool, 100)
27    toolbox.register("population", tools.init_repeat, list, toolbox.individual)
28
29    toolbox.register("mate", tools.cx_two_point)
30    toolbox.register("mutate", tools.mut_flip_bit, mut_prob=0.05)
31    toolbox.register("select", tools.sel_tournament, contestants=3)
32    toolbox.register("evaluate", evaluate)
33
34    stats = tools.Statistics(lambda ind: ind.fitness.values)
35    stats.register("avg", numpy.mean)
36    stats.register("std", numpy.std)
37    stats.register("min", numpy.min)
38    stats.register("max", numpy.max)
39
40    return toolbox, stats
41
42
43def print_results(best_ind):
44    if not all(gene == 1 for gene in best_ind):
45        raise RuntimeError('Evolution failed to converge.')
46    print(f'\nEvolution converged correctly.')
47
48
49def main():
50    toolbox, stats = setup()
51    pop = toolbox.population(size=300)
52    hof = tools.HallOfFame(maxsize=1)
53    with mp.Pool() as pool:
54        toolbox.register("map", pool.map)
55        args = dict(
56            toolbox=toolbox,
57            population=pop,
58            generations=50,
59            cx_prob=0.5,
60            mut_prob=0.2,
61            hof=hof,
62            stats=stats,
63            verbose=True  # prints stats
64        )
65        tools.ea_simple(**args)
66        print_results(hof[0])
67
68
69if __name__ == "__main__":
70    main()