萤火虫算法-python实现

视频的容积

　　FAIndividual.py



1 import numpy as np
2 import ObjFunction
3
4
5 class FAIndividual:
6
7     '''
8     individual of firefly algorithm
9     '''
10
11     def __init__(self,  vardim, bound):
12         '''
13         vardim: dimension of variables
14         bound: boundaries of variables
15         '''
16         self.vardim = vardim
17         self.bound = bound
18         self.fitness = 0.
19         self.trials = 0
20
21     def generate(self):
22         '''
23         generate a random chromsome for firefly algorithm
24         '''
25         len = self.vardim
26         rnd = np.random.random(size=len)
27         self.chrom = np.zeros(len)
28         for i in xrange(0, len):
29             self.chrom = self.bound[0, i] + \
30                 (self.bound[1, i] - self.bound[0, i]) * rnd
31
32     def calculateFitness(self):
33         '''
34         calculate the fitness of the chromsome
35         '''
36         self.fitness = ObjFunction.GrieFunc(
37             self.vardim, self.chrom, self.bound)
　　FA.py



  1 import numpy as np
  2 from FAIndividual import FAIndividual
  3 import random
  4 import copy
  5 import matplotlib.pyplot as plt
  6
  7
  8 class FireflyAlgorithm:
  9
10     '''
11     The class for firefly algorithm
12     '''
13
14     def __init__(self, sizepop, vardim, bound, MAXGEN, params):
15         '''
16         sizepop: population sizepop
17         vardim: dimension of variables
18         bound: boundaries of variables
19         MAXGEN: termination condition
20         param: algorithm required parameters, it is a list which is consisting of [beta0, gamma, alpha]
21         '''
22         self.sizepop = sizepop
23         self.MAXGEN = MAXGEN
24         self.vardim = vardim
25         self.bound = bound
26         self.population = []
27         self.fitness = np.zeros((self.sizepop, 1))
28         self.trace = np.zeros((self.MAXGEN, 2))
29         self.params = params
30
31     def initialize(self):
32         '''
33         initialize the population
34         '''
35         for i in xrange(0, self.sizepop):
36             ind = FAIndividual(self.vardim, self.bound)
37             ind.generate()
38             self.population.append(ind)
39
40     def evaluate(self):
41         '''
42         evaluation of the population fitnesses
43         '''
44         for i in xrange(0, self.sizepop):
45             self.population.calculateFitness()
46             self.fitness = self.population.fitness
47
48     def solve(self):
49         '''
50         evolution process of firefly algorithm
51         '''
52         self.t = 0
53         self.initialize()
54         self.evaluate()
55         best = np.max(self.fitness)
56         bestIndex = np.argmax(self.fitness)
57         self.best = copy.deepcopy(self.population[bestIndex])
58         self.avefitness = np.mean(self.fitness)
59         self.trace[self.t, 0] = (1 - self.best.fitness) / self.best.fitness
60         self.trace[self.t, 1] = (1 - self.avefitness) / self.avefitness
61         print("Generation %d: optimal function value is: %f; average function value is %f" % (
62             self.t, self.trace[self.t, 0], self.trace[self.t, 1]))
63         while (self.t < self.MAXGEN - 1):
64             self.t += 1
65             self.move()
66             self.evaluate()
67             best = np.max(self.fitness)
68             bestIndex = np.argmax(self.fitness)
69             if best > self.best.fitness:
70                 self.best = copy.deepcopy(self.population[bestIndex])
71             self.avefitness = np.mean(self.fitness)
72             self.trace[self.t, 0] = (1 - self.best.fitness) / self.best.fitness
73             self.trace[self.t, 1] = (1 - self.avefitness) / self.avefitness
74             print("Generation %d: optimal function value is: %f; average function value is %f" % (
75                 self.t, self.trace[self.t, 0], self.trace[self.t, 1]))
76
77         print("Optimal function value is: %f; " %
78               self.trace[self.t, 0])
79         print "Optimal solution is:"
80         print self.best.chrom
81         self.printResult()
82
83     def move(self):
84         '''
85         move the a firefly to another brighter firefly
86         '''
87         for i in xrange(0, self.sizepop):
88             for j in xrange(0, self.sizepop):
89                 if self.fitness[j] > self.fitness:
90                     r = np.linalg.norm(
91                         self.population.chrom - self.population[j].chrom)
92                     beta = self.params[0] * \
93                         np.exp(-1 * self.params[1] * (r ** 2))
94                     # beta = 1 / (1 + self.params[1] * r)
95                     # print beta
96                     self.population.chrom += beta * (self.population[j].chrom - self.population[
97                         i].chrom) + self.params[2] * np.random.uniform(low=-1, high=1, size=self.vardim)
98                     for k in xrange(0, self.vardim):
99                         if self.population.chrom[k] < self.bound[0, k]:
100                             self.population.chrom[k] = self.bound[0, k]
101                         if self.population.chrom[k] > self.bound[1, k]:
102                             self.population.chrom[k] = self.bound[1, k]
103                     self.population.calculateFitness()
104                     self.fitness = self.population.fitness
105
106     def printResult(self):
107         '''
108         plot the result of the firefly algorithm
109         '''
110         x = np.arange(0, self.MAXGEN)
111         y1 = self.trace[:, 0]
112         y2 = self.trace[:, 1]
113         plt.plot(x, y1, 'r', label='optimal value')
114         plt.plot(x, y2, 'g', label='average value')
115         plt.xlabel("Iteration")
116         plt.ylabel("function value")
117         plt.title("Firefly Algorithm for function optimization")
118         plt.legend()
119         plt.show()
　　运行程序：



1 if __name__ == "__main__":
2
3     bound = np.tile([[-600], [600]], 25)
4     fa = FA(60, 25, bound, 200, [1.0, 0.000001, 0.6])
5     fa.solve()
　　
　　ObjFunction见简单遗传算法-python实现。