رویکرد هوش ازدحامی با استفاده از کلونی زنبور عسل مصنوعی برای حل مسائل بهینه‌سازی

1import numpy as np
2
3from scipy import optimize
4from deap.benchmarks import schwefel
5
6from abc import ABCMeta
7from abc import abstractmethod
8from six import add_metaclass
9
10
11@add_metaclass(ABCMeta)
12class ObjectiveFunction(object):
13
14    def __init__(self, name, dim, minf, maxf):
15        self.name = name
16        self.dim = dim
17        self.minf = minf
18        self.maxf = maxf
19
20    def sample(self):
21        return np.random.uniform(low=self.minf, high=self.maxf, size=self.dim)
22
23    def custom_sample(self):
24        return np.repeat(self.minf, repeats=self.dim) \
25               + np.random.uniform(low=0, high=1, size=self.dim) *\
26               np.repeat(self.maxf - self.minf, repeats=self.dim)
27
28    @abstractmethod
29    def evaluate(self, x):
30        pass
31
32
33class Sphere(ObjectiveFunction):
34
35    def __init__(self, dim):
36        super(Sphere, self).__init__('Sphere', dim, -100.0, 100.0)
37
38    def evaluate(self, x):
39        return sum(np.power(x, 2))
40
41
42class Rosenbrock(ObjectiveFunction):
43
44    def __init__(self, dim):
45        super(Rosenbrock, self).__init__('Rosenbrock', dim, -30.0, 30.0)
46
47    def evaluate(self, x):
48        return optimize.rosen(x)
49
50
51class Rastrigin(ObjectiveFunction):
52
53    def __init__(self, dim):
54        super(Rastrigin, self).__init__('Rastrigin', dim, -5.12, 5.12)
55
56    def evaluate(self, x):
57        return 10 * len(x)\
58               + np.sum(np.power(x, 2) - 10 * np.cos(2 * np.pi * np.array(x)))
59
60
61class Schwefel(ObjectiveFunction):
62
63    def __init__(self, dim):
64        super(Schwefel, self).__init__('Schwefel', dim, -500.0, 500.0)
65
66    def evaluate(self, x):
67        return schwefel(x)[0]

1import numpy as np
2
3from copy import deepcopy
4from abc import ABCMeta
5from six import add_metaclass
6
7
8@add_metaclass(ABCMeta)
9class ArtificialBee(object):
10
11    TRIAL_INITIAL_DEFAULT_VALUE = 0
12    INITIAL_DEFAULT_PROBABILITY = 0.0
13
14    def __init__(self, obj_function):
15        self.pos = obj_function.custom_sample()
16        self.obj_function = obj_function
17        self.minf = obj_function.minf
18        self.maxf = obj_function.maxf
19        self.fitness = obj_function.evaluate(self.pos)
20        self.trial = ArtificialBee.TRIAL_INITIAL_DEFAULT_VALUE
21        self.prob = ArtificialBee.INITIAL_DEFAULT_PROBABILITY
22
23    def evaluate_boundaries(self, pos):
24        if (pos < self.minf).any() or (pos > self.maxf).any():
25            pos[pos > self.maxf] = self.maxf
26            pos[pos < self.minf] = self.minf
27        return pos
28
29    def update_bee(self, pos, fitness):
30        if fitness <= self.fitness:
31            self.pos = pos
32            self.fitness = fitness
33            self.trial = 0
34        else:
35            self.trial += 1
36
37    def reset_bee(self, max_trials):
38        if self.trial >= max_trials:
39            self.__reset_bee()
40
41    def __reset_bee(self):
42        self.pos = self.obj_function.custom_sample()
43        self.fitness = self.obj_function.evaluate(self.pos)
44        self.trial = ArtificialBee.TRIAL_INITIAL_DEFAULT_VALUE
45        self.prob = ArtificialBee.INITIAL_DEFAULT_PROBABILITY

1class EmployeeBee(ArtificialBee):
2
3    def explore(self, max_trials):
4        if self.trial <= max_trials:
5            component = np.random.choice(self.pos)
6            phi = np.random.uniform(low=-1, high=1, size=len(self.pos))
7            n_pos = self.pos + (self.pos - component) * phi
8            n_pos = self.evaluate_boundaries(n_pos)
9            n_fitness = self.obj_function.evaluate(n_pos)
10            self.update_bee(n_pos, n_fitness)
11
12    def get_fitness(self):
13        return 1 / (1 + self.fitness) if self.fitness >= 0 else 1 + np.abs(self.fitness)
14
15    def compute_prob(self, max_fitness):
16        self.prob = self.get_fitness() / max_fitness

1class OnLookerBee(ArtificialBee):
2
3    def onlook(self, best_food_sources, max_trials):
4        candidate = np.random.choice(best_food_sources)
5        self.__exploit(candidate.pos, candidate.fitness, max_trials)
6
7    def __exploit(self, candidate, fitness, max_trials):
8        if self.trial <= max_trials:
9            component = np.random.choice(candidate)
10            phi = np.random.uniform(low=-1, high=1, size=len(candidate))
11            n_pos = candidate + (candidate - component) * phi
12            n_pos = self.evaluate_boundaries(n_pos)
13            n_fitness = self.obj_function.evaluate(n_pos)
14
15            if n_fitness <= fitness:
16                self.pos = n_pos
17                self.fitness = n_fitness
18                self.trial = 0
19            else:
20                self.trial += 1

