启发搜索之遗传算法

遗传算法(Genetic Algorithm,GA)是模拟达尔文生物进化论的自然选择和遗传学机理的生物进化过程的计算模型,是一种通过模拟自然进化过程搜索最优解的方法。
它以一种群体中的所有个体为对象,并利用随机化技术指导一个被编码的参数空间进行高效搜索。其中,选择、交叉和变异构成了遗传算法的遗传操作;参数编码、初始群体的设定、适应度函数的设计、遗传操作设计、控制参数设定五个要素组成了遗传算法的核心内容。

遗传算法过程

遗传算法是从代表问题可能潜在的解集的一个种群(population)开始的,而一个种群则由经过基因(gene)编码的一定数目的个体(individual)组成。每个个体实际上是染色体(chromosome)带有特征的实体。
染色体作为遗传物质的主要载体,即多个基因的集合,其内部表现(即基因型)是某种基因组合,它决定了个体的形状的外部表现,如黑头发的特征是由染色体中控制这一特征的某种基因组合决定的。因此,在一开始需要实现从表现型到基因型的映射即编码工作。由于仿照基因编码的工作很复杂,我们往往进行简化,如二进制编码。
初代种群产生之后,按照适者生存和优胜劣汰的原理,逐代(generation)演化产生出越来越好的近似解,在每一代,根据问题域中个体的适应度(fitness)大小选择(selection)个体,并借助于自然遗传学的遗传算子(genetic operators)进行组合交叉(crossover)和变异(mutation),产生出代表新的解集的种群。
这个过程将导致种群像自然进化一样的后生代种群比前代更加适应于环境,末代种群中的最优个体经过解码(decoding),可以作为问题近似最优解 。
可以总结为如下步骤:
STEP1: 随机产生种群。
STEP2: 根据策略判断个体的适应度,是否符合优化准则,若符合,输出最佳个体及其最优解,结束。否则,进行下一步。
STEP3: 依据适应度选择父母,适应度高的个体被选中的概率高,适应度低的个体被淘汰。
STEP4: 用父母的染色体按照一定的方法进行交叉,生成子代。
STEP5: 对子代染色体进行变异。
STEP6: 由交叉和变异产生新一代种群,返回步骤2,直到最优解产生。

遗传算法的代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
import numpy as np
import random
import math
import copy
import matplotlib.pyplot as plt

#========================================================
# 辅助工具
#========================================================

class GAIndividual:
'''
模拟生物个体
'''
def __init__(self, vardim, bound):
'''
个体初始化
vardim: 变量维数
bound: 变量取值范围
'''
self.vardim = vardim
self.bound = bound
self.fitness = 0. # 适应性得分

def generate(self):
'''
生成个体遗传物质--染色体(chromsome)
'''
rnd = np.random.random(size=self.vardim)
self.chrom = np.zeros(self.vardim)
for i in range(0, self.vardim):
self.chrom[i] = self.bound[0, i] + (self.bound[1, i] - self.bound[0, i]) * rnd[i]

def GrieFunc(self, vardim, x, bound):
'''
差分进化算法(Griewangk function)
'''
s1 = 0.
s2 = 1.
for i in range(1, vardim + 1):
s1 = s1 + x[i - 1] ** 2
s2 = s2 * math.cos(x[i - 1] / math.sqrt(i))
y = (1. / 4000.) * s1 - s2 + 1
y = 1. / (1. + y)
return y

def calculateFitness(self):
'''
计算染色体的适应性
'''
self.fitness = self.GrieFunc(self.vardim, self.chrom, self.bound)

#========================================================
# 核心算法
#========================================================

class GA:
'''
遗传算法(Genetic Algorithm)
'''
def __init__(self, sizepop, vardim, bound, MAXGEN, params):
'''
参数设置
sizepop: 种群规模
vardim: 变量维数
bound: 变量取值范围
MAXGEN: 最大繁衍代数(终止条件)
param: 其他参数(列表), 包含交叉率(crossover rate), 变异率(mutation rate), alpha参数
'''
self.sizepop = sizepop
self.MAXGEN = MAXGEN
self.vardim = vardim
self.bound = bound
self.population = [] # 种群
self.fitness = np.zeros((self.sizepop, 1)) # 适应性评分
self.history = np.zeros((self.MAXGEN, 2)) # 演化历史
self.params = params

def initialize(self):
'''
初始化种群
'''
for i in range(0, self.sizepop):
ind = GAIndividual(self.vardim, self.bound)
ind.generate()
self.population.append(ind)

def selectionOperation(self):
'''
模拟自然选择
'''
newpop = []
totalFitness = np.sum(self.fitness)
accuFitness = np.zeros((self.sizepop, 1))

sum1 = 0.
for i in range(0, self.sizepop):
accuFitness[i] = sum1 + self.fitness[i] / totalFitness
sum1 = accuFitness[i]

