Single-Swarm

Using Builtins

 1from deap_er import creator
 2from deap_er import tools
 3from deap_er import base
 4import operator
 5import random
 6import numpy
 7import math
 8
 9
10random.seed(1234)  # disables randomization
11
12NGEN = 1000
13
14
15def generate(size, pmin, pmax, smin, smax):
16    p_list = [random.uniform(pmin, pmax) for _ in range(size)]
17    s_list = [random.uniform(smin, smax) for _ in range(size)]
18    part = creator.Particle(p_list)
19    part.speed = s_list
20    part.smin = smin
21    part.smax = smax
22    return part
23
24
25def update(part, best, phi1, phi2):
26    u1 = (random.uniform(0, phi1) for _ in range(len(part)))
27    u2 = (random.uniform(0, phi2) for _ in range(len(part)))
28    v_u1 = map(operator.mul, u1, map(operator.sub, part.best, part))
29    v_u2 = map(operator.mul, u2, map(operator.sub, best, part))
30    part.speed = list(map(operator.add, part.speed, map(operator.add, v_u1, v_u2)))
31    for i, speed in enumerate(part.speed):
32        if abs(speed) < part.smin:
33            part.speed[i] = math.copysign(part.smin, speed)
34        elif abs(speed) > part.smax:
35            part.speed[i] = math.copysign(part.smax, speed)
36    part[:] = list(map(operator.add, part, part.speed))
37
38
39def setup():
40    creator.create("FitnessMax", base.Fitness, weights=(1.0,))
41    creator.create("Particle", list, fitness=creator.FitnessMax,
42                   speed=list, smin=None, smax=None, best=None)
43
44    toolbox = base.Toolbox()
45    toolbox.register("particle", generate, size=2, pmin=-6, pmax=6, smin=-3, smax=3)
46    toolbox.register("population", tools.init_repeat, list, toolbox.particle)
47    toolbox.register("update", update, phi1=2.0, phi2=2.0)
48    toolbox.register("evaluate", tools.bm_h1)
49
50    stats = tools.Statistics(lambda ind: ind.fitness.values)
51    stats.register("avg", numpy.mean)
52    stats.register("std", numpy.std)
53    stats.register("min", numpy.min)
54    stats.register("max", numpy.max)
55
56    logbook = tools.Logbook()
57    logbook.header = ["gen", "evals"] + stats.fields
58
59    return toolbox, stats, logbook
60
61
62def print_results(best_ind):
63    if not best_ind.fitness.values <= (2,):
64        raise RuntimeError('Evolution failed to converge.')
65    print(f'\nEvolution converged correctly.')
66
67
68def main():
69    toolbox, stats, logbook = setup()
70    pop = toolbox.population(size=5)
71
72    best = None
73    for generation in range(NGEN):
74        for part in pop:
75            part.fitness.values = toolbox.evaluate(part)
76            if not part.best or part.best.fitness < part.fitness:
77                part.best = creator.Particle(part)
78                part.best.fitness.values = part.fitness.values
79            if not best or best.fitness < part.fitness:
80                best = creator.Particle(part)
81                best.fitness.values = part.fitness.values
82        for part in pop:
83            toolbox.update(part, best)
84        logbook.record(gen=generation, evals=len(pop), **stats.compile(pop))
85        print(logbook.stream)
86
87    print_results(best)
88
89
90if __name__ == "__main__":
91    main()

Using Numpy

 1from deap_er import creator
 2from deap_er import tools
 3from deap_er import base
 4import random
 5import numpy
 6import math
 7
 8
 9random.seed(1234)  # disables randomization
10
11NGEN = 1000
12
13
14def generate(size, pmin, pmax, smin, smax):
15    p_list = numpy.random.uniform(pmin, pmax, size)
16    s_list = numpy.random.uniform(smin, smax, size)
17    part = creator.Particle(p_list)
18    part.speed = s_list
19    part.smin = smin
20    part.smax = smax
21    return part
22
23
24def update(part, best, phi1, phi2):
25    u1 = numpy.random.uniform(0, phi1, len(part))
26    u2 = numpy.random.uniform(0, phi2, len(part))
27    v_u1 = u1 * (part.best - part)
28    v_u2 = u2 * (best - part)
29    part.speed += v_u1 + v_u2
30    for i, speed in enumerate(part.speed):
31        if abs(speed) < part.smin:
32            part.speed[i] = math.copysign(part.smin, speed)
33        elif abs(speed) > part.smax:
34            part.speed[i] = math.copysign(part.smax, speed)
35    part += part.speed
36
37
38def setup():
39    creator.create("FitnessMax", base.Fitness, weights=(1.0,))
40    creator.create("Particle", numpy.ndarray, fitness=creator.FitnessMax,
41                   speed=list, smin=None, smax=None, best=None)
42
43    toolbox = base.Toolbox()
44    toolbox.register("particle", generate, size=2, pmin=-6, pmax=6, smin=-3, smax=3)
45    toolbox.register("population", tools.init_repeat, list, toolbox.particle)
46    toolbox.register("update", update, phi1=2.0, phi2=2.0)
47    toolbox.register("evaluate", tools.bm_h1)
48
49    stats = tools.Statistics(lambda ind: ind.fitness.values)
50    stats.register("avg", numpy.mean)
51    stats.register("std", numpy.std)
52    stats.register("min", numpy.min)
53    stats.register("max", numpy.max)
54
55    logbook = tools.Logbook()
56    logbook.header = ["gen", "evals"] + stats.fields
57
58    return toolbox, stats, logbook
59
60
61def print_results(best_ind):
62    if not best_ind.fitness.values <= (2,):
63        raise RuntimeError('Evolution failed to converge.')
64    print(f'\nEvolution converged correctly.')
65
66
67def main():
68    toolbox, stats, logbook = setup()
69    pop = toolbox.population(size=5)
70
71    best = None
72    for g in range(NGEN):
73        for part in pop:
74            part.fitness.values = toolbox.evaluate(part)
75            if part.best is None or part.best.fitness < part.fitness:
76                part.best = creator.Particle(part)
77                part.best.fitness.values = part.fitness.values
78            if best is None or best.fitness < part.fitness:
79                best = creator.Particle(part)
80                best.fitness.values = part.fitness.values
81        for part in pop:
82            toolbox.update(part, best)
83        logbook.record(gen=g, evals=len(pop), **stats.compile(pop))
84        print(logbook.stream)
85
86    print_results(best)
87
88
89if __name__ == "__main__":
90    main()