1class ABC(object):
2
3    def __init__(self, obj_function, colony_size=30, n_iter=5000, max_trials=100):
4        self.colony_size = colony_size
5        self.obj_function = obj_function
6
7        self.n_iter = n_iter
8        self.max_trials = max_trials
9
10        self.optimal_solution = None
11        self.optimality_tracking = []
12
13    def __reset_algorithm(self):
14        self.optimal_solution = None
15        self.optimality_tracking = []
16
17    def __update_optimality_tracking(self):
18        self.optimality_tracking.append(self.optimal_solution.fitness)
19
20    def __update_optimal_solution(self):
21        n_optimal_solution = \
22            min(self.onlokeer_bees + self.employee_bees,
23                key=lambda bee: bee.fitness)
24        if not self.optimal_solution:
25            self.optimal_solution = deepcopy(n_optimal_solution)
26        else:
27            if n_optimal_solution.fitness < self.optimal_solution.fitness:
28                self.optimal_solution = deepcopy(n_optimal_solution)
29
30    def __initialize_employees(self):
31        self.employee_bees = []
32        for itr in range(self.colony_size // 2):
33            self.employee_bees.append(EmployeeBee(self.obj_function))
34
35    def __initialize_onlookers(self):
36        self.onlokeer_bees = []
37        for itr in range(self.colony_size // 2):
38            self.onlokeer_bees.append(OnLookerBee(self.obj_function))
39
40    def __employee_bees_phase(self):
41        map(lambda bee: bee.explore(self.max_trials), self.employee_bees)
42
43    def __calculate_probabilities(self):
44        sum_fitness = sum(map(lambda bee: bee.get_fitness(), self.employee_bees))
45        map(lambda bee: bee.compute_prob(sum_fitness), self.employee_bees)
46
47    def __select_best_food_sources(self):
48        self.best_food_sources =\
49            filter(lambda bee: bee.prob > np.random.uniform(low=0, high=1),
50                   self.employee_bees)
51        while not self.best_food_sources:
52            self.best_food_sources = \
53                filter(lambda bee: bee.prob > np.random.uniform(low=0, high=1),
54                       self.employee_bees)
55
56    def __onlooker_bees_phase(self):
57        map(lambda bee: bee.onlook(self.best_food_sources, self.max_trials),
58            self.onlokeer_bees)
59
60    def __scout_bees_phase(self):
61        map(lambda bee: bee.reset_bee(self.max_trials),
62            self.onlokeer_bees + self.employee_bees)
63
64    def optimize(self):
65        self.__reset_algorithm()
66        self.__initialize_employees()
67        self.__initialize_onlookers()
68        for itr in range(self.n_iter):
69            self.__employee_bees_phase()
70            self.__update_optimal_solution()
71
72            self.__calculate_probabilities()
73            self.__select_best_food_sources()
74
75            self.__onlooker_bees_phase()
76            self.__scout_bees_phase()
77
78            self.__update_optimal_solution()
79            self.__update_optimality_tracking()
80            print("iter: {} = cost: {}"
81                  .format(itr, "%04.03e" % self.optimal_solution.fitness))

1import numpy as np
2import matplotlib.pyplot as plt
3
4from algorithm.abc import ABC
5
6from matplotlib.style import use
7
8from objection_function import Rastrigin
9from objection_function import Rosenbrock
10from objection_function import Sphere
11from objection_function import Schwefel
12
13
14use('classic')
15
16
17def get_objective(objective, dimension=30):
18    objectives = {'Sphere': Sphere(dimension),
19                  'Rastrigin': Rastrigin(dimension),
20                  'Rosenbrock': Rosenbrock(dimension),
21                  'Schwefel': Schwefel(dimension)}
22    return objectives[objective]
23
24
25def simulate(obj_function, colony_size=30, n_iter=5000,
26             max_trials=100, simulations=30):
27    itr = range(n_iter)
28    values = np.zeros(n_iter)
29    box_optimal = []
30    for _ in range(simulations):
31        optimizer = ABC(obj_function=get_objective(obj_function),
32                        colony_size=colony_size, n_iter=n_iter,
33                        max_trials=max_trials)
34        optimizer.optimize()
35        values += np.array(optimizer.optimality_tracking)
36        box_optimal.append(optimizer.optimal_solution.fitness)
37        print(optimizer.optimal_solution.pos)
38    values /= simulations
39
40    plt.plot(itr, values, lw=0.5, label=obj_function)
41    plt.legend(loc='upper right')
42
43
44def main():
45    plt.figure(figsize=(10, 7))
46    simulate('Rastrigin')
47    plt.ticklabel_format(axis='y', style='sci', scilimits=(-2, 2))
48    plt.xticks(rotation=45)
49    plt.show()
50
51
52if __name__ == '__main__':
53    main()