for i in range(0, self.sizepop):
r = random.random()
idx = 0
for j in range(0, self.sizepop - 1):
if j == 0 and r < accuFitness[j]:
idx = 0
break
elif r >= accuFitness[j] and r < accuFitness[j + 1]:
idx = j + 1
break
newpop.append(self.population[idx])
self.population = newpop

def crossoverOperation(self):
'''
模拟自然繁衍
'''
newpop = []
for i in range(0, self.sizepop, 2):
idx1 = random.randint(0, self.sizepop - 1)
idx2 = random.randint(0, self.sizepop - 1)
while idx2 == idx1:
idx2 = random.randint(0, self.sizepop - 1)
newpop.append(copy.deepcopy(self.population[idx1]))
newpop.append(copy.deepcopy(self.population[idx2]))
r = random.random()
if r < self.params[0]:
crossPos = random.randint(1, self.vardim - 1)
for j in range(crossPos, self.vardim):
newpop[i].chrom[j] = newpop[i].chrom[
j] * self.params[2] + (1 - self.params[2]) * newpop[i + 1].chrom[j]
newpop[i + 1].chrom[j] = newpop[i + 1].chrom[j] * self.params[2] + \
(1 - self.params[2]) * newpop[i].chrom[j]
self.population = newpop

def mutationOperation(self):
'''
模拟遗传变异
'''
newpop = []
for i in range(0, self.sizepop):
newpop.append(copy.deepcopy(self.population[i]))
r = random.random()
if r < self.params[1]:
mutatePos = random.randint(0, self.vardim - 1)
theta = random.random()
if theta > 0.5:
newpop[i].chrom[mutatePos] = newpop[i].chrom[
mutatePos] - (newpop[i].chrom[mutatePos] - self.bound[0, mutatePos]) * (1 - random.random() ** (1 - self.t / self.MAXGEN))
else:
newpop[i].chrom[mutatePos] = newpop[i].chrom[
mutatePos] + (self.bound[1, mutatePos] - newpop[i].chrom[mutatePos]) * (1 - random.random() ** (1 - self.t / self.MAXGEN))
self.population = newpop

def evaluate(self):
'''
评估环境适应性得分
'''
for i in range(0, self.sizepop):
self.population[i].calculateFitness()
self.fitness[i] = self.population[i].fitness

def printResult(self):
'''
绘制遗传算法结果
'''
x = np.arange(0, self.MAXGEN)
y1 = self.history[:, 0]
y2 = self.history[:, 1]
plt.plot(x, y1, 'r', label='optimal value')
plt.plot(x, y2, 'g', label='average value')
plt.xlabel("Iteration")
plt.ylabel("function value")
plt.title("Genetic algorithm for function optimization")
plt.legend()
plt.show()

def main(self):
'''
主流程:模拟遗传演化过程(evolution process)
'''
# 演化次数
self.t = 0
# 种群初始化
self.initialize()
# 评估适应性得分
self.evaluate()
# 评估演化结果
best = np.max(self.fitness)
bestIndex = np.argmax(self.fitness)
self.best = copy.deepcopy(self.population[bestIndex])
self.avefitness = np.mean(self.fitness)
# 记录演化结果
self.history[self.t, 0] = (1 - self.best.fitness) / self.best.fitness # 最优
self.history[self.t, 1] = (1 - self.avefitness) / self.avefitness # 平均
print("Generation %d: optimal function value is: %f; average function value is %f" % (self.t, self.history[self.t, 0], self.history[self.t, 1]))
while (self.t < self.MAXGEN - 1):
self.t += 1
# 自然选择
self.selectionOperation()
# 自然繁衍
self.crossoverOperation()
# 遗传变异
self.mutationOperation()
# 评估适应性得分
self.evaluate()
best = np.max(self.fitness)
bestIndex = np.argmax(self.fitness)
if best > self.best.fitness:
self.best = copy.deepcopy(self.population[bestIndex])
self.avefitness = np.mean(self.fitness)
# 记录演化结果
self.history[self.t, 0] = (1 - self.best.fitness) / self.best.fitness
self.history[self.t, 1] = (1 - self.avefitness) / self.avefitness
print("Generation %d: optimal function value is: %f; average function value is %f" % (self.t, self.history[self.t, 0], self.history[self.t, 1]))

# 打印最优结果
print("Optimal function value is: %f; " % self.history[self.t, 0])
# 打印最优个体遗传信息
print("Optimal solution is:")
print(self.best.chrom)
# 绘制演化历史
self.printResult()

if __name__ == "__main__":
bound = np.tile([[-600], [600]], 25)
ga = GA(60, 25, bound, 1000, [0.9, 0.1, 0.5])
ga.main()
0%