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[i] = self.bound[0, i] + 
30                 (self.bound[1, i] - self.bound[0, i]) * rnd[i]
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[i].calculateFitness()
 46             self.fitness[i] = self.population[i].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[i]:
 90                     r = np.linalg.norm(
 91                         self.population[i].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[i].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[i].chrom[k] < self.bound[0, k]:
100                             self.population[i].chrom[k] = self.bound[0, k]
101                         if self.population[i].chrom[k] > self.bound[1, k]:
102                             self.population[i].chrom[k] = self.bound[1, k]
103                     self.population[i].calculateFitness()
104                     self.fitness[i] = self.population[i].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实现。